diff --git a/.gitattributes b/.gitattributes
deleted file mode 100644
index e85bf95..0000000
--- a/.gitattributes
+++ /dev/null
@@ -1,6 +0,0 @@
-* text=auto
-*.js linguist-language=java
-*.css linguist-language=java
-*.html linguist-language=java
-
-
diff --git a/.gitignore b/.gitignore
index 517ec8a..e233607 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,5 @@ out
 gen
 /target/
 
+
+
diff --git a/ReadMe.md b/ReadMe.md
index b9348a8..84572da 100644
--- a/ReadMe.md
+++ b/ReadMe.md
@@ -1,379 +1,492 @@
-本仓库为【Java工程师技术指南】力求打造最完整最实用的Java工程师学习指南！
+<div align="center">
+<a href="https://github.com/h2pl/Java-Tutorial">
+    <img src="https://java-tutorial.oss-cn-shanghai.aliyuncs.com/Javatutorial-v1.png" width="300" height="300"/>
+</a>
+</div>
+
+<p>
+<div align="center">
+    <a href="https://github.com/h2pl/Java-Tutorial"><img src="https://img.shields.io/github/stars/h2pl/JavaTutorial.svg"></a>
+    <a href="https://github.com/h2pl/Java-Tutorial"><img src="https://img.shields.io/github/forks/h2pl/JavaTutorial.svg"></a>
+    <a href="https://github.com/h2pl/Java-Tutorial"><img src="https://img.shields.io/github/issues/h2pl/JavaTutorial.svg"></a>
+    <a href="https://github.com/h2pl/Java-Tutorial"><img src="https://img.shields.io/github/license/h2pl/JavaTutorial.svg"></a>
+    <a href="https://github.com/h2pl/Java-Tutorial"><img src="https://img.shields.io/github/last-commit/h2pl/JavaTutorial.svg"></a>
+    <a href="https://github.com/h2pl/Java-Tutorial"><img src="https://img.shields.io/github/release/h2pl/JavaTutorial.svg"></a>
+</div>
+</p>
+
+力求打造最完整最实用的Java工程师学习指南！
 
 这些文章和总结都是我近几年学习Java总结和整理出来的，非常实用，对于学习Java后端的朋友来说应该是最全面最完整的技术仓库。
 我靠着这些内容进行复习，拿到了BAT等大厂的offer，这个仓库也已经帮助了很多的Java学习者，如果对你有用，希望能给个star支持我，谢谢！
 
 为了更好地讲清楚每个知识模块，我们也参考了很多网上的优质博文，力求不漏掉每一个知识点，所有参考博文都将声明转载来源，如有侵权，请联系我。
 
-点击关注[微信公众号](#微信公众号)及时获取笔主最新更新文章，并可免费领取Java工程师必备学习资源，以及我原创的电子书《菜鸟程序员成长之路：从技术小白到阿里巴巴Java工程师》
+点击关注[微信公众号](#微信公众号)及时获取笔主最新更新文章，并可免费领取Java工程师必备学习资源
 
 <p align="center">
 <a href="https://github.com/h2pl/Java-Tutorial" target="_blank">
-    <img src="https://s2.ax1x.com/2019/09/23/uFaedP.jpg" width="200" height="160"/>
+    <img src="https://java-tutorial.oss-cn-shanghai.aliyuncs.com/Javatutorial.jpeg" width="900" height="300"/>
 </a>
 </p>
 
-<p align="center">
-  <a href="https://how2playlife.com/"><img src="https://img.shields.io/badge/阅读-read-brightgreen.svg" alt="阅读"></a>
-  <a href="#微信公众号"><img src="https://img.shields.io/badge/chat-微信群-blue.svg" alt="微信公众号"></a>
-</p>
-
-推荐使用 https://how2playlife.com/ 在线阅读，在线阅读内容本仓库同步一致。这种方式阅读的优势在于：左侧边栏有目录，阅读体验更好。
-
-
-## 目录
-
-- [Java基础](#Java基础)
-    - [基础知识](#基础知识)
-    - [容器](#容器)
-    - [设计模式](#设计模式)
-- [JavaWeb](#JavaWeb)
-    - [Srping](#Spring)
-    - [SpringMVC](#SpringMVC)
-    - [SpringBoot](#SpringBoot)
-- [Java进阶](#Java进阶)
-    - [并发](#并发)
-    - [JVM](#JVM)
-    - [Java网络编程](#Java网络编程)
-- [计算机基础](#计算机基础)
-    - [计算机网络](#计算机网络)
-    - [操作系统](#操作系统)
-        - [Linux相关](#linux相关)
-    - [数据结构与算法](#数据结构与算法)
-        - [数据结构](#数据结构)
-        - [算法](#算法)
-- [数据库](#数据库)
-    - [MySQL](#MySQL)
-- [缓存](#缓存)
-    - [Redis](#Redis)
-- [消息队列](#消息队列)
-    - [Kafka](#Kafka)
-- [大后端](#大后端)
-- [分布式](#分布式)
-    - [理论](#理论)
-    - [实战](#实战)
-- [面试指南](#面试指南)
-    - [校招指南](#校招指南)
-    - [面经](#面经)
-- [工具](#工具)
-    - [Git](#git)
-- [资料](#资料)
-    - [书单](#书单)
-- [待办](#待办)
-- [说明](#说明)
-- [微信公众号](#微信公众号)
-
-## Java基础
-
-### 基础知识
-
-* [面向对象基础](docs/java/basic/1、面向对象基础.md)
-* [Java基本数据类型](docs/java/basic/2、Java基本数据类型.md)
-* [string和包装类](docs/java/basic/3、string和包装类.md)
-* [final关键字特性](docs/java/basic/4、final关键字特性.md)
-* [Java类和包](docs/java/basic/5、Java类和包.md)
-* [抽象类和接口](docs/java/basic/6、抽象类和接口.md)
-* [代码块和代码执行顺序](docs/java/basic/7、代码块和代码执行顺序.md)
-* [Java自动拆箱装箱里隐藏的秘密](docs/java/basic/8、Java自动拆箱装箱里隐藏的秘密.md)
-* [Java中的Class类和Object类](docs/java/basic/9、Java中的Class类和Object类.md)
-* [Java异常](docs/java/basic/10、Java异常.md)
-* [解读Java中的回调](docs/java/basic/11、解读Java中的回调.md)
-* [反射](docs/java/basic/12、反射.md)
-* [泛型](docs/java/basic/13、泛型.md)
-* [枚举类](docs/java/basic/14、枚举类.md)
-* [Java注解和最佳实践](docs/java/basic/15、Java注解和最佳实践.md)
-* [JavaIO流](docs/java/basic/16、JavaIO流.md)
-* [多线程](docs/java/basic/17、多线程.md)
-* [深入理解内部类](docs/java/basic/18、深入理解内部类.md)
-* [javac和javap](docs/java/basic/19、Java集合框架梳理.md)
-* [Java8新特性终极指南](docs/java/basic/20、javac和javap.md)
-* [Java类和包](docs/java/basic/21、Java8新特性终极指南.md)
-* [序列化和反序列化](docs/java/basic/22、序列化和反序列化.md)
-* [继承、封装、多态的实现原理](docs/java/basic/23、继承、封装、多态的实现原理.md)
-
-### 容器
-
-* [Java集合类总结](docs/java/collection/Java集合类总结.md)
-* [Java集合详解1：一文读懂ArrayList,Vector与Stack使用方法和实现原理](docs/java/collection/Java集合详解1：一文读懂ArrayList,Vector与Stack使用方法和实现原理.md)  
-* [Java集合详解2：Queue和LinkedList](docs/java/collection/Java集合详解2：Queue和LinkedList.md)
-* [Java集合详解3：Iterator，fail-fast机制与比较器](docs/java/collection/Java集合详解3：Iterator，fail-fast机制与比较器.md)
-* [Java集合详解4：HashMap和HashTable](docs/java/collection/Java集合详解4：HashMap和HashTable.md)
-* [Java集合详解5：深入理解LinkedHashMap和LRU缓存](docs/java/collection/Java集合详解5：深入理解LinkedHashMap和LRU缓存.md)
-* [Java集合详解6：TreeMap和红黑树](docs/java/collection/Java集合详解6：TreeMap和红黑树.md)
-* [Java集合详解7：HashSet，TreeSet与LinkedHashSet](docs/java/collection/Java集合详解7：HashSet，TreeSet与LinkedHashSet.md)
-* [Java集合详解8：Java集合类细节精讲](docs/java/collection/Java集合详解8：Java集合类细节精讲.md)
-
-### 设计模式
-
-* [设计模式学习总结](docs/java/design-parttern/设计模式学习总结.md)
-* [初探Java设计模式1：创建型模式（工厂，单例等）.md](docs/java/design-parttern/初探Java设计模式1：创建型模式（工厂，单例等）.md)
-* [初探Java设计模式2：结构型模式（代理模式，适配器模式等）.md](docs/java/design-parttern/初探Java设计模式2：结构型模式（代理模式，适配器模式等）.md)
-* [初探Java设计模式3：行为型模式（策略，观察者等）.md](docs/java/design-parttern/初探Java设计模式3：行为型模式（策略，观察者等）.md)
-* [初探Java设计模式4：JDK中的设计模式.md](docs/java/design-parttern/初探Java设计模式4：JDK中的设计模式.md)
-* [初探Java设计模式5：Spring涉及到的9种设计模式.md](docs/java/design-parttern/初探Java设计模式5：Spring涉及到的9种设计模式.md)
-
-## JavaWeb
-
-* [走进JavaWeb技术世界1：JavaWeb的由来和基础知识](docs/java-web/走进JavaWeb技术世界1：JavaWeb的由来和基础知识.md)
-* [走进JavaWeb技术世界2：JSP与Servlet的曾经与现在](docs/java-web/走进JavaWeb技术世界2：JSP与Servlet的曾经与现在.md)
-* [走进JavaWeb技术世界3：JDBC的进化与连接池技术](docs/java-web/走进JavaWeb技术世界3：JDBC的进化与连接池技术.md)
-* [走进JavaWeb技术世界4：Servlet 工作原理详解](docs/java-web/走进JavaWeb技术世界4：Servlet%29工作原理详解.md)
-* [走进JavaWeb技术世界5：初探Tomcat的HTTP请求过程](docs/java-web/走进JavaWeb技术世界5：初探Tomcat的HTTP请求过程.md)
-* [走进JavaWeb技术世界6：Tomcat5总体架构剖析](docs/java-web/走进JavaWeb技术世界6：Tomcat5总体架构剖析.md)
-* [走进JavaWeb技术世界7：Tomcat和其他WEB容器的区别](docs/java-web/走进JavaWeb技术世界7：Tomcat和其他WEB容器的区别.md)
-* [走进JavaWeb技术世界8：浅析Tomcat9请求处理流程与启动部署过程](docs/java-web/走进JavaWeb技术世界8：浅析Tomcat9请求处理流程与启动部署过程.md)
-* [走进JavaWeb技术世界9：Java日志系统的诞生与发展](docs/java-web/走进JavaWeb技术世界9：Java日志系统的诞生与发展.md)
-* [走进JavaWeb技术世界10：从JavaBean讲到Spring](docs/java-web/走进JavaWeb技术世界10：从JavaBean讲到Spring.md)
-* [走进JavaWeb技术世界11：单元测试框架Junit](docs/java-web/走进JavaWeb技术世界11：单元测试框架Junit.md)
-* [走进JavaWeb技术世界12：从手动编译打包到项目构建工具Maven](docs/java-web/走进JavaWeb技术世界12：从手动编译打包到项目构建工具Maven.md)
-* [走进JavaWeb技术世界13：Hibernate入门经典与注解式开发](docs/java-web/走进JavaWeb技术世界13：Hibernate入门经典与注解式开发.md)
-* [走进JavaWeb技术世界14：Mybatis入门](docs/java-web/走进JavaWeb技术世界14：Mybatis入门.md)
-* [深入JavaWeb技术世界15：深入浅出Mybatis基本原理](docs/java-web/深入JavaWeb技术世界15：深入浅出Mybatis基本原理.md)
-* [走进JavaWeb技术世界16：极简配置的SpringBoot](docs/java-web/走进JavaWeb技术世界16：极简配置的SpringBoot.md)
-
-### Spring
-
-* [Spring源码剖析1：Spring概述](docs/java-web/Spring/Spring源码剖析1：Spring概述.md)
-* [Spring源码剖析2：初探Spring IOC核心流程](docs/java-web/Spring/Spring源码剖析2：初探Spring%20IOC核心流程.md)
-* [Spring源码剖析3：Spring IOC容器的加载过程 ](docs/java-web/Spring/Spring源码剖析3：Spring%20IOC容器的加载过程.md)
-* [Spring源码剖析4：懒加载的单例Bean获取过程分析](docs/java-web/Spring/Spring源码剖析4：懒加载的单例Bean获取过程分析.md)
-* [Spring源码剖析5：JDK和cglib动态代理原理详解 ](docs/java-web/Spring/Spring源码剖析5：JDK和cglib动态代理原理详解.md)
-* [Spring源码剖析6：Spring AOP概述](docs/java-web/Spring/Spring源码剖析6：Spring%20AOP概述.md)
-* [Spring源码剖析7：AOP实现原理详解 ](docs/java-web/Spring/Spring源码剖析7：AOP实现原理详解.md)
-* [Spring源码剖析8：Spring事务概述](docs/java-web/Spring/Spring源码剖析8：Spring事务概述.md)
-* [Spring源码剖析9：Spring事务源码剖析](docs/java-web/Spring/Spring源码剖析9：Spring事务源码剖析.md)
-
-### SpringMVC
-
-* [SpringMVC源码分析1：SpringMVC概述](docs/java-web/Spring/SSM/SpringMVC源码分析1：SpringMVC概述.md)
-* [SpringMVC源码分析2：SpringMVC设计理念与DispatcherServlet](docs/java-web/Spring/SSM/SpringMVC源码分析2：SpringMVC设计理念与DispatcherServlet.md)
-* [SpringMVC源码分析3：DispatcherServlet的初始化与请求转发 ](docs/java-web/Spring/SSM/SpringMVC源码分析3：DispatcherServlet的初始化与请求转发.md)
-* [SpringMVC源码分析4：DispatcherServlet如何找到正确的Controller ](docs/java-web/Spring/SSM/SpringMVC源码分析4：DispatcherServlet如何找到正确的Controller.md)
-* [SpringMVC源码剖析5：消息转换器HttpMessageConverter与@ResponseBody注解](docs/java-web/Spring/SSM/SpringMVC源码剖析5：消息转换器HttpMessageConverter与@ResponseBody注解.md)
-* [SpringMVC源码分析6：SpringMVC的视图解析原理 ](docs/java-web/Spring/SSM/SpringMVC源码分析6：SpringMVC的视图解析原理.md)
-
-### SpringBoot
-
-todo
-
-### SpringCloud
-
-todo
-
-## Java进阶
-
-### 并发
-
-* [Java并发指南1：并发基础与Java多线程](docs/java/currency/Java并发指南1：并发基础与Java多线程.md)
-* [Java并发指南2：深入理解Java内存模型JMM](docs/java/currency/Java并发指南2：深入理解Java内存模型JMM.md)
-* [Java并发指南3：并发三大问题与volatile关键字，CAS操作](docs/java/currency/Java并发指南3：并发三大问题与volatile关键字，CAS操作.md)
-* [Java并发指南4：Java中的锁 Lock和synchronized](docs/java/currency/Java并发指南4：Java中的锁%20Lock和synchronized.md)
-* [Java并发指南5：JMM中的final关键字解析](docs/java/currency/Java并发指南5：JMM中的final关键字解析.md)
-* [Java并发指南6：Java内存模型JMM总结](docs/java/currency/Java并发指南6：Java内存模型JMM总结.md)
-* [Java并发指南7：JUC的核心类AQS详解](docs/java/currency/Java并发指南7：JUC的核心类AQS详解.md)
-* [Java并发指南8：AQS中的公平锁与非公平锁，Condtion](docs/java/currency/Java并发指南8：AQS中的公平锁与非公平锁，Condtion.md)
-* [Java并发指南9：AQS共享模式与并发工具类的实现](docs/java/currency/Java并发指南9：AQS共享模式与并发工具类的实现.md)
-* [Java并发指南10：Java 读写锁 ReentrantReadWriteLock 源码分析](docs/java/currency/Java并发指南10：Java%20读写锁%20ReentrantReadWriteLock%20源码分析.md)
-* [Java并发指南11：解读 Java 阻塞队列 BlockingQueue](docs/java/currency/Java并发指南11：解读%20Java%20阻塞队列%20BlockingQueue.md)
-* [Java并发指南12：深度解读 java 线程池设计思想及源码实现](docs/java/currency/Java并发指南12：深度解读%20java%20线程池设计思想及源码实现.md)
-* [Java并发指南13：Java 中的 HashMap 和 ConcurrentHashMap 全解析](https://github.com/h2pl/Java-Tutorial/blob/master/docs/java/currency/Java%E5%B9%B6%E5%8F%91%E6%8C%87%E5%8D%9713%EF%BC%9AJava%20%E4%B8%AD%E7%9A%84%20HashMap%20%E5%92%8C%20ConcurrentHashMap%20%E5%85%A8%E8%A7%A3%E6%9E%90.md)
-* [Java并发指南14：JUC中常用的Unsafe和Locksupport](docs/java/currency/Java并发指南14：JUC中常用的Unsafe和Locksupport.md)
-* [Java并发指南15：Fork join并发框架与工作窃取算法剖析](docs/java/currency/Java并发编程指南15：Fork%20join并发框架与工作窃取算法剖析.md)
-* [Java并发编程学习总结](https://github.com/h2pl/Java-Tutorial/blob/master/docs/java/currency/Java%E5%B9%B6%E5%8F%91%E6%80%BB%E7%BB%93.md)
-
-### JVM
-
-* [JVM总结](docs/java/jvm/JVM总结.md)
-* [深入理解JVM虚拟机1：JVM内存的结构与消失的永久代](docs/java/jvm/深入理解JVM虚拟机1：JVM内存的结构与消失的永久代.md)
-* [深入理解JVM虚拟机2：JVM垃圾回收基本原理和算法](docs/java/jvm/深入理解JVM虚拟机2：JVM垃圾回收基本原理和算法.md)
-* [深入理解JVM虚拟机3：垃圾回收器详解](docs/java/jvm/深入理解JVM虚拟机3：垃圾回收器详解.md)
-* [深入理解JVM虚拟机4：Javaclass介绍与解析实践](docs/java/jvm/深入理解JVM虚拟机4：Javaclass介绍与解析实践.md)
-* [深入理解JVM虚拟机5：虚拟机字节码执行引擎](docs/java/jvm/深入理解JVM虚拟机5：虚拟机字节码执行引擎.md)
-* [深入理解JVM虚拟机6：深入理解JVM类加载机制](docs/java/jvm/深入理解JVM虚拟机6：深入理解JVM类加载机制.md)
-* [深入理解JVM虚拟机7：JNDI，OSGI，Tomcat类加载器实现](docs/java/jvm/深入理解JVM虚拟机7：JNDI，OSGI，Tomcat类加载器实现.md)
-* [深入了解JVM虚拟机8：Java的编译期优化与运行期优化](docs/java/jvm/深入了解JVM虚拟机8：Java的编译期优化与运行期优化.md)
-* [深入理解JVM虚拟机9：JVM监控工具与诊断实践](docs/java/jvm/深入理解JVM虚拟机9：JVM监控工具与诊断实践.md)
-* [深入理解JVM虚拟机10：JVM常用参数以及调优实践](docs/java/jvm/深入理解JVM虚拟机10：JVM常用参数以及调优实践.md)
-* [深入理解JVM虚拟机11：Java内存异常原理与实践](docs/java/jvm/深入理解JVM虚拟机11：Java内存异常原理与实践.md)
-* [深入理解JVM虚拟机12：JVM性能管理神器VisualVM介绍与实战](docs/java/jvm/深入理解JVM虚拟机12：JVM性能管理神器VisualVM介绍与实战.md)
-* [深入理解JVM虚拟机13：再谈四种引用及GC实践](docs/java/jvm/深入理解JVM虚拟机13：再谈四种引用及GC实践.md)
-* [深入理解JVM虚拟机14：GC调优思路与常用工具](docs/java/jvm/深入理解JVM虚拟机：GC调优思路与常用工具.md)
-
-### Java网络编程
-
-* [Java网络编程和NIO详解1：JAVA 中原生的 socket 通信机制](docs/java/jvm/Java网络编程和NIO详解1：JAVA%20中原生的%20socket%20通信机制.md)
-* [Java网络编程与NIO详解2：JAVA NIO 一步步构建IO多路复用的请求模型](docs/java/jvm/Java网络编程与NIO详解2：JAVA%20NIO%20一步步构建IO多路复用的请求模型.md) 
-* [Java网络编程和NIO详解3：IO模型与Java网络编程模型](docs/java/jvm/Java网络编程和NIO详解3：IO模型与Java网络编程模型.md) 
-* [Java网络编程与NIO详解4：浅析NIO包中的Buffer、Channel 和 Selector](https://github.com/h2pl/Java-Tutorial/blob/master/docs/java/network-programming/Java%E7%BD%91%E7%BB%9C%E7%BC%96%E7%A8%8B%E4%B8%8ENIO%E8%AF%A6%E8%A7%A34%EF%BC%9A%E6%B5%85%E6%9E%90NIO%E5%8C%85%E4%B8%AD%E7%9A%84Buffer%E3%80%81Channel%20%E5%92%8C%20Selector.md) 
-* [Java网络编程和NIO详解5：Java 非阻塞 IO 和异步 IO](https://github.com/h2pl/Java-Tutorial/blob/master/docs/java/network-programming/Java%E7%BD%91%E7%BB%9C%E7%BC%96%E7%A8%8B%E5%92%8CNIO%E8%AF%A6%E8%A7%A35%EF%BC%9AJava%20%E9%9D%9E%E9%98%BB%E5%A1%9E%20IO%20%E5%92%8C%E5%BC%82%E6%AD%A5%20IO.md)
-* [Java网络编程和NIO详解6：Linux epoll实现原理详解](docs/java/jvm/Java网络编程和NIO详解6：Linux%20epoll实现原理详解.md) 
-* [Java网络编程和NIO详解7：浅谈 Linux 中NIO Selector 的实现原理](Java网络编程和NIO详解7：浅谈%20Linux%20中NIO%20Selector%20的实现原理.md)
-* [Java网络编程与NIO详解8：浅析mmap和Direct Buffer](https://github.com/h2pl/Java-Tutorial/blob/master/docs/java/network-programming/Java%E7%BD%91%E7%BB%9C%E7%BC%96%E7%A8%8B%E4%B8%8ENIO%E8%AF%A6%E8%A7%A38%EF%BC%9A%E6%B5%85%E6%9E%90mmap%E5%92%8CDirect%20Buffer.md)
-* [Java网络编程和NIO详解9：基于NIO的网络编程框架Netty](docs/java/jvm/Java网络编程和NIO详解9：基于NIO的网络编程框架Netty.md)
-* [Java网络编程与NIO详解10：深度解读Tomcat中的NIO模型](https://github.com/h2pl/Java-Tutorial/blob/master/docs/java/network-programming/Java%E7%BD%91%E7%BB%9C%E7%BC%96%E7%A8%8B%E4%B8%8ENIO%E8%AF%A6%E8%A7%A310%EF%BC%9A%E6%B7%B1%E5%BA%A6%E8%A7%A3%E8%AF%BBTomcat%E4%B8%AD%E7%9A%84NIO%E6%A8%A1%E5%9E%8B.md)
-* [Java网络编程与NIO详解11：Tomcat中的Connector源码分析（NIO）](docs/java/jvm/Java网络编程与NIO详解11：Tomcat中的Connector源码分析（NIO）.md)
-
-## 计算机基础
-
-### 计算机网络
+<p>
+    
+# Java基础
+
+## 基础知识
+* [面向对象基础](docs/Java/basic/面向对象基础.md)
+* [Java基本数据类型](docs/Java/basic/Java基本数据类型.md)
+* [string和包装类](docs/Java/basic/string和包装类.md)
+* [final关键字特性](docs/Java/basic/final关键字特性.md)
+* [Java类和包](docs/Java/basic/Java类和包.md)
+* [抽象类和接口](docs/Java/basic/抽象类和接口.md)
+* [代码块和代码执行顺序](docs/Java/basic/代码块和代码执行顺序.md)
+* [Java自动拆箱装箱里隐藏的秘密](docs/Java/basic/Java自动拆箱装箱里隐藏的秘密.md)
+* [Java中的Class类和Object类](docs/Java/basic/Java中的Class类和Object类.md)
+* [Java异常](docs/Java/basic/Java异常.md)
+* [解读Java中的回调](docs/Java/basic/解读Java中的回调.md)
+* [反射](docs/Java/basic/反射.md)
+* [泛型](docs/Java/basic/泛型.md)
+* [枚举类](docs/Java/basic/枚举类.md)
+* [Java注解和最佳实践](docs/Java/basic/Java注解和最佳实践.md)
+* [JavaIO流](docs/Java/basic/JavaIO流.md)
+* [多线程](docs/Java/basic/多线程.md)
+* [深入理解内部类](docs/Java/basic/深入理解内部类.md)
+* [javac和javap](docs/Java/basic/javac和javap.md)
+* [Java8新特性终极指南](docs/Java/basic/Java8新特性终极指南.md)
+* [序列化和反序列化](docs/Java/basic/序列化和反序列化.md)
+* [继承封装多态的实现原理](docs/Java/basic/继承封装多态的实现原理.md)
+
+## 集合类
+
+* [Java集合类总结](docs/Java/collection/Java集合类总结.md)
+* [Java集合详解：一文读懂ArrayList,Vector与Stack使用方法和实现原理](docs/Java/collection/Java集合详解：一文读懂ArrayList,Vector与Stack使用方法和实现原理.md)  
+* [Java集合详解：Queue和LinkedList](docs/Java/collection/Java集合详解：Queue和LinkedList.md)
+* [Java集合详解：Iterator，fail-fast机制与比较器](docs/Java/collection/Java集合详解：Iterator，fail-fast机制与比较器.md)
+* [Java集合详解：HashMap和HashTable](docs/Java/collection/Java集合详解：HashMap和HashTable.md)
+* [Java集合详解：深入理解LinkedHashMap和LRU缓存](docs/Java/collection/Java集合详解：深入理解LinkedHashMap和LRU缓存.md)
+* [Java集合详解：TreeMap和红黑树](docs/Java/collection/Java集合详解：TreeMap和红黑树.md)
+* [Java集合详解：HashSet，TreeSet与LinkedHashSet](docs/Java/collection/Java集合详解：HashSet，TreeSet与LinkedHashSet.md)
+* [Java集合详解：Java集合类细节精讲](docs/Java/collection/Java集合详解：Java集合类细节精讲.md)
+
+# JavaWeb
+
+* [走进JavaWeb技术世界：JavaWeb的由来和基础知识](docs/JavaWeb/走进JavaWeb技术世界：JavaWeb的由来和基础知识.md)
+* [走进JavaWeb技术世界：JSP与Servlet的曾经与现在](docs/JavaWeb/走进JavaWeb技术世界：JSP与Servlet的曾经与现在.md)
+* [走进JavaWeb技术世界：JDBC的进化与连接池技术](docs/JavaWeb/走进JavaWeb技术世界：JDBC的进化与连接池技术.md)
+* [走进JavaWeb技术世界：Servlet工作原理详解](docs/JavaWeb/走进JavaWeb技术世界：Servlet工作原理详解.md)
+* [走进JavaWeb技术世界：初探Tomcat的HTTP请求过程](docs/JavaWeb/走进JavaWeb技术世界：初探Tomcat的HTTP请求过程.md)
+* [走进JavaWeb技术世界：Tomcat5总体架构剖析](docs/JavaWeb/走进JavaWeb技术世界：Tomcat5总体架构剖析.md)
+* [走进JavaWeb技术世界：Tomcat和其他WEB容器的区别](docs/JavaWeb/走进JavaWeb技术世界：Tomcat和其他WEB容器的区别.md)
+* [走进JavaWeb技术世界：浅析Tomcat9请求处理流程与启动部署过程](docs/JavaWeb/走进JavaWeb技术世界：浅析Tomcat9请求处理流程与启动部署过程.md)
+* [走进JavaWeb技术世界：Java日志系统的诞生与发展](docs/JavaWeb/走进JavaWeb技术世界：Java日志系统的诞生与发展.md)
+* [走进JavaWeb技术世界：从JavaBean讲到Spring](docs/JavaWeb/走进JavaWeb技术世界：从JavaBean讲到Spring.md)
+* [走进JavaWeb技术世界：单元测试框架Junit](docs/JavaWeb/走进JavaWeb技术世界：单元测试框架Junit.md)
+* [走进JavaWeb技术世界：从手动编译打包到项目构建工具Maven](docs/JavaWeb/走进JavaWeb技术世界：从手动编译打包到项目构建工具Maven.md)
+* [走进JavaWeb技术世界：Hibernate入门经典与注解式开发](docs/JavaWeb/走进JavaWeb技术世界：Hibernate入门经典与注解式开发.md)
+* [走进JavaWeb技术世界：Mybatis入门](docs/JavaWeb/走进JavaWeb技术世界：Mybatis入门.md)
+* [走进JavaWeb技术世界：深入浅出Mybatis基本原理](docs/JavaWeb/走进JavaWeb技术世界：深入浅出Mybatis基本原理.md)
+* [走进JavaWeb技术世界：极简配置的SpringBoot](docs/JavaWeb/走进JavaWeb技术世界：极简配置的SpringBoot.md)
+
+# Java进阶
+
+## 并发编程
+
+* [Java并发指南：并发基础与Java多线程](docs/Java/concurrency/Java并发指南：并发基础与Java多线程.md)
+* [Java并发指南：深入理解Java内存模型JMM](docs/Java/concurrency/Java并发指南：深入理解Java内存模型JMM.md)
+* [Java并发指南：并发三大问题与volatile关键字，CAS操作](docs/Java/concurrency/Java并发指南：并发三大问题与volatile关键字，CAS操作.md)
+* [Java并发指南：Java中的锁Lock和synchronized](docs/Java/concurrency/Java并发指南：Java中的锁Lock和synchronized.md)
+* [Java并发指南：JMM中的final关键字解析](docs/Java/concurrency/Java并发指南：JMM中的final关键字解析.md)
+* [Java并发指南：Java内存模型JMM总结](docs/Java/concurrency/Java并发指南：Java内存模型JMM总结.md)
+* [Java并发指南：JUC的核心类AQS详解](docs/Java/concurrency/Java并发指南：JUC的核心类AQS详解.md)
+* [Java并发指南：AQS中的公平锁与非公平锁，Condtion](docs/Java/concurrency/Java并发指南：AQS中的公平锁与非公平锁，Condtion.md)
+* [Java并发指南：AQS共享模式与并发工具类的实现](docs/Java/concurrency/Java并发指南：AQS共享模式与并发工具类的实现.md)
+* [Java并发指南：Java读写锁ReentrantReadWriteLock源码分析](docs/Java/concurrency/Java并发指南：Java读写锁ReentrantReadWriteLock源码分析.md)
+* [Java并发指南：解读Java阻塞队列BlockingQueue](docs/Java/concurrency/Java并发指南：解读Java阻塞队列BlockingQueue.md)
+* [Java并发指南：深度解读java线程池设计思想及源码实现](docs/Java/concurrency/Java并发指南：深度解读Java线程池设计思想及源码实现.md)
+* [Java并发指南：Java中的HashMap和ConcurrentHashMap全解析](docs/Java/concurrency/Java并发指南：Java中的HashMap和ConcurrentHashMap全解析.md)
+* [Java并发指南：JUC中常用的Unsafe和Locksupport](docs/Java/concurrency/Java并发指南：JUC中常用的Unsafe和Locksupport.md)
+* [Java并发指南：ForkJoin并发框架与工作窃取算法剖析](docs/Java/concurrency/Java并发指南：ForkJoin并发框架与工作窃取算法剖析.md)
+* [Java并发编程学习总结](docs/Java/concurrency/Java并发编程学习总结.md)
+
+## JVM
+
+* [JVM总结](docs/Java/JVM/JVM总结.md)
+* [深入理解JVM虚拟机：JVM内存的结构与消失的永久代](docs/Java/JVM/深入理解JVM虚拟机：JVM内存的结构与消失的永久代.md)
+* [深入理解JVM虚拟机：JVM垃圾回收基本原理和算法](docs/Java/JVM/深入理解JVM虚拟机：JVM垃圾回收基本原理和算法.md)
+* [深入理解JVM虚拟机：垃圾回收器详解](docs/Java/JVM/深入理解JVM虚拟机：垃圾回收器详解.md)
+* [深入理解JVM虚拟机：Javaclass介绍与解析实践](docs/Java/JVM/深入理解JVM虚拟机：Java字节码介绍与解析实践.md)
+* [深入理解JVM虚拟机：虚拟机字节码执行引擎](docs/Java/JVM/深入理解JVM虚拟机：虚拟机字节码执行引擎.md)
+* [深入理解JVM虚拟机：深入理解JVM类加载机制](docs/Java/JVM/深入理解JVM虚拟机：深入理解JVM类加载机制.md)
+* [深入理解JVM虚拟机：JNDI，OSGI，Tomcat类加载器实现](docs/Java/JVM/深入理解JVM虚拟机：JNDI，OSGI，Tomcat类加载器实现.md)
+* [深入了解JVM虚拟机：Java的编译期优化与运行期优化](docs/Java/JVM/深入理解JVM虚拟机：Java的编译期优化与运行期优化.md)
+* [深入理解JVM虚拟机：JVM监控工具与诊断实践](docs/Java/JVM/深入理解JVM虚拟机：JVM监控工具与诊断实践.md)
+* [深入理解JVM虚拟机：JVM常用参数以及调优实践](docs/Java/JVM/深入理解JVM虚拟机：JVM常用参数以及调优实践.md)
+* [深入理解JVM虚拟机：Java内存异常原理与实践](docs/Java/JVM/深入理解JVM虚拟机：Java内存异常原理与实践.md)
+* [深入理解JVM虚拟机：JVM性能管理神器VisualVM介绍与实战](docs/Java/JVM/深入理解JVM虚拟机：JVM性能管理神器VisualVM介绍与实战.md)
+* [深入理解JVM虚拟机：再谈四种引用及GC实践](docs/Java/JVM/深入理解JVM虚拟机：再谈四种引用及GC实践.md)
+* [深入理解JVM虚拟机：GC调优思路与常用工具](docs/Java/JVM/深入理解JVM虚拟机：GC调优思路与常用工具.md)
+
+## Java网络编程
+
+* [Java网络编程和NIO详解：JAVA 中原生的 socket 通信机制](docs/Java/network/Java网络编程与NIO详解：JAVA中原生的socket通信机制.md)
+* [Java网络编程与NIO详解：JAVA NIO 一步步构建IO多路复用的请求模型](docs/Java/network/Java网络编程与NIO详解：JavaNIO一步步构建IO多路复用的请求模型.md) 
+* [Java网络编程和NIO详解：IO模型与Java网络编程模型](docs/Java/network/Java网络编程与NIO详解：IO模型与Java网络编程模型.md) 
+* [Java网络编程与NIO详解：浅析NIO包中的BufferChannel和Selector](docs/Java/network/Java网络编程与NIO详解：浅析NIO包中的BufferChannel和Selector.md) 
+* [Java网络编程和NIO详解：Java非阻塞IO和异步IO](docs/Java/network/Java网络编程与NIO详解：Java非阻塞IO和异步IO.md)
+* [Java网络编程与NIO详解：LinuxEpoll实现原理详解](docs/Java/network/Java网络编程与NIO详解：LinuxEpoll实现原理详解.md.md) 
+* [Java网络编程与NIO详解：浅谈Linux中Selector的实现原理](docs/Java/network/Java网络编程与NIO详解：浅谈Linux中Selector的实现原理.md)
+* [Java网络编程与NIO详解：浅析mmap和DirectBuffer](docs/Java/network/Java网络编程与NIO详解：浅析mmap和DirectBuffer.md)
+* [Java网络编程与NIO详解：基于NIO的网络编程框架Netty](docs/Java/network/Java网络编程与NIO详解：基于NIO的网络编程框架Netty.md)
+* [Java网络编程与NIO详解：Java网络编程与NIO详解](docs/Java/network/Java网络编程与NIO详解：深度解读Tomcat中的NIO模型.md)
+* [Java网络编程与NIO详解：Tomcat中的Connector源码分析（NIO）](docs/Java/network/Java网络编程与NIO详解：Tomcat中的Connector源码分析（NIO）.md)
+
+# Spring全家桶
+
+## Spring
+
+* [SpringAOP的概念与作用](docs/Spring全家桶/Spring/Spring常见注解.md)
+* [SpringBean的定义与管理（核心）](docs/Spring全家桶/Spring/Spring常见注解.md)
+* [Spring中对于数据库的访问](docs/Spring全家桶/Spring/Spring常见注解.md)
+* [Spring中对于校验功能的支持](docs/Spring全家桶/Spring/Spring常见注解.md)
+* [Spring中的Environment环境变量](docs/Spring全家桶/Spring/Spring常见注解.md)
+* [Spring中的事件处理机制](docs/Spring全家桶/Spring/Spring常见注解.md)
+* [Spring中的资源管理](docs/Spring全家桶/Spring/Spring常见注解.md)
+* [Spring中的配置元数据（管理配置的基本数据）](docs/Spring全家桶/Spring/Spring常见注解.md)
+* [Spring事务基本用法](docs/Spring全家桶/Spring/Spring常见注解.md)
+* [Spring合集](docs/Spring全家桶/Spring/Spring常见注解.md)
+* [Spring容器与IOC](docs/Spring全家桶/Spring/Spring常见注解.md)
+* [Spring常见注解](docs/Spring全家桶/Spring/Spring常见注解.md)
+* [Spring概述](docs/Spring全家桶/Spring/Spring常见注解.md)
+* [第一个Spring应用](docs/Spring全家桶/Spring/Spring常见注解.md)
+
+## Spring源码分析
+
+### 综合
+* [Spring源码剖析：初探SpringIOC核心流程](docs/Spring全家桶/Spring源码分析/Spring源码剖析：初探SpringIOC核心流程.md)
+* [Spring源码剖析：SpringIOC容器的加载过程 ](docs/Spring全家桶/Spring源码分析/Spring源码剖析：SpringIOC容器的加载过程.md)
+* [Spring源码剖析：懒加载的单例Bean获取过程分析](docs/Spring全家桶/Spring源码分析/Spring源码剖析：懒加载的单例Bean获取过程分析.md)
+* [Spring源码剖析：JDK和cglib动态代理原理详解 ](docs/Spring全家桶/Spring源码分析/Spring源码剖析：JDK和cglib动态代理原理详解.md)
+* [Spring源码剖析：SpringAOP概述](docs/Spring全家桶/Spring源码分析/Spring源码剖析：SpringAOP概述.md)
+* [Spring源码剖析：AOP实现原理详解 ](docs/Spring全家桶/Spring源码分析/Spring源码剖析：AOP实现原理详解.md)
+* [Spring源码剖析：Spring事务概述](docs/Spring全家桶/Spring源码分析/Spring源码剖析：Spring事务概述.md)
+* [Spring源码剖析：Spring事务源码剖析](docs/Spring全家桶/Spring源码分析/Spring源码剖析：Spring事务源码剖析.md)
+
+### AOP
+* [AnnotationAwareAspectJAutoProxyCreator 分析（上）](docs/Spring全家桶/Spring源码分析/SpringAOP/AnnotationAwareAspectJAutoProxyCreator分析（上）.md)
+* [AnnotationAwareAspectJAutoProxyCreator 分析（下）](docs/Spring全家桶/Spring源码分析/SpringAOP/AnnotationAwareAspectJAutoProxyCreator分析（下）.md)
+* [AOP示例demo及@EnableAspectJAutoProxy](docs/Spring全家桶/Spring源码分析/SpringAOP/AOP示例demo及@EnableAspectJAutoProxy.md)
+* [SpringAop（四）：jdk 动态代理](docs/Spring全家桶/Spring源码分析/SpringAOP/SpringAop（四）：jdk动态代理.md)
+* [SpringAop（五）：cglib 代理](docs/Spring全家桶/Spring源码分析/SpringAOP/SpringAop（五）：cglib代理.md)
+* [SpringAop（六）：aop 总结](docs/Spring全家桶/Spring源码分析/SpringAOP/SpringAop（六）：aop总结.md)
+
+### 事务
+* [spring 事务（一）：认识事务组件](docs/Spring全家桶/Spring源码分析/Spring事务/Spring事务（一）：认识事务组件.md)
+* [spring 事务（二）：事务的执行流程](docs/Spring全家桶/Spring源码分析/Spring事务/Spring事务（二）：事务的执行流程.md)
+* [spring 事务（三）：事务的隔离级别与传播方式的处理](docs/Spring全家桶/Spring源码分析/Spring事务/Spring事务（三）：事务的隔离级别与传播方式的处理01.md)
+* [spring 事务（四）：事务的隔离级别与传播方式的处理](docs/Spring全家桶/Spring源码分析/Spring事务/Spring事务（四）：事务的隔离级别与传播方式的处理02.md)
+* [spring 事务（五）：事务的隔离级别与传播方式的处理](docs/Spring全家桶/Spring源码分析/Spring事务/Spring事务（五）：事务的隔离级别与传播方式的处理03.md)
+* [spring 事务（六）：事务的隔离级别与传播方式的处理](docs/Spring全家桶/Spring源码分析/Spring事务/Spring事务（六）：事务的隔离级别与传播方式的处理04.md)
+
+### 启动流程
+* [spring启动流程（一）：启动流程概览](docs/Spring全家桶/Spring源码分析/Spring启动流程/Spring启动流程（一）：启动流程概览.md)
+* [spring启动流程（二）：ApplicationContext 的创建](docs/Spring全家桶/Spring源码分析/Spring启动流程/Spring启动流程（二）：ApplicationContext的创建.md)
+* [spring启动流程（三）：包的扫描流程](docs/Spring全家桶/Spring源码分析/Spring启动流程/Spring启动流程（三）：包的扫描流程.md)
+* [spring启动流程（四）：启动前的准备工作](docs/Spring全家桶/Spring源码分析/Spring启动流程/Spring启动流程（四）：启动前的准备工作.md)
+* [spring启动流程（五）：执行 BeanFactoryPostProcessor](docs/Spring全家桶/Spring源码分析/Spring启动流程/Spring启动流程（五）：执行BeanFactoryPostProcessor.md)
+* [spring启动流程（六）：注册 BeanPostProcessor](docs/Spring全家桶/Spring源码分析/Spring启动流程/Spring启动流程（六）：注册BeanPostProcessor.md)
+* [spring启动流程（七）：国际化与事件处理](docs/Spring全家桶/Spring源码分析/Spring启动流程/Spring启动流程（七）：国际化与事件处理.md)
+* [spring启动流程（八）：完成 BeanFactory 的初始化](docs/Spring全家桶/Spring源码分析/Spring启动流程/Spring启动流程（八）：完成BeanFactory的初始化.md)
+* [spring启动流程（九）：单例 bean 的创建](docs/Spring全家桶/Spring源码分析/Spring启动流程/Spring启动流程（九）：单例bean的创建.md)
+* [spring启动流程（十）：启动完成的处理](docs/Spring全家桶/Spring源码分析/Spring启动流程/Spring启动流程（十）：启动完成的处理.md)
+* [spring启动流程（十一）：启动流程总结](docs/Spring全家桶/Spring源码分析/Spring启动流程/Spring启动流程（十一）：启动流程总结.md)
+
+### 组件分析
+* [spring 组件之 ApplicationContext](docs/Spring全家桶/Spring源码分析/Spring组件分析/Spring组件之ApplicationContext.md)
+* [spring 组件之 BeanDefinition](docs/Spring全家桶/Spring源码分析/Spring组件分析/Spring组件之BeanDefinition.md)
+* [Spring 组件之 BeanFactory](docs/Spring全家桶/Spring源码分析/Spring组件分析/Spring组件之BeanFactory.md)
+* [spring 组件之 BeanFactoryPostProcessor](docs/Spring全家桶/Spring源码分析/Spring组件分析/Spring组件之BeanFactoryPostProcessor.md)
+* [spring 组件之 BeanPostProcessor](docs/Spring全家桶/Spring源码分析/Spring组件分析/Spring组件之BeanPostProcessor.md)
+
+### 重要机制探秘
+
+* [ConfigurationClassPostProcessor（一）：处理 @ComponentScan 注解](docs/Spring全家桶/Spring源码分析/Spring重要机制探秘/ConfigurationClassPostProcessor（一）：处理@ComponentScan注解.md)
+* [ConfigurationClassPostProcessor（三）：处理 @Import 注解](docs/Spring全家桶/Spring源码分析/Spring重要机制探秘/ConfigurationClassPostProcessor（三）：处理@Import注解.md)
+* [ConfigurationClassPostProcessor（二）：处理 @Bean 注解](docs/Spring全家桶/Spring源码分析/Spring重要机制探秘/ConfigurationClassPostProcessor（二）：处理@Bean注解.md)
+* [ConfigurationClassPostProcessor（四）：处理 @Conditional 注解](docs/Spring全家桶/Spring源码分析/Spring重要机制探秘/ConfigurationClassPostProcessor（四）：处理@Conditional注解.md)
+* [Spring 探秘之 AOP 的执行顺序](docs/Spring全家桶/Spring源码分析/Spring重要机制探秘/Spring探秘之AOP的执行顺序.md)
+* [Spring 探秘之 Spring 事件机制](docs/Spring全家桶/Spring源码分析/Spring重要机制探秘/Spring探秘之Spring事件机制.md)
+* [spring 探秘之循环依赖的解决（一）：理论基石](docs/Spring全家桶/Spring源码分析/Spring重要机制探秘/Spring探秘之循环依赖的解决（一）：理论基石.md)
+* [spring 探秘之循环依赖的解决（二）：源码分析](docs/Spring全家桶/Spring源码分析/Spring重要机制探秘/Spring探秘之循环依赖的解决（二）：源码分析.md)
+* [spring 探秘之监听器注解 @EventListener](docs/Spring全家桶/Spring源码分析/Spring重要机制探秘/spring探秘之监听器注解@EventListener.md)
+* [spring 探秘之组合注解的处理](docs/Spring全家桶/Spring源码分析/Spring重要机制探秘/Spring探秘之组合注解的处理.md)
+
+## SpringMVC
+
+* [SpringMVC中的国际化功能](docs/Spring全家桶/SpringMVC/SpringMVC中的国际化功能.md)
+* [SpringMVC中的异常处理器](docs/Spring全家桶/SpringMVC/SpringMVC中的异常处理器.md)
+* [SpringMVC中的拦截器](docs/Spring全家桶/SpringMVC/SpringMVC中的拦截器.md)
+* [SpringMVC中的视图解析器](docs/Spring全家桶/SpringMVC/SpringMVC中的视图解析器.md)
+* [SpringMVC中的过滤器Filter](docs/Spring全家桶/SpringMVC/SpringMVC中的过滤器Filter.md)
+* [SpringMVC基本介绍与快速入门](docs/Spring全家桶/SpringMVC/SpringMVC基本介绍与快速入门.md)
+* [SpringMVC如何实现文件上传](docs/Spring全家桶/SpringMVC/SpringMVC如何实现文件上传.md)
+* [SpringMVC中的常用功能](docs/Spring全家桶/SpringMVC/SpringMVC中的常用功能.md)
+
+## SpringMVC源码分析
+
+* [SpringMVC源码分析：SpringMVC概述](docs/Spring全家桶/SpringMVC源码分析/SpringMVC源码分析：SpringMVC概述.md)
+* [SpringMVC源码分析：SpringMVC设计理念与DispatcherServlet](docs/Spring全家桶/SpringMVC源码分析/SpringMVC源码分析：SpringMVC设计理念与DispatcherServlet.md)
+* [SpringMVC源码分析：DispatcherServlet的初始化与请求转发 ](docs/Spring全家桶/SpringMVC源码分析/SpringMVC源码分析：DispatcherServlet的初始化与请求转发.md)
+* [SpringMVC源码分析：DispatcherServlet如何找到正确的Controller ](docs/Spring全家桶/SpringMVC源码分析/SpringMVC源码分析：DispatcherServlet如何找到正确的Controller.md)
+* [SpringMVC源码剖析：消息转换器HttpMessageConverter与@ResponseBody注解](docs/Spring全家桶/SpringMVC/SpringMVC源码剖析：消息转换器HttpMessageConverter与@ResponseBody注解.md)
+* [DispatcherServlet 初始化流程 ](docs/Spring全家桶/SpringMVC源码分析/DispatcherServlet初始化流程.md)
+* [RequestMapping 初始化流程 ](docs/Spring全家桶/SpringMVC源码分析/RequestMapping初始化流程.md)
+* [Spring 容器启动 Tomcat ](docs/Spring全家桶/SpringMVC源码分析/Spring容器启动Tomcat.md)
+* [SpringMVC demo 与@EnableWebMvc 注解 ](docs/Spring全家桶/SpringMVC源码分析/SpringMVC的Demo与@EnableWebMvc注解.md)
+* [SpringMVC 整体源码结构总结 ](docs/Spring全家桶/SpringMVC源码分析/SpringMVC整体源码结构总结.md)
+* [请求执行流程（一）之获取 Handler ](docs/Spring全家桶/SpringMVC源码分析/请求执行流程（一）之获取Handler.md)
+* [请求执行流程（二）之执行 Handler 方法 ](docs/Spring全家桶/SpringMVC源码分析/请求执行流程（二）之执行Handler方法.md)
+
+## SpringBoot
+
+* [SpringBoot系列:SpringBoot的前世今生](docs/Spring全家桶/SpringBoot/SpringBoot的前世今生.md)
+* [给你一份SpringBoot知识清单.md](docs/Spring全家桶/SpringBoot/给你一份SpringBoot知识清单.md)
+* [Spring常见注解使用指南(包含Spring+SpringMVC+SpringBoot)](docs/Spring全家桶/SpringBoot/Spring常见注解使用指南(包含Spring+SpringMVC+SpringBoot).md)
+* [SpringBoot中的日志管理](docs/Spring全家桶/SpringBoot/SpringBoot中的日志管理.md)
+* [SpringBoot常见注解](docs/Spring全家桶/SpringBoot/SpringBoot常见注解.md)
+* [SpringBoot应用也可以部署到外部Tomcat](docs/Spring全家桶/SpringBoot/SpringBoot应用也可以部署到外部Tomcat.md)
+* [SpringBoot生产环境工具Actuator](docs/Spring全家桶/SpringBoot/SpringBoot生产环境工具Actuator.md)
+* [SpringBoot的Starter机制](docs/Spring全家桶/SpringBoot/SpringBoot的Starter机制.md)
+* [SpringBoot的前世今生](docs/Spring全家桶/SpringBoot/SpringBoot的前世今生.md)
+* [SpringBoot的基本使用](docs/Spring全家桶/SpringBoot/SpringBoot的基本使用.md)
+* [SpringBoot的配置文件管理](docs/Spring全家桶/SpringBoot/SpringBoot的配置文件管理.md)
+* [SpringBoot自带的热部署工具](docs/Spring全家桶/SpringBoot/SpringBoot自带的热部署工具.md)
+* [SpringBoot中的任务调度与@Async](docs/Spring全家桶/SpringBoot/SpringBoot中的任务调度与@Async.md)
+* [基于SpringBoot中的开源监控工具SpringBootAdmin](docs/Spring全家桶/SpringBoot/基于SpringBoot中的开源监控工具SpringBootAdmin.md)
+
+## SpringBoot源码分析
+* [@SpringBootApplication 注解](docs/Spring全家桶/SpringBoot源码解析/@SpringBootApplication注解.md)
+* [springboot web应用（一）：servlet 组件的注册流程](docs/Spring全家桶/SpringBoot源码解析/SpringBootWeb应用（一）：servlet组件的注册流程.md)
+* [springboot web应用（二）：WebMvc 装配过程](docs/Spring全家桶/SpringBoot源码解析/SpringBootWeb应用（二）：WebMvc装配过程.md)
+
+* [SpringBoot 启动流程（一）：准备 SpringApplication](docs/Spring全家桶/SpringBoot源码解析/SpringBoot启动流程（一）：准备SpringApplication.md)
+* [SpringBoot 启动流程（二）：准备运行环境](docs/Spring全家桶/SpringBoot源码解析/SpringBoot启动流程（二）：准备运行环境.md)
+* [SpringBoot 启动流程（三）：准备IOC容器](docs/Spring全家桶/SpringBoot源码解析/SpringBoot启动流程（三）：准备IOC容器.md)
+* [springboot 启动流程（四）：启动IOC容器](docs/Spring全家桶/SpringBoot源码解析/SpringBoot启动流程（四）：启动IOC容器.md)
+* [springboot 启动流程（五）：完成启动](docs/Spring全家桶/SpringBoot源码解析/SpringBoot启动流程（五）：完成启动.md)
+* [springboot 启动流程（六）：启动流程总结](docs/Spring全家桶/SpringBoot源码解析/SpringBoot启动流程（六）：启动流程总结.md)
+
+* [springboot 自动装配（一）：加载自动装配类](docs/Spring全家桶/SpringBoot源码解析/SpringBoot自动装配（一）：加载自动装配类.md)
+* [springboot 自动装配（二）：条件注解](docs/Spring全家桶/SpringBoot源码解析/SpringBoot自动装配（二）：条件注解.md)
+* [springboot 自动装配（三）：自动装配顺序](docs/Spring全家桶/SpringBoot源码解析/SpringBoot自动装配（三）：自动装配顺序.md)
+
+## SpringCloud
+* [SpringCloud概述](docs/Spring全家桶/SpringCloud/SpringCloud概述.md)
+* [Spring Cloud Config](docs/Spring全家桶/SpringCloud/SpringCloudConfig.md)
+* [Spring Cloud Consul](docs/Spring全家桶/SpringCloud/SpringCloudConsul.md)
+* [Spring Cloud Eureka](docs/Spring全家桶/SpringCloud/SpringCloudEureka.md)
+* [Spring Cloud Gateway](docs/Spring全家桶/SpringCloud/SpringCloudGateway.md)
+* [Spring Cloud Hystrix](docs/Spring全家桶/SpringCloud/SpringCloudHystrix.md)
+* [Spring Cloud LoadBalancer](docs/Spring全家桶/SpringCloud/SpringCloudLoadBalancer.md)
+* [Spring Cloud OpenFeign](docs/Spring全家桶/SpringCloud/SpringCloudOpenFeign.md)
+* [Spring Cloud Ribbon](docs/Spring全家桶/SpringCloud/SpringCloudRibbon.md)
+* [Spring Cloud Sleuth](docs/Spring全家桶/SpringCloud/SpringCloudSleuth.md)
+* [Spring Cloud Zuul](docs/Spring全家桶/SpringCloud/SpringCloudZuul.md)
+
+## SpringCloud 源码分析
+* [Spring Cloud Config源码分析](docs/Spring全家桶/SpringCloud源码分析/SpringCloudConfig源码分析.md)
+* [Spring Cloud Eureka源码分析](docs/Spring全家桶/SpringCloud源码分析/SpringCloudEureka源码分析.md)
+* [Spring Cloud Gateway源码分析](docs/Spring全家桶/SpringCloud源码分析/SpringCloudGateway源码分析.md)
+* [Spring Cloud Hystrix源码分析](docs/Spring全家桶/SpringCloud源码分析/SpringCloudHystrix源码分析.md)
+* [Spring Cloud LoadBalancer源码分析](docs/Spring全家桶/SpringCloud源码分析/SpringCloudLoadBalancer源码分析.md)
+* [Spring Cloud OpenFeign源码分析](docs/Spring全家桶/SpringCloud源码分析/SpringCloudOpenFeign源码分析.md)
+* [Spring Cloud Ribbon源码分析](docs/Spring全家桶/SpringCloud源码分析/SpringCloudRibbon源码分析.md)
+
+## SpringCloud Alibaba
+* [SpringCloud Alibaba概览](docs/Spring全家桶/SpringCloudAlibaba/SpringCloudAlibaba概览.md)
+* [SpringCloud Alibaba nacos](docs/Spring全家桶/SpringCloudAlibaba/SpringCloudAlibabaNacos.md)
+* [SpringCloud Alibaba RocketMQ](docs/Spring全家桶/SpringCloudAlibaba/SpringCloudAlibabaRocketMQ.md)
+* [SpringCloud Alibaba sentinel](docs/Spring全家桶/SpringCloudAlibaba/SpringCloudAlibabaSentinel.md)
+* [SpringCloud Alibaba skywalking](docs/Spring全家桶/SpringCloudAlibaba/SpringCloudAlibabaSkywalking.md)
+* [SpringCloud Alibaba seata](docs/Spring全家桶/SpringCloudAlibaba/SpringCloudAlibabaSeata.md)
+
+## SpringCloud Alibaba源码分析
+* [Spring Cloud Seata源码分析](docs/Spring全家桶/SpringCloudAlibaba源码分析/SpringCloudSeata源码分析.md)
+* [Spring Cloud Sentinel源码分析](docs/Spring全家桶/SpringCloudAlibaba源码分析/SpringCloudSentinel源码分析.md)
+* [SpringCloudAlibaba nacos源码分析：概览](docs/Spring全家桶/SpringCloudAlibaba源码分析/SpringCloudAlibabaNacos源码分析：概览.md)
+* [SpringCloudAlibaba nacos源码分析：服务发现](docs/Spring全家桶/SpringCloudAlibaba源码分析/SpringCloudAlibabaNacos源码分析：服务发现.md)
+* [SpringCloudAlibaba nacos源码分析：服务注册](docs/Spring全家桶/SpringCloudAlibaba源码分析/SpringCloudAlibabaNacos源码分析：服务注册.md)
+* [SpringCloudAlibaba nacos源码分析：配置中心](docs/Spring全家桶/SpringCloudAlibaba源码分析/SpringCloudAlibabaNacos源码分析：配置中心.md)
+* [Spring Cloud RocketMQ源码分析](docs/Spring全家桶/SpringCloudAlibaba源码分析/SpringCloudRocketMQ源码分析.md)
+
+# 设计模式
+
+* [设计模式学习总结](docs/Java/design-parttern/设计模式学习总结.md)
+* [初探Java设计模式：创建型模式（工厂，单例等）.md](docs/Java/design-parttern/初探Java设计模式：创建型模式（工厂，单例等）.md)
+* [初探Java设计模式：结构型模式（代理模式，适配器模式等）.md](docs/Java/design-parttern/初探Java设计模式：结构型模式（代理模式，适配器模式等）.md)
+* [初探Java设计模式：行为型模式（策略，观察者等）.md](docs/Java/design-parttern/初探Java设计模式：行为型模式（策略，观察者等）.md)
+* [初探Java设计模式：JDK中的设计模式.md](docs/Java/design-parttern/初探Java设计模式：JDK中的设计模式.md)
+* [初探Java设计模式：Spring涉及到的种设计模式.md](docs/Java/design-parttern/初探Java设计模式：Spring涉及到的种设计模式.md)
+
+
+# 计算机基础
+
+## 计算机网络
 todo
 
 
-### 操作系统
+## 操作系统
 todo
 
-#### Linux相关
+## Linux相关
 todo
 
 
-### 数据结构与算法
+## 数据结构与算法
 todo
 
-#### 数据结构
+## 数据结构
 todo
 
-#### 算法
+## 算法
 todo
 
-## 数据库
+# 数据库
 todo
 
-### MySQL
+## MySQL
 * [Mysql原理与实践总结](docs/database/Mysql原理与实践总结.md)
-* [重新学习Mysql数据库1：无废话MySQL入门](docs/database/重新学习Mysql数据库1：无废话MySQL入门.md)
-* [重新学习Mysql数据库2：『浅入浅出』MySQL 和 InnoDB](docs/database/重新学习Mysql数据库2：%20『浅入浅出』MySQL%20和%20InnoDB.md)
-* [重新学习Mysql数据库3：Mysql存储引擎与数据存储原理](docs/database/重新学习Mysql数据库3：Mysql存储引擎与数据存储原理.md)
-* [重新学习Mysql数据库4：Mysql索引实现原理和相关数据结构算法](docs/database/重新学习Mysql数据库4：Mysql索引实现原理和相关数据结构算法.md)
-* [重新学习Mysql数据库5：根据MySQL索引原理进行分析与优化](docs/database/重新学习Mysql数据库5：根据MySQL索引原理进行分析与优化.md)
-* [重新学习MySQL数据库6：浅谈MySQL的中事务与锁](docs/database/重新学习MySQL数据库6：浅谈MySQL的中事务与锁.md) 
-* [重新学习Mysql数据库7：详解MyIsam与InnoDB引擎的锁实现](docs/database/重新学习Mysql数据库7：详解MyIsam与InnoDB引擎的锁实现.md) 
-* [重新学习Mysql数据库8：MySQL的事务隔离级别实战](docs/database/重新学习Mysql数据库8：MySQL的事务隔离级别实战.md)
-* [重新学习MySQL数据库9：Innodb中的事务隔离级别和锁的关系](docs/database/重新学习MySQL数据库9：Innodb中的事务隔离级别和锁的关系.md) 
-* [重新学习MySQL数据库10：MySQL里的那些日志们](docs/database/重新学习MySQL数据库10：MySQL里的那些日志们.md) 
-* [重新学习MySQL数据库11：以Java的视角来聊聊SQL注入](docs/database/重新学习MySQL数据库11：以Java的视角来聊聊SQL注入.md) 
-* [重新学习MySQL数据库12：从实践sql语句优化开始](docs/database/重新学习MySQL数据库12：从实践sql语句优化开始.md) 
-* [重新学习Mysql数据库13：Mysql主从复制，读写分离，分表分库策略与实践](docs/database/重新学习Mysql数据13：Mysql主从复制，读写分离，分表分库策略与实践.md)
-
-
-## 缓存
-
-### Redis
+* [重新学习Mysql数据库：无废话MySQL入门](docs/database/重新学习MySQL数据库：无废话MySQL入门.md)
+* [重新学习Mysql数据库：『浅入浅出』MySQL和InnoDB](docs/database/重新学习MySQL数据库：『浅入浅出』MySQL和InnoDB.md)
+* [重新学习Mysql数据库：Mysql存储引擎与数据存储原理](docs/database/重新学习MySQL数据库：Mysql存储引擎与数据存储原理.md)
+* [重新学习Mysql数据库：Mysql索引实现原理和相关数据结构算法](docs/database/重新学习MySQL数据库：Mysql索引实现原理和相关数据结构算法.md)
+* [重新学习Mysql数据库：根据MySQL索引原理进行分析与优化](docs/database/重新学习MySQL数据库：根据MySQL索引原理进行分析与优化.md)
+* [重新学习MySQL数据库：浅谈MySQL的中事务与锁](docs/database/重新学习MySQL数据库：浅谈MySQL的中事务与锁.md) 
+* [重新学习Mysql数据库：详解MyIsam与InnoDB引擎的锁实现](docs/database/重新学习MySQL数据库：详解MyIsam与InnoDB引擎的锁实现.md) 
+* [重新学习Mysql数据库：MySQL的事务隔离级别实战](docs/database/重新学习MySQL数据库：MySQL的事务隔离级别实战.md)
+* [重新学习MySQL数据库：Innodb中的事务隔离级别和锁的关系](docs/database/重新学习MySQL数据库：Innodb中的事务隔离级别和锁的关系.md) 
+* [重新学习MySQL数据库：MySQL里的那些日志们](docs/database/重新学习MySQL数据库：MySQL里的那些日志们.md) 
+* [重新学习MySQL数据库：以Java的视角来聊聊SQL注入](docs/database/重新学习MySQL数据库：以Java的视角来聊聊SQL注入.md) 
+* [重新学习MySQL数据库：从实践sql语句优化开始](docs/database/重新学习MySQL数据库：从实践sql语句优化开始.md) 
+* [重新学习Mysql数据库：Mysql主从复制，读写分离，分表分库策略与实践](docs/database/重新学习MySQL数据库：Mysql主从复制，读写分离，分表分库策略与实践.md)
+
+
+# 缓存
+
+## Redis
 * [Redis原理与实践总结](docs/cache/Redis原理与实践总结.md)
 * [探索Redis设计与实现开篇：什么是Redis](docs/cache/探索Redis设计与实现开篇：什么是Redis.md)
-* [探索Redis设计与实现1：Redis 的基础数据结构概览](docs/cache/探索Redis设计与实现1：Redis%20的基础数据结构概览.md)
-* [探索Redis设计与实现2：Redis内部数据结构详解——dict](docs/cache/探索Redis设计与实现2：Redis内部数据结构详解——dict.md)
-* [探索Redis设计与实现3：Redis内部数据结构详解——sds](docs/cache/探索Redis设计与实现3：Redis内部数据结构详解——sds.md)
-* [探索Redis设计与实现4：Redis内部数据结构详解——ziplist](docs/cache/探索Redis设计与实现4：Redis内部数据结构详解——ziplist.md)
-* [探索Redis设计与实现5：Redis内部数据结构详解——quicklist](docs/cache/探索Redis设计与实现5：Redis内部数据结构详解——quicklist.md)
-* [探索Redis设计与实现6：Redis内部数据结构详解——skiplist](docs/cache/探索Redis设计与实现6：Redis内部数据结构详解——skiplist.md)
-* [探索Redis设计与实现7：Redis内部数据结构详解——intset](docs/cache/探索Redis设计与实现7：Redis内部数据结构详解——intset.md)
-* [探索Redis设计与实现8：连接底层与表面的数据结构robj](docs/cache/探索Redis设计与实现8：连接底层与表面的数据结构robj.md)
-* [探索Redis设计与实现9：数据库redisDb与键过期删除策略](docs/cache/探索Redis设计与实现9：数据库redisDb与键过期删除策略.md)
-* [探索Redis设计与实现10：Redis的事件驱动模型与命令执行过程](docs/cache/探索Redis设计与实现10：Redis的事件驱动模型与命令执行过程.md)
-* [探索Redis设计与实现11：使用快照和AOF将Redis数据持久化到硬盘中](docs/cache/探索Redis设计与实现11：使用快照和AOF将Redis数据持久化到硬盘中.md)
-* [探索Redis设计与实现12：浅析Redis主从复制](docs/cache/探索Redis设计与实现12：浅析Redis主从复制.md)
-* [探索Redis设计与实现13：Redis集群机制及一个Redis架构演进实例](docs/cache/探索Redis设计与实现13：Redis集群机制及一个Redis架构演进实例.md)
-* [探索Redis设计与实现14：Redis事务浅析与ACID特性介绍](docs/cache/探索Redis设计与实现14：Redis事务浅析与ACID特性介绍.md)
-* [探索Redis设计与实现15：Redis分布式锁进化史 ](docs/cache/探索Redis设计与实现15：Redis分布式锁进化史.md )
-
-## 消息队列
-
-### Kafka
-
-## 大后端
-* [后端技术杂谈开篇：云计算，大数据与AI的故事](docs/big-backEnd/后端技术杂谈开篇：云计算，大数据与AI的故事.md)
-* [后端技术杂谈1：搜索引擎基础倒排索引](docs/big-backEnd/后端技术杂谈1：搜索引擎基础倒排索引.md)
-* [后端技术杂谈2：搜索引擎工作原理](docs/big-backEnd/后端技术杂谈2：搜索引擎工作原理.md)
-* [后端技术杂谈3：Lucene基础原理与实践](docs/big-backEnd/后端技术杂谈3：Lucene基础原理与实践.md)
-* [后端技术杂谈4：Elasticsearch与solr入门实践](docs/big-backEnd/后端技术杂谈4：Elasticsearch与solr入门实践.md)
-* [后端技术杂谈5：云计算的前世今生](docs/big-backEnd/后端技术杂谈5：云计算的前世今生.md)
-* [后端技术杂谈6：白话虚拟化技术](docs/big-backEnd/后端技术杂谈6：白话虚拟化技术.md )
-* [后端技术杂谈7：OpenStack的基石KVM](docs/big-backEnd/后端技术杂谈7：OpenStack的基石KVM.md)
-* [后端技术杂谈8：OpenStack架构设计](docs/big-backEnd/后端技术杂谈8：OpenStack架构设计.md)
-* [后端技术杂谈9：先搞懂Docker核心概念吧](docs/big-backEnd/后端技术杂谈9：先搞懂Docker核心概念吧.md)
-* [后端技术杂谈10：Docker 核心技术与实现原理](docs/big-backEnd/后端技术杂谈10：Docker%20核心技术与实现原理.md)
-* [后端技术杂谈11：十分钟理解Kubernetes核心概念](docs/big-backEnd/后端技术杂谈11：十分钟理解Kubernetes核心概念.md)
-* [后端技术杂谈12：捋一捋大数据研发的基本概念](docs/big-backEnd/后端技术杂谈12：捋一捋大数据研发的基本概念.md)
-
-## 分布式
-### 理论
-* [分布式系统理论基础开篇：从放弃到入门](docs/distrubuted/理论/分布式系统理论基础开篇：从放弃到入门.md)
-* [分布式系统理论基础1： 一致性、2PC和3PC ](docs/distrubuted/理论/分布式系统理论基础1：%20一致性、2PC和3PC.md)
-* [分布式系统理论基础2：CAP ](docs/distrubuted/理论/分布式系统理论基础2%20：CAP.md)
-* [分布式系统理论基础3： 时间、时钟和事件顺序](docs/distrubuted/理论/分布式系统理论基础3：%20时间、时钟和事件顺序.md)
-* [分布式系统理论基础4：Paxos](docs/distrubuted/理论/分布式系统理论基础4：Paxos.md)
-* [分布式系统理论基础5：选举、多数派和租约](docs/distrubuted/理论/分布式系统理论基础5：选举、多数派和租约.md)
-* [分布式系统理论基础6：Raft、Zab ](docs/distrubuted/理论/分布式系统理论基础6：Raft、Zab.md)
-* [分布式系统理论进阶7：Paxos变种和优化 ](docs/distrubuted/理论/分布式系统理论进阶7：Paxos变种和优化.md)
-* [分布式系统理论基础8：zookeeper分布式协调服务 ](docs/distrubuted/理论/分布式系统理论基础8：zookeeper分布式协调服务.md)
-
-### 技术
-* [搞懂分布式技术1：分布式系统的一些基本概念 ](docs/distrubuted/实战/搞懂分布式技术1：分布式系统的一些基本概念.md )
-* [搞懂分布式技术2：分布式一致性协议与Paxos，Raft算法](docs/distrubuted/实战/搞懂分布式技术2：分布式一致性协议与Paxos，Raft算法.md)
-* [搞懂分布式技术3：初探分布式协调服务zookeeper ](docs/distrubuted/实战/搞懂分布式技术3：初探分布式协调服务zookeeper.md )
-* [搞懂分布式技术4：ZAB协议概述与选主流程详解 ](docs/distrubuted/实战/搞懂分布式技术4：ZAB协议概述与选主流程详解.md )
-* [搞懂分布式技术5：Zookeeper的配置与集群管理实战](docs/distrubuted/实战/搞懂分布式技术5：Zookeeper的配置与集群管理实战.md)
-* [搞懂分布式技术6：Zookeeper典型应用场景及实践 ](docs/distrubuted/实战/搞懂分布式技术6：Zookeeper典型应用场景及实践.md )
-* [搞懂分布式技术7：负载均衡概念与主流方案](docs/distrubuted/实战/搞懂分布式技术7：负载均衡概念与主流方案.md)
-* [搞懂分布式技术8：负载均衡原理剖析 ](docs/distrubuted/实战/搞懂分布式技术8：负载均衡原理剖析.md )
-* [搞懂分布式技术9：Nginx负载均衡原理与实践 ](docs/distrubuted/实战/搞懂分布式技术9：Nginx负载均衡原理与实践.md)
-* [搞懂分布式技术10：LVS实现负载均衡的原理与实践 ](docs/distrubuted/实战/搞懂分布式技术10：LVS实现负载均衡的原理与实践.md )
-* [搞懂分布式技术11：分布式session解决方案与一致性hash](docs/distrubuted/实战/搞懂分布式技术11：分布式session解决方案与一致性hash.md)
-* [搞懂分布式技术12：分布式ID生成方案 ](docs/distrubuted/实战/搞懂分布式技术12：分布式ID生成方案.md )
-* [搞懂分布式技术13：缓存的那些事](docs/distrubuted/实战/搞懂分布式技术13：缓存的那些事.md)
-* [搞懂分布式技术14：Spring Boot使用注解集成Redis缓存](docs/distrubuted/实战/搞懂分布式技术14：Spring%20Boot使用注解集成Redis缓存.md)
-* [搞懂分布式技术15：缓存更新的套路 ](docs/distrubuted/实战/搞懂分布式技术15：缓存更新的套路.md )
-* [搞懂分布式技术16：浅谈分布式锁的几种方案 ](docs/distrubuted/实战/搞懂分布式技术16：浅谈分布式锁的几种方案.md )
-* [搞懂分布式技术17：浅析分布式事务 ](docs/distrubuted/实战/搞懂分布式技术17：浅析分布式事务.md )
-* [搞懂分布式技术18：分布式事务常用解决方案 ](docs/distrubuted/实战/搞懂分布式技术18：分布式事务常用解决方案.md )
-* [搞懂分布式技术19：使用RocketMQ事务消息解决分布式事务 ](docs/distrubuted/实战/搞懂分布式技术19：使用RocketMQ事务消息解决分布式事务.md )
-* [搞懂分布式技术20：消息队列因何而生](docs/distrubuted/实战/搞懂分布式技术20：消息队列因何而生.md)
-* [搞懂分布式技术21：浅谈分布式消息技术 Kafka ](docs/distrubuted/实战/搞懂分布式技术21：浅谈分布式消息技术%20Kafka.md )
-
-
-## 面试指南
+* [探索Redis设计与实现：Redis的基础数据结构概览](docs/cache/探索Redis设计与实现：Redis的基础数据结构概览.md)
+* [探索Redis设计与实现：Redis内部数据结构详解——dict](docs/cache/探索Redis设计与实现：Redis内部数据结构详解——dict.md)
+* [探索Redis设计与实现：Redis内部数据结构详解——sds](docs/cache/探索Redis设计与实现：Redis内部数据结构详解——sds.md)
+* [探索Redis设计与实现：Redis内部数据结构详解——ziplist](docs/cache/探索Redis设计与实现：Redis内部数据结构详解——ziplist.md)
+* [探索Redis设计与实现：Redis内部数据结构详解——quicklist](docs/cache/探索Redis设计与实现：Redis内部数据结构详解——quicklist.md)
+* [探索Redis设计与实现：Redis内部数据结构详解——skiplist](docs/cache/探索Redis设计与实现：Redis内部数据结构详解——skiplist.md)
+* [探索Redis设计与实现：Redis内部数据结构详解——intset](docs/cache/探索Redis设计与实现：Redis内部数据结构详解——intset.md)
+* [探索Redis设计与实现：连接底层与表面的数据结构robj](docs/cache/探索Redis设计与实现：连接底层与表面的数据结构robj.md)
+* [探索Redis设计与实现：数据库redisDb与键过期删除策略](docs/cache/探索Redis设计与实现：数据库redisDb与键过期删除策略.md)
+* [探索Redis设计与实现：Redis的事件驱动模型与命令执行过程](docs/cache/探索Redis设计与实现：Redis的事件驱动模型与命令执行过程.md)
+* [探索Redis设计与实现：使用快照和AOF将Redis数据持久化到硬盘中](docs/cache/探索Redis设计与实现：使用快照和AOF将Redis数据持久化到硬盘中.md)
+* [探索Redis设计与实现：浅析Redis主从复制](docs/cache/探索Redis设计与实现：浅析Redis主从复制.md)
+* [探索Redis设计与实现：Redis集群机制及一个Redis架构演进实例](docs/cache/探索Redis设计与实现：Redis集群机制及一个Redis架构演进实例.md)
+* [探索Redis设计与实现：Redis事务浅析与ACID特性介绍](docs/cache/探索Redis设计与实现：Redis事务浅析与ACID特性介绍.md)
+* [探索Redis设计与实现：Redis分布式锁进化史 ](docs/cache/探索Redis设计与实现：Redis分布式锁进化史.md )
+
+# 消息队列
+
+## Kafka
+* [消息队列kafka详解：Kafka快速上手（Java版）](docs/mq/kafka/消息队列kafka详解：Kafka快速上手（Java版）.md)
+* [消息队列kafka详解：Kafka一条消息存到broker的过程](docs/mq/kafka/消息队列kafka详解：Kafka一条消息存到broker的过程.md)
+* [消息队列kafka详解：消息队列kafka详解：Kafka介绍](docs/mq/kafka/消息队列kafka详解：Kafka介绍.md)
+* [消息队列kafka详解：Kafka原理分析总结篇](docs/mq/kafka/消息队列kafka详解：Kafka原理分析总结篇.md)
+* [消息队列kafka详解：Kafka常见命令及配置总结](docs/mq/kafka/消息队列kafka详解：Kafka常见命令及配置总结.md)
+* [消息队列kafka详解：Kafka架构介绍](docs/mq/kafka/消息队列kafka详解：Kafka架构介绍.md)
+* [消息队列kafka详解：Kafka的集群工作原理](docs/mq/kafka/消息队列kafka详解：Kafka的集群工作原理.md)
+* [消息队列kafka详解：Kafka重要知识点+面试题大全](docs/mq/kafka/消息队列kafka详解：Kafka重要知识点+面试题大全.md)
+* [消息队列kafka详解：如何实现延迟队列](docs/mq/kafka/消息队列kafka详解：如何实现延迟队列.md)
+* [消息队列kafka详解：如何实现死信队列](docs/mq/kafka/消息队列kafka详解：如何实现死信队列.md)
+
+## RocketMQ
+* [RocketMQ系列：事务消息（最终一致性）](docs/mq/RocketMQ/RocketMQ系列：事务消息（最终一致性）.md)
+* [RocketMQ系列：基本概念](docs/mq/RocketMQ/RocketMQ系列：基本概念.md)
+* [RocketMQ系列：广播与延迟消息](docs/mq/RocketMQ/RocketMQ系列：广播与延迟消息.md)
+* [RocketMQ系列：批量发送与过滤](docs/mq/RocketMQ/RocketMQ系列：批量发送与过滤.md)
+* [RocketMQ系列：消息的生产与消费](docs/mq/RocketMQ/RocketMQ系列：消息的生产与消费.md)
+* [RocketMQ系列：环境搭建](docs/mq/RocketMQ/RocketMQ系列：环境搭建.md)
+* [RocketMQ系列：顺序消费](docs/mq/RocketMQ/RocketMQ系列：顺序消费.md)
+
+# 大后端
+* [后端技术杂谈开篇：云计算，大数据与AI的故事](docs/backend/后端技术杂谈开篇：云计算，大数据与AI的故事.md)
+* [后端技术杂谈：搜索引擎基础倒排索引](docs/backend/后端技术杂谈：搜索引擎基础倒排索引.md)
+* [后端技术杂谈：搜索引擎工作原理](docs/backend/后端技术杂谈：搜索引擎工作原理.md)
+* [后端技术杂谈：Lucene基础原理与实践](docs/backend/后端技术杂谈：Lucene基础原理与实践.md)
+* [后端技术杂谈：Elasticsearch与solr入门实践](docs/backend/后端技术杂谈：Elasticsearch与solr入门实践.md)
+* [后端技术杂谈：云计算的前世今生](docs/backend/后端技术杂谈：云计算的前世今生.md)
+* [后端技术杂谈：白话虚拟化技术](docs/backend/后端技术杂谈：白话虚拟化技术.md )
+* [后端技术杂谈：OpenStack的基石KVM](docs/backend/后端技术杂谈：OpenStack的基石KVM.md)
+* [后端技术杂谈：OpenStack架构设计](docs/backend/后端技术杂谈：OpenStack架构设计.md)
+* [后端技术杂谈：先搞懂Docker核心概念吧](docs/backend/后端技术杂谈：先搞懂Docker核心概念吧.md)
+* [后端技术杂谈：Docker 核心技术与实现原理](docs/backend/后端技术杂谈：Docker%核心技术与实现原理.md)
+* [后端技术杂谈：十分钟理解Kubernetes核心概念](docs/backend/后端技术杂谈：十分钟理解Kubernetes核心概念.md)
+* [后端技术杂谈：捋一捋大数据研发的基本概念](docs/backend/后端技术杂谈：捋一捋大数据研发的基本概念.md)
+
+# 分布式
+## 分布式理论
+* [分布式系统理论基础：一致性PC和PC ](docs/distributed/basic/分布式系统理论基础：一致性PC和PC.md)
+* [分布式系统理论基础：CAP ](docs/distributed/basic/分布式系统理论基础：CAP.md)
+* [分布式系统理论基础：时间时钟和事件顺序](docs/distributed/basic/分布式系统理论基础：时间时钟和事件顺序.md)
+* [分布式系统理论基础：Paxos](docs/distributed/basic/分布式系统理论基础：Paxos.md)
+* [分布式系统理论基础：选举多数派和租约](docs/distributed/basic/分布式系统理论基础：选举多数派和租约.md)
+* [分布式系统理论基础：RaftZab ](docs/distributed/basic/分布式系统理论基础：RaftZab.md)
+* [分布式系统理论进阶：Paxos变种和优化 ](docs/distributed/basic/分布式系统理论进阶：Paxos变种和优化.md)
+* [分布式系统理论基础：zookeeper分布式协调服务 ](docs/distributed/basic/分布式系统理论基础：zookeeper分布式协调服务.md)
+* [分布式理论总结](docs/distributed/分布式技术实践总结.md)
+
+## 分布式技术
+* [搞懂分布式技术：分布式系统的一些基本概念](docs/distributed/practice/搞懂分布式技术：分布式系统的一些基本概念.md )
+* [搞懂分布式技术：分布式一致性协议与Paxos，Raft算法](docs/distributed/practice/搞懂分布式技术：分布式一致性协议与Paxos，Raft算法.md)
+* [搞懂分布式技术：初探分布式协调服务zookeeper](docs/distributed/practice/搞懂分布式技术：初探分布式协调服务zookeeper.md )
+* [搞懂分布式技术：ZAB协议概述与选主流程详解](docs/distributed/practice/搞懂分布式技术：ZAB协议概述与选主流程详解.md )
+* [搞懂分布式技术：Zookeeper的配置与集群管理实战](docs/distributed/practice/搞懂分布式技术：Zookeeper的配置与集群管理实战.md)
+* [搞懂分布式技术：Zookeeper典型应用场景及实践](docs/distributed/practice/搞懂分布式技术：Zookeeper典型应用场景及实践.md )
+* [搞懂分布式技术：LVS实现负载均衡的原理与实践 ](docs/distributed/practice/搞懂分布式技术：LVS实现负载均衡的原理与实践.md )
+* [搞懂分布式技术：分布式session解决方案与一致性hash](docs/distributed/practice/搞懂分布式技术：分布式session解决方案与一致性hash.md)
+* [搞懂分布式技术：分布式ID生成方案 ](docs/distributed/practice/搞懂分布式技术：分布式ID生成方案.md )
+* [搞懂分布式技术：缓存的那些事](docs/distributed/practice/搞懂分布式技术：缓存的那些事.md)
+* [搞懂分布式技术：SpringBoot使用注解集成Redis缓存](docs/distributed/practice/搞懂分布式技术：SpringBoot使用注解集成Redis缓存.md)
+* [搞懂分布式技术：缓存更新的套路 ](docs/distributed/practice/搞懂分布式技术：缓存更新的套路.md )
+* [搞懂分布式技术：浅谈分布式锁的几种方案 ](docs/distributed/practice/搞懂分布式技术：浅谈分布式锁的几种方案.md )
+* [搞懂分布式技术：浅析分布式事务](docs/distributed/practice/搞懂分布式技术：浅析分布式事务.md )
+* [搞懂分布式技术：分布式事务常用解决方案 ](docs/distributed/practice/搞懂分布式技术：分布式事务常用解决方案.md )
+* [搞懂分布式技术：使用RocketMQ事务消息解决分布式事务 ](docs/distributed/practice/搞懂分布式技术：使用RocketMQ事务消息解决分布式事务.md )
+* [搞懂分布式技术：消息队列因何而生](docs/distributed/practice/搞懂分布式技术：消息队列因何而生.md)
+* [搞懂分布式技术：浅谈分布式消息技术Kafka](docs/distributed/practice/搞懂分布式技术：浅谈分布式消息技术Kafka.md )
+* [分布式技术实践总结](docs/distributed/分布式理论总结.md)
+
+# 面试指南
 
 todo
-### 校招指南
+## 校招指南
 todo
 
-### 面经
+## 面经
 todo
 
-## 工具
+# 工具
 todo
 
-## 资料
+# 资料
 todo
 
-### 书单
+## 书单
 todo
 
-## 待办
+# 待办
 springboot和springcloud
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师技术学习资料:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-**Java进阶架构师资料:** 关注公众号后回复 **”架构师“** 即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：程序员黄小斜
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:** 关注微信公众号【程序员黄小斜】后回复 **"原创电子书"** 即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号【程序员黄小斜】后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
+# 微信公众号
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
+## Java技术江湖
+如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/Javatutorial.jpeg)
diff --git a/_config.yml b/_config.yml
deleted file mode 100644
index 34ac42a..0000000
--- a/_config.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-theme: jekyll-theme-cayman
-
diff --git a/backup.md b/backup.md
deleted file mode 100644
index f2fb131..0000000
--- a/backup.md
+++ /dev/null
@@ -1,81 +0,0 @@
-## 声明
-
-**关于仓库**
-
-本仓库是笔者在准备 2018 年秋招复习过程中的学习总结，内容以Java后端的知识总结为主，其中大部分都是笔者根据自己的理解加上个人博客总结而来的。
-
-其中有少数内容可能会包含瞎XX说，语句不通顺，内容不全面等各方面问题，还请见谅。
-
-每篇文章都会有笔者更加详细的一系列博客可供参考，这些文章也被我发表在CSDN技术博客上，整理成博客专栏，欢迎查看━(*｀∀´*)ノ亻!
-
-详细内容请见我的CSDN技术博客：https://blog.csdn.net/a724888
-
-**更多校招干货和技术文章请关注我的公众号：黄小斜**
-
-|               Ⅰ                |                    Ⅱ                     |             Ⅲ              |                     Ⅳ                      |              Ⅴ               |                  Ⅵ                  |                      Ⅶ                      |                  Ⅷ                   |                       Ⅸ                        |
-| :----------------------------: | :--------------------------------------: | :------------------------: | :----------------------------------------: | :--------------------------: | :---------------------------------: | :-----------------------------------------: | :----------------------------------: | :--------------------------------------------: |
-| 算法[:pencil2:](#算法-pencil2) | 操作系统[:computer:](#操作系统-computer) | 网络[:cloud:](#网络-cloud) | 数据库[:floppy_disk:](#数据库-floppy_disk) | Java[:couple:](#Java-couple) | JavaWeb [:coffee:](#JavaWeb-coffee) | 分布式 [:sweat_drops:](#分布式-sweat_drops) | 设计模式[:hammer:](#设计模式-hammer) | Hadoop[:speak_no_evil:](#Hadoop-speak_no_evil) |
-
-## 算法 :pencil2:
-
-> [剑指offer算法总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/%E5%89%91%E6%8C%87offer.md)
-
-> [LeetCode刷题指南](https://github.com/h2pl/Java-Tutorial/blob/master/md/LeetCode%E5%88%B7%E9%A2%98%E6%8C%87%E5%8D%97.md)
-
-## 操作系统 :computer:
-
-> [操作系统学习总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E6%80%BB%E7%BB%93.md)
-
-> [Linux内核与基础命令学习总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/Linux%E5%86%85%E6%A0%B8%E4%B8%8E%E5%9F%BA%E7%A1%80%E5%91%BD%E4%BB%A4%E5%AD%A6%E4%B9%A0%E6%80%BB%E7%BB%93.md)
-
-## 网络 :cloud:
-
-> [计算机网络学习总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C%E5%AD%A6%E4%B9%A0%E6%80%BB%E7%BB%93.md)
-
-## 数据库 :floppy_disk:
-
-> [Mysql原理与实践总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/Mysql%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5%E6%80%BB%E7%BB%93.md)
-
-> [Redis原理与实践总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/Redis%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5%E6%80%BB%E7%BB%93.md)
-
-## Java :couple:
-
-> [Java核心技术总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/Java%E6%A0%B8%E5%BF%83%E6%8A%80%E6%9C%AF%E6%80%BB%E7%BB%93.md)
-
-> [Java集合类总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/Java%E9%9B%86%E5%90%88%E7%B1%BB%E6%80%BB%E7%BB%93.md)
-
-> [Java并发技术总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/Java%E5%B9%B6%E5%8F%91%E6%80%BB%E7%BB%93.md)
-
-> [JVM原理学习总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/JVM%E6%80%BB%E7%BB%93.md)
-
-> [Java网络与NIO总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/Java%E7%BD%91%E7%BB%9C%E4%B8%8ENIO%E6%80%BB%E7%BB%93.md)
-
-## JavaWeb :coffee: 
-
-> [JavaWeb技术学习总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/JavaWeb%E6%8A%80%E6%9C%AF%E6%80%BB%E7%BB%93.md)
-
-> [Spring与SpringMVC源码解析](https://github.com/h2pl/Java-Tutorial/blob/master/md/Spring%E4%B8%8ESpringMVC%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90%E6%80%BB%E7%BB%93.md)
-
-## 分布式 :sweat_drops:
-
-> [分布式理论学习总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/%E5%88%86%E5%B8%83%E5%BC%8F%E7%90%86%E8%AE%BA%E6%80%BB%E7%BB%93.md)
-
-> [分布式技术学习总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/%E5%88%86%E5%B8%83%E5%BC%8F%E6%8A%80%E6%9C%AF%E5%AE%9E%E8%B7%B5%E6%80%BB%E7%BB%93.md)
-
-## 设计模式 :hammer:
-> [设计模式学习总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E5%AD%A6%E4%B9%A0%E6%80%BB%E7%BB%93.md)
-
-## Hadoop :speak_no_evil:
-
-> [Hadoop生态学习总结](https://github.com/h2pl/Java-Tutorial/blob/master/md/Hadoop%E7%94%9F%E6%80%81%E6%80%BB%E7%BB%93.md)
-
-</br>
-
-**关于转载**
-
-转载的时候请注明一下出处就行啦。
-
-另外我这个仓库的格式模仿的是@CyC2018 大佬的仓库
-
-并且其中一篇LeetCode刷题指南也是fork这位大佬而来的。我只是自己刷了一遍然后稍微加了一些解析，站在大佬肩膀上。
-
diff --git "a/docs/java/jvm/JVM\346\200\273\347\273\223.md" "b/docs/Java/JVM/JVM\346\200\273\347\273\223.md"
similarity index 86%
rename from "docs/java/jvm/JVM\346\200\273\347\273\223.md"
rename to "docs/Java/JVM/JVM\346\200\273\347\273\223.md"
index 2762768..60b89e6 100644
--- "a/docs/java/jvm/JVM\346\200\273\347\273\223.md"
+++ "b/docs/Java/JVM/JVM\346\200\273\347\273\223.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [JVM介绍和源码](#jvm介绍和源码)
   * [JVM内存模型](#jvm内存模型)
@@ -11,9 +11,7 @@
   * [编译期优化和运行期优化](#编译期优化和运行期优化)
   * [JVM的垃圾回收](#jvm的垃圾回收)
   * [JVM的锁优化](#jvm的锁优化)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 ---
@@ -153,20 +151,4 @@ g1收集器和cms的收集方式类似，但是g1将堆内存划分成了大小
 
 在Java并发中讲述了synchronized重量级锁以及锁优化的方法，包括轻量级锁，偏向锁，自旋锁等。详细内容可以参考我的专栏：Java并发技术指南
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232GC\350\260\203\344\274\230\346\200\235\350\267\257\344\270\216\345\270\270\347\224\250\345\267\245\345\205\267.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232GC\350\260\203\344\274\230\346\200\235\350\267\257\344\270\216\345\270\270\347\224\250\345\267\245\345\205\267.md"
new file mode 100644
index 0000000..ceda305
--- /dev/null
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232GC\350\260\203\344\274\230\346\200\235\350\267\257\344\270\216\345\270\270\347\224\250\345\267\245\345\205\267.md"
@@ -0,0 +1,838 @@
+# 目录
+
+* [核心概念(Core Concepts)](#核心概念core-concepts)
+  * [Latency(延迟)](#latency延迟)
+  * [Throughput(吞吐量)](#throughput吞吐量)
+  * [Capacity(系统容量)](#capacity系统容量)
+* [相关示例](#相关示例)
+  * [Tuning for Latency(调优延迟指标)](#tuning-for-latency调优延迟指标)
+  * [Tuning for Throughput(吞吐量调优)](#tuning-for-throughput吞吐量调优)
+  * [Tuning for Capacity(调优系统容量)](#tuning-for-capacity调优系统容量)
+  * [6\. GC 调优(工具篇) - GC参考手册](#6-gc-调优工具篇---gc参考手册)
+  * [JMX API](#jmx-api)
+  * [JVisualVM](#jvisualvm)
+  * [jstat](#jstat)
+  * [GC日志(GC logs)](#gc日志gc-logs)
+  * [GCViewer](#gcviewer)
+  * [分析器(Profilers)](#分析器profilers)
+    * [hprof](#hprof)
+    * [Java VisualVM](#java-visualvm)
+    * [AProf](#aprof)
+  * [参考文章](#参考文章)
+
+
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+文章首发于我的个人博客：
+> www.how2playlife.com
+
+本文是微信公众号【Java技术江湖】的《深入理解JVM虚拟机》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+该系列博文会告诉你如何从入门到进阶，一步步地学习JVM基础知识，并上手进行JVM调优实战，JVM是每一个Java工程师必须要学习和理解的知识点，你必须要掌握其实现原理，才能更完整地了解整个Java技术体系，形成自己的知识框架。为了更好地总结和检验你的学习成果，本系列文章也会提供每个知识点对应的面试题以及参考答案。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+<!-- more -->
+
+> **说明**:
+>
+> **Capacity**: 性能,能力,系统容量; 文中翻译为”**系统容量**“; 意为硬件配置。
+
+您应该已经阅读了前面的章节:
+
+1.  垃圾收集简介 - GC参考手册
+2.  Java中的垃圾收集 - GC参考手册
+3.  GC 算法(基础篇) - GC参考手册
+4.  GC 算法(实现篇) - GC参考手册
+
+GC调优(Tuning Garbage Collection)和其他性能调优是同样的原理。初学者可能会被 200 多个 GC参数弄得一头雾水, 然后随便调整几个来试试结果,又或者修改几行代码来测试。其实只要参照下面的步骤，就能保证你的调优方向正确:
+
+1.  列出性能调优指标(State your performance goals)
+2.  执行测试(Run tests)
+3.  检查结果(Measure the results)
+4.  与目标进行对比(Compare the results with the goals)
+5.  如果达不到指标, 修改配置参数, 然后继续测试(go back to running tests)
+
+第一步, 我们需要做的事情就是: 制定明确的GC性能指标。对所有性能监控和管理来说, 有三个维度是通用的:
+
+*   Latency(延迟)
+*   Throughput(吞吐量)
+*   Capacity(系统容量)
+
+我们先讲解基本概念,然后再演示如何使用这些指标。如果您对 延迟、吞吐量和系统容量等概念很熟悉, 可以跳过这一小节。
+
+### 核心概念(Core Concepts)
+
+我们先来看一家工厂的装配流水线。工人在流水线将现成的组件按顺序拼接,组装成自行车。通过实地观测, 我们发现从组件进入生产线，到另一端组装成自行车需要4小时。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404224347.png)
+继续观察,我们还发现,此后每分钟就有1辆自行车完成组装, 每天24小时,一直如此。将这个模型简化, 并忽略维护窗口期后得出结论：**这条流水线每小时可以组装60辆自行车**。
+
+> **说明**: 时间窗口/窗口期，请类比车站卖票的窗口，是一段规定/限定做某件事的时间段。
+
+通过这两种测量方法, 就知道了生产线的相关性能信息：**延迟**与**吞吐量**:
+
+*   生产线的延迟:**4小时**
+*   生产线的吞吐量:**60辆/小时**
+
+请注意, 衡量延迟的时间单位根据具体需要而确定 —— 从纳秒(nanosecond)到几千年(millennia)都有可能。系统的吞吐量是每个单位时间内完成的操作。操作(Operations)一般是特定系统相关的东西。在本例中,选择的时间单位是小时, 操作就是对自行车的组装。
+
+掌握了延迟和吞吐量两个概念之后, 让我们对这个工厂来进行实际的调优。自行车的需求在一段时间内都很稳定, 生产线组装自行车有四个小时延迟, 而吞吐量在几个月以来都很稳定: 60辆/小时。假设某个销售团队突然业绩暴涨, 对自行车的需求增加了1倍。客户每天需要的自行车不再是 60 * 24 = 1440辆, 而是 2*1440 = 2880辆/天。老板对工厂的产能不满意，想要做些调整以提升产能。
+
+看起来总经理很容易得出正确的判断, 系统的延迟没法子进行处理 —— 他关注的是每天的自行车生产总量。得出这个结论以后, 假若工厂资金充足, 那么应该立即采取措施, 改善吞吐量以增加产能。
+
+我们很快会看到, 这家工厂有两条相同的生产线。每条生产线一分钟可以组装一辆成品自行车。 可以想象，每天生产的自行车数量会增加一倍。达到 2880辆/天。要注意的是, 不需要减少自行车的装配时间 —— 从开始到结束依然需要 4 小时。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404224359.png)
+
+巧合的是，这样进行的性能优化,同时增加了吞吐量和产能。一般来说，我们会先测量当前的系统性能, 再设定新目标, 只优化系统的某个方面来满足性能指标。
+
+在这里做了一个很重要的决定 —— 要增加吞吐量,而不是减小延迟。在增加吞吐量的同时, 也需要增加系统容量。比起原来的情况, 现在需要两条流水线来生产出所需的自行车。在这种情况下, 增加系统的吞吐量并不是免费的, 需要水平扩展, 以满足增加的吞吐量需求。
+
+在处理性能问题时, 应该考虑到还有另一种看似不相关的解决办法。假如生产线的延迟从1分钟降低为30秒,那么吞吐量同样可以增长 1 倍。
+
+或者是降低延迟, 或者是客户非常有钱。软件工程里有一种相似的说法 —— 每个性能问题背后,总有两种不同的解决办法。 可以用更多的机器, 或者是花精力来改善性能低下的代码。
+
+#### Latency(延迟)
+
+GC的延迟指标由一般的延迟需求决定。延迟指标通常如下所述:
+
+*   所有交易必须在10秒内得到响应
+*   90%的订单付款操作必须在3秒以内处理完成
+*   推荐商品必须在 100 ms 内展示到用户面前
+
+面对这类性能指标时, 需要确保在交易过程中, GC暂停不能占用太多时间，否则就满足不了指标。“不能占用太多” 的意思需要视具体情况而定, 还要考虑到其他因素, 比如外部数据源的交互时间(round-trips), 锁竞争(lock contention), 以及其他的安全点等等。
+
+假设性能需求为:`90%`的交易要在`1000ms`以内完成, 每次交易最长不能超过`10秒`。 根据经验, 假设GC暂停时间比例不能超过10%。 也就是说, 90%的GC暂停必须在`100ms`内结束, 也不能有超过`1000ms`的GC暂停。为简单起见, 我们忽略在同一次交易过程中发生多次GC停顿的可能性。
+
+有了正式的需求,下一步就是检查暂停时间。有许多工具可以使用, 在接下来的6\. GC 调优(工具篇)
+
+
+
+```
+2015-06-04T13:34:16.974-0200: 2.578: [Full GC (Ergonomics)
+        [PSYoungGen: 93677K->70109K(254976K)] 
+        [ParOldGen: 499597K->511230K(761856K)] 
+        593275K->581339K(1016832K),
+        [Metaspace: 2936K->2936K(1056768K)]
+    , 0.0713174 secs]
+    [Times: user=0.21 sys=0.02, real=0.07 secs
+```
+
+
+
+这表示一次GC暂停, 在`2015-06-04T13:34:16`这个时刻触发. 对应于JVM启动之后的`2,578 ms`。
+
+此事件将应用线程暂停了`0.0713174`秒。虽然花费的总时间为 210 ms, 但因为是多核CPU机器, 所以最重要的数字是应用线程被暂停的总时间, 这里使用的是并行GC, 所以暂停时间大约为`70ms`。 这次GC的暂停时间小于`100ms`的阈值，满足需求。
+
+继续分析, 从所有GC日志中提取出暂停相关的数据, 汇总之后就可以得知是否满足需求。
+
+#### Throughput(吞吐量)
+
+吞吐量和延迟指标有很大区别。当然两者都是根据一般吞吐量需求而得出的。一般吞吐量需求(Generic requirements for throughput) 类似这样:
+
+*   解决方案每天必须处理 100万个订单
+*   解决方案必须支持1000个登录用户,同时在5-10秒内执行某个操作: A、B或C
+*   每周对所有客户进行统计, 时间不能超过6小时，时间窗口为每周日晚12点到次日6点之间。
+
+可以看出,吞吐量需求不是针对单个操作的, 而是在给定的时间内, 系统必须完成多少个操作。和延迟需求类似, GC调优也需要确定GC行为所消耗的总时间。每个系统能接受的时间不同, 一般来说, GC占用的总时间比不能超过`10%`。
+
+现在假设需求为: 每分钟处理 1000 笔交易。同时, 每分钟GC暂停的总时间不能超过6秒(即10%)。
+
+有了正式的需求, 下一步就是获取相关的信息。依然是从GC日志中提取数据, 可以看到类似这样的信息:
+
+
+
+```
+2015-06-04T13:34:16.974-0200: 2.578: [Full GC (Ergonomics)
+        [PSYoungGen: 93677K->70109K(254976K)] 
+        [ParOldGen: 499597K->511230K(761856K)] 
+        593275K->581339K(1016832K), 
+        [Metaspace: 2936K->2936K(1056768K)], 
+     0.0713174 secs] 
+     [Times: user=0.21 sys=0.02, real=0.07 secs
+```
+
+
+
+此时我们对 用户耗时(user)和系统耗时(sys)感兴趣, 而不关心实际耗时(real)。在这里, 我们关心的时间为`0.23s`(user + sys = 0.21 + 0.02 s), 这段时间内, GC暂停占用了 cpu 资源。 重要的是, 系统运行在多核机器上, 转换为实际的停顿时间(stop-the-world)为`0.0713174秒`, 下面的计算会用到这个数字。
+
+提取出有用的信息后, 剩下要做的就是统计每分钟内GC暂停的总时间。看看是否满足需求: 每分钟内总的暂停时间不得超过6000毫秒(6秒)。
+
+#### Capacity(系统容量)
+
+系统容量(Capacity)需求,是在达成吞吐量和延迟指标的情况下,对硬件环境的额外约束。这类需求大多是来源于计算资源或者预算方面的原因。例如:
+
+*   系统必须能部署到小于512 MB内存的Android设备上
+*   系统必须部署在Amazon**EC2**实例上, 配置不得超过**c3.xlarge(4核8GB)**。
+*   每月的 Amazon EC2 账单不得超过`$12,000`
+
+因此, 在满足延迟和吞吐量需求的基础上必须考虑系统容量。可以说, 假若有无限的计算资源可供挥霍, 那么任何 延迟和吞吐量指标 都不成问题, 但现实情况是, 预算(budget)和其他约束限制了可用的资源。
+
+### 相关示例
+
+介绍完性能调优的三个维度后, 我们来进行实际的操作以达成GC性能指标。
+
+请看下面的代码:
+
+
+
+```
+//imports skipped for brevity
+public class Producer implements Runnable {
+
+  private static ScheduledExecutorService executorService
+         = Executors.newScheduledThreadPool(2);
+
+  private Deque<byte[]> deque;
+  private int objectSize;
+  private int queueSize;
+
+  public Producer(int objectSize, int ttl) {
+    this.deque = new ArrayDeque<byte[]>();
+    this.objectSize = objectSize;
+    this.queueSize = ttl * 1000;
+  }
+
+  @Override
+  public void run() {
+    for (int i = 0; i < 100; i++) { 
+        deque.add(new byte[objectSize]); 
+        if (deque.size() > queueSize) {
+            deque.poll();
+        }
+    }
+  }
+
+  public static void main(String[] args) 
+        throws InterruptedException {
+    executorService.scheduleAtFixedRate(
+        new Producer(200 * 1024 * 1024 / 1000, 5), 
+        0, 100, TimeUnit.MILLISECONDS
+    );
+    executorService.scheduleAtFixedRate(
+        new Producer(50 * 1024 * 1024 / 1000, 120), 
+        0, 100, TimeUnit.MILLISECONDS);
+    TimeUnit.MINUTES.sleep(10);
+    executorService.shutdownNow();
+  }
+}
+```
+
+
+
+这段程序代码, 每 100毫秒 提交两个作业(job)来。每个作业都模拟特定的生命周期: 创建对象, 然后在预定的时间释放, 接着就不管了, 由GC来自动回收占用的内存。
+
+在运行这个示例程序时，通过以下JVM参数打开GC日志记录:
+
+
+
+```
+-XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCTimeStamps
+```
+
+
+
+还应该加上JVM参数`-Xloggc`以指定GC日志的存储位置,类似这样:
+
+
+
+```
+-Xloggc:C:\\Producer_gc.log
+```
+
+
+
+*   1
+*   2
+
+在日志文件中可以看到GC的行为, 类似下面这样:
+
+
+
+```
+2015-06-04T13:34:16.119-0200: 1.723: [GC (Allocation Failure) 
+        [PSYoungGen: 114016K->73191K(234496K)] 
+    421540K->421269K(745984K), 
+    0.0858176 secs] 
+    [Times: user=0.04 sys=0.06, real=0.09 secs] 
+
+2015-06-04T13:34:16.738-0200: 2.342: [GC (Allocation Failure) 
+        [PSYoungGen: 234462K->93677K(254976K)] 
+    582540K->593275K(766464K), 
+    0.2357086 secs] 
+    [Times: user=0.11 sys=0.14, real=0.24 secs] 
+
+2015-06-04T13:34:16.974-0200: 2.578: [Full GC (Ergonomics) 
+        [PSYoungGen: 93677K->70109K(254976K)] 
+        [ParOldGen: 499597K->511230K(761856K)] 
+    593275K->581339K(1016832K), 
+        [Metaspace: 2936K->2936K(1056768K)], 
+    0.0713174 secs] 
+    [Times: user=0.21 sys=0.02, real=0.07 secs]
+```
+
+
+
+基于日志中的信息, 可以通过三个优化目标来提升性能:
+
+1.  确保最坏情况下,GC暂停时间不超过预定阀值
+2.  确保线程暂停的总时间不超过预定阀值
+3.  在确保达到延迟和吞吐量指标的情况下, 降低硬件配置以及成本。
+
+为此, 用三种不同的配置, 将代码运行10分钟, 得到了三种不同的结果, 汇总如下:
+
+<colgroup data-id="c7104f7d-gSmaHJLh"><col data-id="cdf32f61-8J2cfg0C" span="1" width="239"><col data-id="cdf32f61-AWERG8eA" span="1" width="239"><col data-id="cdf32f61-NaGTMlPG" span="1" width="239"><col data-id="cdf32f61-dRpWPkiD" span="1" width="239"></colgroup>
+| **堆内存大小(Heap)** | **GC算法(GC Algorithm)** | **有效时间比(Useful work)** | **最长停顿时间(Longest pause)** |
+| -Xmx12g | -XX:+UseConcMarkSweepGC | 89.8% | **560 ms** |
+| -Xmx12g | -XX:+UseParallelGC | 91.5% | 1,104 ms |
+| -Xmx8g | -XX:+UseConcMarkSweepGC | 66.3% | 1,610 ms |
+
+使用不同的GC算法,和不同的内存配置,运行相同的代码, 以测量GC暂停时间与 延迟、吞吐量的关系。实验的细节和结果在后面章节详细介绍。
+
+注意, 为了尽量简单, 示例中只改变了很少的输入参数, 此实验也没有在不同CPU数量或者不同的堆布局下进行测试。
+
+#### Tuning for Latency(调优延迟指标)
+
+假设有一个需求,**每次作业必须在 1000ms 内处理完成**。我们知道, 实际的作业处理只需要100 ms，简化后， 两者相减就可以算出对 GC暂停的延迟要求。现在需求变成:**GC暂停不能超过900ms**。这个问题很容易找到答案, 只需要解析GC日志文件, 并找出GC暂停中最大的那个暂停时间即可。
+
+再来看测试所用的三个配置:
+
+<colgroup data-id="c7104f7d-odLOoE9j"><col data-id="cdf32f61-NXanPMa5" span="1" width="239"><col data-id="cdf32f61-agXUo5B7" span="1" width="239"><col data-id="cdf32f61-1a1qqOLf" span="1" width="239"><col data-id="cdf32f61-k2joL2XZ" span="1" width="239"></colgroup>
+| **堆内存大小(Heap)** | **GC算法(GC Algorithm)** | **有效时间比(Useful work)** | **最长停顿时间(Longest pause)** |
+| -Xmx12g | -XX:+UseConcMarkSweepGC | 89.8% | **560 ms** |
+| -Xmx12g | -XX:+UseParallelGC | 91.5% | 1,104 ms |
+| -Xmx8g | -XX:+UseConcMarkSweepGC | 66.3% | 1,610 ms |
+
+可以看到,其中有一个配置达到了要求。运行的参数为:
+
+
+
+```
+java -Xmx12g -XX:+UseConcMarkSweepGC Producer
+```
+
+
+
+对应的GC日志中,暂停时间最大为`560 ms`, 这达到了延迟指标`900 ms`的要求。如果还满足吞吐量和系统容量需求的话,就可以说成功达成了GC调优目标, 调优结束。
+
+#### Tuning for Throughput(吞吐量调优)
+
+假定吞吐量指标为:**每小时完成 1300万次操作处理**。同样是上面的配置, 其中有一种配置满足了需求:
+
+<colgroup data-id="c7104f7d-XWFk01FQ"><col data-id="cdf32f61-bRSQkdW2" span="1" width="239"><col data-id="cdf32f61-AX9oFR9r" span="1" width="239"><col data-id="cdf32f61-6dlMCOOR" span="1" width="239"><col data-id="cdf32f61-rnF2Ml61" span="1" width="239"></colgroup>
+| **堆内存大小(Heap)** | **GC算法(GC Algorithm)** | **有效时间比(Useful work)** | **最长停顿时间(Longest pause)** |
+| -Xmx12g | -XX:+UseConcMarkSweepGC | 89.8% | 560 ms |
+| -Xmx12g | -XX:+UseParallelGC | **91.5%** | 1,104 ms |
+| -Xmx8g | -XX:+UseConcMarkSweepGC | 66.3% | 1,610 ms |
+
+此配置对应的命令行参数为:
+
+
+
+```
+java -Xmx12g -XX:+UseParallelGC Producer
+```
+
+
+
+*   可以看到,GC占用了 8.5%的CPU时间,剩下的`91.5%`是有效的计算时间。为简单起见, 忽略示例中的其他安全点。现在需要考虑:
+
+1.  每个CPU核心处理一次作业需要耗时`100ms`
+2.  因此, 一分钟内每个核心可以执行 60,000 次操作(**每个job完成100次操作**)
+3.  一小时内, 一个核心可以执行 360万次操作
+4.  有四个CPU内核, 则每小时可以执行: 4 x 3.6M = 1440万次操作
+
+理论上，通过简单的计算就可以得出结论, 每小时可以执行的操作数为:`14.4 M * 91.5% = 13,176,000`次, 满足需求。
+
+值得一提的是, 假若还要满足延迟指标, 那就有问题了, 最坏情况下, GC暂停时间为`1,104 ms`, 最大延迟时间是前一种配置的两倍。
+
+#### Tuning for Capacity(调优系统容量)
+
+假设需要将软件部署到服务器上(commodity-class hardware), 配置为`4核10G`。这样的话, 系统容量的要求就变成: 最大的堆内存空间不能超过`8GB`。有了这个需求, 我们需要调整为第三套配置进行测试:
+
+<colgroup data-id="c7104f7d-CM3OYb8V"><col data-id="cdf32f61-2q4eRIn9" span="1" width="239"><col data-id="cdf32f61-e9evDkSA" span="1" width="239"><col data-id="cdf32f61-32S42uAd" span="1" width="239"><col data-id="cdf32f61-VjMFsW5B" span="1" width="239"></colgroup>
+| **堆内存大小(Heap)** | **GC算法(GC Algorithm)** | **有效时间比(Useful work)** | **最长停顿时间(Longest pause)** |
+| -Xmx12g | -XX:+UseConcMarkSweepGC | 89.8% | 560 ms |
+| -Xmx12g | -XX:+UseParallelGC | 91.5% | 1,104 ms |
+| **-Xmx8g** | -XX:+UseConcMarkSweepGC | 66.3% | 1,610 ms |
+
+程序可以通过如下参数执行:
+
+
+
+```
+java -Xmx8g -XX:+UseConcMarkSweepGC Producer
+```
+
+
+
+*   测试结果是延迟大幅增长, 吞吐量同样大幅降低:
+*   现在,GC占用了更多的CPU资源, 这个配置只有`66.3%`的有效CPU时间。因此,这个配置让吞吐量从最好的情况**13,176,000 操作/小时**下降到**不足 9,547,200次操作/小时**.
+*   最坏情况下的延迟变成了**1,610 ms**, 而不再是**560ms**。
+
+通过对这三个维度的介绍, 你应该了解, 不是简单的进行“性能(performance)”优化, 而是需要从三种不同的维度来进行考虑, 测量, 并调优延迟和吞吐量, 此外还需要考虑系统容量的约束。
+
+请继续阅读下一章:6\. GC 调优(工具篇) - GC参考手册
+
+原文链接:[GC Tuning: Basics](https://plumbr.eu/handbook/gc-tuning)
+
+翻译时间: 2016年02月06日
+
+## 6\. GC 调优(工具篇) - GC参考手册
+
+2017年02月23日 18:56:02
+
+阅读数：6469
+
+进行GC性能调优时, 需要明确了解, 当前的GC行为对系统和用户有多大的影响。有多种监控GC的工具和方法, 本章将逐一介绍常用的工具。
+
+您应该已经阅读了前面的章节:
+
+1.  垃圾收集简介 - GC参考手册
+2.  Java中的垃圾收集 - GC参考手册
+3.  GC 算法(基础篇) - GC参考手册
+4.  GC 算法(实现篇) - GC参考手册
+5.  GC 调优(基础篇) - GC参考手册
+
+JVM 在程序执行的过程中, 提供了GC行为的原生数据。那么, 我们就可以利用这些原生数据来生成各种报告。原生数据(_raw data_) 包括:
+
+*   各个内存池的当前使用情况,
+*   各个内存池的总容量,
+*   每次GC暂停的持续时间,
+*   GC暂停在各个阶段的持续时间。
+
+可以通过这些数据算出各种指标, 例如: 程序的内存分配率, 提升率等等。本章主要介绍如何获取原生数据。 后续的章节将对重要的派生指标(derived metrics)展开讨论, 并引入GC性能相关的话题。
+
+## JMX API
+
+从 JVM 运行时获取GC行为数据, 最简单的办法是使用标准[JMX API 接口](https://docs.oracle.com/javase/tutorial/jmx/index.html). JMX是获取 JVM内部运行时状态信息 的标准API. 可以编写程序代码, 通过 JMX API 来访问本程序所在的JVM，也可以通过JMX客户端执行(远程)访问。
+
+最常见的 JMX客户端是[JConsole](http://docs.oracle.com/javase/7/docs/technotes/guides/management/jconsole.html)和[JVisualVM](http://docs.oracle.com/javase/7/docs/technotes/tools/share/jvisualvm.html)(可以安装各种插件,十分强大)。两个工具都是标准JDK的一部分, 而且很容易使用. 如果使用的是 JDK 7u40 及更高版本, 还可以使用另一个工具:[Java Mission Control](http://www.oracle.com/technetwork/java/javaseproducts/mission-control/java-mission-control-1998576.html)( 大致翻译为 Java控制中心,`jmc.exe`)。
+
+> JVisualVM安装MBeans插件的步骤: 通过 工具(T) – 插件(G) – 可用插件 – 勾选VisualVM-MBeans – 安装 – 下一步 – 等待安装完成…… 其他插件的安装过程基本一致。
+
+所有 JMX客户端都是独立的程序,可以连接到目标JVM上。目标JVM可以在本机, 也可能是远端JVM. 如果要连接远端JVM, 则目标JVM启动时必须指定特定的环境变量,以开启远程JMX连接/以及端口号。 示例如下:
+
+
+
+```
+java -Dcom.sun.management.jmxremote.port=5432 com.yourcompany.YourApp
+```
+
+
+
+在此处, JVM 打开端口`5432`以支持JMX连接。
+
+通过 JVisualVM 连接到某个JVM以后, 切换到 MBeans 标签, 展开 “java.lang/GarbageCollector” . 就可以看到GC行为信息, 下图是 JVisualVM 中的截图:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404224430.png)
+
+下图是Java Mission Control 中的截图:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404224439.png)
+
+从以上截图中可以看到两款垃圾收集器。其中一款负责清理年轻代(**PS Scavenge**)，另一款负责清理老年代(**PS MarkSweep**); 列表中显示的就是垃圾收集器的名称。可以看到 , jmc 的功能和展示数据的方式更强大。
+
+对所有的垃圾收集器, 通过 JMX API 获取的信息包括:
+
+*   **CollectionCount**: 垃圾收集器执行的GC总次数,
+*   **CollectionTime**: 收集器运行时间的累计。这个值等于所有GC事件持续时间的总和,
+*   **LastGcInfo**: 最近一次GC事件的详细信息。包括 GC事件的持续时间(duration), 开始时间(startTime) 和 结束时间(endTime), 以及各个内存池在最近一次GC之前和之后的使用情况,
+*   **MemoryPoolNames**: 各个内存池的名称,
+*   **Name**: 垃圾收集器的名称
+*   **ObjectName**: 由JMX规范定义的 MBean的名字,,
+*   **Valid**: 此收集器是否有效。本人只见过 “`true`“的情况 (^_^)
+
+根据经验, 这些信息对GC的性能来说,不能得出什么结论. 只有编写程序, 获取GC相关的 JMX 信息来进行统计和分析。 在下文可以看到, 一般也不怎么关注 MBean , 但 MBean 对于理解GC的原理倒是挺有用的。
+
+## JVisualVM
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404224451.png)
+
+Visual GC 插件常用来监控本机运行的Java程序, 比如开发者和性能调优专家经常会使用此插件, 以快速获取程序运行时的GC信息。
+
+![06_03_jvmsualvm-garbage-collection-monitoring.png](https://s4.51cto.com/images/blog/202106/25/eabd68ba262d004c4919475f00d8ec9c.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk= "06_03_jvmsualvm-garbage-collection-monitoring.png")
+
+左侧的图表展示了各个内存池的使用情况: Metaspace/永久代, 老年代, Eden区以及两个存活区。
+
+在右边, 顶部的两个图表与 GC无关, 显示的是 JIT编译时间 和 类加载时间。下面的6个图显示的是内存池的历史记录, 每个内存池的GC次数,GC总时间, 以及最大值，峰值, 当前使用情况。
+
+再下面是 HistoGram, 显示了年轻代对象的年龄分布。至于对象的年龄监控(objects tenuring monitoring), 本章不进行讲解。
+
+与纯粹的JMX工具相比, VisualGC 插件提供了更友好的界面, 如果没有其他趁手的工具, 请选择VisualGC. 本章接下来会介绍其他工具, 这些工具可以提供更多的信息, 以及更好的视角. 当然, 在“Profilers(分析器)”一节中，也会介绍 JVisualVM 的适用场景 —— 如: 分配分析(allocation profiling), 所以我们绝不会贬低哪一款工具, 关键还得看实际情况。
+
+## jstat
+
+[jstat](https://docs.oracle.com/javase/8/docs/technotes/tools/unix/jstat.html)也是标准JDK提供的一款监控工具(Java Virtual Machine statistics monitoring tool),可以统计各种指标。既可以连接到本地JVM,也可以连到远程JVM. 查看支持的指标和对应选项可以执行 “`jstat -options`” 。例如:
+
+
+
+```
++-----------------+---------------------------------------------------------------+
+|     Option      |                          Displays...                          |
++-----------------+---------------------------------------------------------------+
+|class            | Statistics on the behavior of the class loader                |
+|compiler         | Statistics  on  the behavior of the HotSpot Just-In-Time com- |
+|                 | piler                                                         |
+|gc               | Statistics on the behavior of the garbage collected heap      |
+|gccapacity       | Statistics of the capacities of  the  generations  and  their |
+|                 | corresponding spaces.                                         |
+|gccause          | Summary  of  garbage collection statistics (same as -gcutil), |
+|                 | with the cause  of  the  last  and  current  (if  applicable) |
+|                 | garbage collection events.                                    |
+|gcnew            | Statistics of the behavior of the new generation.             |
+|gcnewcapacity    | Statistics of the sizes of the new generations and its corre- |
+|                 | sponding spaces.                                              |
+|gcold            | Statistics of the behavior of the old and  permanent  genera- |
+|                 | tions.                                                        |
+|gcoldcapacity    | Statistics of the sizes of the old generation.                |
+|gcpermcapacity   | Statistics of the sizes of the permanent generation.          |
+|gcutil           | Summary of garbage collection statistics.                     |
+|printcompilation | Summary of garbage collection statistics.                     |
++-----------------+---------------------------------------------------------------+
+```
+
+
+
+*   jstat 对于快速确定GC行为是否健康非常有用。启动方式为: “`jstat -gc -t PID 1s`” , 其中,PID 就是要监视的Java进程ID。可以通过`jps`命令查看正在运行的Java进程列表。
+
+
+
+```
+jps
+
+jstat -gc -t 2428 1s
+```
+
+
+
+以上命令的结果, 是 jstat 每秒向标准输出输出一行新内容, 比如:
+
+
+
+```
+Timestamp  S0C    S1C    S0U    S1U      EC       EU        OC         OU       MC     MU    CCSC   CCSU   YGC     YGCT    FGC    FGCT     GCT   
+200.0    8448.0 8448.0 8448.0  0.0   67712.0  67712.0   169344.0   169344.0  21248.0 20534.3 3072.0 2807.7     34    0.720  658   133.684  134.404
+201.0    8448.0 8448.0 8448.0  0.0   67712.0  67712.0   169344.0   169343.2  21248.0 20534.3 3072.0 2807.7     34    0.720  662   134.712  135.432
+202.0    8448.0 8448.0 8102.5  0.0   67712.0  67598.5   169344.0   169343.6  21248.0 20534.3 3072.0 2807.7     34    0.720  667   135.840  136.559
+203.0    8448.0 8448.0 8126.3  0.0   67712.0  67702.2   169344.0   169343.6  21248.0 20547.2 3072.0 2807.7     34    0.720  669   136.178  136.898
+204.0    8448.0 8448.0 8126.3  0.0   67712.0  67702.2   169344.0   169343.6  21248.0 20547.2 3072.0 2807.7     34    0.720  669   136.178  136.898
+205.0    8448.0 8448.0 8134.6  0.0   67712.0  67712.0   169344.0   169343.5  21248.0 20547.2 3072.0 2807.7     34    0.720  671   136.234  136.954
+206.0    8448.0 8448.0 8134.6  0.0   67712.0  67712.0   169344.0   169343.5  21248.0 20547.2 3072.0 2807.7     34    0.720  671   136.234  136.954
+207.0    8448.0 8448.0 8154.8  0.0   67712.0  67712.0   169344.0   169343.5  21248.0 20547.2 3072.0 2807.7     34    0.720  673   136.289  137.009
+208.0    8448.0 8448.0 8154.8  0.0   67712.0  67712.0   169344.0   169343.5  21248.0 20547.2 3072.0 2807.7     34    0.720  673   136.289  137.009
+```
+
+
+
+稍微解释一下上面的内容。参考[jstat manpage](http://www.manpagez.com/man/1/jstat/), 我们可以知道:
+
+*   jstat 连接到 JVM 的时间, 是JVM启动后的 200秒。此信息从第一行的 “**Timestamp**” 列得知。继续看下一行, jstat 每秒钟从JVM 接收一次信息, 也就是命令行参数中 “`1s`” 的含义。
+*   从第一行的 “**YGC**” 列得知年轻代共执行了34次GC, 由 “**FGC**” 列得知整个堆内存已经执行了 658次 full GC。
+*   年轻代的GC耗时总共为`0.720 秒`, 显示在“**YGCT**” 这一列。
+*   Full GC 的总计耗时为`133.684 秒`, 由“**FGCT**”列得知。 这立马就吸引了我们的目光, 总的JVM 运行时间只有 200 秒,**但其中有 66% 的部分被 Full GC 消耗了**。
+
+再看下一行, 问题就更明显了。
+
+*   在接下来的一秒内共执行了 4 次 Full GC。参见 “**FGC**” 列.
+*   这4次 Full GC 暂停占用了差不多 1秒的时间(根据**FGCT**列的差得知)。与第一行相比, Full GC 耗费了`928 毫秒`, 即`92.8%`的时间。
+*   根据 “**OC**和 “**OU**” 列得知,**整个老年代的空间**为`169,344.0 KB`(“OC“), 在 4 次 Full GC 后依然占用了`169,344.2 KB`(“OU“)。用了`928ms`的时间却只释放了 800 字节的内存, 怎么看都觉得很不正常。
+
+只看这两行的内容, 就知道程序出了很严重的问题。继续分析下一行, 可以确定问题依然存在,而且变得更糟。
+
+JVM几乎完全卡住了(stalled), 因为GC占用了90%以上的计算资源。GC之后, 所有的老代空间仍然还在占用。事实上, 程序在一分钟以后就挂了, 抛出了 “[java.lang.OutOfMemoryError: GC overhead limit exceeded](https://plumbr.eu/outofmemoryerror/gc-overhead-limit-exceeded)” 错误。
+
+可以看到, 通过 jstat 能很快发现对JVM健康极为不利的GC行为。一般来说, 只看 jstat 的输出就能快速发现以下问题:
+
+*   最后一列 “**GCT**”, 与JVM的总运行时间 “**Timestamp**” 的比值, 就是GC 的开销。如果每一秒内, “**GCT**” 的值都会明显增大, 与总运行时间相比, 就暴露出GC开销过大的问题. 不同系统对GC开销有不同的容忍度, 由性能需求决定, 一般来讲, 超过`10%`的GC开销都是有问题的。
+*   “**YGC**” 和 “**FGC**” 列的快速变化往往也是有问题的征兆。频繁的GC暂停会累积,并导致更多的线程停顿(stop-the-world pauses), 进而影响吞吐量。
+*   如果看到 “**OU**” 列中,老年代的使用量约等于老年代的最大容量(**OC**), 并且不降低的话, 就表示虽然执行了老年代GC, 但基本上属于无效GC。
+
+## GC日志(GC logs)
+
+通过日志内容也可以得到GC相关的信息。因为GC日志模块内置于JVM中, 所以日志中包含了对GC活动最全面的描述。 这就是事实上的标准, 可作为GC性能评估和优化的最真实数据来源。
+
+GC日志一般输出到文件之中, 是纯 text 格式的, 当然也可以打印到控制台。有多个可以控制GC日志的JVM参数。例如,可以打印每次GC的持续时间, 以及程序暂停时间(`-XX:+PrintGCApplicationStoppedTime`), 还有GC清理了多少引用类型(`-XX:+PrintReferenceGC`)。
+
+要打印GC日志, 需要在启动脚本中指定以下参数:
+
+
+
+```
+-XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintGCDetails -Xloggc:<filename>
+```
+
+
+
+以上参数指示JVM: 将所有GC事件打印到日志文件中, 输出每次GC的日期和时间戳。不同GC算法输出的内容略有不同. ParallelGC 输出的日志类似这样:
+
+
+
+```
+199.879: [Full GC (Ergonomics) [PSYoungGen: 64000K->63998K(74240K)] [ParOldGen: 169318K->169318K(169472K)] 233318K->233317K(243712K), [Metaspace: 20427K->20427K(1067008K)], 0.1473386 secs] [Times: user=0.43 sys=0.01, real=0.15 secs]
+200.027: [Full GC (Ergonomics) [PSYoungGen: 64000K->63998K(74240K)] [ParOldGen: 169318K->169318K(169472K)] 233318K->233317K(243712K), [Metaspace: 20427K->20427K(1067008K)], 0.1567794 secs] [Times: user=0.41 sys=0.00, real=0.16 secs]
+200.184: [Full GC (Ergonomics) [PSYoungGen: 64000K->63998K(74240K)] [ParOldGen: 169318K->169318K(169472K)] 233318K->233317K(243712K), [Metaspace: 20427K->20427K(1067008K)], 0.1621946 secs] [Times: user=0.43 sys=0.00, real=0.16 secs]
+200.346: [Full GC (Ergonomics) [PSYoungGen: 64000K->63998K(74240K)] [ParOldGen: 169318K->169318K(169472K)] 233318K->233317K(243712K), [Metaspace: 20427K->20427K(1067008K)], 0.1547695 secs] [Times: user=0.41 sys=0.00, real=0.15 secs]
+200.502: [Full GC (Ergonomics) [PSYoungGen: 64000K->63999K(74240K)] [ParOldGen: 169318K->169318K(169472K)] 233318K->233317K(243712K), [Metaspace: 20427K->20427K(1067008K)], 0.1563071 secs] [Times: user=0.42 sys=0.01, real=0.16 secs]
+200.659: [Full GC (Ergonomics) [PSYoungGen: 64000K->63999K(74240K)] [ParOldGen: 169318K->169318K(169472K)] 233318K->233317K(243712K), [Metaspace: 20427K->20427K(1067008K)], 0.1538778 secs] [Times: user=0.42 sys=0.00, real=0.16 secs]
+```
+
+
+
+在 “04\. GC算法:实现篇” 中详细介绍了这些格式, 如果对此不了解, 可以先阅读该章节。
+
+分析以上日志内容, 可以得知:
+
+*   这部分日志截取自JVM启动后200秒左右。
+*   日志片段中显示, 在`780毫秒`以内, 因为垃圾回收 导致了5次 Full GC 暂停(去掉第六次暂停,这样更精确一些)。
+*   这些暂停事件的总持续时间是`777毫秒`, 占总运行时间的**99.6%**。
+*   在GC完成之后, 几乎所有的老年代空间(`169,472 KB`)依然被占用(`169,318 KB`)。
+
+通过日志信息可以确定, 该应用的GC情况非常糟糕。JVM几乎完全停滞, 因为GC占用了超过`99%`的CPU时间。 而GC的结果是, 老年代空间仍然被占满, 这进一步肯定了我们的结论。 示例程序和jstat 小节中的是同一个, 几分钟之后系统就挂了, 抛出 “[java.lang.OutOfMemoryError: GC overhead limit exceeded](https://plumbr.eu/outofmemoryerror/gc-overhead-limit-exceeded)” 错误, 不用说, 问题是很严重的.
+
+从此示例可以看出, GC日志对监控GC行为和JVM是否处于健康状态非常有用。一般情况下, 查看 GC 日志就可以快速确定以下症状:
+
+*   GC开销太大。如果GC暂停的总时间很长, 就会损害系统的吞吐量。不同的系统允许不同比例的GC开销, 但一般认为, 正常范围在`10%`以内。
+*   极个别的GC事件暂停时间过长。当某次GC暂停时间太长, 就会影响系统的延迟指标. 如果延迟指标规定交易必须在`1,000 ms`内完成, 那就不能容忍任何超过`1000毫秒`的GC暂停。
+*   老年代的使用量超过限制。如果老年代空间在 Full GC 之后仍然接近全满, 那么GC就成为了性能瓶颈, 可能是内存太小, 也可能是存在内存泄漏。这种症状会让GC的开销暴增。
+
+可以看到,GC日志中的信息非常详细。但除了这些简单的小程序, 生产系统一般都会生成大量的GC日志, 纯靠人工是很难阅读和进行解析的。
+
+## GCViewer
+
+我们可以自己编写解析器, 来将庞大的GC日志解析为直观易读的图形信息。 但很多时候自己写程序也不是个好办法, 因为各种GC算法的复杂性, 导致日志信息格式互相之间不太兼容。那么神器来了:[GCViewer](https://github.com/chewiebug/GCViewer)。
+
+[GCViewer](https://github.com/chewiebug/GCViewer)是一款开源的GC日志分析工具。项目的 GitHub 主页对各项指标进行了完整的描述. 下面我们介绍最常用的一些指标。
+
+第一步是获取GC日志文件。这些日志文件要能够反映系统在性能调优时的具体场景. 假若运营部门(operational department)反馈: 每周五下午,系统就运行缓慢, 不管GC是不是主要原因, 分析周一早晨的日志是没有多少意义的。
+
+获取到日志文件之后, 就可以用 GCViewer 进行分析, 大致会看到类似下面的图形界面:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404224526.png)
+
+使用的命令行大致如下:
+
+
+
+```
+java -jar gcviewer_1.3.4.jar gc.log
+```
+
+
+
+当然, 如果不想打开程序界面,也可以在后面加上其他参数,直接将分析结果输出到文件。
+
+命令大致如下:
+
+
+
+```
+java -jar gcviewer_1.3.4.jar gc.log summary.csv chart.png
+```
+
+
+
+以上命令将信息汇总到当前目录下的 Excel 文件`summary.csv`之中, 将图形信息保存为`chart.png`文件。
+
+点击下载:gcviewer的jar包及使用示例
+
+上图中, Chart 区域是对GC事件的图形化展示。包括各个内存池的大小和GC事件。上图中, 只有两个可视化指标: 蓝色线条表示堆内存的使用情况, 黑色的Bar则表示每次GC暂停时间的长短。
+
+从图中可以看到, 内存使用量增长很快。一分钟左右就达到了堆内存的最大值. 堆内存几乎全部被消耗, 不能顺利分配新对象, 并引发频繁的 Full GC 事件. 这说明程序可能存在内存泄露, 或者启动时指定的内存空间不足。
+
+从图中还可以看到 GC暂停的频率和持续时间。`30秒`之后, GC几乎不间断地运行,最长的暂停时间超过`1.4秒`。
+
+在右边有三个选项卡。“`**Summary**`(摘要)” 中比较有用的是 “`Throughput`”(吞吐量百分比) 和 “`Number of GC pauses`”(GC暂停的次数), 以及“`Number of full GC pauses`”(Full GC 暂停的次数). 吞吐量显示了有效工作的时间比例, 剩下的部分就是GC的消耗。
+
+以上示例中的吞吐量为`**6.28%**`。这意味着有`**93.72%**`
+
+下一个有意思的地方是“**Pause**”(暂停)选项卡:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404224540.png)
+
+“`Pause`” 展示了GC暂停的总时间,平均值,最小值和最大值, 并且将 total 与minor/major 暂停分开统计。如果要优化程序的延迟指标, 这些统计可以很快判断出暂停时间是否过长。另外, 我们可以得出明确的信息: 累计暂停时间为`634.59 秒`, GC暂停的总次数为`3,938 次`, 这在`11分钟/660秒`的总运行时间里那不是一般的高。
+
+更详细的GC暂停汇总信息, 请查看主界面中的 “**Event details**” 标签:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404224553.png)
+
+从“**Event details**” 标签中, 可以看到日志中所有重要的GC事件汇总:`普通GC停顿`和`Full GC 停顿次数`, 以及`并发执行数`,`非 stop-the-world 事件`等。此示例中, 可以看到一个明显的地方, Full GC 暂停严重影响了吞吐量和延迟, 依据是:`3,928 次 Full GC`, 暂停了`634秒`。
+
+可以看到, GCViewer 能用图形界面快速展现异常的GC行为。一般来说, 图像化信息能迅速揭示以下症状:
+
+*   低吞吐量。当应用的吞吐量下降到不能容忍的地步时, 有用工作的总时间就大量减少. 具体有多大的 “容忍度”(tolerable) 取决于具体场景。按照经验, 低于 90% 的有效时间就值得警惕了, 可能需要好好优化下GC。
+*   单次GC的暂停时间过长。只要有一次GC停顿时间过长,就会影响程序的延迟指标. 例如, 延迟需求规定必须在 1000 ms以内完成交易, 那就不能容忍任何一次GC暂停超过1000毫秒。
+*   堆内存使用率过高。如果老年代空间在 Full GC 之后仍然接近全满, 程序性能就会大幅降低, 可能是资源不足或者内存泄漏。这种症状会对吞吐量产生严重影响。
+
+业界良心 —— 图形化展示的GC日志信息绝对是我们重磅推荐的。不用去阅读冗长而又复杂的GC日志,通过容易理解的图形, 也可以得到同样的信息。
+
+## 分析器(Profilers)
+
+下面介绍分析器([profilers](http://zeroturnaround.com/rebellabs/developer-productivity-report-2015-java-performance-survey-results/3/), Oracle官方翻译是:`抽样器`)。相对于前面的工具, 分析器只关心GC中的一部分领域. 本节我们也只关注分析器相关的GC功能。
+
+首先警告 —— 不要认为分析器适用于所有的场景。分析器有时确实作用很大, 比如检测代码中的CPU热点时。但某些情况使用分析器不一定是个好方案。
+
+对GC调优来说也是一样的。要检测是否因为GC而引起延迟或吞吐量问题时, 不需要使用分析器. 前面提到的工具(`jstat`或 原生/可视化GC日志)就能更好更快地检测出是否存在GC问题. 特别是从生产环境中收集性能数据时, 最好不要使用分析器, 因为性能开销非常大。
+
+如果确实需要对GC进行优化, 那么分析器就可以派上用场了, 可以对 Object 的创建信息一目了然. 换个角度看, 如果GC暂停的原因不在某个内存池中, 那就只会是因为创建对象太多了。 所有分析器都能够跟踪对象分配(via allocation profiling), 根据内存分配的轨迹, 让你知道**实际驻留在内存中的是哪些对象**。
+
+分配分析能定位到在哪个地方创建了大量的对象. 使用分析器辅助进行GC调优的好处是, 能确定哪种类型的对象最占用内存, 以及哪些线程创建了最多的对象。
+
+下面我们通过实例介绍3种分配分析器:`**hprof**`,`**JVisualV**`**M**和`**AProf**`。实际上还有很多分析器可供选择, 有商业产品,也有免费工具, 但其功能和应用基本上都是类似的。
+
+### hprof
+
+[hprof 分析器](http://docs.oracle.com/javase/8/docs/technotes/samples/hprof.html)内置于JDK之中。 在各种环境下都可以使用, 一般优先使用这款工具。
+
+要让`hprof`和程序一起运行, 需要修改启动脚本, 类似这样:
+
+
+
+```
+java -agentlib:hprof=heap=sites com.yourcompany.YourApplication
+```
+
+
+
+在程序退出时,会将分配信息dump(转储)到工作目录下的`java.hprof.txt`文件中。使用文本编辑器打开, 并搜索 “**SITES BEGIN**” 关键字, 可以看到:
+
+
+
+```
+SITES BEGIN (ordered by live bytes) Tue Dec  8 11:16:15 2015
+          percent          live          alloc'ed  stack class
+ rank   self  accum     bytes objs     bytes  objs trace name
+    1  64.43% 4.43%   8370336 20121  27513408 66138 302116 int[]
+    2  3.26% 88.49%    482976 20124   1587696 66154 302104 java.util.ArrayList
+    3  1.76% 88.74%    241704 20121   1587312 66138 302115 eu.plumbr.demo.largeheap.ClonableClass0006
+    ... 部分省略 ...
+
+SITES END
+```
+
+
+
+从以上片段可以看到, allocations 是根据每次创建的对象数量来排序的。第一行显示所有对象中有`**64.43%**`的对象是整型数组(`int[]`), 在标识为`302116`的位置创建。搜索 “**TRACE 302116**” 可以看到:
+
+
+
+```
+TRACE 302116:   
+    eu.plumbr.demo.largeheap.ClonableClass0006.<init>(GeneratorClass.java:11)
+    sun.reflect.GeneratedConstructorAccessor7.newInstance(<Unknown Source>:Unknown line)
+    sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
+    java.lang.reflect.Constructor.newInstance(Constructor.java:422)
+```
+
+
+
+现在, 知道有`64.43%`的对象是整数数组, 在`ClonableClass0006`类的构造函数中, 第11行的位置, 接下来就可以优化代码, 以减少GC的压力。
+
+### Java VisualVM
+
+本章前面的第一部分, 在监控 JVM 的GC行为工具时介绍了 JVisualVM , 本节介绍其在分配分析上的应用。
+
+JVisualVM 通过GUI的方式连接到正在运行的JVM。 连接上目标JVM之后 :
+
+1.  打开 “工具” –> “选项” 菜单, 点击**性能分析(Profiler)**标签, 新增配置, 选择 Profiler 内存, 确保勾选了 “Record allocations stack traces”(记录分配栈跟踪)。
+2.  勾选 “Settings”(设置) 复选框, 在内存设置标签下,修改预设配置。
+3.  点击 “Memory”(内存) 按钮开始进行内存分析。
+4.  让程序运行一段时间,以收集关于对象分配的足够信息。
+5.  单击下方的 “Snapshot”(快照) 按钮。可以获取收集到的快照信息。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404224729.png)
+
+完成上面的步骤后, 可以得到类似这样的信息:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404224743.png)
+
+上图按照每个类被创建的对象数量多少来排序。看第一行可以知道, 创建的最多的对象是`int[]`数组. 鼠标右键单击这行, 就可以看到这些对象都在哪些地方创建的:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404224753.png)
+
+与`hprof`相比, JVisualVM 更加容易使用 —— 比如上面的截图中, 在一个地方就可以看到所有`int[]`的分配信息, 所以多次在同一处代码进行分配的情况就很容易发现。
+
+### AProf
+
+最重要的一款分析器,是由 Devexperts 开发的[**AProf**](https://code.devexperts.com/display/AProf/About+Aprof)。 内存分配分析器 AProf 也被打包为 Java agent 的形式。
+
+用 AProf 分析应用程序, 需要修改 JVM 启动脚本,类似这样:
+
+
+
+```
+java -javaagent:/path-to/aprof.jar com.yourcompany.YourApplication
+```
+
+
+
+重启应用之后, 工作目录下会生成一个`aprof.txt`文件。此文件每分钟更新一次, 包含这样的信息:
+
+
+
+```
+========================================================================================================================
+TOTAL allocation dump for 91,289 ms (0h01m31s)
+Allocated 1,769,670,584 bytes in 24,868,088 objects of 425 classes in 2,127 locations
+========================================================================================================================
+
+Top allocation-inducing locations with the data types allocated from them
+------------------------------------------------------------------------------------------------------------------------
+eu.plumbr.demo.largeheap.ManyTargetsGarbageProducer.newRandomClassObject: 1,423,675,776 (80.44%) bytes in 17,113,721 (68.81%) objects (avg size 83 bytes)
+    int[]: 711,322,976 (40.19%) bytes in 1,709,911 (6.87%) objects (avg size 416 bytes)
+    char[]: 369,550,816 (20.88%) bytes in 5,132,759 (20.63%) objects (avg size 72 bytes)
+    java.lang.reflect.Constructor: 136,800,000 (7.73%) bytes in 1,710,000 (6.87%) objects (avg size 80 bytes)
+    java.lang.Object[]: 41,079,872 (2.32%) bytes in 1,710,712 (6.87%) objects (avg size 24 bytes)
+    java.lang.String: 41,063,496 (2.32%) bytes in 1,710,979 (6.88%) objects (avg size 24 bytes)
+    java.util.ArrayList: 41,050,680 (2.31%) bytes in 1,710,445 (6.87%) objects (avg size 24 bytes)
+          ... cut for brevity ...
+```
+
+
+
+上面的输出是按照`size`进行排序的。可以看出,`80.44%`的 bytes 和`68.81%`的 objects 是在`ManyTargetsGarbageProducer.newRandomClassObject()`方法中分配的。 其中,**int[]**数组占用了`40.19%`的内存, 是最大的一个。
+
+继续往下看, 会发现`allocation traces`(分配痕迹)相关的内容, 也是以 allocation size 排序的:
+
+
+
+```
+Top allocated data types with reverse location traces
+------------------------------------------------------------------------------------------------------------------------
+int[]: 725,306,304 (40.98%) bytes in 1,954,234 (7.85%) objects (avg size 371 bytes)
+    eu.plumbr.demo.largeheap.ClonableClass0006.: 38,357,696 (2.16%) bytes in 92,206 (0.37%) objects (avg size 416 bytes)
+        java.lang.reflect.Constructor.newInstance: 38,357,696 (2.16%) bytes in 92,206 (0.37%) objects (avg size 416 bytes)
+            eu.plumbr.demo.largeheap.ManyTargetsGarbageProducer.newRandomClassObject: 38,357,280 (2.16%) bytes in 92,205 (0.37%) objects (avg size 416 bytes)
+            java.lang.reflect.Constructor.newInstance: 416 (0.00%) bytes in 1 (0.00%) objects (avg size 416 bytes)
+... cut for brevity ...
+```
+
+
+
+可以看到,`int[]`数组的分配, 在`ClonableClass0006`构造函数中继续增大。
+
+和其他工具一样,`AProf`揭露了 分配的大小以及位置信息(`allocation size and locations`), 从而能够快速找到最耗内存的部分。在我们看来,**AProf**是最有用的分配分析器, 因为它只专注于内存分配, 所以做得最好。 当然, 这款工具是开源免费的, 资源开销也最小。
+
+请继续阅读下一章:7\. GC 调优(实战篇) - GC参考手册
+
+原文链接:[GC Tuning: Tooling](https://plumbr.eu/handbook/gc-tuning-measuring)
+
+翻译时间: 2016年02月06日
+
+## 参考文章
+
+<https://segmentfault.com/a/1190000009707894>
+
+<https://www.cnblogs.com/hysum/p/7100874.html>
+
+<http://c.biancheng.net/view/939.html>
+
+<https://www.runoob.com/>
+
+https://blog.csdn.net/android_hl/article/details/53228348
+
+
diff --git "a/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JNDI\357\274\214OSGI\357\274\214Tomcat\347\261\273\345\212\240\350\275\275\345\231\250\345\256\236\347\216\260.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JNDI\357\274\214OSGI\357\274\214Tomcat\347\261\273\345\212\240\350\275\275\345\231\250\345\256\236\347\216\260.md"
new file mode 100644
index 0000000..6c1b066
--- /dev/null
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JNDI\357\274\214OSGI\357\274\214Tomcat\347\261\273\345\212\240\350\275\275\345\231\250\345\256\236\347\216\260.md"
@@ -0,0 +1,372 @@
+# 目录
+  * [打破双亲委派模型](#打破双亲委派模型)
+    * [JNDI](#jndi)
+    * [JNDI 的理解](#[jndi-的理解])
+  * [OSGI](#osgi)
+    * [1.如何正确的理解和认识OSGI技术？](#1如何正确的理解和认识osgi技术？)
+  * [Tomcat类加载器以及应用间class隔离与共享](#tomcat类加载器以及应用间class隔离与共享)
+    * [类加载器](#类加载器)
+  * [参考文章](#参考文章)
+
+
+
+本文转自互联网，侵删
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+文章将同步到我的个人博客：
+> www.how2playlife.com
+
+本文是微信公众号【Java技术江湖】的《深入理解JVM虚拟机》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+
+该系列博文会告诉你如何从入门到进阶，一步步地学习JVM基础知识，并上手进行JVM调优实战，JVM是每一个Java工程师必须要学习和理解的知识点，你必须要掌握其实现原理，才能更完整地了解整个Java技术体系，形成自己的知识框架。
+
+为了更好地总结和检验你的学习成果，本系列文章也会提供每个知识点对应的面试题以及参考答案。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+<!-- more -->
+
+## 打破双亲委派模型
+
+### JNDI
+
+### JNDI 的理解
+
+
+JNDI是 Java 命名与文件夹接口（Java Naming and Directory Interface），在J2EE规范中是重要的规范之中的一个，不少专家觉得，没有透彻理解JNDI的意义和作用，就没有真正掌握J2EE特别是EJB的知识。
+
+那么，JNDI究竟起什么作用？//带着问题看文章是最有效的
+
+要了解JNDI的作用，我们能够从“假设不用JNDI我们如何做？用了JNDI后我们又将如何做？”这个问题来探讨。
+
+没有JNDI的做法：
+
+程序猿开发时，知道要开发訪问MySQL数据库的应用，于是将一个对 MySQL JDBC 驱动程序类的引用进行了编码，并通过使用适当的 JDBC URL 连接到数据库。
+就像以下代码这样：
+
+```` 
+    1.  Connectionconn=null;
+    2.  try{
+    3.  Class.forName("com.mysql.jdbc.Driver",
+    4.  true,Thread.currentThread().getContextClassLoader());
+    5.  conn=DriverManager.
+    6.  getConnection("jdbc:mysql://MyDBServer?user=qingfeng&password=mingyue");
+    7.  ......
+    8.  conn.close();
+    9.  }catch(Exceptione){
+    10.  e.printStackTrace();
+    11.  }finally{
+    12.  if(conn!=null){
+    13.  try{
+    14.  conn.close();
+    15.  }catch(SQLExceptione){}
+    16.  }
+    17.  }
+````
+
+
+这是传统的做法，也是曾经非Java程序猿（如Delphi、VB等）常见的做法。
+
+这种做法一般在小规模的开发过程中不会产生问题，仅仅要程序猿熟悉Java语言、了解JDBC技术和MySQL，能够非常快开发出对应的应用程序。
+
+没有JNDI的做法存在的问题：
+
+    1、数据库server名称MyDBServer 、username和口令都可能须要改变，由此引发JDBC URL须要改动；
+    2、数据库可能改用别的产品，如改用DB2或者Oracle，引发JDBC驱动程序包和类名须要改动；
+    3、随着实际使用终端的添加，原配置的连接池參数可能须要调整；
+    4、......
+
+解决的方法：
+
+程序猿应该不须要关心“详细的数据库后台是什么？JDBC驱动程序是什么？JDBC URL格式是什么？訪问数据库的username和口令是什么？”等等这些问题。
+
+程序猿编写的程序应该没有对 JDBC驱动程序的引用，没有server名称，没实username称或口令 —— 甚至没有数据库池或连接管理。
+
+而是把这些问题交给J2EE容器（比方weblogic）来配置和管理，程序猿仅仅须要对这些配置和管理进行引用就可以。
+
+由此，就有了JNDI。
+
+//看的出来。是为了一个最最核心的问题：是为了解耦，是为了开发出更加可维护、可扩展//的系统
+
+用了JNDI之后的做法：
+首先。在在J2EE容器中配置JNDI參数，定义一个数据源。也就是JDBC引用參数，给这个数据源设置一个名称；然后，在程序中，通过数据源名称引用数据源从而訪问后台数据库。
+
+//红色的字能够看出。JNDI是由j2ee容器提供的功能
+
+详细操作例如以下（以JBoss为例）：
+1、配置数据源
+在JBoss 的 D:\jboss420GA\docs\examples\jca 文件夹以下。有非常多不同数据库引用的数据源定义模板。
+
+将当中的 mysql-ds.xml 文件Copy到你使用的server下，如 D:\jboss420GA\server\default\deploy。
+改动 mysql-ds.xml 文件的内容，使之能通过JDBC正确訪问你的MySQL数据库。例如以下：
+
+
+    
+````    
+<?xmlversion="1.0"encoding="UTF-8"?>
+<datasources>
+<local-tx-datasource>
+<jndi-name>MySqlDS</jndi-name>
+<connection-url>jdbc:mysql://localhost:3306/lw</connection-url>
+<driver-class>com.mysql.jdbc.Driver</driver-class>
+<user-name>root</user-name>
+<password>rootpassword</password>
+<exception-sorter-class-name>
+org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter
+</exception-sorter-class-name>
+<metadata>
+<type-mapping>mySQL</type-mapping>
+</metadata>
+</local-tx-datasource>
+</datasources>
+````
+
+
+这里，定义了一个名为MySqlDS的数据源。其參数包含JDBC的URL。驱动类名，username及密码等。
+
+2、在程序中引用数据源：
+
+````    
+1.  Connectionconn=null;
+2.  try{
+3.  Contextctx=newInitialContext();
+4.  ObjectdatasourceRef=ctx.lookup("java:MySqlDS");//引用数据源
+5.  DataSourceds=(Datasource)datasourceRef;
+6.  conn=ds.getConnection();
+7.  ......
+8.  c.close();
+9.  }catch(Exceptione){
+10.  e.printStackTrace();
+11.  }finally{
+12.  if(conn!=null){
+13.  try{
+14.  conn.close();
+15.  }catch(SQLExceptione){}
+16.  }
+17.  }
+````    
+
+
+直接使用JDBC或者通过JNDI引用数据源的编程代码量相差无几，可是如今的程序能够不用关心详细JDBC參数了。
+
+//解藕了。可扩展了
+在系统部署后。假设数据库的相关參数变更。仅仅须要又一次配置 mysql-ds.xml 改动当中的JDBC參数，仅仅要保证数据源的名称不变，那么程序源码就无需改动。
+
+由此可见。JNDI避免了程序与数据库之间的紧耦合，使应用更加易于配置、易于部署。
+
+JNDI的扩展：
+JNDI在满足了数据源配置的要求的基础上。还进一步扩充了作用：全部与系统外部的资源的引用，都能够通过JNDI定义和引用。
+
+//注意什么叫资源
+
+所以，在J2EE规范中，J2EE 中的资源并不局限于 JDBC 数据源。
+
+引用的类型有非常多，当中包含资源引用（已经讨论过）、环境实体和 EJB 引用。
+
+特别是 EJB 引用，它暴露了 JNDI 在 J2EE 中的另外一项关键角色：查找其它应用程序组件。
+
+EJB 的 JNDI 引用非常相似于 JDBC 资源的引用。在服务趋于转换的环境中，这是一种非常有效的方法。能够对应用程序架构中所得到的全部组件进行这类配置管理，从 EJB 组件到 JMS 队列和主题。再到简单配置字符串或其它对象。这能够降低随时间的推移服务变更所产生的维护成本，同一时候还能够简化部署，降低集成工作。外部资源”。
+
+总结：
+
+J2EE 规范要求全部 J2EE 容器都要提供 JNDI 规范的实现。//sun 果然喜欢制定规范JNDI 在 J2EE 中的角色就是“交换机” —— J2EE 组件在执行时间接地查找其它组件、资源或服务的通用机制。在多数情况下，提供 JNDI 供应者的容器能够充当有限的数据存储。这样管理员就能够设置应用程序的执行属性，并让其它应用程序引用这些属性（Java 管理扩展（Java Management Extensions，JMX）也能够用作这个目的）。JNDI 在 J2EE 应用程序中的主要角色就是提供间接层，这样组件就能够发现所须要的资源，而不用了解这些间接性。
+
+在 J2EE 中，JNDI 是把 J2EE 应用程序合在一起的粘合剂。JNDI 提供的间接寻址同意跨企业交付可伸缩的、功能强大且非常灵活的应用程序。
+
+这是 J2EE 的承诺，并且经过一些计划和预先考虑。这个承诺是全然能够实现的。
+
+ 从上面的文章中能够看出：
+1、JNDI 提出的目的是为了解藕，是为了开发更加easy维护，easy扩展。easy部署的应用。
+2、JNDI 是一个sun提出的一个规范(相似于jdbc),详细的实现是各个j2ee容器提供商。sun 仅仅是要求，j2ee容器必须有JNDI这种功能。
+
+3、JNDI 在j2ee系统中的角色是“交换机”，是J2EE组件在执行时间接地查找其它组件、资源或服务的通用机制。
+4、JNDI 是通过资源的名字来查找的，资源的名字在整个j2ee应用中(j2ee容器中)是唯一的。
+
+
+ 上文提到过双亲委派模型并不是一个强制性的约束模型，而是Java设计者推荐给开发者的类加载器实现方式。在Java的世界中大部分的类加载器都遵循这个模型，但也有例外。
+
+ 双亲委派模型的一次“被破坏”是由这个模型自身的缺陷所导致的，双亲委派很好地解决了各个类加载器的基础类的统一问题（越基础的类由越上层的加载器进行加载），基础类之所以称为“基础”，是因为它们总是作为被用户代码调用的API，但世事往往没有绝对的完美，如果基础类又要调用回用户的代码，那该怎么办？
+
+这并非是不可能的事情，一个典型的例子便是JNDI服务，JNDI现在已经是Java的标准服务，它的代码由启动类加载器去加载（在JDK 1.3时放进去的rt.jar），但JNDI的目的就是对资源进行集中管理和查找，它需要调用由独立厂商实现并部署在应用程序的ClassPath下的JNDI接口提供者（SPI，Service Provider Interface）的代码，但启动类加载器不可能“认识”这些代码，因为启动类加载器的搜索范围中找不到用户应用程序类，那该怎么办？
+
+
+为了解决这个问题，Java设计团队只好引入了一个不太优雅的设计：线程上下文类加载器（Thread Context ClassLoader）。这个类加载器可以通过java.lang.Thread类的setContextClassLoader()方法进行设置，如果创建线程时还未设置，它将会从父线程中继承一个，如果在应用程序的全局范围内都没有设置过的话，那这个类加载器默认就是应用程序类加载器（Application ClassLoader）。
+
+ 有了线程上下文类加载器，就可以做一些“舞弊”的事情了，JNDI服务使用这个线程上下文类加载器去加载所需要的SPI代码，也就是父类加载器请求子类加载器去完成类加载的动作，这种行为实际上就是打通了双亲委派模型的层次结构来逆向使用类加载器，实际上已经违背了双亲委派模型的一般性原则，但这也是无可奈何的事情。Java中所有涉及SPI的加载动作基本上都采用这种方式，例如JNDI、JDBC、JCE、JAXB和JBI等。
+
+  
+
+## OSGI
+
+  
+
+目前，业内关于OSGI技术的学习资源或者技术文档还是很少的。我在某宝网搜索了一下“OSGI”的书籍，结果倒是有，但是种类少的可怜，而且几乎没有人购买。
+因为工作的原因我需要学习OSGI，所以我不得不想尽办法来主动学习OSGI。我将用文字记录学习OSGI的整个过程，通过整理书籍和视频教程，来让我更加了解这门技术，同时也让需要学习这门技术的同志们有一个清晰的学习路线。
+
+我们需要解决一下几问题:
+
+### 1.如何正确的理解和认识OSGI技术？
+
+我们从外文资料上或者从翻译过来的资料上看到OSGi解释和定义，都是直译过来的，但是OSGI的真实意义未必是中文直译过来的意思。OSGI的解释就是Open Service Gateway Initiative，直译过来就是“开放的服务入口(网关)的初始化”，听起来非常费解，什么是服务入口初始化？
+
+所以我们不去直译这个OSGI，我们换一种说法来描述OSGI技术。
+
+我们来回到我们以前的某些开发场景中去，假设我们使用SSH(struts+spring+hibernate)框架来开发我们的Web项目，我们做产品设计和开发的时候都是分模块的，我们分模块的目的就是实现模块之间的“解耦”，更进一步的目的是方便对一个项目的控制和管理。
+我们对一个项目进行模块化分解之后，我们就可以把不同模块交给不同的开发人员来完成开发，然后项目经理把大家完成的模块集中在一起，然后拼装成一个最终的产品。一般我们开发都是这样的基本情况。
+
+那么我们开发的时候预计的是系统的功能，根据系统的功能来进行模块的划分，也就是说，这个产品的功能或客户的需求是划分的重要依据。
+
+但是我们在开发过程中，我们模块之间还要彼此保持联系，比如A模块要从B模块拿到一些数据，而B模块可能要调用C模块中的一些方法(除了公共底层的工具类之外)。所以这些模块只是一种逻辑意义上的划分。
+
+最重要的一点是，我们把最终的项目要去部署到tomcat或者jBoss的服务器中去部署。那么我们启动服务器的时候，能不能关闭项目的某个模块或功能呢？很明显是做不到的，一旦服务器启动，所有模块就要一起启动，都要占用服务器资源，所以关闭不了模块，假设能强制拿掉，就会影响其它的功能。
+
+以上就是我们传统模块式开发的一些局限性。
+
+我们做软件开发一直在追求一个境界，就是模块之间的真正“解耦”、“分离”，这样我们在软件的管理和开发上面就会更加的灵活，甚至包括给客户部署项目的时候都可以做到更加的灵活可控。但是我们以前使用SSH框架等架构模式进行产品开发的时候我们是达不到这种要求的。
+
+所以我们“架构师”或顶尖的技术高手都在为模块化开发努力的摸索和尝试，然后我们的OSGI的技术规范就应运而生。
+
+现在我们的OSGI技术就可以满足我们之前所说的境界:在不同的模块中做到彻底的分离，而不是逻辑意义上的分离，是物理上的分离，也就是说在运行部署之后都可以在不停止服务器的时候直接把某些模块拿下来，其他模块的功能也不受影响。
+
+由此，OSGI技术将来会变得非常的重要，因为它在实现模块化解耦的路上，走得比现在大家经常所用的SSH框架走的更远。这个技术在未来大规模、高访问、高并发的Java模块化开发领域，或者是项目规范化管理中，会大大超过SSH等框架的地位。
+
+现在主流的一些应用服务器，Oracle的weblogic服务器，IBM的WebSphere，JBoss，还有Sun公司的glassfish服务器，都对OSGI提供了强大的支持，都是在OSGI的技术基础上实现的。有那么多的大型厂商支持OSGI这门技术，我们既可以看到OSGI技术的重要性。所以将来OSGI是将来非常重要的技术。 
+
+但是OSGI仍然脱离不了框架的支持，因为OSGI本身也使用了很多spring等框架的基本控件(因为要实现AOP依赖注入等功能)，但是哪个项目又不去依赖第三方jar呢？
+
+  
+ 双亲委派模型的另一次“被破坏”是由于用户对程序动态性的追求而导致的，这里所说的“动态性”指的是当前一些非常“热门”的名词：代码热替换（HotSwap）、模块热部署（HotDeployment）等，说白了就是希望应用程序能像我们的计算机外设那样，接上鼠标、U盘，不用重启机器就能立即使用，鼠标有问题或要升级就换个鼠标，不用停机也不用重启。
+
+ 对于个人计算机来说，重启一次其实没有什么大不了的，但对于一些生产系统来说，关机重启一次可能就要被列为生产事故，这种情况下热部署就对软件开发者，尤其是企业级软件开发者具有很大的吸引力。Sun公司所提出的JSR-294、JSR-277规范在与JCP组织的模块化规范之争中落败给JSR-291（即OSGi R4.2），虽然Sun不甘失去Java模块化的主导权，独立在发展Jigsaw项目，但目前OSGi已经成为了业界“事实上”的Java模块化标准，而OSGi实现模块化热部署的关键则是它自定义的类加载器机制的实现。
+
+ 每一个程序模块（OSGi中称为Bundle）都有一个自己的类加载器，当需要更换一个Bundle时，就把Bundle连同类加载器一起换掉以实现代码的热替换。
+
+ 在OSGi环境下，类加载器不再是双亲委派模型中的树状结构，而是进一步发展为更加复杂的网状结构，当收到类加载请求时，OSGi将按照下面的顺序进行类搜索：
+
+    1）将以java.*开头的类委派给父类加载器加载。
+    
+    2）否则，将委派列表名单内的类委派给父类加载器加载。
+    
+    3）否则，将Import列表中的类委派给Export这个类的Bundle的类加载器加载。
+    
+    4）否则，查找当前Bundle的ClassPath，使用自己的类加载器加载。
+    
+    5）否则，查找类是否在自己的Fragment Bundle中，如果在，则委派给Fragment Bundle的类加载器加载。
+    
+    6）否则，查找Dynamic Import列表的Bundle，委派给对应Bundle的类加载器加载。
+    
+    7）否则，类查找失败。
+
+ 上面的查找顺序中只有开头两点仍然符合双亲委派规则，其余的类查找都是在平级的类加载器中进行的。
+
+ 只要有足够意义和理由，突破已有的原则就可认为是一种创新。正如OSGi中的类加载器并不符合传统的双亲委派的类加载器，并且业界对其为了实现热部署而带来的额外的高复杂度还存在不少争议，但在Java程序员中基本有一个共识：OSGi中对类加载器的使用是很值得学习的，弄懂了OSGi的实现，就可以算是掌握了类加载器的精髓。
+
+
+## Tomcat类加载器以及应用间class隔离与共享
+
+
+
+Tomcat的用户一定都使用过其应用部署功能，无论是直接拷贝文件到webapps目录，还是修改server.xml以目录的形式部署，或者是增加虚拟主机，指定新的appBase等等。
+
+但部署应用时，不知道你是否曾注意过这几点：
+
+1.  如果在一个Tomcat内部署多个应用，甚至多个应用内使用了某个类似的几个不同版本，但它们之间却互不影响。这是如何做到的。
+
+2.  如果多个应用都用到了某类似的相同版本，是否可以统一提供，不在各个应用内分别提供，占用内存呢。
+
+3.  还有时候，在开发Web应用时，在pom.xml中添加了servlet-api的依赖，那实际应用的class加载时，会加载你的servlet-api 这个jar吗
+
+以上提到的这几点，在Tomcat以及各类的应用服务器中，都是通过类加载器（ClasssLoader）来实现的。通过本文，你可以了解到Tomcat内部提供的各种类加载器，Web应用的class和资源等加载的方式，以及其内部的实现原理。在遇到类似问题时，更胸有成竹。
+
+### 类加载器
+
+Java语言本身，以及现在其它的一些基于JVM之上的语言(Groovy，Jython， Scala...)，都是在将代码编译生成class文件，以实现跨多平台，write once, run anywhere。最终的这些class文件，在应用中，又被加载到JVM虚拟机中，开始工作。而把class文件加载到JVM的组件，就是我们所说的类加载器。而对于类加载器的抽象，能面对更多的class数据提供形式，例如网络、文件系统等。
+
+Java中常见的那个ClassNotFoundException和NoClassDefFoundError就是类加载器告诉我们的。
+
+Servlet规范指出，容器用于加载Web应用内Servlet的class loader, 允许加载位于Web应用内的资源。但不允许重写java.*, javax.*以及容器实现的类。同时
+
+每个应用内使用Thread.currentThread.getContextClassLoader()获得的类加载器，都是该应用区别于其它应用的类加载器等等。
+
+根据Servlet规范，各个应用服务器厂商自行实现。所以像其他的一些应用服务器一样， Tomcat也提供了多种的类加载器，以便应用服务器内的class以及部署的Web应用类文件运行在容器中时，可以使用不同的class repositories。
+
+在Java中，类加载器是以一种父子关系树来组织的。除Bootstrap外，都会包含一个parent 类加载器。(这里写parent 类加载器，而不是父类加载器，不是为了装X，是为了避免和Java里的父类混淆)一般以类加载器需要加载一个class或者资源文件的时候，他会先委托给他的parent类加载器，让parent类加载器先来加载，如果没有，才再在自己的路径上加载。这就是人们常说的双亲委托，即把类加载的请求委托给parent。
+
+但是...，这里需要注意一下
+
+> 对于Web应用的类加载，和上面的双亲委托是有区别的。
+
+ 主流的Java Web服务器（也就是Web容器），如Tomcat、Jetty、WebLogic、WebSphere或其他笔者没有列举的服务器，都实现了自己定义的类加载器（一般都不止一个）。因为一个功能健全的Web容器，要解决如下几个问题：
+
+ 1）部署在同一个Web容器上的两个Web应用程序所使用的Java类库可以实现相互隔离。这是最基本的需求，两个不同的应用程序可能会依赖同一个第三方类库的不同版本，不能要求一个类库在一个服务器中只有一份，服务器应当保证两个应用程序的类库可以互相独立使用。
+
+ 2）部署在同一个Web容器上的两个Web应用程序所使用的Java类库可以互相共享。这个需求也很常见，例如，用户可能有10个使用[spring](https://yq.aliyun.com/go/articleRenderRedirect?url=https%3A%2F%2Flink.juejin.im%2F%3Ftarget%3Dhttp%253A%252F%252Flib.csdn.net%252Fbase%252Fjavaee "Java EE知识库")组织的应用程序部署在同一台服务器上，如果把10份Spring分别存放在各个应用程序的隔离目录中，将会是很大的资源浪费——这主要倒不是浪费磁盘空间的问题，而是指类库在使用时都要被加载到Web容器的内存，如果类库不能共享，虚拟机的方法区就会很容易出现过度膨胀的风险。
+
+ 3）Web容器需要尽可能地保证自身的安全不受部署的Web应用程序影响。目前，有许多主流的Java Web容器自身也是使用Java语言来实现的。因此，Web容器本身也有类库依赖的问题，一般来说，基于安全考虑，容器所使用的类库应该与应用程序的类库互相独立。
+
+ 4）支持JSP应用的Web容器，大多数都需要支持HotSwap功能。我们知道，JSP文件最终要编译成Java Class才能由虚拟机执行，但JSP文件由于其纯文本存储的特性，运行时修改的概率远远大于第三方类库或程序自身的Class文件。而且ASP、[PHP](https://yq.aliyun.com/go/articleRenderRedirect?url=https%3A%2F%2Flink.juejin.im%2F%3Ftarget%3Dhttp%253A%252F%252Flib.csdn.net%252Fbase%252Fphp "PHP知识库")和JSP这些网页应用也把修改后无须重启作为一个很大的“优势”来看待，因此“主流”的Web容器都会支持JSP生成类的热替换，当然也有“非主流”的，如运行在生产模式（Production Mode）下的WebLogic服务器默认就不会处理JSP文件的变化。
+
+ 由于存在上述问题，在部署Web应用时，单独的一个Class Path就无法满足需求了，所以各种Web容都“不约而同”地提供了好几个Class Path路径供用户存放第三方类库，这些路径一般都以“lib”或“classes”命名。被放置到不同路径中的类库，具备不同的访问范围和服务对象，通常，每一个目录都会有一个相应的自定义类加载器去加载放置在里面的Java类库。现在，就以Tomcat容器为例，看一看Tomcat具体是如何规划用户类库结构和类加载器的。
+
+ 在Tomcat目录结构中，有3组目录（“/common/*”、“/server/*”和“/shared/*”）可以存放Java类库，另外还可以加上Web应用程序自身的目录“/WEB-INF/*”，一共4组，把Java类库放置在这些目录中的含义分别如下：
+
+ ①放置在/common目录中：类库可被Tomcat和所有的Web应用程序共同使用。
+
+ ②放置在/server目录中：类库可被Tomcat使用，对所有的Web应用程序都不可见。
+
+ ③放置在/shared目录中：类库可被所有的Web应用程序共同使用，但对Tomcat自己不可见。
+
+ ④放置在/WebApp/WEB-INF目录中：类库仅仅可以被此Web应用程序使用，对Tomcat和其他Web应用程序都不可见。
+
+ 为了支持这套目录结构，并对目录里面的类库进行加载和隔离，Tomcat自定义了多个类加载器，这些类加载器按照经典的双亲委派模型来实现，其关系如下图所示。
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404222020.png)
+  
+
+  
+
+
+
+ 上图中灰色背景的3个类加载器是JDK默认提供的类加载器，这3个加载器的作用已经介绍过了。而CommonClassLoader、CatalinaClassLoader、SharedClassLoader和WebappClassLoader则是Tomcat自己定义的类加载器，它们分别加载/common/*、/server/*、/shared/*和/WebApp/WEB-INF/*中的Java类库。其中WebApp类加载器和Jsp类加载器通常会存在多个实例，每一个Web应用程序对应一个WebApp类加载器，每一个JSP文件对应一个Jsp类加载器。
+
+ 从图中的委派关系中可以看出，CommonClassLoader能加载的类都可以被CatalinaClassLoader和SharedClassLoader使用，而CatalinaClassLoader和SharedClassLoader自己能加载的类则与对方相互隔离。WebAppClassLoader可以使用SharedClassLoader加载到的类，但各个WebAppClassLoader实例之间相互隔离。
+
+ 而JasperLoader的加载范围仅仅是这个JSP文件所编译出来的那一个.Class文件，它出现的目的就是为了被丢弃：当Web容器检测到JSP文件被修改时，会替换掉目前的JasperLoader的实例，并通过再建立一个新的Jsp类加载器来实现JSP文件的HotSwap功能。
+
+对于Tomcat的6.x版本，只有指定了tomcat/conf/catalina.properties配置文件的server.loader和share.loader项后才会真正建立CatalinaClassLoader和Shared ClassLoader的实例，否则在用到这两个类加载器的地方都会用Common ClassLoader的实例代替，而默认的配置文件中没有设置这两个loader项，所以Tomcat 6.x顺理成章地把/common、/server和/shared三个目录默认合并到一起变成一个/lib目录，这个目录里的类库相当于以前/common目录中类库的作用。
+
+这是Tomcat设计团队为了简化大多数的部署场景所做的一项改进，如果默认设置不能满足需要，用户可以通过修改配置文件指定server.loader和share.loader的方式重新启用Tomcat 5.x的加载器[架构](https://yq.aliyun.com/go/articleRenderRedirect?url=https%3A%2F%2Flink.juejin.im%2F%3Ftarget%3Dhttp%253A%252F%252Flib.csdn.net%252Fbase%252Farchitecture "大型网站架构知识库")。
+
+  Tomcat加载器的实现清晰易懂，并且采用了官方推荐的“正统”的使用类加载器的方式。如果读者阅读完上面的案例后，能完全理解Tomcat设计团队这样布置加载器架构的用意，那说明已经大致掌握了类加载器“主流”的使用方式，那么笔者不妨再提一个问题让读者思考一下：前面曾经提到过一个场景，如果有10个Web应用程序都是用Spring来进行组织和管理的话，可以把Spring放到Common或Shared目录下让这些程序共享。
+
+  Spring要对用户程序的类进行管理，自然要能访问到用户程序的类，而用户的程序显然是放在/WebApp/WEB-INF目录中的，那么被CommonClassLoader或SharedClassLoader加载的Spring如何访问并不在其加载范围内的用户程序呢？如果研究过虚拟机类加载器机制中的双亲委派模型，相信读者可以很容易地回答这个问题。
+
+分析：如果按主流的双亲委派机制，显然无法做到让父类加载器加载的类去访问子类加载器加载的类，上面在类加载器一节中提到过通过线程上下文方式传播类加载器。
+
+ 答案是使用线程上下文类加载器来实现的，使用线程上下文加载器，可以让父类加载器请求子类加载器去完成类加载的动作。
+
+ 看spring源码发现，spring加载类所用的Classloader是通过Thread.currentThread().getContextClassLoader()来获取的，而当线程创建时会默认setContextClassLoader(AppClassLoader)，即线程上下文类加载器被设置为AppClassLoader，spring中始终可以获取到这个AppClassLoader(在Tomcat里就是WebAppClassLoader)子类加载器来加载bean，以后任何一个线程都可以通过getContextClassLoader()获取到WebAppClassLoader来getbean了。
+
+  
+
+本篇博文内容取材自《深入理解Java虚拟机：JVM高级特性与最佳实践》
+
+## 参考文章
+
+<https://segmentfault.com/a/1190000009707894>
+
+<https://www.cnblogs.com/hysum/p/7100874.html>
+
+<http://c.biancheng.net/view/939.html>
+
+<https://www.runoob.com/>
+
+https://blog.csdn.net/android_hl/article/details/53228348
+
+
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2721\357\274\232JVM\345\206\205\345\255\230\347\232\204\347\273\223\346\236\204\344\270\216\346\266\210\345\244\261\347\232\204\346\260\270\344\271\205\344\273\243.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\345\206\205\345\255\230\347\232\204\347\273\223\346\236\204\344\270\216\346\266\210\345\244\261\347\232\204\346\260\270\344\271\205\344\273\243.md"
similarity index 75%
rename from "docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2721\357\274\232JVM\345\206\205\345\255\230\347\232\204\347\273\223\346\236\204\344\270\216\346\266\210\345\244\261\347\232\204\346\260\270\344\271\205\344\273\243.md"
rename to "docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\345\206\205\345\255\230\347\232\204\347\273\223\346\236\204\344\270\216\346\266\210\345\244\261\347\232\204\346\260\270\344\271\205\344\273\243.md"
index d040fa5..17431e9 100644
--- "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2721\357\274\232JVM\345\206\205\345\255\230\347\232\204\347\273\223\346\236\204\344\270\216\346\266\210\345\244\261\347\232\204\346\260\270\344\271\205\344\273\243.md"
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\345\206\205\345\255\230\347\232\204\347\273\223\346\236\204\344\270\216\346\266\210\345\244\261\347\232\204\346\260\270\344\271\205\344\273\243.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [前言](#前言)
   * [Java堆（Heap）](#java堆（heap）)
   * [方法区（Method Area）](#方法区（method-area）)
@@ -7,25 +6,22 @@
   * [JVM栈（JVM Stacks）](#jvm栈（jvm-stacks）)
   * [本地方法栈（Native Method Stacks）](#本地方法栈（native-method-stacks）)
   * [哪儿的OutOfMemoryError](#哪儿的outofmemoryerror)
-* [[JDK8-废弃永久代（PermGen）迎来元空间（Metaspace）](https://www.cnblogs.com/yulei126/p/6777323.html)](#[jdk8-废弃永久代（permgen）迎来元空间（metaspace）]httpswwwcnblogscomyulei126p6777323html)
   * [一、背景](#一、背景)
     * [1.1 永久代（PermGen）在哪里？](#11-永久代（permgen）在哪里？)
     * [1.2 JDK8永久代的废弃](#12-jdk8永久代的废弃)
-  * [ 二、为什么废弃永久代（PermGen）](# 二、为什么废弃永久代（permgen）)
-    * [ 2.1 官方说明](# 21-官方说明)
+  * [二、为什么废弃永久代（PermGen）](#二、为什么废弃永久代（permgen）)
+    * [2.1 官方说明](#21-官方说明)
   * [Motivation](#motivation)
-    * [ 2.2 现实使用中易出问题](# 22-现实使用中易出问题)
+    * [2.2 现实使用中易出问题](#22-现实使用中易出问题)
   * [三、深入理解元空间（Metaspace）](#三、深入理解元空间（metaspace）)
     * [3.1元空间的内存大小](#31元空间的内存大小)
     * [3.2常用配置参数](#32常用配置参数)
     * [3.3测试并追踪元空间大小](#33测试并追踪元空间大小)
-      * [ 3.3.1.测试字符串常量](# 331测试字符串常量)
+      * [3.3.1.测试字符串常量](#331测试字符串常量)
       * [3.3.2.测试元空间溢出](#332测试元空间溢出)
-  * [ 四、总结](# 四、总结)
+  * [四、总结](#四、总结)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 本文转自互联网，侵删
@@ -54,11 +50,9 @@
 
 其实如果你经常解决服务器性能问题，那么这些问题就会变的非常常见，了解JVM内存也是为了服务器出现性能问题的时候可以快速的了解那块的内存区域出现问题，以便于快速的解决生产故障。
 
-
-
 先看一张图，这张图能很清晰的说明JVM内存结构布局。
 
-![](http://blog.itpub.net/ueditor/php/upload/image/20190817/1566036730192392.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404214718.png)
 
 JVM内存结构主要有三大块：堆内存、方法区和栈。堆内存是JVM中最大的一块由年轻代和老年代组成，而年轻代内存又被分成三部分，Eden空间、From Survivor空间、To Survivor空间,默认情况下年轻代按照8:1:1的比例来分配；
 
@@ -66,8 +60,7 @@ JVM内存结构主要有三大块：堆内存、方法区和栈。堆内存是JV
 
 在通过一张图来了解如何通过参数来控制各区域的内存大小
 
-![](http://blog.itpub.net/ueditor/php/upload/image/20190817/1566036730949557.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404214735.png)
 控制参数
 
 *   -Xms设置堆的最小空间大小。
@@ -84,7 +77,7 @@ JVM内存结构主要有三大块：堆内存、方法区和栈。堆内存是JV
 
 从更高的一个维度再次来看JVM和系统调用之间的关系
 
-![](http://blog.itpub.net/ueditor/php/upload/image/20190817/1566036732641186.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404214754.png)
 
 方法区和对是所有线程共享的内存区域；而java栈、本地方法栈和程序员计数器是运行是线程私有的内存区域。
 
@@ -112,7 +105,7 @@ Java虚拟机规范对这个区域的限制非常宽松，除了和Java堆一样
 
 方法区有时被称为持久代（PermGen）。
 
-![](http://blog.itpub.net/ueditor/php/upload/image/20190817/1566036749972827.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404214839.png)
 
 所有的对象在实例化后的整个运行周期内，都被存放在堆内存中。堆内存又被划分成不同的部分：伊甸区(Eden)，幸存者区域(Survivor Sapce)，老年代（Old Generation Space）。
 
@@ -121,27 +114,26 @@ Java虚拟机规范对这个区域的限制非常宽松，除了和Java堆一样
 
 
 
-
-<pre>import java.text.SimpleDateFormat;import java.util.Date;import org.apache.log4j.Logger;
+````
+import java.text.SimpleDateFormat;import java.util.Date;import org.apache.log4j.Logger;
  public class HelloWorld {
-    private static Logger LOGGER = Logger.getLogger(HelloWorld.class.getName());
-    public void sayHello(String message) {
-        SimpleDateFormat formatter = new SimpleDateFormat("dd.MM.YYYY");
-        String today = formatter.format(new Date());
-        LOGGER.info(today + ": " + message);
-    }}</pre>
-
+  private static Logger LOGGER = Logger.getLogger(HelloWorld.class.getName());
+  public void sayHello(String message) {
+    SimpleDateFormat formatter = new SimpleDateFormat("dd.MM.YYYY");
+    String today = formatter.format(new Date());
+    LOGGER.info(today + ": " + message);
+  }}
 
+````
 
 
 
 这段程序的数据在内存中的存放如下：
 
-![](http://blog.itpub.net/ueditor/php/upload/image/20190817/1566036766406898.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404214906.png)
 通过JConsole工具可以查看运行中的Java程序（比如Eclipse）的一些信息：堆内存的分配，线程的数量以及加载的类的个数；
 
-![](http://blog.itpub.net/ueditor/php/upload/image/20190817/1566036768475136.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404214922.png)
 
 ## 程序计数器（Program Counter Register）
 
@@ -172,69 +164,38 @@ Java虚拟机规范对这个区域的限制非常宽松，除了和Java堆一样
 对内存结构清晰的认识同样可以帮助理解不同OutOfMemoryErrors：
 
 
-
-
-
-<pre>Exception in thread “main”: java.lang.OutOfMemoryError: Java heap space</pre>
-
-
-
+Exception in thread “main”: java.lang.OutOfMemoryError: Java heap space
 
 
 原因：对象不能被分配到堆内存中
 
 
-
-
-
-<pre>Exception in thread “main”: java.lang.OutOfMemoryError: PermGen space</pre>
-
-
-
+Exception in thread “main”: java.lang.OutOfMemoryError: PermGen space
 
 
 原因：类或者方法不能被加载到持久代。它可能出现在一个程序加载很多类的时候，比如引用了很多第三方的库；
 
-
-
-
-
-<pre>Exception in thread “main”: java.lang.OutOfMemoryError: Requested array size exceeds VM limit</pre>
-
-
-
+Exception in thread “main”: java.lang.OutOfMemoryError: Requested array size exceeds VM limit
 
 
 原因：创建的数组大于堆内存的空间
 
 
-
-
-
-<pre>Exception in thread “main”: java.lang.OutOfMemoryError: request <size> bytes for <reason>. Out of swap space?</pre>
-
-
-
+Exception in thread “main”: java.lang.OutOfMemoryError: request <size> bytes for <reason>. Out of swap space?
 
 
 原因：分配本地分配失败。JNI、本地库或者Java虚拟机都会从本地堆中分配内存空间。
 
 
-
-
-
-<pre>Exception in thread “main”: java.lang.OutOfMemoryError: <reason> <stack trace>（Native method）</pre>
-
-
-
+Exception in thread “main”: java.lang.OutOfMemoryError: <reason> <stack trace>（Native method）
 
 
 原因：同样是本地方法内存分配失败，只不过是JNI或者本地方法或者Java虚拟机发现
 
-# [JDK8-废弃永久代（PermGen）迎来元空间（Metaspace）](https://www.cnblogs.com/yulei126/p/6777323.html)
-
-
+关于永久代的废弃可以参考这篇文章
 
+JDK8-废弃永久代（PermGen）迎来元空间（Metaspace）
+(https://www.cnblogs.com/yulei126/p/6777323.html)
 
 
 1.背景
@@ -253,8 +214,7 @@ Java虚拟机规范对这个区域的限制非常宽松，除了和Java堆一样
 
 根据，hotspot jvm结构如下(虚拟机栈和本地方法栈合一起了)：
 
-![](http://blog.itpub.net/ueditor/php/upload/image/20190817/1566036768860207.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404215109.png)
 上图引自网络，但有个问题：方法区和heap堆都是线程共享的内存区域。
 
 关于方法区和永久代：
@@ -265,17 +225,16 @@ Java虚拟机规范对这个区域的限制非常宽松，除了和Java堆一样
 
 JDK8 永久代变化如下图：
 
-![](http://blog.itpub.net/ueditor/php/upload/image/20190817/1566036768834803.jpg)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404215123.png)
 1.新生代：Eden+From Survivor+To Survivor
 
 2.老年代：OldGen
 
 3.永久代（方法区的实现） : PermGen----->替换为Metaspace(本地内存中)
 
-##  二、为什么废弃永久代（PermGen）
+## 二、为什么废弃永久代（PermGen）
 
-###  2.1 官方说明
+### 2.1 官方说明
 
 参照JEP122：http://openjdk.java.net/jeps/122，原文截取：
 
@@ -283,9 +242,9 @@ JDK8 永久代变化如下图：
 
 This is part of the JRockit and Hotspot convergence effort. JRockit customers do not need to configure the permanent generation (since JRockit does not have a permanent generation) and are accustomed to not configuring the permanent generation.
 
- 即：移除永久代是为融合HotSpot JVM与 JRockit VM而做出的努力，因为JRockit没有永久代，不需要配置永久代。
+即：移除永久代是为融合HotSpot JVM与 JRockit VM而做出的努力，因为JRockit没有永久代，不需要配置永久代。
 
-###  2.2 现实使用中易出问题
+### 2.2 现实使用中易出问题
 
 由于永久代内存经常不够用或发生内存泄露，爆出异常java.lang.OutOfMemoryError: PermGen
 
@@ -303,7 +262,7 @@ This is part of the JRockit and Hotspot convergence effort. JRockit customers do
 
 1.MetaspaceSize
 
-初始化的Metaspace大小，控制元空间发生GC的阈值。GC后，动态增加或降低MetaspaceSize。在默认情况下，这个值大小根据不同的平台在12M到20M浮动。使用[Java](http://lib.csdn.net/base/javase "Java SE知识库") -XX:+PrintFlagsInitial命令查看本机的初始化参数
+初始化的Metaspace大小，控制元空间发生GC的阈值。GC后，动态增加或降低MetaspaceSize。在默认情况下，这个值大小根据不同的平台在12M到20M浮动。使用[Java](http://lib.csdn.net/base/javase "Java SE知识库")-XX:+PrintFlagsInitial命令查看本机的初始化参数
 
 2.MaxMetaspaceSize
 
@@ -327,40 +286,32 @@ Metaspace增长时的最小幅度。在本机上该参数的默认值为340784B
 
 ### 3.3测试并追踪元空间大小
 
-####  3.3.1.测试字符串常量
-
-
-
-
-
-
-<pre> 1 public class StringOomMock {
- 2     static String  base = "string";
- 3     
- 4     public static void main(String[] args) {
- 5         List<String> list = new ArrayList<String>();
- 6         for (int i=0;i< Integer.MAX_VALUE;i++){
- 7             String str = base + base;
- 8             base = str;
- 9             list.add(str.intern());
-10         }
-11     }
-12 }</pre>
-
-
-
-
-
+#### 3.3.1.测试字符串常量
+
+````
+public class StringOomMock {
+    static String  base = "string";
+    
+    public static void main(String[] args) {
+        List<String> list = new ArrayList<String>();
+        for (int i=0;i< Integer.MAX_VALUE;i++){
+            String str = base + base;
+            base = str;
+            list.add(str.intern());
+        }
+    }
+}
+````
 
 在eclipse中选中类--》run configuration-->java application--》new 参数如下：
 
-![](http://blog.itpub.net/ueditor/php/upload/image/20190817/1566036770114377.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404215213.png)
 
- 由于设定了最大内存20M，很快就溢出，如下图：
+由于设定了最大内存20M，很快就溢出，如下图：
 
-![](http://blog.itpub.net/ueditor/php/upload/image/20190817/1566036770308300.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404215254.png)
 
- 可见在jdk8中：
+可见在jdk8中：
 
 1.字符串常量由永久代转移到堆中。
 
@@ -369,86 +320,71 @@ Metaspace增长时的最小幅度。在本机上该参数的默认值为340784B
 #### 3.3.2.测试元空间溢出
 
 根据定义，我们以加载类来测试元空间溢出，代码如下：
-
-
-
-
-
-
-<pre> 1 package jdk8;
- 2 
- 3 import java.io.File;
- 4 import java.lang.management.ClassLoadingMXBean;
- 5 import java.lang.management.ManagementFactory;
- 6 import java.net.URL;
- 7 import java.net.URLClassLoader;
- 8 import java.util.ArrayList;
- 9 import java.util.List;
-10 
-11 /**
-12  * 
-13  * @ClassName:OOMTest
-14  * @Description:模拟类加载溢出（元空间oom）
-15  * @author diandian.zhang
-16  * @date 2017年4月27日上午9:45:40
-17  */
-18 public class OOMTest {  
-19     public static void main(String[] args) {  
-20         try {  
-21             //准备url  
-22             URL url = new File("D:/58workplace/11study/src/main/java/jdk8").toURI().toURL();  
-23             URL[] urls = {url};  
-24             //获取有关类型加载的JMX接口  
-25             ClassLoadingMXBean loadingBean = ManagementFactory.getClassLoadingMXBean();  
-26             //用于缓存类加载器  
-27             List<ClassLoader> classLoaders = new ArrayList<ClassLoader>();  
-28             while (true) {  
-29                 //加载类型并缓存类加载器实例  
-30                 ClassLoader classLoader = new URLClassLoader(urls);  
-31                 classLoaders.add(classLoader);  
-32                 classLoader.loadClass("ClassA");  
-33                 //显示数量信息（共加载过的类型数目，当前还有效的类型数目，已经被卸载的类型数目）  
-34                 System.out.println("total: " + loadingBean.getTotalLoadedClassCount());  
-35                 System.out.println("active: " + loadingBean.getLoadedClassCount());  
-36                 System.out.println("unloaded: " + loadingBean.getUnloadedClassCount());  
-37             }  
-38         } catch (Exception e) {  
-39             e.printStackTrace();  
-40         }  
-41     }  
-42 }  </pre>
-
-
-
-
-
+````
+package jdk8;
+
+import java.io.File;
+import java.lang.management.ClassLoadingMXBean;
+import java.lang.management.ManagementFactory;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 
+ * @ClassName:OOMTest
+ * @Description:模拟类加载溢出（元空间oom）
+ * @author diandian.zhang
+ * @date 2017年4月27日上午9:45:40
+ */
+public class OOMTest {  
+    public static void main(String[] args) {  
+        try {  
+            //准备url  
+            URL url = new File("D:/58workplace/11study/src/main/java/jdk8").toURI().toURL();  
+            URL[] urls = {url};  
+            //获取有关类型加载的JMX接口  
+            ClassLoadingMXBean loadingBean = ManagementFactory.getClassLoadingMXBean();  
+            //用于缓存类加载器  
+            List<ClassLoader> classLoaders = new ArrayList<ClassLoader>();  
+            while (true) {  
+                //加载类型并缓存类加载器实例  
+                ClassLoader classLoader = new URLClassLoader(urls);  
+                classLoaders.add(classLoader);  
+                classLoader.loadClass("ClassA");  
+                //显示数量信息（共加载过的类型数目，当前还有效的类型数目，已经被卸载的类型数目）  
+                System.out.println("total: " + loadingBean.getTotalLoadedClassCount());  
+                System.out.println("active: " + loadingBean.getLoadedClassCount());  
+                System.out.println("unloaded: " + loadingBean.getUnloadedClassCount());  
+            }  
+        } catch (Exception e) {  
+            e.printStackTrace();  
+        }  
+    }  
+}  
+````
 
 为了快速溢出，设置参数：-XX:MetaspaceSize=8m -XX:MaxMetaspaceSize=80m，运行结果如下：
 
-![](http://blog.itpub.net/ueditor/php/upload/image/20190817/1566036772261654.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404215337.png)
 
- 上图证实了，我们的JDK8中类加载（方法区的功能）已经不在永久代PerGem中了，而是Metaspace中。可以配合JVisualVM来看，更直观一些。
+上图证实了，我们的JDK8中类加载（方法区的功能）已经不在永久代PerGem中了，而是Metaspace中。可以配合JVisualVM来看，更直观一些。
 
-##  四、总结
+## 四、总结
 
 本文讲解了元空间（Metaspace）的由来和本质，常用配置，以及监控测试。元空间的大小是动态变更的，但不是无限大的，最好也时常关注一下大小，以免影响服务器内存。
 
 
-
-
-
-
-
-
 ## 参考文章
 
-<https://segmentfault.com/a/1190000009707894>
+https://segmentfault.com/a/1190000009707894
 
-<https://www.cnblogs.com/hysum/p/7100874.html>
+https://www.cnblogs.com/hysum/p/7100874.html
 
-<http://c.biancheng.net/view/939.html>
+http://c.biancheng.net/view/939.html
 
-<https://www.runoob.com/>
+https://www.runoob.com
 
 https://blog.csdn.net/android_hl/article/details/53228348
 
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2722\357\274\232JVM\345\236\203\345\234\276\345\233\236\346\224\266\345\237\272\346\234\254\345\216\237\347\220\206\345\222\214\347\256\227\346\263\225.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\345\236\203\345\234\276\345\233\236\346\224\266\345\237\272\346\234\254\345\216\237\347\220\206\345\222\214\347\256\227\346\263\225.md"
similarity index 80%
rename from "docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2722\357\274\232JVM\345\236\203\345\234\276\345\233\236\346\224\266\345\237\272\346\234\254\345\216\237\347\220\206\345\222\214\347\256\227\346\263\225.md"
rename to "docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\345\236\203\345\234\276\345\233\236\346\224\266\345\237\272\346\234\254\345\216\237\347\220\206\345\222\214\347\256\227\346\263\225.md"
index e8a7e29..8048fb5 100644
--- "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2722\357\274\232JVM\345\236\203\345\234\276\345\233\236\346\224\266\345\237\272\346\234\254\345\216\237\347\220\206\345\222\214\347\256\227\346\263\225.md"
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\345\236\203\345\234\276\345\233\236\346\224\266\345\237\272\346\234\254\345\216\237\347\220\206\345\222\214\347\256\227\346\263\225.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [JVM GC基本原理与GC算法](#jvm-gc基本原理与gc算法)
   * [Java关键术语](#java关键术语)
   * [Java HotSpot 虚拟机](#java-hotspot-虚拟机)
@@ -15,7 +14,7 @@
   * [垃圾回收中实例的终结](#垃圾回收中实例的终结)
   * [对象什么时候符合垃圾回收的条件？](#对象什么时候符合垃圾回收的条件？)
     * [GC Scope 示例程序](#gc-scope-示例程序)
-  * [[JVM GC算法](https://www.cnblogs.com/wupeixuan/p/8670341.html)](#[jvm-gc算法]httpswwwcnblogscomwupeixuanp8670341html)
+  * [JVM GC算法](#JVM GC算法)
   * [JVM垃圾判定算法](#jvm垃圾判定算法)
     * [引用计数算法(Reference Counting)](#引用计数算法reference-counting)
     * [可达性分析算法（根搜索算法）](#可达性分析算法（根搜索算法）)
@@ -26,9 +25,7 @@
   * [标记—整理算法（Mark-Compact）](#标记整理算法（mark-compact）)
   * [分代收集算法(Generational Collection)](#分代收集算法generational-collection)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 本文转自互联网，侵删
@@ -53,8 +50,6 @@
 
 ## JVM GC基本原理与GC算法
 
-
-
 Java的内存分配与回收全部由JVM垃圾回收进程自动完成。与C语言不同，Java开发者不需要自己编写代码实现垃圾回收。这是Java深受大家欢迎的众多特性之一，能够帮助程序员更好地编写Java程序。
 
 下面四篇教程是了解Java 垃圾回收（GC）的基础：
@@ -100,7 +95,7 @@ Java 垃圾回收是一项自动化的过程，用来管理程序所使用的运
 
 虽然这个请求机制提供给程序员一个启动 GC 过程的机会，但是启动由 JVM负责。JVM可以拒绝这个请求，所以并不保证这些调用都将执行垃圾回收。启动时机的选择由JVM决定，并且取决于堆内存中Eden区是否可用。JVM将这个选择留给了Java规范的实现，不同实现具体使用的算法不尽相同。
 
-毋庸置疑，我们知道垃圾回收过程是不能被强制执行的。我刚刚发现了一个调用`System.gc()`有意义的场景。通过这篇文章了解一下[适合调用System.gc() ](http://javapapers.com/core-java/system-gc-invocation-a-suitable-scenario/)这种极端情况。
+毋庸置疑，我们知道垃圾回收过程是不能被强制执行的。我刚刚发现了一个调用`System.gc()`有意义的场景。通过这篇文章了解一下[适合调用System.gc()](http://javapapers.com/core-java/system-gc-invocation-a-suitable-scenario/)这种极端情况。
 
 ## 各种GC的触发时机(When)
 
@@ -125,11 +120,11 @@ Java 垃圾回收是一项自动化的过程，用来管理程序所使用的运
 
 除直接调用System.gc外，触发Full GC执行的情况有如下四种。
 
-1. 旧生代空间不足
+1.旧生代空间不足
 
 旧生代空间只有在新生代对象转入及创建为大对象、大数组时才会出现不足的现象，当执行Full GC后空间仍然不足，则抛出如下错误：
 
-java.lang.OutOfMemoryError: Java heap space 
+java.lang.OutOfMemoryError:Javaheapspace
 
 为避免以上两种状况引起的Full GC，调优时应尽量做到让对象在Minor GC阶段被回收、让对象在新生代多存活一段时间及不要创建过大的对象及数组。
 
@@ -137,7 +132,7 @@ java.lang.OutOfMemoryError: Java heap space 
 
 Permanet Generation中存放的为一些class的信息等，当系统中要加载的类、反射的类和调用的方法较多时，Permanet Generation可能会被占满，在未配置为采用CMS GC的情况下会执行Full GC。如果经过Full GC仍然回收不了，那么JVM会抛出如下错误信息：
 
-java.lang.OutOfMemoryError: PermGen space 
+java.lang.OutOfMemoryError:PermGenspace
 
 为避免Perm Gen占满造成Full GC现象，可采用的方法为增大Perm Gen空间或转为使用CMS GC。
 
@@ -149,7 +144,7 @@ promotion failed是在进行Minor GC时，survivor space放不下、对象只能
 
 应对措施为：增大survivor space、旧生代空间或调低触发并发GC的比率，但在JDK 5.0+、6.0+的版本中有可能会由于JDK的bug29导致CMS在remark完毕后很久才触发sweeping动作。对于这种状况，可通过设置-XX: CMSMaxAbortablePrecleanTime=5（单位为ms）来避免。
 
-4. 统计得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间
+4.统计得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间
 
 这是一个较为复杂的触发情况，Hotspot为了避免由于新生代对象晋升到旧生代导致旧生代空间不足的现象，在进行Minor GC时，做了一个判断，如果之前统计所得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间，那么就直接触发Full GC。
 
@@ -161,7 +156,7 @@ promotion failed是在进行Minor GC时，survivor space放不下、对象只能
 
 ### 总结
 
-** Minor GC ，Full GC 触发条件**
+**Minor GC ，Full GC 触发条件**
 
 Minor GC触发条件：当Eden区满时，触发Minor GC。
 
@@ -201,7 +196,7 @@ JVM里有一条特殊的线程－－VM Threads，专门用来执行一些特殊
 
 Eden 区：当一个实例被创建了，首先会被存储在堆内存年轻代的 Eden 区中。
 
-注意：如果你不能理解这些词汇，我建议你阅读这篇 [垃圾回收介绍](http://javapapers.com/java/java-garbage-collection-introduction/) ，这篇教程详细地介绍了内存模型、JVM 架构以及这些术语。
+注意：如果你不能理解这些词汇，我建议你阅读这篇[垃圾回收介绍](http://javapapers.com/java/java-garbage-collection-introduction/)，这篇教程详细地介绍了内存模型、JVM 架构以及这些术语。
 
 Survivor 区（S0 和 S1）：作为年轻代 GC（Minor GC）周期的一部分，存活的对象（仍然被引用的）从 Eden 区被移动到 Survivor 区的 S0 中。类似的，垃圾回收器会扫描 S0 然后将存活的实例移动到 S1 中。
 
@@ -209,7 +204,7 @@ Survivor 区（S0 和 S1）：作为年轻代 GC（Minor GC）周期的一部分
 
 死亡的实例（不再被引用）被标记为垃圾回收。根据垃圾回收器（有四种常用的垃圾回收器，将在下一教程中介绍它们）选择的不同，要么被标记的实例都会不停地从内存中移除，要么回收过程会在一个单独的进程中完成。
 
-老年代： 老年代（Old or tenured generation）是堆内存中的第二块逻辑区。当垃圾回收器执行 Minor GC 周期时，在 S1 Survivor 区中的存活实例将会被晋升到老年代，而未被引用的对象被标记为回收。
+老年代：老年代（Old or tenured generation）是堆内存中的第二块逻辑区。当垃圾回收器执行 Minor GC 周期时，在 S1 Survivor 区中的存活实例将会被晋升到老年代，而未被引用的对象被标记为回收。
 
 老年代 GC（Major GC）：相对于 Java 垃圾回收过程，老年代是实例生命周期的最后阶段。Major GC 扫描老年代的垃圾回收过程。如果实例不再被引用，那么它们会被标记为回收，否则它们会继续留在老年代中。
 
@@ -217,7 +212,7 @@ Survivor 区（S0 和 S1）：作为年轻代 GC（Minor GC）周期的一部分
 
 ## 垃圾回收中实例的终结
 
-在释放一个实例和回收内存空间之前，Java 垃圾回收器会调用实例各自的 `finalize()` 方法，从而该实例有机会释放所持有的资源。虽然可以保证 `finalize()` 会在回收内存空间之前被调用，但是没有指定的顺序和时间。多个实例间的顺序是无法被预知，甚至可能会并行发生。程序不应该预先调整实例之间的顺序并使用 `finalize()` 方法回收资源。
+在释放一个实例和回收内存空间之前，Java 垃圾回收器会调用实例各自的`finalize()`方法，从而该实例有机会释放所持有的资源。虽然可以保证`finalize()`会在回收内存空间之前被调用，但是没有指定的顺序和时间。多个实例间的顺序是无法被预知，甚至可能会并行发生。程序不应该预先调整实例之间的顺序并使用`finalize()`方法回收资源。
 
 *   任何在 finalize过程中未被捕获的异常会自动被忽略，然后该实例的 finalize 过程被取消。
 *   JVM 规范中并没有讨论关于弱引用的垃圾回收机制，也没有很明确的要求。具体的实现都由实现方决定。
@@ -237,8 +232,8 @@ Survivor 区（S0 和 S1）：作为年轻代 GC（Minor GC）周期的一部分
 | 弱引用（Weak Reference） | 符合垃圾收集 |
 | 虚引用（Phantom Reference） | 符合垃圾收集 |
 
-在编译过程中作为一种优化技术，Java 编译器能选择给实例赋 `null` 值，从而标记实例为可回收。
-
+在编译过程中作为一种优化技术，Java 编译器能选择给实例赋`null`值，从而标记实例为可回收。
+````
     class Animal {
     
         public static void main(String[] args) {
@@ -258,140 +253,143 @@ Survivor 区（S0 和 S1）：作为年轻代 GC（Minor GC）周期的一部分
         }
     
     }
-
-在上面的类中，`lion` 对象在实例化行后从未被使用过。因此 Java 编译器作为一种优化措施可以直接在实例化行后赋值`lion = null`。因此，即使在 SOP 输出之前， finalize 函数也能够打印出 `'Rest in Peace!'`。我们不能证明这确定会发生，因为它依赖JVM的实现方式和运行时使用的内存。然而，我们还能学习到一点：如果编译器看到该实例在未来再也不会被引用，能够选择并提早释放实例空间。
+````
+在上面的类中，`lion`对象在实例化行后从未被使用过。因此 Java 编译器作为一种优化措施可以直接在实例化行后赋值`lion = null`。因此，即使在 SOP 输出之前， finalize 函数也能够打印出`'Rest in Peace!'`。我们不能证明这确定会发生，因为它依赖JVM的实现方式和运行时使用的内存。然而，我们还能学习到一点：如果编译器看到该实例在未来再也不会被引用，能够选择并提早释放实例空间。
 
 *   关于对象什么时候符合垃圾回收有一个更好的例子。实例的所有属性能被存储在寄存器中，随后寄存器将被访问并读取内容。无一例外，这些值将被写回到实例中。虽然这些值在将来能被使用，这个实例仍然能被标记为符合垃圾回收。这是一个很经典的例子，不是吗？
 *   当被赋值为null时，这是很简单的一个符合垃圾回收的示例。当然，复杂的情况可以像上面的几点。这是由 JVM 实现者所做的选择。目的是留下尽可能小的内存占用，加快响应速度，提高吞吐量。为了实现这一目标， JVM 的实现者可以选择一个更好的方案或算法在垃圾回收过程中回收内存空间。
-*   当 `finalize()` 方法被调用时，JVM 会释放该线程上的所有同步锁。
+*   当`finalize()`方法被调用时，JVM 会释放该线程上的所有同步锁。
 
 ### GC Scope 示例程序
-    Class GCScope {
-    
-        GCScope t;
-    
-        static int i = 1;
-    
-     
-    
-        public static void main(String args[]) {
-    
-            GCScope t1 = new GCScope();
-    
-            GCScope t2 = new GCScope();
-    
-            GCScope t3 = new GCScope();
-    
-     
-    
-            // No Object Is Eligible for GC
-    
-     
-    
-            t1.t = t2; // No Object Is Eligible for GC
-    
-            t2.t = t3; // No Object Is Eligible for GC
-    
-            t3.t = t1; // No Object Is Eligible for GC
-    
-     
-    
-            t1 = null;
-    
-            // No Object Is Eligible for GC (t3.t still has a reference to t1)
-    
-     
-    
-            t2 = null;
-    
-            // No Object Is Eligible for GC (t3.t.t still has a reference to t2)
-    
-     
-    
-            t3 = null;
-    
-            // All the 3 Object Is Eligible for GC (None of them have a reference.
-    
-            // only the variable t of the objects are referring each other in a
-    
-            // rounded fashion forming the Island of objects with out any external
-    
-            // reference)
-    
-        }
-    
-     
-    
-        protected void finalize() {
-    
-            System.out.println("Garbage collected from object" + i);
-    
-            i++;
-    
-        }
-    
-     
-    
-    class GCScope {
-    
-        GCScope t;
-    
-        static int i = 1;
-    
-     
-    
-        public static void main(String args[]) {
-    
-            GCScope t1 = new GCScope();
-    
-            GCScope t2 = new GCScope();
-    
-            GCScope t3 = new GCScope();
-    
-     
-    
-            // 没有对象符合GC
-    
-            t1.t = t2; // 没有对象符合GC
-    
-            t2.t = t3; // 没有对象符合GC
-    
-            t3.t = t1; // 没有对象符合GC
-    
-     
-    
-            t1 = null;
-    
-            // 没有对象符合GC (t3.t 仍然有一个到 t1 的引用)
-    
-     
-    
-            t2 = null;
-    
-            // 没有对象符合GC (t3.t.t 仍然有一个到 t2 的引用)
-    
-     
-    
-            t3 = null;
-    
-            // 所有三个对象都符合GC (它们中没有一个拥有引用。
-    
-            // 只有各对象的变量 t 还指向了彼此，
-    
-            // 形成了一个由对象组成的环形的岛，而没有任何外部的引用。)
-    
-        }
-    
-     
-    
-        protected void finalize() {
-    
-            System.out.println("Garbage collected from object" + i);
-    
-            i++;
-    
-        }
-## [JVM GC算法](https://www.cnblogs.com/wupeixuan/p/8670341.html)
+````
+Class GCScope {
+
+    GCScope t;
+
+    static int i = 1;
+
+ 
+
+    public static void main(String args[]) {
+
+        GCScope t1 = new GCScope();
+
+        GCScope t2 = new GCScope();
+
+        GCScope t3 = new GCScope();
+
+ 
+
+        // No Object Is Eligible for GC
+
+ 
+
+        t1.t = t2; // No Object Is Eligible for GC
+
+        t2.t = t3; // No Object Is Eligible for GC
+
+        t3.t = t1; // No Object Is Eligible for GC
+
+ 
+
+        t1 = null;
+
+        // No Object Is Eligible for GC (t3.t still has a reference to t1)
+
+ 
+
+        t2 = null;
+
+        // No Object Is Eligible for GC (t3.t.t still has a reference to t2)
+
+ 
+
+        t3 = null;
+
+        // All the 3 Object Is Eligible for GC (None of them have a reference.
+
+        // only the variable t of the objects are referring each other in a
+
+        // rounded fashion forming the Island of objects with out any external
+
+        // reference)
+
+    }
+
+ 
+
+    protected void finalize() {
+
+        System.out.println("Garbage collected from object" + i);
+
+        i++;
+
+    }
+
+ 
+
+class GCScope {
+
+    GCScope t;
+
+    static int i = 1;
+
+ 
+
+    public static void main(String args[]) {
+
+        GCScope t1 = new GCScope();
+
+        GCScope t2 = new GCScope();
+
+        GCScope t3 = new GCScope();
+
+ 
+
+        // 没有对象符合GC
+
+        t1.t = t2; // 没有对象符合GC
+
+        t2.t = t3; // 没有对象符合GC
+
+        t3.t = t1; // 没有对象符合GC
+
+ 
+
+        t1 = null;
+
+        // 没有对象符合GC (t3.t 仍然有一个到 t1 的引用)
+
+ 
+
+        t2 = null;
+
+        // 没有对象符合GC (t3.t.t 仍然有一个到 t2 的引用)
+
+ 
+
+        t3 = null;
+
+        // 所有三个对象都符合GC (它们中没有一个拥有引用。
+
+        // 只有各对象的变量 t 还指向了彼此，
+
+        // 形成了一个由对象组成的环形的岛，而没有任何外部的引用。)
+
+    }
+
+ 
+
+    protected void finalize() {
+
+        System.out.println("Garbage collected from object" + i);
+
+        i++;
+
+    }
+}
+````
+## JVM GC算法
 
 在判断哪些内存需要回收和什么时候回收用到GC 算法，本文主要对GC 算法进行讲解。
 
@@ -433,7 +431,6 @@ public class ReferenceCountingGC {
 运行结果
 
 ```
-
 [GC (System.gc()) [PSYoungGen: 3329K->744K(38400K)] 3329K->752K(125952K), 0.0341414 secs] [Times: user=0.00 sys=0.00, real=0.06 secs] 
 [Full GC (System.gc()) [PSYoungGen: 744K->0K(38400K)] [ParOldGen: 8K->628K(87552K)] 752K->628K(125952K), [Metaspace: 3450K->3450K(1056768K)], 0.0060728 secs] [Times: user=0.05 sys=0.00, real=0.01 secs] 
 Heap
@@ -457,7 +454,7 @@ Process finished with exit code 0
 
 从GC Roots（每种具体实现对GC Roots有不同的定义）作为起点，向下搜索它们引用的对象，可以生成一棵引用树，树的节点视为可达对象，反之视为不可达。
 
-![可达性分析算法](https://images.cnblogs.com/cnblogs_com/wupeixuan/1186116/o_4240985.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404215732.png)
 
 在Java语言中，可以作为GC Roots的对象包括下面几种：
 
@@ -524,8 +521,7 @@ Stop-the-world意味着 JVM由于要执行GC而停止了应用程序的执行，
 *   标记和清除过程效率都不高
 *   会产生大量碎片，内存碎片过多可能导致无法给大对象分配内存。
 
-![标记-清除](https://images.cnblogs.com/cnblogs_com/wupeixuan/1186116/o_a4248c4b-6c1d-4fb8-a557-86da92d3a294.jpg)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404215805.png)
 ## 复制算法（Copying）
 
 将内存划分为大小相等的两块，每次只使用其中一块，当这一块内存用完了就将还存活的对象复制到另一块上面，然后再把使用过的内存空间进行一次清理。
@@ -537,7 +533,7 @@ Stop-the-world意味着 JVM由于要执行GC而停止了应用程序的执行，
 *   将内存缩小为原来的一半，浪费了一半的内存空间，代价太高；如果不想浪费一半的空间，就需要有额外的空间进行分配担保，以应对被使用的内存中所有对象都100%存活的极端情况，所以在老年代一般不能直接选用这种算法。
 *   复制收集算法在对象存活率较高时就要进行较多的复制操作，效率将会变低。
 
-![复制](https://images.cnblogs.com/cnblogs_com/wupeixuan/1186116/o_e6b733ad-606d-4028-b3e8-83c3a73a3797.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404215817.png)
 
 ## 标记—整理算法（Mark-Compact）
 
@@ -547,7 +543,7 @@ Stop-the-world意味着 JVM由于要执行GC而停止了应用程序的执行，
 
 效率不高，不仅要标记存活对象，还要整理所有存活对象的引用地址，在效率上不如复制算法。
 
-![标记—整理](https://images.cnblogs.com/cnblogs_com/wupeixuan/1186116/o_902b83ab-8054-4bd2-898f-9a4a0fe52830.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404215845.png)
 
 ## 分代收集算法(Generational Collection)
 
@@ -569,20 +565,4 @@ Stop-the-world意味着 JVM由于要执行GC而停止了应用程序的执行，
 
 https://blog.csdn.net/android_hl/article/details/53228348
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\345\270\270\347\224\250\345\217\202\346\225\260\344\273\245\345\217\212\350\260\203\344\274\230\345\256\236\350\267\265.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\345\270\270\347\224\250\345\217\202\346\225\260\344\273\245\345\217\212\350\260\203\344\274\230\345\256\236\350\267\265.md"
new file mode 100644
index 0000000..caac027
--- /dev/null
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\345\270\270\347\224\250\345\217\202\346\225\260\344\273\245\345\217\212\350\260\203\344\274\230\345\256\236\350\267\265.md"
@@ -0,0 +1,659 @@
+# 目录
+
+  * [JVM优化的必要性](#jvm优化的必要性)
+  * [JVM调优原则](#jvm调优原则)
+    * [JVM运行参数设置](#jvm运行参数设置)
+  * [JVM性能调优工具](#jvm性能调优工具)
+  * [常用调优策略](#常用调优策略)
+  * [六、JVM调优实例](#六、jvm调优实例)
+  * [七、一个具体的实战案例分析](#七、一个具体的实战案例分析)
+  * [参考资料](#参考资料)
+  * [参考文章](#参考文章)
+
+
+
+
+![](https://pic.rmb.bdstatic.com/bjh/down/97522789c423e19931adafa65bd5424d.png)
+
+## JVM优化的必要性
+
+**1.1： 项目上线后，什么原因使得我们需要进行jvm调优**
+
+1)、垃圾太多（java线程，对象占满内存），内存占满了，程序跑不动了！！
+2)、垃圾回收线程太多，频繁地回收垃圾（垃圾回收线程本身也会占用资源： 占用内存，cpu资源），导致程序性能下降
+3)、回收垃圾频繁导致STW
+
+因此基于以上的原因，程序上线后，必须进行调优，否则程序性能就无法提升；也就是程序上线后，必须设置合理的垃圾回收策略；
+
+**1.2： jvm调优的本质是什么？？**
+
+答案： 回收垃圾，及时回收没有用垃圾对象，及时释放掉内存空间
+
+**1.3： 基于服务器环境，jvm堆内存到底应用设置多少内存？**
+
+1、32位的操作系统 --- 寻址能力 2^32 = 4GB ,最大的能支持4gb; jvm可以分配 2g+
+
+2、64位的操作系统 --- 寻址能力 2^64 = 16384PB , 高性能计算机（IBM Z unix 128G 200+）
+
+![](https://pic.rmb.bdstatic.com/bjh/down/aae367a929e2d1361975942091ffadfe.png)
+
+Jvm堆内存不能设置太大，否则会导致寻址垃圾的时间过长，也就是导致整个程序STW, 也不能设置太小，否则会导致回收垃圾过于频繁；
+
+**1.4：总结**
+
+如果你遇到以下情况，就需要考虑进行JVM调优了：
+
+*   Heap内存（老年代）持续上涨达到设置的最大内存值；
+
+*   Full GC 次数频繁；
+
+*   GC 停顿时间过长（超过1秒）；
+
+*   应用出现OutOfMemory 等内存异常；
+
+*   应用中有使用本地缓存且占用大量内存空间；
+
+*   系统吞吐量与响应性能不高或下降。
+
+## JVM调优原则
+
+![](https://pic.rmb.bdstatic.com/bjh/down/7cd4f5c19ab4f5f5d3087422097ee931.png)
+
+JVM调优是一个手段，但并不一定所有问题都可以通过JVM进行调优解决，因此，在进行JVM调优时，我们要遵循一些原则：
+
+*   大多数的Java应用不需要进行JVM优化；
+
+*   大多数导致GC问题的原因是代码层面的问题导致的（代码层面）；
+
+*   上线之前，应先考虑将机器的JVM参数设置到最优；
+
+*   减少创建对象的数量（代码层面）；
+
+*   减少使用全局变量和大对象（代码层面）；
+
+*   优先架构调优和代码调优，JVM优化是不得已的手段（代码、架构层面）；
+
+*   分析GC情况优化代码比优化JVM参数更好（代码层面）；
+
+通过以上原则，我们发现，其实最有效的优化手段是架构和代码层面的优化，而JVM优化则是最后不得已的手段，也可以说是对服务器配置的最后一次“压榨”。
+
+**2.1 JVM调优目标**
+
+调优的最终目的都是为了令应用程序使用最小的硬件消耗来承载更大的吞吐。jvm调优主要是针对垃圾收集器的收集性能优化，令运行在虚拟机上的应用能够使用更少的内存以及延迟获取更大的吞吐量。
+
+*   延迟：GC低停顿和GC低频率；
+
+*   低内存占用；
+
+*   高吞吐量;
+
+其中，任何一个属性性能的提高，几乎都是以牺牲其他属性性能的损为代价的，不可兼得。具体根据在业务中的重要性确定。
+
+**2.2 JVM调优量化目标**
+
+下面展示了一些JVM调优的量化目标参考实例：
+
+*   Heap 内存使用率 <= 70%;
+
+*   Old generation内存使用率<= 70%;
+
+*   avgpause <= 1秒;
+
+*   Full gc 次数0 或 avg pause interval >= 24小时 ;
+
+注意：不同应用的JVM调优量化目标是不一样的。
+
+**2.3 JVM调优的步骤**
+
+一般情况下，JVM调优可通过以下步骤进行：
+
+*   分析GC日志及dump文件，判断是否需要优化，确定瓶颈问题点；
+
+*   确定JVM调优量化目标；
+
+*   确定JVM调优参数（根据历史JVM参数来调整）；
+
+*   依次调优内存、延迟、吞吐量等指标；
+
+*   对比观察调优前后的差异；
+
+*   不断的分析和调整，直到找到合适的JVM参数配置；
+
+*   找到最合适的参数，将这些参数应用到所有服务器，并进行后续跟踪。
+
+以上操作步骤中，某些步骤是需要多次不断迭代完成的。一般是从满足程序的内存使用需求开始的，之后是时间延迟的要求，最后才是吞吐量的要求，要基于这个步骤来不断优化，每一个步骤都是进行下一步的基础，不可逆行之。
+
+![](https://pic.rmb.bdstatic.com/bjh/down/c271890a3714d538ed3362073c66893d.png)
+
+**调优原则总结**
+
+JVM的自动内存管理本来就是为了将开发人员从内存管理的泥潭里拉出来。JVM调优不是常规手段，性能问题一般第一选择是优化程序，最后的选择才是进行JVM调优。
+
+即使不得不进行JVM调优，也绝对不能拍脑门就去调整参数，一定要全面监控，详细分析性能数据。
+
+**附录：系统性能优化指导**
+
+![](https://pic.rmb.bdstatic.com/bjh/down/00d90cef8369568f8581a9850dcd42e6.png)
+
+### JVM运行参数设置
+
+**3.1、堆参数设置**
+
+**-XX:+PrintGC**使用这个参数，虚拟机启动后，只要遇到GC就会打印日志
+
+**-XX:+UseSerialGC**配置串行回收器
+
+**-XX:+PrintGCDetails**可以查看详细信息，包括各个区的情况
+
+**-Xms**设置Java程序启动时初始化堆大小
+
+**-Xmx**设置Java程序能获得最大的堆大小
+
+**-Xmx20m -Xms5m -XX:+PrintCommandLineFlags**可以将隐式或者显示传给虚拟机的参数输出
+
+**3.2、新生代参数配置**
+
+**-Xmn**可以设置新生代的大小，设置一个比较大的新生代会减少老年代的大小，这个参数对系统性能以及GC行为有很大的影响，新生代大小一般会设置整个堆空间的1/3到1/4左右
+
+**-XX:SurvivorRatio**用来设置新生代中eden空间和from/to空间的比例。含义：-XX:SurvivorRatio=eden/from**/**eden/to
+
+不同的堆分布情况，对系统执行会产生一定的影响，在实际工作中，应该根据系统的特点做出合理的配置，基本策略：尽可能将对象预留在新生代，减少老年代的GC次数
+
+除了可以设置新生代的绝对大小（-Xmn），还可以使用（-XX:NewRatio）设置新生代和老年代的比例：-XX：NewRatio=老年代/新生代
+
+**配置运行时参数：**
+
+-Xms20m -Xmx20m -Xmn1m -XX:SurvivorRatio=2 -XX:+PrintGCDetails -XX:+UseSerialGC
+
+**3.3、堆溢出参数配置**
+
+在Java程序在运行过程中，如果对空间不足，则会抛出内存溢出的错误（Out Of Memory）OOM，一旦这类问题发生在生产环境，则可能引起严重的业务中断，Java虚拟机提供了**-XX:+
+HeapDumpOnOutOfMemoryError**，使用该参数可以在内存溢出时导出整个堆信息，与之配合使用的还有参数**-XX:HeapDumpPath**，可以设置导出堆的存放路径
+
+内存分析工具：Memory Analyzer
+
+**配置运行时参数**-Xms1m -Xmx1m -XX:+
+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=d:/Demo3.dump
+
+**3.4、栈参数配置**
+
+Java虚拟机提供了参数**-Xss**来指定线程的最大栈空间，整个参数也直接决定了函数可调用的最大深度。
+
+**配置运行时参数：**-Xss1m
+
+3.5、方法区参数配置
+
+和Java堆一样，方法区是一块所有线程共享的内存区域，它用于保存系统的类信息，方法区（永久区）可以保存多少信息可以对其进行配置，在默认情况下，**-XX:MaxPermSize**为64M，如果系统运行时生产大量的类，就需要设置一个相对合适的方法区，以免出现永久区内存溢出的问题
+
+-XX:PermSize=64M -XX:MaxPermSize=64M
+
+**3.6、直接内存参数配置**
+
+直接内存也是Java程序中非常重要的组成部分，特别是广泛用在NIO中，直接内存跳过了Java堆，使用Java程序可以直接访问原生堆空间，因此在一定程度上加快了内存空间的访问速度
+
+但是说直接内存一定就可以提高内存访问速度也不见得，具体情况具体分析
+
+**相关配置参数：-XX:MaxDirectMemorySize**，如果不设置，默认值为最大堆空间，即-Xmx。直接内存使用达到上限时，就会触发垃圾回收，如果不能有效的释放空间，就会引起系统的OOM
+
+**3.7、对象进入老年代的参数配置**
+
+一般而言，对象首次创建会被放置在新生代的eden区，如果没有GC介入，则对象不会离开eden区，那么eden区的对象如何进入老年代呢？
+
+通常情况下，只要对象的年龄达到一定的大小，就会自动离开年轻代进入老年代，对象年龄是由对象经历数次GC决定的，在新生代每次GC之后如果对象没有被回收，则年龄加1
+
+虚拟机提供了一个参数来控制新生代对象的最大年龄，当超过这个年龄范围就会晋升老年代
+
+**-XX:MaxTenuringThreshold**，默认情况下为15
+
+**配置运行时参数：**-Xmx64M -Xms64M -XX:+PrintGCDetails
+
+**结论**：对象首次创建会被放置在新生代的eden区，因此输出结果中from和to区都为0%
+
+根据设置MaxTenuringThreshold参数，可以指定新生代对象经过多少次回收后进入老年代。另外，大对象新生代eden区无法装入时，也会直接进入老年代。
+
+JVM里有个参数可以设置对象的大小超过在指定的大小之后，直接晋升老年代 **-XX:PretenureSizeThreshold=15**
+
+参数：-Xmx1024M -Xms1024M -XX:+UseSerialGC -XX:MaxTenuringThreshold=15 -XX:+PrintGCDetails
+
+使用PretenureSizeThreshold可以进行指定进入老年代的对象大小，但是要注意TLAB区域优先分配空间。虚拟机对于体积不大的对象 会优先把数据分配到TLAB区域中，因此就失去了在老年代分配的机会
+
+参数：-Xmx30M -Xms30M -XX:+UseSerialGC -XX:+PrintGCDetails
+-XX:PretenureSizeThreshold=1000 -XX:-UseTLAB
+
+**3.8、TLAB参数配置**
+
+TLAB全称是Thread Local Allocation Buffer，即线程本地分配缓存，从名字上看是一个线程专用的内存分配区域，是为了加速对象分配对象而生的。每一个线程都会产生一个TLAB，该线程独享的工作区域，Java虚拟机使用这种TLAB区来避免多线程冲突问题，提高了对象分配的效率
+
+TLAB空间一般不会太大，当大对象无法在TLAB分配时，则会直接分配到堆上
+
+**-XX:+UseTLAB**使用TLAB
+
+**-XX:+TLABSize**设置TLAB大小
+
+**-XX:TLABRefillWasteFraction**设置维护进入TLAB空间的单个对象大小，它是一个比例值，默认为64，即如果对象大于整个空间的1/64，则在堆创建对象
+
+**-XX:+PrintTLAB**查看TLAB信息
+
+**-XX:ResizeTLAB**自调整TLABRefillWasteFraction阈值
+
+参数：-XX:+UseTLAB -XX:+PrintTLAB -XX:+PrintGC -XX:TLABSize=102400 -XX:-ResizeTLAB
+-XX:TLABRefillWasteFraction=100 -XX:-DoEscapeAnalysis -server
+
+内存参数
+
+
+
+
+
+![](https://pics7.baidu.com/feed/bba1cd11728b47102f9e1e7af46fe7f6fd03237b.png@f_auto?token=ca9d5541411861cfb09e792849a82a06)
+
+
+
+
+
+## JVM性能调优工具
+
+这个篇幅在这里就不过多介绍了，可以参照：
+
+深入理解JVM虚拟机——Java虚拟机的监控及诊断工具大全
+
+## 常用调优策略
+
+这里还是要提一下，及时确定要进行JVM调优，也不要陷入“知见障”，进行分析之后，发现可以通过优化程序提升性能，仍然首选优化程序。
+
+**5.1、选择合适的垃圾回收器**
+
+CPU单核，那么毫无疑问Serial 垃圾收集器是你唯一的选择。
+
+CPU多核，关注吞吐量 ，那么选择PS+PO组合。
+
+CPU多核，关注用户停顿时间，JDK版本1.6或者1.7，那么选择CMS。
+
+CPU多核，关注用户停顿时间，JDK1.8及以上，JVM可用内存6G以上，那么选择G1。
+
+参数配置：
+
+> //设置Serial垃圾收集器（新生代）
+>
+> 开启：-XX:+UseSerialGC
+>
+> //设置PS+PO,新生代使用功能Parallel Scavenge 老年代将会使用Parallel Old收集器
+>
+> 开启 -XX:+UseParallelOldGC
+>
+> //CMS垃圾收集器（老年代）
+>
+> 开启 -XX:+UseConcMarkSweepGC
+>
+> //设置G1垃圾收集器
+>
+> 开启 -XX:+UseG1GC
+
+**5.2、调整内存大小**
+
+现象：垃圾收集频率非常频繁。
+
+原因：如果内存太小，就会导致频繁的需要进行垃圾收集才能释放出足够的空间来创建新的对象，所以增加堆内存大小的效果是非常显而易见的。
+
+注意：如果垃圾收集次数非常频繁，但是每次能回收的对象非常少，那么这个时候并非内存太小，而可能是内存泄露导致对象无法回收，从而造成频繁GC。
+
+参数配置：
+
+> //设置堆初始值
+>
+> 指令1：-Xms2g
+>
+> 指令2：-XX:InitialHeapSize=2048m
+>
+> //设置堆区最大值
+>
+> 指令1：`-Xmx2g`
+>
+> 指令2： -XX:MaxHeapSize=2048m
+>
+> //新生代内存配置
+>
+> 指令1：-Xmn512m
+>
+> 指令2：-XX:MaxNewSize=512m
+
+**5.3、设置符合预期的停顿时间**
+
+**现象**：程序间接性的卡顿
+
+**原因**：如果没有确切的停顿时间设定，垃圾收集器以吞吐量为主，那么垃圾收集时间就会不稳定。
+
+**注意**：不要设置不切实际的停顿时间，单次时间越短也意味着需要更多的GC次数才能回收完原有数量的垃圾.
+
+**参数配置**：
+
+> //GC停顿时间，垃圾收集器会尝试用各种手段达到这个时间
+>
+> -XX:MaxGCPauseMillis
+
+**5.4、调整内存区域大小比率**
+
+现象：某一个区域的GC频繁，其他都正常。
+
+原因：如果对应区域空间不足，导致需要频繁GC来释放空间，在JVM堆内存无法增加的情况下，可以调整对应区域的大小比率。
+
+注意：也许并非空间不足，而是因为内存泄造成内存无法回收。从而导致GC频繁。
+
+参数配置：
+
+> //survivor区和Eden区大小比率
+>
+> 指令：-XX:SurvivorRatio=6 //S区和Eden区占新生代比率为1:6,两个S区2:6
+>
+> //新生代和老年代的占比
+>
+> -XX:NewRatio=4 //表示新生代:老年代 = 1:4 即老年代占整个堆的4/5；默认值=2
+
+**5.5、调整对象升老年代的年龄**
+
+**现象**：老年代频繁GC，每次回收的对象很多。
+
+**原因**：如果升代年龄小，新生代的对象很快就进入老年代了，导致老年代对象变多，而这些对象其实在随后的很短时间内就可以回收，这时候可以调整对象的升级代年龄，让对象不那么容易进入老年代解决老年代空间不足频繁GC问题。
+
+**注意**：增加了年龄之后，这些对象在新生代的时间会变长可能导致新生代的GC频率增加，并且频繁复制这些对象新生的GC时间也可能变长。
+
+配置参数：
+
+> //进入老年代最小的GC年龄,年轻代对象转换为老年代对象最小年龄值，默认值7
+>
+> -XX:InitialTenuringThreshol=7
+
+**5.6、调整大对象的标准**
+
+**现象**：老年代频繁GC，每次回收的对象很多,而且单个对象的体积都比较大。
+
+**原因**：如果大量的大对象直接分配到老年代，导致老年代容易被填满而造成频繁GC，可设置对象直接进入老年代的标准。
+
+**注意**：这些大对象进入新生代后可能会使新生代的GC频率和时间增加。
+
+配置参数：
+
+> //新生代可容纳的最大对象,大于则直接会分配到老年代，0代表没有限制。
+>
+> -XX:PretenureSizeThreshold=1000000
+
+**5.7、调整GC的触发时机**
+
+**现象**：CMS，G1 经常 Full GC，程序卡顿严重。
+
+**原因**：G1和CMS 部分GC阶段是并发进行的，业务线程和垃圾收集线程一起工作，也就说明垃圾收集的过程中业务线程会生成新的对象，所以在GC的时候需要预留一部分内存空间来容纳新产生的对象，如果这个时候内存空间不足以容纳新产生的对象，那么JVM就会停止并发收集暂停所有业务线程（STW）来保证垃圾收集的正常运行。这个时候可以调整GC触发的时机（比如在老年代占用60%就触发GC），这样就可以预留足够的空间来让业务线程创建的对象有足够的空间分配。
+
+**注意**：提早触发GC会增加老年代GC的频率。
+
+配置参数：
+
+> //使用多少比例的老年代后开始CMS收集，默认是68%，如果频繁发生SerialOld卡顿，应该调小
+>
+> -XX:CMSInitiatingOccupancyFraction
+>
+> //G1混合垃圾回收周期中要包括的旧区域设置占用率阈值。默认占用率为 65%
+>
+> -XX:G1MixedGCLiveThresholdPercent=65
+
+5.8、调整 JVM本地内存大小
+
+**现象**：GC的次数、时间和回收的对象都正常，堆内存空间充足，但是报OOM
+
+**原因**： JVM除了堆内存之外还有一块堆外内存，这片内存也叫本地内存，可是这块内存区域不足了并不会主动触发GC，只有在堆内存区域触发的时候顺带会把本地内存回收了，而一旦本地内存分配不足就会直接报OOM异常。
+
+**注意**： 本地内存异常的时候除了上面的现象之外，异常信息可能是OutOfMemoryError：Direct buffer memory。 解决方式除了调整本地内存大小之外，也可以在出现此异常时进行捕获，手动触发GC（System.gc()）。
+
+配置参数：
+
+> XX:MaxDirectMemorySize
+
+## 六、JVM调优实例
+
+整理的一些JVM调优实例：
+
+**6.1、网站流量浏览量暴增后，网站反应页面响很慢**
+
+> 1、问题推测：在测试环境测速度比较快，但是一到生产就变慢，所以推测可能是因为垃圾收集导致的业务线程停顿。
+>
+> 2、定位：为了确认推测的正确性，在线上通过jstat -gc 指令 看到JVM进行GC 次数频率非常高，GC所占用的时间非常长，所以基本推断就是因为GC频率非常高，所以导致业务线程经常停顿，从而造成网页反应很慢。
+>
+> 3、解决方案：因为网页访问量很高，所以对象创建速度非常快，导致堆内存容易填满从而频繁GC，所以这里问题在于新生代内存太小，所以这里可以增加JVM内存就行了，所以初步从原来的2G内存增加到16G内存。
+>
+> 4、第二个问题：增加内存后的确平常的请求比较快了，但是又出现了另外一个问题，就是不定期的会间断性的卡顿，而且单次卡顿的时间要比之前要长很多。
+>
+> 5、问题推测：练习到是之前的优化加大了内存，所以推测可能是因为内存加大了，从而导致单次GC的时间变长从而导致间接性的卡顿。
+>
+> 6、定位：还是通过jstat -gc 指令 查看到 的确FGC次数并不是很高，但是花费在FGC上的时间是非常高的,根据GC日志 查看到单次FGC的时间有达到几十秒的。
+>
+> 7、解决方案： 因为JVM默认使用的是PS+PO的组合，PS+PO垃圾标记和收集阶段都是STW，所以内存加大了之后，需要进行垃圾回收的时间就变长了，所以这里要想避免单次GC时间过长，所以需要更换并发类的收集器，因为当前的JDK版本为1.7，所以最后选择CMS垃圾收集器，根据之前垃圾收集情况设置了一个预期的停顿的时间，上线后网站再也没有了卡顿问题。
+
+**6.2、后台导出数据引发的OOM**
+
+**问题描述：**公司的后台系统，偶发性的引发OOM异常，堆内存溢出。
+
+> 1、因为是偶发性的，所以第一次简单的认为就是堆内存不足导致，所以单方面的加大了堆内存从4G调整到8G。
+>
+> 2、但是问题依然没有解决，只能从堆内存信息下手，通过开启了-XX:+
+> HeapDumpOnOutOfMemoryError参数 获得堆内存的dump文件。
+>
+> 3、VisualVM 对 堆dump文件进行分析，通过VisualVM查看到占用内存最大的对象是String对象，本来想跟踪着String对象找到其引用的地方，但dump文件太大，跟踪进去的时候总是卡死，而String对象占用比较多也比较正常，最开始也没有认定就是这里的问题，于是就从线程信息里面找突破点。
+>
+> 4、通过线程进行分析，先找到了几个正在运行的业务线程，然后逐一跟进业务线程看了下代码，发现有个引起我注意的方法，导出订单信息。
+>
+> 5、因为订单信息导出这个方法可能会有几万的数据量，首先要从数据库里面查询出来订单信息，然后把订单信息生成excel，这个过程会产生大量的String对象。
+>
+> 6、为了验证自己的猜想，于是准备登录后台去测试下，结果在测试的过程中发现到处订单的按钮前端居然没有做点击后按钮置灰交互事件，结果按钮可以一直点，因为导出订单数据本来就非常慢，使用的人员可能发现点击后很久后页面都没反应，结果就一直点，结果就大量的请求进入到后台，堆内存产生了大量的订单对象和EXCEL对象，而且方法执行非常慢，导致这一段时间内这些对象都无法被回收，所以最终导致内存溢出。
+>
+> 7、知道了问题就容易解决了，最终没有调整任何JVM参数，只是在前端的导出订单按钮上加上了置灰状态，等后端响应之后按钮才可以进行点击，然后减少了查询订单信息的非必要字段来减少生成对象的体积，然后问题就解决了。
+
+**6.3、单个缓存数据过大导致的系统CPU飚高**
+
+> 1、系统发布后发现CPU一直飚高到600%，发现这个问题后首先要做的是定位到是哪个应用占用CPU高，通过top 找到了对应的一个java应用占用CPU资源600%。
+>
+> 2、如果是应用的CPU飚高，那么基本上可以定位可能是锁资源竞争，或者是频繁GC造成的。
+>
+> 3、所以准备首先从GC的情况排查，如果GC正常的话再从线程的角度排查，首先使用jstat -gc PID 指令打印出GC的信息，结果得到得到的GC 统计信息有明显的异常，应用在运行了才几分钟的情况下GC的时间就占用了482秒，那么问这很明显就是频繁GC导致的CPU飚高。
+>
+> 4、定位到了是GC的问题，那么下一步就是找到频繁GC的原因了，所以可以从两方面定位了，可能是哪个地方频繁创建对象，或者就是有内存泄露导致内存回收不掉。
+>
+> 5、根据这个思路决定把堆内存信息dump下来看一下，使用jmap -dump 指令把堆内存信息dump下来（堆内存空间大的慎用这个指令否则容易导致会影响应用，因为我们的堆内存空间才2G所以也就没考虑这个问题了）。
+>
+> 6、把堆内存信息dump下来后，就使用visualVM进行离线分析了，首先从占用内存最多的对象中查找，结果排名第三看到一个业务VO占用堆内存约10%的空间，很明显这个对象是有问题的。
+>
+> 7、通过业务对象找到了对应的业务代码，通过代码的分析找到了一个可疑之处，这个业务对象是查看新闻资讯信息生成的对象，由于想提升查询的效率，所以把新闻资讯保存到了redis缓存里面，每次调用资讯接口都是从缓存里面获取。
+>
+> 8、把新闻保存到redis缓存里面这个方式是没有问题的，有问题的是新闻的50000多条数据都是保存在一个key里面，这样就导致每次调用查询新闻接口都会从redis里面把50000多条数据都拿出来，再做筛选分页拿出10条返回给前端。50000多条数据也就意味着会产生50000多个对象，每个对象280个字节左右，50000个对象就有13.3M，这就意味着只要查看一次新闻信息就会产生至少13.3M的对象，那么并发请求量只要到10，那么每秒钟都会产生133M的对象，而这种大对象会被直接分配到老年代，这样的话一个2G大小的老年代内存，只需要几秒就会塞满，从而触发GC。
+>
+> 9、知道了问题所在后那么就容易解决了，问题是因为单个缓存过大造成的，那么只需要把缓存减小就行了，这里只需要把缓存以页的粒度进行缓存就行了，每个key缓存10条作为返回给前端1页的数据，这样的话每次查询新闻信息只会从缓存拿出10条数据，就避免了此问题的 产生。
+
+**6.4、CPU经常100% 问题定位**
+
+问题分析：CPU高一定是某个程序长期占用了CPU资源。
+
+1、所以先需要找出那个进行占用CPU高。
+
+> top 列出系统各个进程的资源占用情况。
+
+2、然后根据找到对应进行里哪个线程占用CPU高。
+
+> top -Hp 进程ID 列出对应进程里面的线程占用资源情况
+
+3、找到对应线程ID后，再打印出对应线程的堆栈信息
+
+> printf "%x\n" PID 把线程ID转换为16进制。
+>
+> jstack PID 打印出进程的所有线程信息，从打印出来的线程信息中找到上一步转换为16进制的线程ID对应的线程信息。
+
+4、最后根据线程的堆栈信息定位到具体业务方法,从代码逻辑中找到问题所在。
+
+> 查看是否有线程长时间的watting 或blocked
+>
+> 如果线程长期处于watting状态下， 关注watting on xxxxxx，说明线程在等待这把锁，然后根据锁的地址找到持有锁的线程。
+
+**6.5、内存飚高问题定位**
+
+分析： 内存飚高如果是发生在java进程上，一般是因为创建了大量对象所导致，持续飚高说明垃圾回收跟不上对象创建的速度，或者内存泄露导致对象无法回收。
+
+1、先观察垃圾回收的情况
+
+> jstat -gcPID 1000查看GC次数，时间等信息，每隔一秒打印一次。
+>
+> jmap -histo PID | head -20 查看堆内存占用空间最大的前20个对象类型,可初步查看是哪个对象占用了内存。
+
+如果每次GC次数频繁，而且每次回收的内存空间也正常，那说明是因为对象创建速度快导致内存一直占用很高；如果每次回收的内存非常少，那么很可能是因为内存泄露导致内存一直无法被回收。
+
+2、导出堆内存文件快照
+
+> jmap -dump:live,format=b,file=/home/myheapdump.hprof PID dump堆内存信息到文件。
+
+3、使用visualVM对dump文件进行离线分析,找到占用内存高的对象，再找到创建该对象的业务代码位置，从代码和业务场景中定位具体问题。
+
+**6.6、数据分析平台系统频繁 Full GC**
+
+平台主要对用户在 App 中行为进行定时分析统计，并支持报表导出，使用 CMS GC 算法。
+
+数据分析师在使用中发现系统页面打开经常卡顿，通过 jstat 命令发现系统每次 Young GC 后大约有 10% 的存活对象进入老年代。
+
+原来是因为 Survivor 区空间设置过小，每次 Young GC 后存活对象在 Survivor 区域放不下，提前进入老年代。
+
+通过调大 Survivor 区，使得 Survivor 区可以容纳 Young GC 后存活对象，对象在 Survivor 区经历多次 Young GC 达到年龄阈值才进入老年代。
+
+调整之后每次 Young GC 后进入老年代的存活对象稳定运行时仅几百 Kb，Full GC 频率大大降低。
+
+**6.7、业务对接网关 OOM**
+
+网关主要消费 Kafka 数据，进行数据处理计算然后转发到另外的 Kafka 队列，系统运行几个小时候出现 OOM，重启系统几个小时之后又 OOM。
+
+通过 jmap 导出堆内存，在 eclipse MAT 工具分析才找出原因：代码中将某个业务 Kafka 的 topic 数据进行日志异步打印，该业务数据量较大，大量对象堆积在内存中等待被打印，导致 OOM。
+
+**6.8、鉴权系统频繁长时间 Full GC**
+
+系统对外提供各种账号鉴权服务，使用时发现系统经常服务不可用，通过 Zabbix 的监控平台监控发现系统频繁发生长时间 Full GC，且触发时老年代的堆内存通常并没有占满，发现原来是业务代码中调用了
+
+## 七、一个具体的实战案例分析
+
+**7.1 典型调优参数设置**
+
+> 服务器配置： 4cpu,8GB内存 ---- jvm调优实际上是设置一个合理大小的jvm堆内存（既不能太大，也不能太小）
+
+> -Xmx3550m 设置jvm堆内存最大值 (经验值设置： 根据压力测试，根据线上程序运行效果情况)
+>
+> -Xms3550m 设置jvm堆内存初始化大小，一般情况下必须设置此值和最大的最大的堆内存空间保持一致，防止内存抖动，消耗性能
+>
+> -Xmn2g 设置年轻代占用的空间大小
+>
+> -Xss256k 设置线程堆栈的大小；jdk5.0以后默认线程堆栈大小为1MB; 在相同的内存情况下，减小堆栈大小，可以使得操作系统创建更多的业务线程；
+
+jvm堆内存设置:
+
+> nohup java -Xmx3550m -Xms3550m -Xmn2g -Xss256k -jar jshop-web-1.0-SNAPSHOT.jar --spring.addition-location=application.yaml > jshop.log 2>&1 ><
+
+TPS性能曲线：
+
+![](https://pic.rmb.bdstatic.com/bjh/down/ee3949fc51c360330ece8f6729cd0560.png)
+
+**7.2 分析gc日志**
+
+如果需要分析gc日志，就必须使得服务gc输入gc详情到log日志文件中，然后使用相应gc日志分析工具来对日志进行分析即可；
+
+把gc详情输出到一个gc.log日志文件中，便于gc分析
+
+> -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -Xloggc:gc.log
+
+Throughput: 业务线程执行时间 / (gc时间+业务线程时间)
+
+![](https://pic.rmb.bdstatic.com/bjh/down/25529b786b50b8b30067e6f721101369.png)
+
+分析gc日志，发现，一开始就发生了3次fullgc，很明显jvm优化参数的设置是有问题的；
+
+![](https://pic.rmb.bdstatic.com/bjh/down/e70f3ffedc03bc0b387ff860cb8c948b.png)
+
+查看fullgc发生问题原因： jstat -gcutil pid
+
+![](https://pic.rmb.bdstatic.com/bjh/down/0e135e59c1e140aaded9223edd2f0177.png)
+
+Metaspace持久代： 初始化分配大小20m , 当metaspace被占满后，必须对持久代进行扩容，如果metaspace每进行一次扩容，fullgc就需要执行一次；（fullgc回收整个堆空间，非常占用时间）
+
+调整gc配置： 修改永久代空间初始化大小:
+
+> nohup java -Xmx3550m -Xms3550m -Xmn2g -Xss256k -XX:MetaspaceSize=256m -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -Xloggc:gc.log -jar jshop-web-1.0-SNAPSHOT.jar --spring.addition-location=application.yaml > jshop.log 2>&1 ><
+
+经过调优后，fullgc现象已经消失了：
+
+![](https://pic.rmb.bdstatic.com/bjh/down/0f8e8b90a8f9d810759ae43b3b0ed1b9.png)
+
+**7.3 Young&Old比例**
+
+年轻代和老年代比例：1:2 参数：-XX:NewRetio = 4 , 表示年轻代（eden,s0,s1）和老年代所占比值为1:4
+
+1） -XX:NewRetio = 4
+
+![](https://pic.rmb.bdstatic.com/bjh/down/f8353c852a2f65626b5b3a23f9616208.png)
+
+年轻代分配的内存大小变小了，这样YGC次数变多了，虽然fullgc不发生了，但是YGC花费的时间更多了！
+
+2） -XX:NewRetio = 2 YGC发生的次数必然会减少；因为eden区域的大小变大了，因此YGC就会变少；
+
+![](https://pic.rmb.bdstatic.com/bjh/down/11ca145ee5a93f511feda69e749582cb.png)
+
+7.4 Eden&S0S1
+
+为了进一步减少YGC, 可以设置 enden ,s 区域的比值大小； 设置方式： -XX:SurvivorRatio=8
+
+1） 设置比值：8:1:1
+
+![](https://pic.rmb.bdstatic.com/bjh/down/6330cbdd9acd6a5c18e91c5bea13cca2.png)
+
+2） Xmn2g 8:1:1
+
+nohup java -Xmx3550m -Xms3550m -Xmn2g -XX:SurvivorRatio=8 -Xss256k -XX:MetaspaceSize=256m -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -Xloggc:gc.log -jar jshop-web-1.0-SNAPSHOT.jar --spring.addition-location=application.yaml > jshop.log 2>&1 ><
+
+根据gc调优，垃圾回收次数，时间，吞吐量都是一个比较优的一个配置；
+
+![](https://pic.rmb.bdstatic.com/bjh/down/68edd8bfceb7d5e85d18a53e150cad2a.png)
+
+**7.5 吞吐量优先**
+
+使用并行的垃圾回收器，可以充分利用多核心cpu来帮助进行垃圾回收；这样的gc方式，就叫做吞吐量优先的调优方式
+
+垃圾回收器组合： ps(parallel scavenge) + po (parallel old) 此垃圾回收器是Jdk1.8 默认的垃圾回收器组合；
+
+> nohup java -Xmx3550m -Xms3550m -Xmn2g -XX:SurvivorRatio=8 -Xss256k -XX:+UseParallelGC -XX:UseParallelOldGC -XX:MetaspaceSize=256m -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -Xloggc:gc.log -jar jshop-web-1.0-SNAPSHOT.jar --spring.addition-location=application.yaml > jshop.log 2>&1 ><
+
+**7.6 响应时间优先**
+
+使用cms垃圾回收器，就是一个响应时间优先的组合； cms垃圾回收器（垃圾回收和业务线程交叉执行，不会让业务线程进行停顿stw）尽可能的减少stw的时间，因此使用cms垃圾回收器组合，是响应时间优先组合
+
+> nohup java -Xmx3550m -Xms3550m -Xmn2g -XX:SurvivorRatio=8 -Xss256k -XX:+UseParNewGC -XX:UseConcMarkSweepGC -XX:MetaspaceSize=256m -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -Xloggc:gc.log -jar jshop-web-1.0-SNAPSHOT.jar --spring.addition-location=application.yaml > jshop.log 2>&1 ><
+
+可以发现，cms垃圾回收器时间变长；
+
+**7.7 g1**
+
+配置方式如下所示：
+
+> nohup java -Xmx3550m -Xms3550m -Xmn2g -XX:SurvivorRatio=8 -Xss256k -XX:+UseG1GC -XX:MetaspaceSize=256m -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -Xloggc:gc.log -jar jshop-web-1.0-SNAPSHOT.jar --spring.addition-location=application.yaml > jshop.log 2>&1 ><
+
+![](https://pic.rmb.bdstatic.com/bjh/down/4146281952d45f65334e7ba97c6ba873.png)
+
+
+## 参考资料
+
+*   [Java HotSpot™ Virtual Machine Performance Enhancements](http://docs.oracle.com/javase/8/docs/technotes/guides/vm/performance-enhancements-7.html)
+*   [Java HotSpot Virtual Machine Garbage Collection Tuning Guide](http://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/index.html)
+*   [[HotSpot VM] JVM调优的”标准参数”的各种陷阱](http://hllvm.group.iteye.com/group/topic/27945)
+
+
+## 参考文章
+
+<https://segmentfault.com/a/1190000009707894>
+
+<https://www.cnblogs.com/hysum/p/7100874.html>
+
+<http://c.biancheng.net/view/939.html>
+
+<https://www.runoob.com/>
+
+https://blog.csdn.net/android_hl/article/details/53228348
+
+
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\27212\357\274\232JVM\346\200\247\350\203\275\347\256\241\347\220\206\347\245\236\345\231\250VisualVM\344\273\213\347\273\215\344\270\216\345\256\236\346\210\230.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\346\200\247\350\203\275\347\256\241\347\220\206\347\245\236\345\231\250VisualVM\344\273\213\347\273\215\344\270\216\345\256\236\346\210\230.md"
similarity index 90%
rename from "docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\27212\357\274\232JVM\346\200\247\350\203\275\347\256\241\347\220\206\347\245\236\345\231\250VisualVM\344\273\213\347\273\215\344\270\216\345\256\236\346\210\230.md"
rename to "docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\346\200\247\350\203\275\347\256\241\347\220\206\347\245\236\345\231\250VisualVM\344\273\213\347\273\215\344\270\216\345\256\236\346\210\230.md"
index 9df9174..e2547b3 100644
--- "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\27212\357\274\232JVM\346\200\247\350\203\275\347\256\241\347\220\206\347\245\236\345\231\250VisualVM\344\273\213\347\273\215\344\270\216\345\256\236\346\210\230.md"
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\346\200\247\350\203\275\347\256\241\347\220\206\347\245\236\345\231\250VisualVM\344\273\213\347\273\215\344\270\216\345\256\236\346\210\230.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [一、VisualVM是什么？](#一、visualvm是什么？)
   * [二、如何获取VisualVM？](#二、如何获取visualvm？)
   * [三、获取那个版本？](#三、获取那个版本？)
@@ -9,9 +8,6 @@
   * [查找JAVA应用程序耗时的方法函数](#查找java应用程序耗时的方法函数)
   * [排查JAVA应用程序线程锁](#排查java应用程序线程锁)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
 
 
 本文转自互联网，侵删
@@ -36,9 +32,6 @@
 
 ## 一、VisualVM是什么？
     VisualVM是一款免费的JAVA虚拟机图形化监控分析工具。
-
- 
-
     1.  拥有图形化的监控界面。
     2. 提供本地、远程的JVM监控分析功能。
     3. 是一款免费的JAVA工具。
@@ -49,13 +42,7 @@
     VisualVM各版本下载页面: http://visualvm.java.net/releases.html
 
      下载VisualVM时也应该注意，不同的JDK版本对应不同版本的VisualVM，具体根据安装的JDK版本来下载第一的VisualVM。
-
- 
-
- 
-
 ## 三、获取那个版本？
- 
 
        下载版本参考：Java虚拟机性能管理神器 - VisualVM（4） - JDK版本与VisualVM版本对应关系
 
@@ -257,20 +244,4 @@
 
 https://blog.csdn.net/android_hl/article/details/53228348
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2729\357\274\232JVM\347\233\221\346\216\247\345\267\245\345\205\267\344\270\216\350\257\212\346\226\255\345\256\236\350\267\265.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\347\233\221\346\216\247\345\267\245\345\205\267\344\270\216\350\257\212\346\226\255\345\256\236\350\267\265.md"
similarity index 89%
rename from "docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2729\357\274\232JVM\347\233\221\346\216\247\345\267\245\345\205\267\344\270\216\350\257\212\346\226\255\345\256\236\350\267\265.md"
rename to "docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\347\233\221\346\216\247\345\267\245\345\205\267\344\270\216\350\257\212\346\226\255\345\256\236\350\267\265.md"
index ab03095..1d57b95 100644
--- "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2729\357\274\232JVM\347\233\221\346\216\247\345\267\245\345\205\267\344\270\216\350\257\212\346\226\255\345\256\236\350\267\265.md"
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232JVM\347\233\221\346\216\247\345\267\245\345\205\267\344\270\216\350\257\212\346\226\255\345\256\236\350\267\265.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [一、jvm常见监控工具&指令](#一、jvm常见监控工具指令)
     * [1、 jps:jvm进程状况工具](#1、-jpsjvm进程状况工具)
     * [2、jstat: jvm统计信息监控工具](#2、jstat-jvm统计信息监控工具)
@@ -14,9 +13,7 @@
     * [2.查看java进程的线程快照信息](#2查看java进程的线程快照信息)
     * [3、OOM内存泄露](#3、oom内存泄露)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 本文转自：https://juejin.im/post/59e6c1f26fb9a0451c397a8c
@@ -57,10 +54,10 @@
 
 
 ```
-jps [options] [hostid]复制代码
+jps [options] [hostid]
 ```
 
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404222505.png)
 
 如果不指定hostid就默认为当前主机或服务器。
 
@@ -95,6 +92,7 @@ generalOption - 单个的常用的命令行选项，如-help, -options, 或 -ver
 
 outputOptions -一个或多个输出选项，由单个的statOption选项组成，可以和-t, -h, and -J等选项配合使用。复制代码
 ```
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404222543.png)
 
 参数选项：
 
@@ -117,7 +115,6 @@ outputOptions -一个或多个输出选项，由单个的statOption选项组成
 
 查看gc 情况执行:jstat-gcutil 27777
 
-![](data:image/svg+xml;utf8,<?xml version="1.0"?><svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="800" height="600"></svg>)
 
 ### 3、jinfo： java配置信息
 
@@ -129,11 +126,10 @@ outputOptions -一个或多个输出选项，由单个的statOption选项组成
 jinfo[option] pid复制代码
 ```
 
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404222602.png)
 
 比如:获取一些当前进程的jvm运行和启动信息。
 
-![](data:image/svg+xml;utf8,<?xml version="1.0"?><svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="800" height="600"></svg>)
 
 ### 4、jmap: java 内存映射工具
 
@@ -150,7 +146,7 @@ jmap [ option ] executable core
 
 jmap [ option ] [server-id@]remote-hostname-or-IP复制代码
 ```
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404222621.png)
 
 
 参数选项：
@@ -175,10 +171,12 @@ jmap [ option ] [server-id@]remote-hostname-or-IP复制代码
 -J 传递参数给jmap启动的jvm. 复制代码
 ```
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404222638.png)
 ### 5、jhat:jvm堆快照分析工具
 
 jhat 命令与jamp搭配使用，用来分析map生产的堆快存储快照。jhat内置了一个微型http/Html服务器，可以在浏览器找那个查看。不过建议尽量不用，既然有dumpt文件，可以从生产环境拉取下来，然后通过本地可视化工具来分析，这样既减轻了线上服务器压力，有可以分析的足够详尽(比如 MAT/jprofile/visualVm)等。
 
+
 ### 6、jstack:java堆栈跟踪工具
 
 jstack用于生成java虚拟机当前时刻的线程快照。线程快照是当前java虚拟机内每一条线程正在执行的方法堆栈的集合，生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源导致的长时间等待等。
@@ -391,20 +389,4 @@ jmap -dump:format=b,file=/tmp/dump.dat 11869
 
 https://blog.csdn.net/android_hl/article/details/53228348
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\27211\357\274\232Java\345\206\205\345\255\230\345\274\202\345\270\270\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232Java\345\206\205\345\255\230\345\274\202\345\270\270\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
similarity index 87%
rename from "docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\27211\357\274\232Java\345\206\205\345\255\230\345\274\202\345\270\270\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
rename to "docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232Java\345\206\205\345\255\230\345\274\202\345\270\270\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
index 0805113..a999de2 100644
--- "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\27211\357\274\232Java\345\206\205\345\255\230\345\274\202\345\270\270\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232Java\345\206\205\345\255\230\345\274\202\345\270\270\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [实战内存溢出异常](#实战内存溢出异常)
   * [1 . 对象的创建过程](#1--对象的创建过程)
   * [2 . 对象的内存布局](#2--对象的内存布局)
@@ -22,9 +21,7 @@
       * [6、单例模式](#6、单例模式)
   * [如何检测内存泄漏](#如何检测内存泄漏)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 本文转自互联网，侵删
@@ -77,16 +74,16 @@ Student stu =new Student("张三"，"18");
 *   实例数据
 *   对齐填充
 
-**对象头:** 对象头中包含了对象运行时一些必要的信息，如GC分代信息，锁信息，哈希码，指向Class类元信息的指针等，其中对Javaer比较有用的是**锁信息与指向Class对象的指针**，关于锁信息，后期有机会讲解并发编程JUC时再扩展，关于指向Class对象的指针其实很好理解。比如上面那个Student的例子，当我们拿到stu对象时，调用Class stuClass=stu.getClass();的时候，其实就是根据这个指针去拿到了stu对象所属的Student类在方法区存放的Class类对象。虽然说的有点拗口，但这句话我反复琢磨了好几遍，应该是说清楚了。
+**对象头:**对象头中包含了对象运行时一些必要的信息，如GC分代信息，锁信息，哈希码，指向Class类元信息的指针等，其中对Javaer比较有用的是**锁信息与指向Class对象的指针**，关于锁信息，后期有机会讲解并发编程JUC时再扩展，关于指向Class对象的指针其实很好理解。比如上面那个Student的例子，当我们拿到stu对象时，调用Class stuClass=stu.getClass();的时候，其实就是根据这个指针去拿到了stu对象所属的Student类在方法区存放的Class类对象。虽然说的有点拗口，但这句话我反复琢磨了好几遍，应该是说清楚了。
 
-**实例数据:** 实例数据部分是对象真正存储的有效信息，就是程序代码中所定义的各种类型的字段内容。
+**实例数据:**实例数据部分是对象真正存储的有效信息，就是程序代码中所定义的各种类型的字段内容。
 
-**对齐填充:** 虚拟机规范要求对象大小必须是8字节的整数倍。对齐填充其实就是来补全对象大小的。
+**对齐填充:**虚拟机规范要求对象大小必须是8字节的整数倍。对齐填充其实就是来补全对象大小的。
 
 ## 3 . 对象的访问定位
 
 谈到对象的访问，还拿上面学生的例子来说，当我们拿到stu对象时，直接调用stu.getName();时，其实就完成了对对象的访问。但这里要累赘说一下的是，stu虽然通常被认为是一个对象，其实准确来说是不准确的，stu只是一个变量，变量里存储的是指向对象的指针，(如果干过C或者C++的小伙伴应该比较清楚指针这个概念)，当我们调用stu.getName()时，虚拟机会根据指针找到堆里面的对象然后拿到实例数据name.需要注意的是，当我们调用stu.getClass()时，虚拟机会首先根据stu指针定位到堆里面的对象，然后根据对象头里面存储的指向Class类元信息的指针再次到方法区拿到Class对象，进行了两次指针寻找。具体讲解图如下:
-![在这里插入图片描述](https://img-blog.csdnimg.cn/201901092235030.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE5MjczMg==,size_16,color_FFFFFF,t_70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404223333.png)
 
 ## 4 .实战内存异常
 
@@ -140,8 +137,10 @@ Dumping heap to /Users/zdy/Desktop/dump/java_pid1099.hprof …
 可以看到生成了dump文件到指定目录。并且爆出了OutOfMemoryError，还告诉了你是哪一片区域出的问题:heap space
 
 打开VisualVM工具导入对应的heapDump文件(如何使用请读者自行查阅相关资料)，相应的说明见图:
-![在这里插入图片描述](https://img-blog.csdnimg.cn/20190109224456933.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE5MjczMg==,size_16,color_FFFFFF,t_70)
-![在这里插入图片描述](https://img-blog.csdnimg.cn/20190109224531128.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE5MjczMg==,size_16,color_FFFFFF,t_70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404223348.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404223403.png)
+
 分析dump文件后，我们可以知道，OOMObject这个类创建了810326个实例。所以它能不溢出吗？接下来就在代码里找这个类在哪new的。排查问题。(我们的样例代码就不用排查了，While循环太凶猛了)分析dump文件后，我们可以知道，OOMObject这个类创建了810326个实例。所以它能不溢出吗？接下来就在代码里找这个类在哪new的。排查问题。(我们的样例代码就不用排查了，While循环太凶猛了)
 
 ### Java栈内存异常
@@ -182,7 +181,7 @@ public class JavaVMStackSOF {
 可以看到，递归调用了751次，栈容量不够用了。
 默认的栈容量在正常的方法调用时，栈深度可以达到1000-2000深度，所以，一般的递归是可以承受的住的。如果你的代码出现了StackOverflowError，首先检查代码，而不是改参数。
 
-这里顺带提一下，很多人在做多线程开发时，当创建很多线程时，**容易出现OOM(OutOfMemoryError),** 这时可以通过具体情况，减少最大堆容量，或者栈容量来解决问题，这是为什么呢。请看下面的公式:
+这里顺带提一下，很多人在做多线程开发时，当创建很多线程时，**容易出现OOM(OutOfMemoryError),**这时可以通过具体情况，减少最大堆容量，或者栈容量来解决问题，这是为什么呢。请看下面的公式:
 
 <font color="red">线程数*(最大栈容量)+最大堆值+其他内存(忽略不计或者一般不改动)=机器最大内存</font>
 
@@ -190,10 +189,10 @@ public class JavaVMStackSOF {
 
 ### 方法区内存异常
 
-写到这里时，作者本来想写一个无限创建动态代理对象的例子来演示方法区溢出，避开谈论JDK7与JDK8的内存区域变更的过渡，但细想一想，还是把这一块从始致终的说清楚。在上一篇文章中JVM系列之Java内存结构详解讲到方法区时提到，JDK7环境下方法区包括了(运行时常量池),其实这么说是不准确的。因为从JDK7开始，HotSpot团队就想到开始去"永久代",大家首先明确一个概念，**方法区和"永久代"(PermGen space)是两个概念，方法区是JVM虚拟机规范，任何虚拟机实现(J9等)都不能少这个区间，而"永久代"只是HotSpot对方法区的一个实现。** 为了把知识点列清楚，我还是才用列表的形式:
+写到这里时，作者本来想写一个无限创建动态代理对象的例子来演示方法区溢出，避开谈论JDK7与JDK8的内存区域变更的过渡，但细想一想，还是把这一块从始致终的说清楚。在上一篇文章中JVM系列之Java内存结构详解讲到方法区时提到，JDK7环境下方法区包括了(运行时常量池),其实这么说是不准确的。因为从JDK7开始，HotSpot团队就想到开始去"永久代",大家首先明确一个概念，**方法区和"永久代"(PermGen space)是两个概念，方法区是JVM虚拟机规范，任何虚拟机实现(J9等)都不能少这个区间，而"永久代"只是HotSpot对方法区的一个实现。**为了把知识点列清楚，我还是才用列表的形式:
 
-*   [ ]  JDK7之前(包括JDK7)拥有"永久代"(PermGen space),用来实现方法区。但在JDK7中已经逐渐在实现中把永久代中把很多东西移了出来，比如:符号引用(Symbols)转移到了native heap,运行时常量池(interned strings)转移到了java heap；类的静态变量(class statics)转移到了java heap.
-*   [ ]  所以这就是为什么我说上一篇文章中说方法区中包含运行时常量池是不正确的，因为已经移动到了java heap;
+*   [ ] JDK7之前(包括JDK7)拥有"永久代"(PermGen space),用来实现方法区。但在JDK7中已经逐渐在实现中把永久代中把很多东西移了出来，比如:符号引用(Symbols)转移到了native heap,运行时常量池(interned strings)转移到了java heap；类的静态变量(class statics)转移到了java heap.
+*   [ ] 所以这就是为什么我说上一篇文章中说方法区中包含运行时常量池是不正确的，因为已经移动到了java heap;
     **在JDK7之前(包括7)可以通过-XX:PermSize -XX:MaxPermSize来控制永久代的大小.
     JDK8正式去除"永久代",换成Metaspace(元空间)作为JVM虚拟机规范中方法区的实现。**
     元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。因此，默认情况下，元空间的大小仅受本地内存限制，但仍可以通过参数控制:-XX:MetaspaceSize与-XX:MaxMetaspaceSize来控制大小。
@@ -316,7 +315,8 @@ Java的一个重要优点就是通过垃圾收集器(Garbage Collection，GC)自
 为了更好理解GC的工作原理，我们可以将对象考虑为有向图的顶点，将引用关系考虑为图的有向边，有向边从引用者指向被引对象。另外，每个线程对象可以作为一个图的起始顶点，例如大多程序从main进程开始执行，那么该图就是以main进程顶点开始的一棵根树。在这个有向图中，根顶点可达的对象都是有效对象，GC将不回收这些对象。如果某个对象 (连通子图)与这个根顶点不可达(注意，该图为有向图)，那么我们认为这个(这些)对象不再被引用，可以被GC回收。
 
 以下，我们举一个例子说明如何用有向图表示内存管理。对于程序的每一个时刻，我们都有一个有向图表示JVM的内存分配情况。以下右图，就是左边程序运行到第6行的示意图。
-![在这里插入图片描述](https://img-blog.csdnimg.cn/20190110151433131.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE5MjczMg==,size_16,color_FFFFFF,t_70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404223428.png)
+
 Java使用有向图的方式进行内存管理，可以消除引用循环的问题，例如有三个对象，相互引用，只要它们和根进程不可达的，那么GC也是可以回收它们的。这种方式的优点是管理内存的精度很高，但是效率较低。另外一种常用的内存管理技术是使用计数器，例如COM模型采用计数器方式管理构件，它与有向图相比，精度行低(很难处理循环引用的问题)，但执行效率很高。
 
 ## 什么是Java中的内存泄露？
@@ -326,7 +326,8 @@ Java使用有向图的方式进行内存管理，可以消除引用循环的问
 在C++中，内存泄漏的范围更大一些。有些对象被分配了内存空间，然后却不可达，由于C++中没有GC，这些内存将永远收不回来。在Java中，这些不可达的对象都由GC负责回收，因此程序员不需要考虑这部分的内存泄露。
 
 通过分析，我们得知，对于C++，程序员需要自己管理边和顶点，而对于Java程序员只需要管理边就可以了(不需要管理顶点的释放)。通过这种方式，Java提高了编程的效率。
-![在这里插入图片描述](https://img-blog.csdnimg.cn/20190110152226472.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE5MjczMg==,size_16,color_FFFFFF,t_70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404223441.png)
+
 因此，通过以上分析，我们知道在Java中也有内存泄漏，但范围比C++要小一些。因为Java从语言上保证，任何对象都是可达的，所有的不可达对象都由GC管理。
 
 对于程序员来说，GC基本是透明的，不可见的。虽然，我们只有几个函数可以访问GC，例如运行GC的函数System.gc()，但是根据Java语言规范定义， 该函数不保证JVM的垃圾收集器一定会执行。因为，不同的JVM实现者可能使用不同的算法管理GC。通常，GC的线程的优先级别较低。JVM调用GC的策略也有很多种，有的是内存使用到达一定程度时，GC才开始工作，也有定时执行的，有的是平缓执行GC，有的是中断式执行GC。但通常来说，我们不需要关心这些。除非在一些特定的场合，GC的执行影响应用程序的性能，例如对于基于Web的实时系统，如网络游戏等，用户不希望GC突然中断应用程序执行而进行垃圾回收，那么我们需要调整GC的参数，让GC能够通过平缓的方式释放内存，例如将垃圾回收分解为一系列的小步骤执行，Sun提供的HotSpot JVM就支持这一特性。
@@ -443,12 +444,6 @@ Optimizeit Profiler版本4.11支持Application，Applet，Servlet和Romote Appli
 当设置好所有的参数了，我们就可以在OptimizeIt环境下运行被测程序，在程序运行过程中，Optimizeit可以监视内存的使用曲线(如下图)，包括JVM申请的堆(heap)的大小，和实际使用的内存大小。另外，在运行过程中，我们可以随时暂停程序的运行，甚至强行调用GC，让GC进行内存回收。通过内存使用曲线，我们可以整体了解程序使用内存的情况。这种监测对于长期运行的应用程序非常有必要，也很容易发现内存泄露。
 
 
-
-
-
-
-
-
 ## 参考文章
 
 <https://segmentfault.com/a/1190000009707894>
@@ -461,20 +456,4 @@ Optimizeit Profiler版本4.11支持Application，Applet，Servlet和Romote Appli
 
 https://blog.csdn.net/android_hl/article/details/53228348
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2724\357\274\232Java class\344\273\213\347\273\215\344\270\216\350\247\243\346\236\220\345\256\236\350\267\265.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232Java\345\255\227\350\212\202\347\240\201\344\273\213\347\273\215\344\270\216\350\247\243\346\236\220\345\256\236\350\267\265.md"
similarity index 97%
rename from "docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2724\357\274\232Java class\344\273\213\347\273\215\344\270\216\350\247\243\346\236\220\345\256\236\350\267\265.md"
rename to "docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232Java\345\255\227\350\212\202\347\240\201\344\273\213\347\273\215\344\270\216\350\247\243\346\236\220\345\256\236\350\267\265.md"
index 2371f8f..cf18680 100644
--- "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2724\357\274\232Java class\344\273\213\347\273\215\344\270\216\350\247\243\346\236\220\345\256\236\350\267\265.md"	
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232Java\345\255\227\350\212\202\347\240\201\344\273\213\347\273\215\344\270\216\350\247\243\346\236\220\345\256\236\350\267\265.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [前言](#前言)
   * [Class文件](#class文件)
     * [什么是Class文件？](#什么是class文件？)
@@ -50,8 +49,7 @@ java之所以能够实现跨平台，便在于其编译阶段不是将代码直
 
 随便找到一个class文件，用Sublime Text打开是这样的：
 
-![](https://user-gold-cdn.xitu.io/2017/2/6/0ac6ea6e3c01482f77234bef7aa236f0?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404220426.png)
 
 是不是一脸懵逼，不过java虚拟机规范中给出了class文件的基本格式，只要按照这个格式去解析就可以了：
 
@@ -337,11 +335,7 @@ for (int j = 0; j < methodInfo.attributesCount; j++) {
 
 整个项目终于写完了，接下来就来看看效果如何，随便找一个class文件解析运行：
 
-![](https://user-gold-cdn.xitu.io/2017/2/6/fa350cdc04576bab58ade0955b9f0388?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-<figcaption></figcaption>
-
-</figure>
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404220510.png)
 
 哈哈，是不是很赞！
 
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\344\272\206\350\247\243JVM\350\231\232\346\213\237\346\234\2728\357\274\232Java\347\232\204\347\274\226\350\257\221\346\234\237\344\274\230\345\214\226\344\270\216\350\277\220\350\241\214\346\234\237\344\274\230\345\214\226.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232Java\347\232\204\347\274\226\350\257\221\346\234\237\344\274\230\345\214\226\344\270\216\350\277\220\350\241\214\346\234\237\344\274\230\345\214\226.md"
similarity index 85%
rename from "docs/java/jvm/\346\267\261\345\205\245\344\272\206\350\247\243JVM\350\231\232\346\213\237\346\234\2728\357\274\232Java\347\232\204\347\274\226\350\257\221\346\234\237\344\274\230\345\214\226\344\270\216\350\277\220\350\241\214\346\234\237\344\274\230\345\214\226.md"
rename to "docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232Java\347\232\204\347\274\226\350\257\221\346\234\237\344\274\230\345\214\226\344\270\216\350\277\220\350\241\214\346\234\237\344\274\230\345\214\226.md"
index 2db99f7..58b8166 100644
--- "a/docs/java/jvm/\346\267\261\345\205\245\344\272\206\350\247\243JVM\350\231\232\346\213\237\346\234\2728\357\274\232Java\347\232\204\347\274\226\350\257\221\346\234\237\344\274\230\345\214\226\344\270\216\350\277\220\350\241\214\346\234\237\344\274\230\345\214\226.md"
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232Java\347\232\204\347\274\226\350\257\221\346\234\237\344\274\230\345\214\226\344\270\216\350\277\220\350\241\214\346\234\237\344\274\230\345\214\226.md"
@@ -1,6 +1,5 @@
-# Table of Contents
-
-  * [[java编译期优化](https://www.cnblogs.com/LeonNew/p/6187411.html)](#[java编译期优化]httpswwwcnblogscomleonnewp6187411html)
+# 目录
+  * [java编译期优化](#[java编译期优化])
     * [早期（编译期）优化](#早期（编译期）优化)
         * [泛型与类型擦除](#泛型与类型擦除)
         * [自动装箱、拆箱与遍历循环](#自动装箱、拆箱与遍历循环)
@@ -12,9 +11,7 @@
         * [编译优化技术](#编译优化技术)
     * [java与C/C++编译器对比](#java与cc编译器对比)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 本文转自互联网，侵删
@@ -37,24 +34,14 @@
 
 <!-- more -->
 
-
-
-
-
-
-
-## [java编译期优化](https://www.cnblogs.com/LeonNew/p/6187411.html)
-
-
-
-
+## java编译期优化
 
 java语言的编译期其实是一段不确定的操作过程，因为它可以分为三类编译过程：
 1.前端编译：把_.java文件转变为_.class文件
 2.后端编译：把字节码转变为机器码
 3.静态提前编译：直接把*.java文件编译成本地机器代码
 从JDK1.3开始，虚拟机设计团队就把对性能的优化集中到了后端的即时编译中，这样可以让那些不是由Javac产生的Class文件（如JRuby、Groovy等语言的Class文件）也能享受到编译期优化所带来的好处
-**Java中即时编译在运行期的优化过程对于程序运行来说更重要，而前端编译期在编译期的优化过程对于程序编码来说关系更加密切    **
+**Java中即时编译在运行期的优化过程对于程序运行来说更重要，而前端编译期在编译期的优化过程对于程序编码来说关系更加密切**
 
 ### 早期（编译期）优化
 
@@ -115,11 +102,10 @@ public static void main(String[] args) {
 
 ##### 解释器与编译器
 
-Java程序最初是通过解释器进行解释执行的，当程序需要迅速启动和执行时，解释器可以首先发挥作用，省去编译时间，立即执行；当程序运行后，随着时间的推移，编译期逐渐发挥作用，把越来越多的代码编译成本地代码，获得更高的执行效率。**解释执行节约内存，编译执行提升效率。** 同时，解释器可以作为编译器激进优化时的一个“逃生门”，让编译器根据概率选择一些大多数时候都能提升运行速度的优化手段，当激进优化的假设不成立，则通过逆优化退回到解释状态继续执行。
+Java程序最初是通过解释器进行解释执行的，当程序需要迅速启动和执行时，解释器可以首先发挥作用，省去编译时间，立即执行；当程序运行后，随着时间的推移，编译期逐渐发挥作用，把越来越多的代码编译成本地代码，获得更高的执行效率。**解释执行节约内存，编译执行提升效率。**同时，解释器可以作为编译器激进优化时的一个“逃生门”，让编译器根据概率选择一些大多数时候都能提升运行速度的优化手段，当激进优化的假设不成立，则通过逆优化退回到解释状态继续执行。
 
 HotSpot虚拟机中内置了两个即时编译器，分别称为Client Compiler(C1编译器)和Server Compiler(C2编译器)，默认采用解释器与其中一个编译器直接配合的方式工作，使用哪个编译器取决于虚拟机运行的模式，也可以自己去指定。若强制虚拟机运行与“解释模式”，编译器完全不介入工作，若强制虚拟机运行于“编译模式”，则优先采用编译方式执行程序，解释器仍然要在编译无法进行的情况下介入执行过程。
-![](https://images2015.cnblogs.com/blog/907283/201612/907283-20161216162941651-154732490.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404222130.png)
 ##### 分层编译策略
 
 ```
@@ -143,13 +129,11 @@ HotSpot虚拟机中内置了两个即时编译器，分别称为Client Compiler(
 ```
 
 HotSpot虚拟机使用的是第二种，它为每个方法准备了两类计数器：方法调用计数器和回边计数器，下图表示方法调用计数器触发即时编译：
-![](https://images2015.cnblogs.com/blog/907283/201612/907283-20161216162952058-1104250840.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404222225.png)
 如果不做任何设置，执行引擎会继续进入解释器按照解释方式执行字节码，直到提交的请求被编译器编译完成，下次调用才会使用已编译的版本。另外，方法调用计数器的值也不是一个绝对次数，而是一段时间之内被调用的次数，超过这个时间，次数就减半，这称为计数器热度的衰减。
 
 下图表示回边计数器触发即时编译：
-![](https://images2015.cnblogs.com/blog/907283/201612/907283-20161216163000854-2133382071.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404222324.png)
 回边计数器没有计数器热度衰减的过程，因此统计的就是绝对次数，并且当计数器溢出时，它还会把方法计数器的值也调整到溢出状态，这样下次进入该方法的时候就会执行标准编译过程。
 
 ##### 编译优化技术
@@ -235,20 +219,4 @@ Java虚拟机的即时编译器与C/C++的静态编译器相比，可能会由
 
 https://blog.csdn.net/android_hl/article/details/53228348
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\27213\357\274\232\345\206\215\350\260\210\345\233\233\347\247\215\345\274\225\347\224\250\345\217\212GC\345\256\236\350\267\265.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232\345\206\215\350\260\210\345\233\233\347\247\215\345\274\225\347\224\250\345\217\212GC\345\256\236\350\267\265.md"
similarity index 81%
rename from "docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\27213\357\274\232\345\206\215\350\260\210\345\233\233\347\247\215\345\274\225\347\224\250\345\217\212GC\345\256\236\350\267\265.md"
rename to "docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232\345\206\215\350\260\210\345\233\233\347\247\215\345\274\225\347\224\250\345\217\212GC\345\256\236\350\267\265.md"
index 3167cfa..cca62d4 100644
--- "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\27213\357\274\232\345\206\215\350\260\210\345\233\233\347\247\215\345\274\225\347\224\250\345\217\212GC\345\256\236\350\267\265.md"
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232\345\206\215\350\260\210\345\233\233\347\247\215\345\274\225\347\224\250\345\217\212GC\345\256\236\350\267\265.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [一、背景](#一、背景)
   * [二、简介](#二、简介)
     * [1.强引用 StrongReference](#1强引用-strongreference)
@@ -8,9 +7,7 @@
     * [4.虚引用 PhantomReference](#4虚引用-phantomreference)
   * [三、小结](#三、小结)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 本文转自互联网，侵删
@@ -35,15 +32,15 @@
 
 ## 一、背景
 
-Java的内存回收不需要程序员负责，JVM会在必要时启动Java GC完成垃圾回收。Java以便我们控制对象的生存周期，提供给了我们四种引用方式，引用强度从强到弱分别为：强引用、软引用、弱引用、虚引用。 
+Java的内存回收不需要程序员负责，JVM会在必要时启动Java GC完成垃圾回收。Java以便我们控制对象的生存周期，提供给了我们四种引用方式，引用强度从强到弱分别为：强引用、软引用、弱引用、虚引用。
 
 ## 二、简介
 
 ### 1.强引用 StrongReference
 
 StrongReference是Java的默认引用形式，使用时不需要显示定义。任何通过强引用所使用的对象不管系统资源有多紧张，Java GC都不会主动回收具有强引用的对象。
-
-<pre>public class StrongReferenceTest {
+````
+public class StrongReferenceTest {
 
 	public static int M = 1024*1024;
 
@@ -76,17 +73,16 @@ StrongReference是Java的默认引用形式，使用时不需要显示定义。
 		System.out.println("strongReference : "+strongReference);
 		}
 }
-</pre>
+````
 
 运行结果：
 
-![](https://user-gold-cdn.xitu.io/2018/1/7/160cd0dc536b2384?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404223852.png)
 ### 2.弱引用 WeakReference
 
 如果一个对象只具有弱引用，无论内存充足与否，Java GC后对象如果只有弱引用将会被自动回收。
-
-<pre>public class WeakReferenceTest {
+````
+public class WeakReferenceTest {
 
 	public static int M = 1024*1024;
 
@@ -110,17 +106,16 @@ StrongReference是Java的默认引用形式，使用时不需要显示定义。
 		System.out.println("weakRerference.get() : "+weakRerference.get());
 	}   
 }
-</pre>
+````
 
 运行结果：
 
-![](https://user-gold-cdn.xitu.io/2018/1/7/160cd0f1ead8184e?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404223905.png)
 ### 3.软引用 SoftReference
 
 软引用和弱引用的特性基本一致， 主要的区别在于软引用在内存不足时才会被回收。如果一个对象只具有软引用，Java GC在内存充足的时候不会回收它，内存不足时才会被回收。
-
-<pre>public class SoftReferenceTest {
+````
+public class SoftReferenceTest {
 
 	public static int M = 1024*1024;
 
@@ -151,17 +146,16 @@ StrongReference是Java的默认引用形式，使用时不需要显示定义。
 		System.out.println("softRerference2.get() : "+softRerference2.get());  
 	 } 
 }
-</pre>
 
+````
 运行结果：
 
-![](https://user-gold-cdn.xitu.io/2018/1/7/160cd1023a8f3de2?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404223922.png)
 ### 4.虚引用 PhantomReference
 
 从PhantomReference类的源代码可以知道，它的get()方法无论何时返回的都只会是null。所以单独使用虚引用时，没有什么意义，需要和引用队列ReferenceQueue类联合使用。当执行Java GC时如果一个对象只有虚引用，就会把这个对象加入到与之关联的ReferenceQueue中。
-
-<pre>public class PhantomReferenceTest {
+````
+public class PhantomReferenceTest {
 
 	public static int M = 1024*1024;
 
@@ -205,12 +199,11 @@ StrongReference是Java的默认引用形式，使用时不需要显示定义。
 	    System.out.println("referenceQueue.poll() : "+referenceQueue.poll());	    	
 	}
 }
-</pre>
 
+````
 运行结果：
 
-![](https://user-gold-cdn.xitu.io/2018/1/7/160cd110cba23d84?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404223938.png)
 ## 三、小结
 
 强引用是 Java 的默认引用形式，使用时不需要显示定义，是我们平时最常使用到的引用方式。不管系统资源有多紧张，Java GC都不会主动回收具有强引用的对象。 弱引用和软引用一般在引用对象为非必需对象的时候使用。它们的区别是被弱引用关联的对象在垃圾回收时总是会被回收，被软引用关联的对象只有在内存不足时才会被回收。 虚引用的get()方法获取的永远是null，无法获取对象实例。Java GC会把虚引用的对象放到引用队列里面。可用来在对象被回收时做额外的一些资源清理或事物回滚等处理。 由于无法从虚引获取到引用对象的实例。它的使用情况比较特别，所以这里不把虚引用放入表格进行对比。这里对强引用、弱引用、软引用进行对比：
@@ -229,20 +222,4 @@ StrongReference是Java的默认引用形式，使用时不需要显示定义。
 
 https://blog.csdn.net/android_hl/article/details/53228348
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2723\357\274\232\345\236\203\345\234\276\345\233\236\346\224\266\345\231\250\350\257\246\350\247\243.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232\345\236\203\345\234\276\345\233\236\346\224\266\345\231\250\350\257\246\350\247\243.md"
similarity index 77%
rename from "docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2723\357\274\232\345\236\203\345\234\276\345\233\236\346\224\266\345\231\250\350\257\246\350\247\243.md"
rename to "docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232\345\236\203\345\234\276\345\233\236\346\224\266\345\231\250\350\257\246\350\247\243.md"
index 741c437..7e89241 100644
--- "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2723\357\274\232\345\236\203\345\234\276\345\233\236\346\224\266\345\231\250\350\257\246\350\247\243.md"
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232\345\236\203\345\234\276\345\233\236\346\224\266\345\231\250\350\257\246\350\247\243.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [1 概述](#1-概述)
   * [2 对象已经死亡？](#2-对象已经死亡？)
     * [2.1引用计数法](#21引用计数法)
@@ -85,8 +84,7 @@ Minor Gc和Full GC 有什么不同呢？
 
 ### 2.2可达性分析算法
 
-这个算法的基本思想就是通过一系列的称为 **“GC Roots”** 的对象作为起点，从这些节点开始向下搜索，节点所走过的路径称为引用链，当一个对象到GC Roots没有任何引用链相连的话，则证明此对象是不可用的。
-![可达性分析算法](https://user-gold-cdn.xitu.io/2018/4/28/1630be33dd8c8e32?w=807&h=485&f=png&s=223006)
+这个算法的基本思想就是通过一系列的称为**“GC Roots”**的对象作为起点，从这些节点开始向下搜索，节点所走过的路径称为引用链，当一个对象到GC Roots没有任何引用链相连的话，则证明此对象是不可用的。
 
 ### 2.3 再谈引用
 
@@ -114,7 +112,7 @@ JDK1.2以后，Java对引用的感念进行了扩充，将引用分为强引用
 
 **虚引用主要用来跟踪对象被垃圾回收的活动**。
 
-**虚引用与软引用和弱引用的一个区别在于：** 虚引用必须和引用队列（ReferenceQueue）联合使用。当垃 圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是 否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
+**虚引用与软引用和弱引用的一个区别在于：**虚引用必须和引用队列（ReferenceQueue）联合使用。当垃 圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是 否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
 
 特别注意，在程序设计中一般很少使用弱引用与虚引用，使用软引用的情况较多，这是因为**软引用可以加速JVM对垃圾内存的回收速度，可以维护系统的运行安全，防止内存溢出（OutOfMemory）等问题的产生**。
 
@@ -126,7 +124,7 @@ JDK1.2以后，Java对引用的感念进行了扩充，将引用分为强引用
 
 方法区（或Hotspot虚拟中的永久代）的垃圾收集主要回收两部分内容：**废弃常量和无用的类。**
 
-判定一个常量是否是“废弃常量”比较简单，而要判定一个类是否是“无用的类”的条件则相对苛刻许多。类需要同时满足下面3个条件才能算是 **“无用的类”** ：
+判定一个常量是否是“废弃常量”比较简单，而要判定一个类是否是“无用的类”的条件则相对苛刻许多。类需要同时满足下面3个条件才能算是**“无用的类”**：
 - 该类所有的实例都已经被回收，也就是Java堆中不存在该类的任何实例。
 - 加载该类的ClassLoader已经被回收。
 - 该类对应的java.lang.Class对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。
@@ -136,19 +134,16 @@ JDK1.2以后，Java对引用的感念进行了扩充，将引用分为强引用
 ### 3.1 标记-清除算法
 
 算法分为“标记”和“清除”阶段：首先标记出所有需要回收的对象，在标记完成后统一回收所有被标记的对象。它是最基础的收集算法，会带来两个明显的问题；1：效率问题和2：空间问题（标记清除后会产生大量不连续的碎片）
-![标记-清除算法](https://user-gold-cdn.xitu.io/2018/4/28/1630bedcd37144b0?w=809&h=438&f=png&s=143686)
 
 ### 3.2 复制算法
 
 为了解决效率问题，“复制”收集算法出现了。它可以将内存分为大小相同的两块，每次使用其中的一块。当这一块的内存使用完后，就将还存活的对象复制到另一块去，然后再把使用的空间一次清理掉。这样就使每次的内存回收都是对内存区间的一半进行回收。
 
-![复制算法](https://user-gold-cdn.xitu.io/2018/4/28/1630bee78552641e?w=829&h=420&f=png&s=188338)
 
 ### 3.3 标记-整理算法
 
 根据老年代的特点特出的一种标记算法，标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象回收，而是让所有存活的对象向一段移动，然后直接清理掉端边界以外的内存。
 
-![标记-整理算法](https://user-gold-cdn.xitu.io/2018/4/28/1630bef38f362a98?w=816&h=459&f=png&s=147162)
 
 ### 3.4分代收集算法
 
@@ -156,7 +151,7 @@ JDK1.2以后，Java对引用的感念进行了扩充，将引用分为强引用
 
 比如在新生代中，每次收集都会有大量对象死去，所以可以选择复制算法，只需要付出少量对象的复制成本就可以完成每次垃圾收集。而老年代的对象存活几率是比较高的所以我们可以选择“标记-清理”或“标记-整理”算法进行垃圾收集。
 
-**延伸面试问题：** HotSpot为什么要分为新生代和老年代？
+**延伸面试问题：**HotSpot为什么要分为新生代和老年代？
 
 根据上面的对分代收集算法的介绍回答。
 
@@ -167,8 +162,7 @@ JDK1.2以后，Java对引用的感念进行了扩充，将引用分为强引用
 
 ### 4.1 Serial收集器
 
-Serial（串行）收集器收集器是最基本、历史最悠久的垃圾收集器了。大家看名字就知道这个收集器是一个单线程收集器了。它的 **“单线程”** 的意义不仅仅意味着它只会使用一条垃圾收集线程去完成垃圾收集工作，更重要的是它在进行垃圾收集工作的时候必须暂停其他所有的工作线程（ **“Stop The World”** 了解一下），直到它收集结束。
-![Serial收集器](https://user-gold-cdn.xitu.io/2018/4/28/1630c032627e6728?w=767&h=177&f=png&s=80000)
+Serial（串行）收集器收集器是最基本、历史最悠久的垃圾收集器了。大家看名字就知道这个收集器是一个单线程收集器了。它的**“单线程”**的意义不仅仅意味着它只会使用一条垃圾收集线程去完成垃圾收集工作，更重要的是它在进行垃圾收集工作的时候必须暂停其他所有的工作线程（**“Stop The World”**了解一下），直到它收集结束。
 
 虚拟机的设计者们当然知道Stop The World带来的不良用户体验，所以在后续的垃圾收集器设计中停顿时间在不断缩短（仍然还有停顿，寻找最优秀的垃圾收集器的过程仍然在继续）。
 
@@ -178,12 +172,11 @@ Serial（串行）收集器收集器是最基本、历史最悠久的垃圾收
 
 **ParNew收集器其实就是Serial收集器的多线程版本，除了使用多线程进行垃圾收集外，其余行为（控制参数、收集算法、回收策略等等）和Serial收集器完全一样。**
 
-![ParNew收集器](https://user-gold-cdn.xitu.io/2018/4/28/1630c07412c5e73a?w=785&h=187&f=png&s=87246)
 它是许多运行在Server模式下的虚拟机的首要选择，除了Serial收集器外，只有它能与CMS收集器（真正意义上的并发收集器，后面会介绍到）配合工作。
 
 **并行和并发概念补充：**
 
-*   **并行（Parallel）** ：指多条垃圾收集线程并行工作，但此时用户线程仍然处于等待状态。
+*   **并行（Parallel）**：指多条垃圾收集线程并行工作，但此时用户线程仍然处于等待状态。
 
 *   **并发（Concurrent）**：指用户线程与垃圾收集线程同时执行（但不一定是并行，可能会交替执行），用户程序在继续运行，而垃圾收集器运行在另一个CPU上。
 
@@ -191,7 +184,7 @@ Serial（串行）收集器收集器是最基本、历史最悠久的垃圾收
 
 Parallel Scavenge收集器是一个新生代收集器，它也是使用复制算法的收集器，又是并行的的多线程收集器。。。那么它有什么特别之处呢？
 
-**Parallel Scavenge收集器关注点是吞吐量（高效率的利用CPU）。CMS等垃圾收集器的关注点更多的是用户线程的停顿时间（提高用户体验）。所谓吞吐量就是CPU中用于运行用户代码的时间与CPU总消耗时间的比值。** Parallel Scavenge收集器提供了很多参数供用户找到最合适的停顿时间或最大吞吐量，如果对于收集器运作不太了解的话，手工优化存在的话可以选择把内存管理优化交给虚拟机去完成也是一个不错的选择。
+**Parallel Scavenge收集器关注点是吞吐量（高效率的利用CPU）。CMS等垃圾收集器的关注点更多的是用户线程的停顿时间（提高用户体验）。所谓吞吐量就是CPU中用于运行用户代码的时间与CPU总消耗时间的比值。**Parallel Scavenge收集器提供了很多参数供用户找到最合适的停顿时间或最大吞吐量，如果对于收集器运作不太了解的话，手工优化存在的话可以选择把内存管理优化交给虚拟机去完成也是一个不错的选择。
 
 ### 4.4.Serial Old收集器
 
@@ -205,45 +198,41 @@ Parallel Scavenge收集器是一个新生代收集器，它也是使用复制算
 
 **CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。它而非常符合在注重用户体验的应用上使用。**
 
-从名字中的**Mark Sweep**这两个词可以看出，CMS收集器是一种 **“标记-清除”算法**实现的，它的运作过程相比于前面几种垃圾收集器来说更加复杂一些。整个过程分为四个步骤：
-
-*   **初始标记：** 暂停所有的其他线程，并记录下直接与root相连的对象，速度很快 ；
-*   **并发标记：** 同时开启GC和用户线程，用一个闭包结构去记录可达对象。但在这个阶段结束，这个闭包结构并不能保证包含当前所有的可达对象。因为用户线程可能会不断的更新引用域，所以GC线程无法保证可达性分析的实时性。所以这个算法里会跟踪记录这些发生引用更新的地方。
-*   **重新标记：** 重新标记阶段就是为了修正并发标记期间因为用户程序继续运行而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段的时间稍长，远远比并发标记阶段时间短
-*   **并发清除：** 开启用户线程，同时GC线程开始对为标记的区域做清扫。
+从名字中的**Mark Sweep**这两个词可以看出，CMS收集器是一种**“标记-清除”算法**实现的，它的运作过程相比于前面几种垃圾收集器来说更加复杂一些。整个过程分为四个步骤：
 
-![CMS收集器](https://user-gold-cdn.xitu.io/2018/4/28/1630c17fcd5f9497?w=816&h=210&f=png&s=91490)
+*   **初始标记：**暂停所有的其他线程，并记录下直接与root相连的对象，速度很快 ；
+*   **并发标记：**同时开启GC和用户线程，用一个闭包结构去记录可达对象。但在这个阶段结束，这个闭包结构并不能保证包含当前所有的可达对象。因为用户线程可能会不断的更新引用域，所以GC线程无法保证可达性分析的实时性。所以这个算法里会跟踪记录这些发生引用更新的地方。
+*   **重新标记：**重新标记阶段就是为了修正并发标记期间因为用户程序继续运行而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段的时间稍长，远远比并发标记阶段时间短
+*   **并发清除：**开启用户线程，同时GC线程开始对为标记的区域做清扫。
 
 从它的名字就可以看出它是一款优秀的垃圾收集器，主要优点：**并发收集、低停顿**。但是它有下面三个明显的缺点：
-- **对CPU资源敏感；**
-- **无法处理浮动垃圾；**
-- **它使用的回收算法-“标记-清除”算法会导致收集结束时会有大量空间碎片产生。**
+-**对CPU资源敏感；**
+-**无法处理浮动垃圾；**
+-**它使用的回收算法-“标记-清除”算法会导致收集结束时会有大量空间碎片产生。**
 
 ### 4.7 G1收集器
 
 上一代的垃圾收集器(串行serial, 并行parallel, 以及CMS)都把堆内存划分为固定大小的三个部分: 年轻代(young generation), 年老代(old generation), 以及持久代(permanent generation).
 
-![年轻代(young generation), 年老代(old generation), 以及持久代(permanent generation)](https://user-gold-cdn.xitu.io/2018/4/28/1630c1b1b3b95713?w=960&h=513&f=png&s=24990)
 
 **G1 (Garbage-First)是一款面向服务器的垃圾收集器,主要针对配备多颗处理器及大容量内存的机器. 以极高概率满足GC停顿时间要求的同时,还具备高吞吐量性能特征.**
 
 被视为JDK1.7中HotSpot虚拟机的一个重要进化特征。它具备一下特点：
-- **并行与并发**：G1能充分利用CPU、多核环境下的硬件优势，使用多个CPU（CPU或者CPU核心）来缩短stop-The-World停顿时间。部分其他收集器原本需要停顿Java线程执行的GC动作，G1收集器仍然可以通过并发的方式让java程序继续执行。
-- **分代收集**：虽然G1可以不需要其他收集器配合就能独立管理整个GC堆，但是还是保留了分代的概念。
-- **空间整合**：与CMS的“标记–清理”算法不同，G1从整体来看是基于“标记整理”算法实现的收集器；从局部上来看是基于“复制”算法实现的。
-- **可预测的停顿**：这是G1相对于CMS的另一个大优势，降低停顿时间是G1和ＣＭＳ共同的关注点，但Ｇ１除了追求低停顿外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为M毫秒的时间片段内。
+-**并行与并发**：G1能充分利用CPU、多核环境下的硬件优势，使用多个CPU（CPU或者CPU核心）来缩短stop-The-World停顿时间。部分其他收集器原本需要停顿Java线程执行的GC动作，G1收集器仍然可以通过并发的方式让java程序继续执行。
+-**分代收集**：虽然G1可以不需要其他收集器配合就能独立管理整个GC堆，但是还是保留了分代的概念。
+-**空间整合**：与CMS的“标记–清理”算法不同，G1从整体来看是基于“标记整理”算法实现的收集器；从局部上来看是基于“复制”算法实现的。
+-**可预测的停顿**：这是G1相对于CMS的另一个大优势，降低停顿时间是G1和ＣＭＳ共同的关注点，但Ｇ１除了追求低停顿外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为M毫秒的时间片段内。
 
 **G1收集器在后台维护了一个优先列表，每次根据允许的收集时间，优先选择回收价值最大的Region(这也就是它的名字Garbage-First的由来)**。这种使用Region划分内存空间以及有优先级的区域回收方式，保证了GF收集器在有限时间内可以尽可能高的收集效率（把内存化整为零）。
 
 G1收集器的运作大致分为以下几个步骤：
-- **初始标记**
-- **并发标记**
-- **最终标记**
-- **筛选回收**
+-**初始标记**
+-**并发标记**
+-**最终标记**
+-**筛选回收**
 
 上面几个步骤的运作过程和CMS有很多相似之处。初始标记阶段仅仅只是标记一下GC Roots能直接关联到的对象，并且修改TAMS的值，让下一个阶段用户程序并发运行时，能在正确可用的Region中创建新对象，这一阶段需要停顿线程，但是耗时很短，并发标记阶段是从GC Root开始对堆中对象进行可达性分析，找出存活的对象，这阶段时耗时较长，但可与用户程序并发执行。而最终标记阶段则是为了修正在并发标记期间因用户程序继续运作而导致标记产生变动的那一部分标记记录，虚拟机将这段时间对象变化记录在线程Remenbered Set Logs里面，最终标记阶段需要把Remembered Set Logs的数据合并到Remembered Set Logs里面，最终标记阶段需要把Remembered Set Logs的数据合并到Remembered Set中，这一阶段需要停顿线程，但是可并行执行。最后在筛选回收阶段首先对各个Region的回收价值和成本进行排序，根据用户所期望的GC停顿时间来制定回收计划。
 
-![G1收集器](https://user-gold-cdn.xitu.io/2018/4/28/1630c1e0bb4557d8?w=814&h=206&f=png&s=98459)
 
 ## 5 内存分配与回收策略
 
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2726\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243JVM\347\261\273\345\212\240\350\275\275\346\234\272\345\210\266.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243JVM\347\261\273\345\212\240\350\275\275\346\234\272\345\210\266.md"
similarity index 82%
rename from "docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2726\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243JVM\347\261\273\345\212\240\350\275\275\346\234\272\345\210\266.md"
rename to "docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243JVM\347\261\273\345\212\240\350\275\275\346\234\272\345\210\266.md"
index 60ad7b7..198ce72 100644
--- "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2726\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243JVM\347\261\273\345\212\240\350\275\275\346\234\272\345\210\266.md"
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243JVM\347\261\273\345\212\240\350\275\275\346\234\272\345\210\266.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [一.目标：](#一目标：)
   * [二.原理 （类的加载过程及其最终产品）:](#二原理-（类的加载过程及其最终产品）)
   * [三.过程（类的生命周期）：](#三过程（类的生命周期）：)
@@ -11,9 +10,6 @@
   * [四.类加载器：](#四类加载器：)
   * [五.双亲委派机制：](#五双亲委派机制：)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
 
 
 本文转自互联网，侵删
@@ -36,7 +32,6 @@
 
 <!-- more -->
 
-<!-- more -->
 ## 一.目标：
 
 1.什么是类的加载？
@@ -56,14 +51,7 @@ JVM将class文件字节码文件加载到内存中， 并将这些静态数据
 JVM类加载机制分为五个部分：加载，验证，准备，解析，初始化，下面我们就分别来看一下这五个过程。其中加载、检验、准备、初始化和卸载这个五个阶段的顺序是固定的，而解析则未必。为了支持动态绑定，解析这个过程可以发生在初始化阶段之后。
 
 
-
-
-
-![](https://upload-images.jianshu.io/upload_images/13202633-3cb11d1712a9efc9.png?imageMogr2/auto-orient/strip|imageView2/2/w/739/format/webp)
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404221551.png)
 
 ### 加载：
 
@@ -139,13 +127,7 @@ java中，对于初始化阶段，有且只有以下五种情况才会对要求
 ## 五.双亲委派机制：
 
 
-
-
-
-![](https://upload-images.jianshu.io/upload_images/13202633-4c819649aebff4df.png?imageMogr2/auto-orient/strip|imageView2/2/w/590/format/webp)
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404221618.png)
 
 
 双亲委派机制工作过程：
@@ -169,20 +151,4 @@ java中，对于初始化阶段，有且只有以下五种情况才会对要求
 
 https://blog.csdn.net/android_hl/article/details/53228348
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2725\357\274\232\350\231\232\346\213\237\346\234\272\345\255\227\350\212\202\347\240\201\346\211\247\350\241\214\345\274\225\346\223\216.md" "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232\350\231\232\346\213\237\346\234\272\345\255\227\350\212\202\347\240\201\346\211\247\350\241\214\345\274\225\346\223\216.md"
similarity index 85%
rename from "docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2725\357\274\232\350\231\232\346\213\237\346\234\272\345\255\227\350\212\202\347\240\201\346\211\247\350\241\214\345\274\225\346\223\216.md"
rename to "docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232\350\231\232\346\213\237\346\234\272\345\255\227\350\212\202\347\240\201\346\211\247\350\241\214\345\274\225\346\223\216.md"
index faebc2d..aabb34c 100644
--- "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2725\357\274\232\350\231\232\346\213\237\346\234\272\345\255\227\350\212\202\347\240\201\346\211\247\350\241\214\345\274\225\346\223\216.md"
+++ "b/docs/Java/JVM/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232\350\231\232\346\213\237\346\234\272\345\255\227\350\212\202\347\240\201\346\211\247\350\241\214\345\274\225\346\223\216.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [1 概述](#1-概述)
   * [2 运行时栈帧结构](#2-运行时栈帧结构)
     * [2.1 局部变量表](#21-局部变量表)
@@ -45,14 +44,13 @@
 
 ## 2 运行时栈帧结构
 
-**栈帧（Stack Frame）** 是用于支持虚拟机方法调用和方法执行的数据结构，它是虚拟机运行时数据区中**虚拟机栈（Virtual Machine Stack）的栈元素**。
+**栈帧（Stack Frame）**是用于支持虚拟机方法调用和方法执行的数据结构，它是虚拟机运行时数据区中**虚拟机栈（Virtual Machine Stack）的栈元素**。
 
 栈帧存储了方法的局部变量表、操作数栈、动态连接和方法返回地址等信息。每一个方法从调用开始至执行完成的过程，都对应着一个栈帧在虚拟机栈里面从入栈到出栈的过程。
 
 **栈帧概念结构如下图所示：**
 
-![栈帧概念结构](https://user-gold-cdn.xitu.io/2018/5/4/1632919c2fc34c02?w=640&h=569&f=png&s=116882)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404221305.png)
 ### 2.1 局部变量表
 
 **局部变量表是一组变量值存储空间，用于存放方法参数和方法内定义的局部变量。
@@ -66,17 +64,16 @@
 
 ### 2.2 操作数栈
 
-**操作数栈（Operand Stack）** 也常称为操作栈，它是一个**后入先出栈**。当一个方法执行开始时，这个方法的操作数栈是空的，在方法执行过程中，会有各种字节码指令往操作数栈中写入和提取内容，也就是 **出栈/入栈**操作。
-
-![操作数栈](https://user-gold-cdn.xitu.io/2018/5/4/16329250e46c341a?w=470&h=411&f=png&s=63864)
+**操作数栈（Operand Stack）**也常称为操作栈，它是一个**后入先出栈**。当一个方法执行开始时，这个方法的操作数栈是空的，在方法执行过程中，会有各种字节码指令往操作数栈中写入和提取内容，也就是**出栈/入栈**操作。
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404221316.png)
 在概念模型中，一个活动线程中两个栈帧是相互独立的。但大多数虚拟机实现都会做一些优化处理：让下一个栈帧的部分操作数栈与上一个栈帧的部分局部变量表重叠在一起，这样的好处是方法调用时可以共享一部分数据，而无须进行额外的参数复制传递。
 
 ### 2.3 动态连接
 
 每个栈帧都包含一个指向运行时常量池中该栈帧所属方法的引用，持有这个引用是为了支持方法调用过程中的**动态连接**；
 
-字节码中方法调用指令是以常量池中的指向方法的符号引用为参数的，有一部分符号引用会在类加载阶段或第一次使用的时候转化为直接引用，这种转化称为 **静态解析**，另外一部分在每次的运行期间转化为直接引用，这部分称为**动态连接**。
+字节码中方法调用指令是以常量池中的指向方法的符号引用为参数的，有一部分符号引用会在类加载阶段或第一次使用的时候转化为直接引用，这种转化称为**静态解析**，另外一部分在每次的运行期间转化为直接引用，这部分称为**动态连接**。
 
 ### 2.4 方法返回地址
 
@@ -106,11 +103,11 @@
 “编译期可知，运行期不可变”的方法（静态方法和私有方法），在类加载的解析阶段，会将其符号引用转化为直接引用（入口地址）。这类方法的调用称为“**解析（Resolution）**”。
 
 在Java虚拟机中提供了5条方法调用字节码指令：
-- **invokestatic** : 调用静态方法
-- **invokespecial**:调用实例构造器方法、私有方法、父类方法
-- **invokevirtual**:调用所有的虚方法
-- **invokeinterface**:调用接口方法，会在运行时在确定一个实现此接口的对象
-- **invokedynamic**:先在运行时动态解析出点限定符所引用的方法，然后再执行该方法，在此之前的4条调用命令的分派逻辑是固化在Java虚拟机内部的，而invokedynamic指令的分派逻辑是由用户所设定的引导方法决定的。
+-**invokestatic**: 调用静态方法
+-**invokespecial**:调用实例构造器方法、私有方法、父类方法
+-**invokevirtual**:调用所有的虚方法
+-**invokeinterface**:调用接口方法，会在运行时在确定一个实现此接口的对象
+-**invokedynamic**:先在运行时动态解析出点限定符所引用的方法，然后再执行该方法，在此之前的4条调用命令的分派逻辑是固化在Java虚拟机内部的，而invokedynamic指令的分派逻辑是由用户所设定的引导方法决定的。
 
 ### 3.2 分派
 
@@ -252,14 +249,14 @@ JDK新增加了invokedynamic指令来是实现“动态类型语言”。
 **静态语言和动态语言的区别：**
 
 *   **静态语言（强类型语言）**：
-    静态语言是在编译时变量的数据类型即可确定的语言，多数静态类型语言要求在使用变量之前必须声明数据类型。 
+    静态语言是在编译时变量的数据类型即可确定的语言，多数静态类型语言要求在使用变量之前必须声明数据类型。
     例如：C++、Java、Delphi、C#等。
-*   **动态语言（弱类型语言）** ：
-    动态语言是在运行时确定数据类型的语言。变量使用之前不需要类型声明，通常变量的类型是被赋值的那个值的类型。 
+*   **动态语言（弱类型语言）**：
+    动态语言是在运行时确定数据类型的语言。变量使用之前不需要类型声明，通常变量的类型是被赋值的那个值的类型。
     例如PHP/ASP/Ruby/Python/Perl/ABAP/SQL/JavaScript/Unix Shell等等。
-*   **强类型定义语言** ：
+*   **强类型定义语言**：
     强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。举个例子：如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。强类型定义语言是类型安全的语言。
-*   **弱类型定义语言** ：
+*   **弱类型定义语言**：
     数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。强类型定义语言在速度上可能略逊色于弱类型定义语言，但是强类型定义语言带来的严谨性能够有效的避免许多错误。
 
 ## 4 基于栈的字节码解释执行引擎
@@ -268,15 +265,13 @@ JDK新增加了invokedynamic指令来是实现“动态类型语言”。
 
 ### 4.1 解释执行
 
-Java语言经常被人们定位为 **“解释执行”语言**，在Java初生的JDK1.0时代，这种定义还比较准确的，但当主流的虚拟机中都包含了即时编译后，Class文件中的代码到底会被解释执行还是编译执行，就成了只有虚拟机自己才能准确判断的事情。再后来，Java也发展出来了直接生成本地代码的编译器[如何GCJ（GNU Compiler for the Java）]，而C/C++也出现了通过解释器执行的版本（如CINT），这时候再笼统的说“解释执行”，对于整个Java语言来说就成了几乎没有任何意义的概念，**只有确定了谈论对象是某种具体的Java实现版本和执行引擎运行模式时，谈解释执行还是编译执行才会比较确切**。
-
-![ 解释执行](https://user-gold-cdn.xitu.io/2018/5/4/16329338654c4e30?w=612&h=274&f=png&s=105184)
+Java语言经常被人们定位为**“解释执行”语言**，在Java初生的JDK1.0时代，这种定义还比较准确的，但当主流的虚拟机中都包含了即时编译后，Class文件中的代码到底会被解释执行还是编译执行，就成了只有虚拟机自己才能准确判断的事情。再后来，Java也发展出来了直接生成本地代码的编译器[如何GCJ（GNU Compiler for the Java）]，而C/C++也出现了通过解释器执行的版本（如CINT），这时候再笼统的说“解释执行”，对于整个Java语言来说就成了几乎没有任何意义的概念，**只有确定了谈论对象是某种具体的Java实现版本和执行引擎运行模式时，谈解释执行还是编译执行才会比较确切**。
 
 Java语言中，javac编译器完成了程序代码经过词法分析、语法分析到抽象语法树，再遍历语法树生成线性的字节码指令流的过程，因为这一部分动作是在Java虚拟机之外进行的，而解释器在虚拟机内部，所以Java程序的编译就是半独立实现的，
 
 ### 4.2 基于栈的指令集和基于寄存器的指令集
 
-Java编译器输出的指令流，基本上是一种**基于栈的指令集架构（Instruction Set Architecture，ISA）**，**依赖操作数栈进行工作**。与之相对应的另一套常用的指令集架构是**基于寄存器的指令集**， **依赖寄存器进行工作**。
+Java编译器输出的指令流，基本上是一种**基于栈的指令集架构（Instruction Set Architecture，ISA）**，**依赖操作数栈进行工作**。与之相对应的另一套常用的指令集架构是**基于寄存器的指令集**，**依赖寄存器进行工作**。
 
 那么，**基于栈的指令集和基于寄存器的指令集这两者有什么不同呢？**
 
diff --git "a/docs/java/basic/21\343\200\201Java8\346\226\260\347\211\271\346\200\247\347\273\210\346\236\201\346\214\207\345\215\227.md" "b/docs/Java/basic/Java8\346\226\260\347\211\271\346\200\247\347\273\210\346\236\201\346\214\207\345\215\227.md"
similarity index 81%
rename from "docs/java/basic/21\343\200\201Java8\346\226\260\347\211\271\346\200\247\347\273\210\346\236\201\346\214\207\345\215\227.md"
rename to "docs/Java/basic/Java8\346\226\260\347\211\271\346\200\247\347\273\210\346\236\201\346\214\207\345\215\227.md"
index 14b4137..fa70648 100644
--- "a/docs/java/basic/21\343\200\201Java8\346\226\260\347\211\271\346\200\247\347\273\210\346\236\201\346\214\207\345\215\227.md"
+++ "b/docs/Java/basic/Java8\346\226\260\347\211\271\346\200\247\347\273\210\346\236\201\346\214\207\345\215\227.md"
@@ -16,18 +16,7 @@
   * [Java虚拟机（JVM）的新特性](#java虚拟机（jvm）的新特性)
   * [总结](#总结)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
----
-title: 夯实Java基础系列21：Java8新特性终极指南
-date: 2019-9-21 15:56:26 # 文章生成时间，一般不改
-categories:
-    - Java技术江湖
-    - Java基础
-tags:
-    - Java8
----
+
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -48,8 +37,7 @@ tags:
 
 这是一个Java8新增特性的总结图。接下来让我们一次实践一下这些新特性吧
 
-![image](https://img2018.cnblogs.com/blog/493447/201906/493447-20190604133048748-2090946599.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230403215737.png)
 ## Java语言新特性
 
 ### Lambda表达式
@@ -100,13 +88,14 @@ java.lang.Runnable与java.util.concurrent.Callable是函数式接口最典型的
 在实际使用过程中，函数式接口是容易出错的：如有某个人在接口定义中增加了另一个方法，这时，这个接口就不再是函数式的了，并且编译过程也会失败。
 
 为了克服函数式接口的这种脆弱性并且能够明确声明接口作为函数式接口的意图，Java8增加了一种特殊的注解@FunctionalInterface（Java8中所有类库的已有接口都添加了@FunctionalInterface注解）。让我们看一下这种函数式接口的定义：
-
+````
 @FunctionalInterface
 public interface Functional {
     void method();
 }
+````
 需要记住的一件事是：默认方法与静态方法并不影响函数式接口的契约，可以任意使用：
-
+````
 @FunctionalInterface
 public interface FunctionalDefaultMethods {
     void method();
@@ -114,82 +103,83 @@ public interface FunctionalDefaultMethods {
     default void defaultMethod() {            
     }        
 }
+````
 Lambda是Java 8最大的卖点。它具有吸引越来越多程序员到Java平台上的潜力，并且能够在纯Java语言环境中提供一种优雅的方式来支持函数式编程。更多详情可以参考官方文档。
 
 下面看一个例子：
+````
+public class lambda和函数式编程 {
+    @Test
+    public void test1() {
+        List names = Arrays.asList("peter", "anna", "mike", "xenia");
 
-    public class lambda和函数式编程 {
-        @Test
-        public void test1() {
-            List names = Arrays.asList("peter", "anna", "mike", "xenia");
-    
-            Collections.sort(names, new Comparator<String>() {
-                @Override
-                public int compare(String a, String b) {
-                    return b.compareTo(a);
-                }
-            });
-            System.out.println(Arrays.toString(names.toArray()));
-        }
-    
-        @Test
-        public void test2() {
-            List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
-    
-            Collections.sort(names, (String a, String b) -> {
+        Collections.sort(names, new Comparator<String>() {
+            @Override
+            public int compare(String a, String b) {
                 return b.compareTo(a);
-            });
-    
-            Collections.sort(names, (String a, String b) -> b.compareTo(a));
-    
-            Collections.sort(names, (a, b) -> b.compareTo(a));
-            System.out.println(Arrays.toString(names.toArray()));
-        }
-    
+            }
+        });
+        System.out.println(Arrays.toString(names.toArray()));
     }
-    
-        static void add(double a,String b) {
-            System.out.println(a + b);
-        }
-        @Test
-        public void test5() {
-            D d = (a,b) -> add(a,b);
-    //        interface D {
-    //            void get(int i,String j);
-    //        }
-            //这里要求，add的两个参数和get的两个参数吻合并且返回类型也要相等，否则报错
-    //        static void add(double a,String b) {
-    //            System.out.println(a + b);
-    //        }
-        }
-    
-        @FunctionalInterface
-        interface D {
-            void get(int i,String j);
-        }
 
-接下来看看Lambda和匿名内部类的区别
+    @Test
+    public void test2() {
+        List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
 
-匿名内部类仍然是一个类，只是不需要我们显式指定类名，编译器会自动为该类取名。比如有如下形式的代码：
+        Collections.sort(names, (String a, String b) -> {
+            return b.compareTo(a);
+        });
 
-    public class LambdaTest {
-        public static void main(String[] args) {
-            new Thread(new Runnable() {
-                @Override
-                public void run() {
-                    System.out.println("Hello World");
-                }
-            }).start();
-        }
+        Collections.sort(names, (String a, String b) -> b.compareTo(a));
+
+        Collections.sort(names, (a, b) -> b.compareTo(a));
+        System.out.println(Arrays.toString(names.toArray()));
+    }
+
+}
+
+    static void add(double a,String b) {
+        System.out.println(a + b);
+    }
+    @Test
+    public void test5() {
+        D d = (a,b) -> add(a,b);
+//        interface D {
+//            void get(int i,String j);
+//        }
+        //这里要求，add的两个参数和get的两个参数吻合并且返回类型也要相等，否则报错
+//        static void add(double a,String b) {
+//            System.out.println(a + b);
+//        }
     }
 
+    @FunctionalInterface
+    interface D {
+        void get(int i,String j);
+    }
+````
+接下来看看Lambda和匿名内部类的区别
+
+匿名内部类仍然是一个类，只是不需要我们显式指定类名，编译器会自动为该类取名。比如有如下形式的代码：
+````
+public class LambdaTest {
+    public static void main(String[] args) {
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                System.out.println("Hello World");
+            }
+        }).start();
+    }
+}
+````
 编译之后将会产生两个 class 文件：
 
     LambdaTest.class
     LambdaTest$1.class
 
 使用 javap -c LambdaTest.class 进一步分析 LambdaTest.class 的字节码，部分结果如下：
-
+````
     public static void main(java.lang.String[]);
     Code:
         0: new           #2                  // class java/lang/Thread
@@ -200,28 +190,28 @@ Lambda是Java 8最大的卖点。它具有吸引越来越多程序员到Java平
         11: invokespecial #5                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
         14: invokevirtual #6                  // Method java/lang/Thread.start:()V
         17: return
-
+````
 可以发现在 4: new #3 这一行创建了匿名内部类的对象。
 
 而对于 Lambda表达式的实现， 接下来我们将上面的示例代码使用 Lambda 表达式实现，代码如下：
-
-    public class LambdaTest {
-        public static void main(String[] args) {
-            new Thread(() -> System.out.println("Hello World")).start();
-        }
+````
+public class LambdaTest {
+    public static void main(String[] args) {
+        new Thread(() -> System.out.println("Hello World")).start();
     }
-
+}
+````
 此时编译后只会产生一个文件 LambdaTest.class，再来看看通过 javap 对该文件反编译后的结果：
-
-    public static void main(java.lang.String[]);
-    Code:
-        0: new           #2                  // class java/lang/Thread
-        3: dup
-        4: invokedynamic #3,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
-        9: invokespecial #4                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
-        12: invokevirtual #5                  // Method java/lang/Thread.start:()V
-        15: return
-
+````
+public static void main(java.lang.String[]);
+Code:
+    0: new           #2                  // class java/lang/Thread
+    3: dup
+    4: invokedynamic #3,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
+    9: invokespecial #4                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
+    12: invokevirtual #5                  // Method java/lang/Thread.start:()V
+    15: return
+````
 从上面的结果我们发现 Lambda 表达式被封装成了主类的一个私有方法，并通过 invokedynamic 指令进行调用。
 
 因此，我们可以得出结论：Lambda 表达式是通过 invokedynamic 指令实现的，并且书写 Lambda 表达式不会产生新的类。
@@ -238,50 +228,50 @@ lambda表达式是如何符合 Java 类型系统的？每个lambda对应于一
 我们可以使用任意的接口作为lambda表达式，只要这个接口只包含一个抽象方法。为了保证你的接口满足需求，你需要增加@FunctionalInterface注解。编译器知道这个注解，一旦你试图给这个接口增加第二个抽象方法声明时，它将抛出一个编译器错误。
 
 下面举几个例子
-    
-    public class 函数式接口使用 {
-        @FunctionalInterface
-        interface A {
-            void say();
-            default void talk() {
-    
-            }
-        }
-        @Test
-        public void test1() {
-            A a = () -> System.out.println("hello");
-            a.say();
-        }
-    
-        @FunctionalInterface
-        interface B {
-            void say(String i);
-        }
-        public void test2() {
-            //下面两个是等价的，都是通过B接口来引用一个方法，而方法可以直接使用::来作为方法引用
-            B b = System.out::println;
-            B b1 = a -> Integer.parseInt("s");//这里的a其实换成别的也行，只是将方法传给接口作为其方法实现
-            B b2 = Integer::valueOf;//i与方法传入参数的变量类型一直时，可以直接替换
-            B b3 = String::valueOf;
-            //B b4 = Integer::parseInt;类型不符，无法使用
-    
-        }
-        @FunctionalInterface
-        interface C {
-            int say(String i);
-        }
-        public void test3() {
-            C c = Integer::parseInt;//方法参数和接口方法的参数一样，可以替换。
-            int i = c.say("1");
-            //当我把C接口的int替换为void时就会报错，因为返回类型不一致。
-            System.out.println(i);
-            //综上所述，lambda表达式提供了一种简便的表达方式，可以将一个方法传到接口中。
-            //函数式接口是只提供一个抽象方法的接口，其方法由lambda表达式注入，不需要写实现类，
-            //也不需要写匿名内部类，可以省去很多代码，比如实现runnable接口。
-            //函数式编程就是指把方法当做一个参数或引用来进行操作。除了普通方法以外，静态方法，构造方法也是可以这样操作的。
+````    
+public class 函数式接口使用 {
+    @FunctionalInterface
+    interface A {
+        void say();
+        default void talk() {
+
         }
     }
+    @Test
+    public void test1() {
+        A a = () -> System.out.println("hello");
+        a.say();
+    }
 
+    @FunctionalInterface
+    interface B {
+        void say(String i);
+    }
+    public void test2() {
+        //下面两个是等价的，都是通过B接口来引用一个方法，而方法可以直接使用::来作为方法引用
+        B b = System.out::println;
+        B b1 = a -> Integer.parseInt("s");//这里的a其实换成别的也行，只是将方法传给接口作为其方法实现
+        B b2 = Integer::valueOf;//i与方法传入参数的变量类型一直时，可以直接替换
+        B b3 = String::valueOf;
+        //B b4 = Integer::parseInt;类型不符，无法使用
+
+    }
+    @FunctionalInterface
+    interface C {
+        int say(String i);
+    }
+    public void test3() {
+        C c = Integer::parseInt;//方法参数和接口方法的参数一样，可以替换。
+        int i = c.say("1");
+        //当我把C接口的int替换为void时就会报错，因为返回类型不一致。
+        System.out.println(i);
+        //综上所述，lambda表达式提供了一种简便的表达方式，可以将一个方法传到接口中。
+        //函数式接口是只提供一个抽象方法的接口，其方法由lambda表达式注入，不需要写实现类，
+        //也不需要写匿名内部类，可以省去很多代码，比如实现runnable接口。
+        //函数式编程就是指把方法当做一个参数或引用来进行操作。除了普通方法以外，静态方法，构造方法也是可以这样操作的。
+    }
+}
+````
 请记住如果@FunctionalInterface 这个注解被遗漏，此代码依然有效。
 
 ### 方法引用
@@ -290,7 +280,7 @@ Lambda表达式和方法引用
 
 有了函数式接口之后，就可以使用Lambda表达式和方法引用了。其实函数式接口的表中的函数描述符就是Lambda表达式，在函数式接口中Lambda表达式相当于匿名内部类的效果。 举个简单的例子：
 
-
+````
 public class TestLambda {
 
     public static void execute(Runnable runnable) {
@@ -310,7 +300,7 @@ public class TestLambda {
         execute(() -> System.out.println("run"));
     }
 }
-
+````
 可以看到，相比于使用匿名内部类的方式，Lambda表达式可以使用更少的代码但是有更清晰的表述。注意，Lambda表达式也不是完全等价于匿名内部类的， 两者的不同点在于this的指向和本地变量的屏蔽上。
 
 方法引用可以看作Lambda表达式的更简洁的一种表达形式，使用::操作符，方法引用主要有三类：
@@ -351,31 +341,31 @@ public class TestLambda {
 ### 接口的默认方法
 
 Java 8 使我们能够使用default 关键字给接口增加非抽象的方法实现。这个特性也被叫做 扩展方法（Extension Methods）。如下例所示：
-
-    public class 接口的默认方法 {
-        class B implements A {
-    //        void a(){}实现类方法不能重名
-        }
-        interface A {
-            //可以有多个默认方法
-            public default void a(){
-                System.out.println("a");
-            }
-            public default void b(){
-                System.out.println("b");
-            }
-            //报错static和default不能同时使用
-    //        public static default void c(){
-    //            System.out.println("c");
-    //        }
+````
+public class 接口的默认方法 {
+    class B implements A {
+//        void a(){}实现类方法不能重名
+    }
+    interface A {
+        //可以有多个默认方法
+        public default void a(){
+            System.out.println("a");
         }
-        public void test() {
-            B b = new B();
-            b.a();
-    
+        public default void b(){
+            System.out.println("b");
         }
+        //报错static和default不能同时使用
+//        public static default void c(){
+//            System.out.println("c");
+//        }
     }
+    public void test() {
+        B b = new B();
+        b.a();
 
+    }
+}
+````
 默认方法出现的原因是为了对原有接口的扩展，有了默认方法之后就不怕因改动原有的接口而对已经使用这些接口的程序造成的代码不兼容的影响。 在Java8中也对一些接口增加了一些默认方法，比如Map接口等等。一般来说，使用默认方法的场景有两个：可选方法和行为的多继承。
 
 默认方法的使用相对来说比较简单，唯一要注意的点是如何处理默认方法的冲突。关于如何处理默认方法的冲突可以参考以下三条规则：
@@ -385,7 +375,7 @@ Java 8 使我们能够使用default 关键字给接口增加非抽象的方法
 如果无法依据第一条规则进行判断，那么子接口的优先级更高：函数签名相同时，优先选择拥有最具体实现的默认方法的接口。即如果B继承了A，那么B就比A更具体。
 
 最后，如果还是无法判断，继承了多个接口的类必须通过显式覆盖和调用期望的方法，显式地选择使用哪一个默认方法的实现。那么如何显式地指定呢:
-
+````
     public class C implements B, A {
      
         public void hello() {
@@ -393,43 +383,46 @@ Java 8 使我们能够使用default 关键字给接口增加非抽象的方法
         }
      
     }
+````
 使用X.super.m(..)显式地调用希望调用的方法。
 
 Java 8用默认方法与静态方法这两个新概念来扩展接口的声明。默认方法使接口有点像Traits（Scala中特征(trait)类似于Java中的Interface，但它可以包含实现代码，也就是目前Java8新增的功能），但与传统的接口又有些不一样，它允许在已有的接口中添加新方法，而同时又保持了与旧版本代码的兼容性。
 
 默认方法与抽象方法不同之处在于抽象方法必须要求实现，但是默认方法则没有这个要求。相反，每个接口都必须提供一个所谓的默认实现，这样所有的接口实现者将会默认继承它（如果有必要的话，可以覆盖这个默认实现）。让我们看看下面的例子：
-
-    private interface Defaulable {
-        // Interfaces now allow default methods, the implementer may or 
-        // may not implement (override) them.
-        default String notRequired() { 
-            return "Default implementation"; 
-        }        
-    }
-             
-    private static class DefaultableImpl implements Defaulable {
-    }
+````
+private interface Defaulable {
+    // Interfaces now allow default methods, the implementer may or 
+    // may not implement (override) them.
+    default String notRequired() { 
+        return "Default implementation"; 
+    }        
+}
          
-    private static class OverridableImpl implements Defaulable {
-        @Override
-        public String notRequired() {
-            return "Overridden implementation";
-        }
+private static class DefaultableImpl implements Defaulable {
+}
+     
+private static class OverridableImpl implements Defaulable {
+    @Override
+    public String notRequired() {
+        return "Overridden implementation";
     }
+}
+````
 Defaulable接口用关键字default声明了一个默认方法notRequired()，Defaulable接口的实现者之一DefaultableImpl实现了这个接口，并且让默认方法保持原样。Defaulable接口的另一个实现者OverridableImpl用自己的方法覆盖了默认方法。
 
 Java 8带来的另一个有趣的特性是接口可以声明（并且可以提供实现）静态方法。例如：
 
-
+````
     private interface DefaulableFactory {
         // Interfaces now allow static methods
         static Defaulable create( Supplier< Defaulable > supplier ) {
             return supplier.get();
         }
     }
+````
 下面的一小段代码片段把上面的默认方法与静态方法黏合到一起。
 
-
+````
     public static void main( String[] args ) {
         Defaulable defaulable = DefaulableFactory.create( DefaultableImpl::new );
         System.out.println( defaulable.notRequired() );
@@ -437,6 +430,7 @@ Java 8带来的另一个有趣的特性是接口可以声明（并且可以提
         defaulable = DefaulableFactory.create( OverridableImpl::new );
         System.out.println( defaulable.notRequired() );
     }
+````
 这个程序的控制台输出如下：
 
 Default implementation
@@ -450,58 +444,57 @@ Overridden implementation
 自从Java 5引入了注解机制，这一特性就变得非常流行并且广为使用。然而，使用注解的一个限制是相同的注解在同一位置只能声明一次，不能声明多次。Java 8打破了这条规则，引入了重复注解机制，这样相同的注解可以在同一地方声明多次。
 
 重复注解机制本身必须用@Repeatable注解。事实上，这并不是语言层面上的改变，更多的是编译器的技巧，底层的原理保持不变。让我们看一个快速入门的例子：
-
-    package com.javacodegeeks.java8.repeatable.annotations;
+````
+package com.javacodegeeks.java8.repeatable.annotations;
+ 
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+ 
+public class RepeatingAnnotations {
+    @Target( ElementType.TYPE )
+    @Retention( RetentionPolicy.RUNTIME )
+    public @interface Filters {
+        Filter[] value();
+    }
      
-    import java.lang.annotation.ElementType;
-    import java.lang.annotation.Repeatable;
-    import java.lang.annotation.Retention;
-    import java.lang.annotation.RetentionPolicy;
-    import java.lang.annotation.Target;
+    @Target( ElementType.TYPE )
+    @Retention( RetentionPolicy.RUNTIME )
+    @Repeatable( Filters.class )
+    public @interface Filter {
+        String value();
+    };
      
-    public class RepeatingAnnotations {
-        @Target( ElementType.TYPE )
-        @Retention( RetentionPolicy.RUNTIME )
-        public @interface Filters {
-            Filter[] value();
-        }
-         
-        @Target( ElementType.TYPE )
-        @Retention( RetentionPolicy.RUNTIME )
-        @Repeatable( Filters.class )
-        public @interface Filter {
-            String value();
-        };
-         
-        @Filter( "filter1" )
-        @Filter( "filter2" )
-        public interface Filterable {        
-        }
-         
-        public static void main(String[] args) {
-            for( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {
-                System.out.println( filter.value() );
-            }
+    @Filter( "filter1" )
+    @Filter( "filter2" )
+    public interface Filterable {        
+    }
+     
+    public static void main(String[] args) {
+        for( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {
+            System.out.println( filter.value() );
         }
     }
+}
+````
 正如我们看到的，这里有个使用@Repeatable( Filters.class )注解的注解类Filter，Filters仅仅是Filter注解的数组，但Java编译器并不想让程序员意识到Filters的存在。这样，接口Filterable就拥有了两次Filter（并没有提到Filter）注解。
 
 同时，反射相关的API提供了新的函数getAnnotationsByType()来返回重复注解的类型（请注意Filterable.class.getAnnotation( Filters.class )经编译器处理后将会返回Filters的实例）。
 
 程序输出结果如下：
 
-filter1
-filter2
+    filter1
+    filter2
 更多详情请参考官方文档
 
-
-
 ## Java编译器的新特性
 
 ### 方法参数名字可以反射获取
 
 很长一段时间里，Java程序员一直在发明不同的方式使得方法参数的名字能保留在Java字节码中，并且能够在运行时获取它们（比如，Paranamer类库）。最终，在Java 8中把这个强烈要求的功能添加到语言层面（通过反射API与Parameter.getName()方法）与字节码文件（通过新版的javac的–parameters选项）中。
-
+````
 package com.javacodegeeks.java8.parameter.names;
 
 import java.lang.reflect.Method;
@@ -515,6 +508,7 @@ public class ParameterNames {
         }
     }
 }
+````
 如果不使用–parameters参数来编译这个类，然后运行这个类，会得到下面的输出：
 
 Parameter: arg0
@@ -531,7 +525,7 @@ Java 8 通过增加大量新类，扩展已有类的功能的方式来改善对
 Optional实际上是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。更多详情请参考官方文档。
 
 我们下面用两个小例子来演示如何使用Optional类：一个允许为空值，一个不允许为空值。
-
+````
     public class 空指针Optional {
         public static void main(String[] args) {
     
@@ -554,7 +548,7 @@ Optional实际上是个容器：它可以保存类型T的值，或者仅仅保
             //输出Optional.empty。
         }
     }
-
+````
 如果Optional类的实例为非空值的话，isPresent()返回true，否从返回false。为了防止Optional为空值，orElseGet()方法通过回调函数来产生一个默认值。map()函数对当前Optional的值进行转化，然后返回一个新的Optional实例。orElse()方法和orElseGet()方法类似，但是orElse接受一个默认值而不是一个回调函数。下面是这个程序的输出：
 
 Full Name is set? false
@@ -581,14 +575,15 @@ Hey Tom!
 Stream API极大简化了集合框架的处理（但它的处理的范围不仅仅限于集合框架的处理，这点后面我们会看到）。让我们以一个简单的Task类为例进行介绍：
 
 Task类有一个分数的概念（或者说是伪复杂度），其次是还有一个值可以为OPEN或CLOSED的状态.让我们引入一个Task的小集合作为演示例子：
-
+````
     final Collection< Task > tasks = Arrays.asList(
         new Task( Status.OPEN, 5 ),
         new Task( Status.OPEN, 13 ),
         new Task( Status.CLOSED, 8 ) 
     );
+````
 我们下面要讨论的第一个问题是所有状态为OPEN的任务一共有多少分数？在Java 8以前，一般的解决方式用foreach循环，但是在Java 8里面我们可以使用stream：一串支持连续、并行聚集操作的元素。
-
+````
     // Calculate total points of all active tasks using sum()
     final long totalPointsOfOpenTasks = tasks
         .stream()
@@ -597,9 +592,10 @@ Task类有一个分数的概念（或者说是伪复杂度），其次是还有
         .sum();
              
     System.out.println( "Total points: " + totalPointsOfOpenTasks );
+````
 程序在控制台上的输出如下：
 
-Total points: 18
+    Total points: 18
 
 这里有几个注意事项。
 
@@ -617,7 +613,7 @@ Total points: 18
 stream另一个有价值的地方是能够原生支持并行处理。让我们来看看这个算task分数和的例子。
 
 stream另一个有价值的地方是能够原生支持并行处理。让我们来看看这个算task分数和的例子。
-
+````
     // Calculate total points of all tasks
     final double totalPoints = tasks
        .stream()
@@ -626,23 +622,28 @@ stream另一个有价值的地方是能够原生支持并行处理。让我们
        .reduce( 0, Integer::sum );
          
     System.out.println( "Total points (all tasks): " + totalPoints );
+````
 这个例子和第一个例子很相似，但这个例子的不同之处在于这个程序是并行运行的，其次使用reduce方法来算最终的结果。
 下面是这个例子在控制台的输出：
 
 Total points (all tasks): 26.0
 经常会有这个一个需求：我们需要按照某种准则来对集合中的元素进行分组。Stream也可以处理这样的需求，下面是一个例子：
 
-
+````
     // Group tasks by their status
     final Map< Status, List< Task > > map = tasks
         .stream()
         .collect( Collectors.groupingBy( Task::getStatus ) );
     System.out.println( map );
+````
+
 这个例子的控制台输出如下：
 
-{CLOSED=[[CLOSED, 8]], OPEN=[[OPEN, 5], [OPEN, 13]]}
+    {CLOSED=[[CLOSED, 8]], OPEN=[[OPEN, 5], [OPEN, 13]]}
+
 让我们来计算整个集合中每个task分数（或权重）的平均值来结束task的例子。
 
+````
     // Calculate the weight of each tasks (as percent of total points) 
     final Collection< String > result = tasks
         .stream()                                        // Stream< String >
@@ -655,15 +656,19 @@ Total points (all tasks): 26.0
         .collect( Collectors.toList() );                 // List< String > 
              
     System.out.println( result );
+````
+
 下面是这个例子的控制台输出：
 
 [19%, 50%, 30%]
 最后，就像前面提到的，Stream API不仅仅处理Java集合框架。像从文本文件中逐行读取数据这样典型的I/O操作也很适合用Stream API来处理。下面用一个例子来应证这一点。
-
+````
     final Path path = new File( filename ).toPath();
     try( Stream< String > lines = Files.lines( path, StandardCharsets.UTF_8 ) ) {
         lines.onClose( () -> System.out.println("Done!") ).forEach( System.out::println );
     }
+````
+
 对一个stream对象调用onClose方法会返回一个在原有功能基础上新增了关闭功能的stream对象，当对stream对象调用close()方法时，与关闭相关的处理器就会执行。
 
 Stream API、Lambda表达式与方法引用在接口默认方法与静态方法的配合下是Java 8对现代软件开发范式的回应。更多详情请参考官方文档。
@@ -674,19 +679,19 @@ Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时
 这种情况直接导致了Joda-Time——一个可替换标准日期/时间处理且功能非常强大的Java API的诞生。Java 8新的Date-Time API (JSR 310)在很大程度上受到Joda-Time的影响，并且吸取了其精髓。新的java.time包涵盖了所有处理日期，时间，日期/时间，时区，时刻（instants），过程（during）与时钟（clock）的操作。在设计新版API时，十分注重与旧版API的兼容性：不允许有任何的改变（从java.util.Calendar中得到的深刻教训）。如果需要修改，会返回这个类的一个新实例。
 
 让我们用例子来看一下新版API主要类的使用方法。第一个是Clock类，它通过指定一个时区，然后就可以获取到当前的时刻，日期与时间。Clock可以替换System.currentTimeMillis()与TimeZone.getDefault()。
-
+````
     // Get the system clock as UTC offset 
     final Clock clock = Clock.systemUTC();
     System.out.println( clock.instant() );
     System.out.println( clock.millis() );
-
+````
 下面是程序在控制台上的输出：
 
     2014-04-12T15:19:29.282Z
     1397315969360
 
 我们需要关注的其他类是LocaleDate与LocalTime。LocaleDate只持有ISO-8601格式且无时区信息的日期部分。相应的，LocaleTime只持有ISO-8601格式且无时区信息的时间部分。LocaleDate与LocalTime都可以从Clock中得到。
-
+````
     // Get the local date and local time
     final LocalDate date = LocalDate.now();
     final LocalDate dateFromClock = LocalDate.now( clock );
@@ -700,7 +705,7 @@ Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时
          
     System.out.println( time );
     System.out.println( timeFromClock );
-
+````
 下面是程序在控制台上的输出：
 
     2014-04-12
@@ -715,7 +720,7 @@ Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时
     2014-04-12T08:47:01.017-07:00[America/Los_Angeles]
 
 最后，让我们看一下Duration类：在秒与纳秒级别上的一段时间。Duration使计算两个日期间的不同变的十分简单。下面让我们看一个这方面的例子。
-
+````
     // Get duration between two dates
     final LocalDateTime from = LocalDateTime.of( 2014, Month.APRIL, 16, 0, 0, 0 );
     final LocalDateTime to = LocalDateTime.of( 2015, Month.APRIL, 16, 23, 59, 59 );
@@ -723,7 +728,7 @@ Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时
     final Duration duration = Duration.between( from, to );
     System.out.println( "Duration in days: " + duration.toDays() );
     System.out.println( "Duration in hours: " + duration.toHours() );
-
+````
 上面的例子计算了两个日期2014年4月16号与2014年4月16号之间的过程。下面是程序在控制台上的输出：
 
 Duration in days: 365
@@ -733,7 +738,7 @@ Duration in hours: 8783
 
 ### 并行（parallel）数组
 Java 8增加了大量的新方法来对数组进行并行处理。可以说，最重要的是parallelSort()方法，因为它可以在多核机器上极大提高数组排序的速度。下面的例子展示了新方法（parallelXxx）的使用。
-
+````
     package com.javacodegeeks.java8.parallel.arrays;
      
     import java.util.Arrays;
@@ -755,7 +760,7 @@ Java 8增加了大量的新方法来对数组进行并行处理。可以说，
             System.out.println();
         }
     }
-
+````
 上面的代码片段使用了parallelSetAll()方法来对一个有20000个元素的数组进行随机赋值。然后，调用parallelSort方法。这个程序首先打印出前10个元素的值，之后对整个数组排序。这个程序在控制台上的输出如下（请注意数组元素是随机生产的）：
 
 Unsorted: 591217 891976 443951 424479 766825 351964 242997 642839 119108 552378 
@@ -766,7 +771,7 @@ Sorted: 39 220 263 268 325 607 655 678 723 793
 在Java8之前，我们会使用JDK提供的Future接口来进行一些异步的操作，其实CompletableFuture也是实现了Future接口， 并且基于ForkJoinPool来执行任务，因此本质上来讲，CompletableFuture只是对原有API的封装， 而使用CompletableFuture与原来的Future的不同之处在于可以将两个Future组合起来，或者如果两个Future是有依赖关系的，可以等第一个执行完毕后再实行第二个等特性。
 
 **先来看看基本的使用方式：**
-
+````
     public Future<Double> getPriceAsync(final String product) {
         final CompletableFuture<Double> futurePrice = new CompletableFuture<>();
         new Thread(() -> {
@@ -775,13 +780,14 @@ Sorted: 39 220 263 268 325 607 655 678 723 793
         }).start();
         return futurePrice;
     }
+````
 得到Future之后就可以使用get方法来获取结果，CompletableFuture提供了一些工厂方法来简化这些API，并且使用函数式编程的方式来使用这些API，例如：
 
 Fufure<Double> price = CompletableFuture.supplyAsync(() -> calculatePrice(product));  
 代码是不是一下子简洁了许多呢。之前说了，CompletableFuture可以组合多个Future，不管是Future之间有依赖的，还是没有依赖的。 
 
 **如果第二个请求依赖于第一个请求的结果，那么可以使用thenCompose方法来组合两个Future**
-
+````
     public List<String> findPriceAsync(String product) {
         List<CompletableFutute<String>> priceFutures = tasks.stream()
         .map(task -> CompletableFuture.supplyAsync(() -> task.getPrice(product),executor))
@@ -791,24 +797,26 @@ Fufure<Double> price = CompletableFuture.supplyAsync(() -> calculatePrice(produc
     
         return priceFutures.stream().map(CompletableFuture::join).collect(Collectors.toList());
     }
+````
 上面这段代码使用了thenCompose来组合两个CompletableFuture。supplyAsync方法第二个参数接受一个自定义的Executor。 首先使用CompletableFuture执行一个任务，调用getPrice方法，得到一个Future，之后使用thenApply方法，将Future的结果应用parse方法， 之后再使用执行完parse之后的结果作为参数再执行一个applyCount方法，然后收集成一个CompletableFuture<String>的List， 最后再使用一个流，调用CompletableFuture的join方法，这是为了等待所有的异步任务执行完毕，获得最后的结果。
 
 注意，这里必须使用两个流，如果在一个流里调用join方法，那么由于Stream的延迟特性，所有的操作还是会串行的执行，并不是异步的。
 
 **再来看一个两个Future之间没有依赖关系的例子：**
-
+````
     Future<String> futurePriceInUsd = CompletableFuture.supplyAsync(() -> shop.getPrice(“price1”))
                                         .thenCombine(CompletableFuture.supplyAsync(() -> shop.getPrice(“price2”)), (s1, s2) -> s1 + s2);
+````
 这里有两个异步的任务，使用thenCombine方法来组合两个Future，thenCombine方法的第二个参数就是用来合并两个Future方法返回值的操作函数。
 
 有时候，我们并不需要等待所有的异步任务结束，只需要其中的一个完成就可以了，CompletableFuture也提供了这样的方法：
-
+````
     //假设getStream方法返回一个Stream<CompletableFuture<String>>
     CompletableFuture[] futures = getStream(“listen”).map(f -> f.thenAccept(System.out::println)).toArray(CompletableFuture[]::new);
     //等待其中的一个执行完毕
     CompletableFuture.anyOf(futures).join();
     使用anyOf方法来响应CompletableFuture的completion事件。
-
+````
 ## Java虚拟机（JVM）的新特性
 PermGen空间被移除了，取而代之的是Metaspace（JEP 122）。JVM选项-XX:PermSize与-XX:MaxPermSize分别被-XX:MetaSpaceSize与-XX:MaxMetaspaceSize所代替。
 
@@ -824,20 +832,3 @@ https://www.jianshu.com/p/4df02599aeb2
 https://www.cnblogs.com/yangzhilong/p/10973006.html
 https://www.cnblogs.com/JackpotHan/p/9701147.html
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/16\343\200\201JavaIO\346\265\201.md" "b/docs/Java/basic/JavaIO\346\265\201.md"
similarity index 88%
rename from "docs/java/basic/16\343\200\201JavaIO\346\265\201.md"
rename to "docs/Java/basic/JavaIO\346\265\201.md"
index a405b7f..9d1ecd1 100644
--- "a/docs/java/basic/16\343\200\201JavaIO\346\265\201.md"
+++ "b/docs/Java/basic/JavaIO\346\265\201.md"
@@ -21,18 +21,7 @@
     * [说说File类](#说说file类)
     * [说说RandomAccessFile?](#说说randomaccessfile)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
----
-title: 夯实Java基础系列16：一文读懂Java IO流和常见面试题
-date: 2019-9-16 15:56:26 # 文章生成时间，一般不改
-categories:
-    - Java技术江湖
-    - Java基础
-tags:
-    - Java IO流
----
+
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -60,7 +49,6 @@ tags:
 > 在这一小节，我会试着给出Java IO(java.io)包下所有类的概述。更具体地说，我会根据类的用途对类进行分组。这个分组将会使你在未来的工作中，进行类的用途判定时，或者是为某个特定用途选择类时变得更加容易。
 
 
-​    
 **输入和输出**
 
     术语“输入”和“输出”有时候会有一点让人疑惑。一个应用程序的输入往往是另外一个应用程序的输出
@@ -174,7 +162,7 @@ java.io.InputStream类是所有Java IO输入流的基类。如果你正在开发
     这使得RandomAccessFile可以覆盖一个文件的某些部分、或者追加内容到它的末尾、或者删除它的某些内容，当然它也可以从文件的任何位置开始读取文件。
 
 下面是具体例子：
-
+````
     @Test
         //文件流范例，打开一个文件的输入流，读取到字节数组，再写入另一个文件的输出流
         public void test1() {
@@ -193,6 +181,7 @@ java.io.InputStream类是所有Java IO输入流的基类。如果你正在开发
                 e.printStackTrace();
             }
         }
+````
 ### 字符流和字节流
 
 Java IO的Reader和Writer除了基于字符之外，其他方面都与InputStream和OutputStream非常类似。他们被用于读写文本。InputStream和OutputStream是基于字节的，还记得吗？
@@ -204,46 +193,47 @@ Writer
 Writer类是Java IO中所有Writer的基类。子类包括BufferedWriter和PrintWriter等等。
 
 这是一个简单的Java IO Reader的例子：
+````
+Reader reader = new FileReader("c:\\data\\myfile.txt");
 
-    Reader reader = new FileReader("c:\\data\\myfile.txt");
-    
-    int data = reader.read();
-    
-    while(data != -1){
-    
-        char dataChar = (char) data;
-    
-        data = reader.read();
-    
-    }
+int data = reader.read();
+
+while(data != -1){
+
+    char dataChar = (char) data;
 
+    data = reader.read();
+
+}
+````
 你通常会使用Reader的子类，而不会直接使用Reader。Reader的子类包括InputStreamReader，CharArrayReader，FileReader等等。可以查看Java IO概述浏览完整的Reader表格。
 
 **整合Reader与InputStream**
 
 一个Reader可以和一个InputStream相结合。如果你有一个InputStream输入流，并且想从其中读取字符，可以把这个InputStream包装到InputStreamReader中。把InputStream传递到InputStreamReader的构造函数中：
-
-    Reader reader = new InputStreamReader(inputStream);
+````
+Reader reader = new InputStreamReader(inputStream);
+````
 在构造函数中可以指定解码方式。
 
 **Writer**
 
 Writer类是Java IO中所有Writer的基类。子类包括BufferedWriter和PrintWriter等等。这是一个Java IO Writer的例子：
+````
+Writer writer = new FileWriter("c:\\data\\file-output.txt"); 
 
-    Writer writer = new FileWriter("c:\\data\\file-output.txt"); 
-    
-    writer.write("Hello World Writer"); 
-    
-    writer.close();
+writer.write("Hello World Writer"); 
 
+writer.close();
+````
 同样，你最好使用Writer的子类，不需要直接使用Writer，因为子类的实现更加明确，更能表现你的意图。常用子类包括OutputStreamWriter，CharArrayWriter，FileWriter等。Writer的write(int c)方法，会将传入参数的低16位写入到Writer中，忽略高16位的数据。
 
 **整合Writer和OutputStream**
 
 与Reader和InputStream类似，一个Writer可以和一个OutputStream相结合。把OutputStream包装到OutputStreamWriter中，所有写入到OutputStreamWriter的字符都将会传递给OutputStream。这是一个OutputStreamWriter的例子：
-
-    Writer writer = new OutputStreamWriter(outputStream);
-
+````
+Writer writer = new OutputStreamWriter(outputStream);
+````
 ### IO管道
 
 Java IO中的管道为运行在同一个JVM中的两个线程提供了通信的能力。所以管道也可以作为数据源以及目标媒介。
@@ -258,37 +248,38 @@ Java IO中的管道为运行在同一个JVM中的两个线程提供了通信的
 
 Java IO管道示例
 这是一个如何将PipedInputStream和PipedOutputStream关联起来的简单例子：
-
-    //使用管道来完成两个线程间的数据点对点传递
-        @Test
-        public void test2() throws IOException {
-            PipedInputStream pipedInputStream = new PipedInputStream();
-            PipedOutputStream pipedOutputStream = new PipedOutputStream(pipedInputStream);
-            new Thread(new Runnable() {
-                @Override
-                public void run() {
-                    try {
-                        pipedOutputStream.write("hello input".getBytes());
-                        pipedOutputStream.close();
-                    } catch (IOException e) {
-                        e.printStackTrace();
-                    }
+````
+//使用管道来完成两个线程间的数据点对点传递
+    @Test
+    public void test2() throws IOException {
+        PipedInputStream pipedInputStream = new PipedInputStream();
+        PipedOutputStream pipedOutputStream = new PipedOutputStream(pipedInputStream);
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    pipedOutputStream.write("hello input".getBytes());
+                    pipedOutputStream.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
                 }
-            }).start();
-            new Thread(new Runnable() {
-                @Override
-                public void run() {
-                    try {
-                        byte []arr = new byte[128];
-                        while (pipedInputStream.read(arr) != -1) {
-                            System.out.println(Arrays.toString(arr));
-                        }
-                        pipedInputStream.close();
-                    } catch (IOException e) {
-                        e.printStackTrace();
+            }
+        }).start();
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    byte []arr = new byte[128];
+                    while (pipedInputStream.read(arr) != -1) {
+                        System.out.println(Arrays.toString(arr));
                     }
+                    pipedInputStream.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
                 }
-            }).start();
+            }
+        }).start();
+````
 
 管道和线程
 请记得，当使用两个相关联的管道流时，务必将它们分配给不同的线程。read()方法和write()方法调用时会导致流阻塞，这意味着如果你尝试在一个线程中同时进行读和写，可能会导致线程死锁。
@@ -304,7 +295,7 @@ Java中网络的内容或多或少的超出了Java IO的范畴。关于Java网
 当两个进程之间建立了网络连接之后，他们通信的方式如同操作文件一样：利用InputStream读取数据，利用OutputStream写入数据。换句话来说，Java网络API用来在不同进程之间建立网络连接，而Java IO则用来在建立了连接之后的进程之间交换数据。
 
 基本上意味着如果你有一份能够对文件进行写入某些数据的代码，那么这些数据也可以很容易地写入到网络连接中去。你所需要做的仅仅只是在代码中利用OutputStream替代FileOutputStream进行数据的写入。因为FileOutputStream是OuputStream的子类，所以这么做并没有什么问题。
-
+````
     //从网络中读取字节流也可以直接使用OutputStream
     public void test3() {
         //读取网络进程的输出流
@@ -318,7 +309,7 @@ Java中网络的内容或多或少的超出了Java IO的范畴。关于Java网
         //处理网络信息
         //do something with the OutputStream
     }
-
+````
 ### 字节和字符数组
 
 
@@ -330,7 +321,7 @@ Java中网络的内容或多或少的超出了Java IO的范畴。关于Java网
 
 前面的例子中，字符数组或字节数组是用来缓存数据的临时存储空间，不过它们同时也可以作为数据来源或者写入目的地。
 举个例子：
-
+````
     //字符数组和字节数组在io过程中的作用
         public void test4() {
             //arr和brr分别作为数据源
@@ -339,7 +330,7 @@ Java中网络的内容或多或少的超出了Java IO的范畴。关于Java网
             byte []brr = {1,2,3,4,5};
             ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(brr);
         }
-
+````
 ### System.in, System.out, System.err    
 
 System.in, System.out, System.err这3个流同样是常见的数据来源和数据流目的地。使用最多的可能是在控制台程序里利用System.out将输出打印到控制台上。
@@ -358,7 +349,7 @@ JVM启动的时候通过Java运行时初始化这3个流，所以你不需要初
 
 System.out和System.err的简单例子：
 这是一个System.out和System.err结合使用的简单示例：
-
+````
      //测试System.in, System.out, System.err    
         public static void main(String[] args) {
             int in = new Scanner(System.in).nextInt();
@@ -370,7 +361,7 @@ System.out和System.err的简单例子：
     //        10
     //        out
         }
-
+````
 
 ### 字符流的Buffered和Filter
 
@@ -437,8 +428,6 @@ Filter Stream是一种IO流主要作用是用来对存在的流增加一些额
 
 在java.io包中主要由4个可用的filter Stream。两个字节filter stream，两个字符filter stream. 分别是FilterInputStream, FilterOutputStream, FilterReader and FilterWriter.这些类是抽象类，不能被实例化的。
 
-
-
 ### 在文件拷贝的时候，那一种流可用提升更多的性能？
 在字节流的时候，使用BufferedInputStream和BufferedOutputStream。
 在字符流的时候，使用BufferedReader 和 BufferedWriter
@@ -459,20 +448,3 @@ https://www.cnblogs.com/UncleWang001/articles/10454685.html
 https://www.cnblogs.com/Jixiangwei/p/Java.html
 https://blog.csdn.net/baidu_37107022/article/details/76890019
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/9\343\200\201Java\344\270\255\347\232\204Class\347\261\273\345\222\214Object\347\261\273.md" "b/docs/Java/basic/Java\344\270\255\347\232\204Class\347\261\273\345\222\214Object\347\261\273.md"
similarity index 91%
rename from "docs/java/basic/9\343\200\201Java\344\270\255\347\232\204Class\347\261\273\345\222\214Object\347\261\273.md"
rename to "docs/Java/basic/Java\344\270\255\347\232\204Class\347\261\273\345\222\214Object\347\261\273.md"
index 4caf35a..7ff3baa 100644
--- "a/docs/java/basic/9\343\200\201Java\344\270\255\347\232\204Class\347\261\273\345\222\214Object\347\261\273.md"
+++ "b/docs/Java/basic/Java\344\270\255\347\232\204Class\347\261\273\345\222\214Object\347\261\273.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [Java中Class类及用法](#java中class类及用法)
     * [Class类原理](#class类原理)
@@ -16,9 +16,7 @@
     * [finalize()方法](#finalize方法)
   * [CLass类和Object类的关系](#class类和object类的关系)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -48,25 +46,25 @@ Java程序在运行时，Java运行时系统一直对所有的对象进行所谓
 > Class类的对象内容是你创建的类的类型信息，比如你创建一个shapes类，那么，Java会生成一个内容是shapes的Class类的对象
 
 > Class类的对象不能像普通类一样，以 new shapes() 的方式创建，它的对象只能由JVM创建，因为这个类没有public构造函数
-
-        /*
-         * Private constructor. Only the Java Virtual Machine creates Class objects.
-         * This constructor is not used and prevents the default constructor being
-         * generated.
-         */
-         //私有构造方法，只能由jvm进行实例化
-        private Class(ClassLoader loader) {
-            // Initialize final field for classLoader.  The initialization value of non-null
-            // prevents future JIT optimizations from assuming this final field is null.
-            classLoader = loader;
-        }
-
+````
+/*
+ * Private constructor. Only the Java Virtual Machine creates Class objects.
+ * This constructor is not used and prevents the default constructor being
+ * generated.
+ */
+ //私有构造方法，只能由jvm进行实例化
+private Class(ClassLoader loader) {
+    // Initialize final field for classLoader.  The initialization value of non-null
+    // prevents future JIT optimizations from assuming this final field is null.
+    classLoader = loader;
+}
+````
 > Class类的作用是运行时提供或获得某个对象的类型信息，和C++中的typeid()函数类似。这些信息也可用于反射。
 
 ### Class类原理
 
 看一下Class类的部分源码
-
+````
     //Class类中封装了类型的各种信息。在jvm中就是通过Class类的实例来获取每个Java类的所有信息的。
     
     public class Class类 {
@@ -161,6 +159,7 @@ Java程序在运行时，Java运行时系统一直对所有的对象进行所谓
     //        }
     //    }
     }
+````
 
 > 我们都知道所有的java类都是继承了object这个类，在object这个类中有一个方法：getclass().这个方法是用来取得该类已经被实例化了的对象的该类的引用，这个引用指向的是Class类的对象。
 > 
@@ -172,11 +171,7 @@ Java程序在运行时，Java运行时系统一直对所有的对象进行所谓
     {
         return defineClass(name, b, off, len, null);
     }
-> 
-> 我们生成的对象都会有个字段记录该对象所属类在CLass类的对象的所在位置。如下图所示：
-
-[外链图片转存失败(img-ZfMJTzO4-1569074134147)(http://dl.iteye.com/upload/picture/pic/101542/0047a6e9-6608-3c3c-a67c-d8ee95e7fcb8.jpg)]
-
+>
 
 ### 如何获得一个Class类对象
 
@@ -204,7 +199,7 @@ Java程序在运行时，Java运行时系统一直对所有的对象进行所谓
 > 生成不精确的object实例
 > 
 
-==获取一个Class类的对象后，可以用 newInstance() 函数来生成目标类的一个实例。然而，该函数并不能直接生成目标类的实例，只能生成object类的实例==
+获取一个Class类的对象后，可以用 newInstance() 函数来生成目标类的一个实例。然而，该函数并不能直接生成目标类的实例，只能生成object类的实例
 
 > Class obj=Class.forName("shapes");
 > Object ShapesInstance=obj.newInstance();
@@ -214,7 +209,7 @@ Java程序在运行时，Java运行时系统一直对所有的对象进行所谓
 > Class<shapes> obj=shapes.class;
 > shapes newShape=obj.newInstance();
 > 因为有了类型限制，所以使用泛化Class语法的对象引用不能指向别的类。
-
+    
     Class obj1=int.class;
     Class<Integer> obj2=int.class;
     obj1=double.class;
@@ -236,11 +231,12 @@ Java程序在运行时，Java运行时系统一直对所有的对象进行所谓
     Class<round> rclass=round.class;
     Class<? super round> sclass= rclass.getSuperClass();
     //Class<shapes> sclass=rclass.getSuperClass();
+
     我们明知道，round的基类就是shapes，但是却不能直接声明 Class < shapes >，必须使用特殊语法
     
     Class < ? super round >
-
-这个记住就可以啦。
+    
+    这个记住就可以啦。
 
 ## Object类
 
@@ -288,7 +284,9 @@ Object类位于java.lang包中，java.lang包包含着Java最基础和核心的
 
 
 ### registerNatives()方法;
+````
 private static native void registerNatives();
+````
 
 > registerNatives函数前面有native关键字修饰，Java中，用native关键字修饰的函数表明该方法的实现并不是在Java中去完成，而是由C/C++去完成，并被编译成了.dll，由Java去调用。
 > 
@@ -298,19 +296,16 @@ private static native void registerNatives();
 >  
 > 既然如此，可能有人会问，registerNatives()修饰符为private，且并没有执行，作用何以达到？其实，在Java源码中，此方法的声明后有紧接着一段静态代码块：
 
-
-    private static native void registerNatives();  
-    static {  
-         registerNatives();  
-    }  
-
+````
+private static native void registerNatives();  
+static {  
+     registerNatives();  
+}  
+````
 ### Clone()方法实现浅拷贝
-
-    protected native Object clone() throwsCloneNotSupportedException;
-
- 
-
-
+````
+protected native Object clone() throwsCloneNotSupportedException;
+````
 > 看，clode()方法又是一个被声明为native的方法，因此，我们知道了clone()方法并不是Java的原生方法，具体的实现是有C/C++完成的。clone英文翻译为"克隆"，其目的是创建并返回此对象的一个副本。
 
 > 形象点理解，这有一辆科鲁兹，你看着不错，想要个一模一样的。你调用此方法即可像变魔术一样变出一辆一模一样的科鲁兹出来。配置一样，长相一样。但从此刻起，原来的那辆科鲁兹如果进行了新的装饰，与你克隆出来的这辆科鲁兹没有任何关系了。
@@ -321,7 +316,7 @@ private static native void registerNatives();
 
 首先看一下下面的这个例子：
 
-
+````
     package com.corn.objectsummary;  
       
     import com.corn.Person;  
@@ -336,9 +331,7 @@ private static native void registerNatives();
         }  
       
     }  
-
- 
-
+````
 
 > 例子很简单，在main()方法中，new一个Oject对象后，想直接调用此对象的clone方法克隆一个对象，但是出现错误提示："The method clone() from the type Object is not visible"
 >  
@@ -350,25 +343,23 @@ private static native void registerNatives();
 
 于是，上例改成如下形式，我们发现，可以正常编译：
 
-
-        public class clone方法 {
-        public static void main(String[] args) {
+````
+public class clone方法 {
+    public static void main(String[] args) {
     
-        }
-        public void test1() {
+    }
+    public void test1() {
     
-            User user = new User();
-    //        User copy = user.clone();
-        }
-        public void test2() {
-            User user = new User();
-    //        User copy = (User)user.clone();
-        }
+    User user = new User();
+    //User copy = user.clone();
     }
+    public void test2() {
+    User user = new User();
+    //User copy = (User)user.clone();
+    }
+}
 
- 
-
-
+````
 是的，因为此时的主调已经是子类的引用了。
 
 > 上述代码在运行过程中会抛出"java.lang.CloneNotSupportedException",表明clone()方法并未正确执行完毕，问题的原因在与Java中的语法规定：
@@ -378,9 +369,8 @@ private static native void registerNatives();
 > Cloneable接口仅是一个表示接口，接口本身不包含任何方法，用来指示Object.clone()可以合法的被子类引用所调用。
 >  
 > 于是，上述代码改成如下形式，即可正确指定clone()方法以实现克隆。
-
-
-    public class User implements Cloneable{
+````
+public class User implements Cloneable{
     public int id;
     public String name;
     public UserInfo userInfo;
@@ -407,11 +397,12 @@ private static native void registerNatives();
     //    com.javase.Class和Object.Object方法.用到的类.User@6ff3c5b5
     //    com.javase.Class和Object.Object方法.用到的类.UserInfo@d716361
     }
+````
 
 总结：
 clone方法实现的是浅拷贝，只拷贝当前对象，并且在堆中分配新的空间，放这个复制的对象。但是对象如果里面有其他类的子对象，那么就不会拷贝到新的对象中。
 
-==深拷贝和浅拷贝的区别==
+深拷贝和浅拷贝的区别
 
 > 浅拷贝
 > 浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。
@@ -430,12 +421,13 @@ clone方法实现的是浅拷贝，只拷贝当前对象，并且在堆中分配
 > 
 > 填充完成之后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部。
 
-==也就是说，一个对象在浅拷贝以后，只是把对象复制了一份放在堆空间的另一个地方，但是成员变量如果有引用指向其他对象，这个引用指向的对象和被拷贝的对象中引用指向的对象是一样的。当然，基本数据类型还是会重新拷贝一份的。==
-
+也就是说，一个对象在浅拷贝以后，只是把对象复制了一份放在堆空间的另一个地方，但是成员变量如果有引用指向其他对象，这个引用指向的对象和被拷贝的对象中引用指向的对象是一样的。当然，基本数据类型还是会重新拷贝一份的。
 
 ### getClass()方法
+````
+public final native Class<?> getClass();
 
-4.public final native Class<?> getClass();
+````
 
 > getClass()也是一个native方法，返回的是此Object对象的类对象/运行时类对象Class<?>。效果与Object.class相同。
 >  
@@ -443,8 +435,8 @@ clone方法实现的是浅拷贝，只拷贝当前对象，并且在堆中分配
 > 
 > 作为概念层次的类，其本身也具有某些共同的特性，如都具有类名称、由类加载器去加载，都具有包，具有父类，属性和方法等。
 > 
-> 于是，Java中有专门定义了一个类，Class，去描述其他类所具有的这些特性，因此，从此角度去看，类本身也都是属于Class类的对象。为与经常意义上的对象相区分，在此称之为"类对象"。
-
+> 于是，Java中定义了一个类，Class，去描述其他类所具有的这些特性，因此，从此角度去看，类本身也都是属于Class类的对象。为与经常意义上的对象相区分，在此称之为"类对象"。
+````
     public class getClass方法 {
         public static void main(String[] args) {
             User user = new User();
@@ -470,6 +462,7 @@ clone方法实现的是浅拷贝，只拷贝当前对象，并且在堆中分配
             }
         }
     } 
+````
 
 此处主要大量涉及到Java中的反射知识
 
@@ -490,9 +483,6 @@ clone方法实现的是浅拷贝，只拷贝当前对象，并且在堆中分配
          return (this == obj);  
     }  
 
- 
-
-
 > 由此可见，Object原生的equals()方法内部调用的正是==，与==具有相同的含义。既然如此，为什么还要定义此equals()方法？
 >  
 > equals()方法的正确理解应该是：判断两个对象是否相等。那么判断对象相等的标尺又是什么？
@@ -506,10 +496,10 @@ ObjectTest中打印出true，因为User类定义中重写了equals()方法，这
 
 > 如上重写equals方法表面上看上去是可以了，实则不然。因为它破坏了Java中的约定：重写equals()方法必须重写hasCode()方法。
 
-
 ### hashCode()方法;
-
-6. public native int hashCode()
+````
+public native int hashCode()
+````
 
 hashCode()方法返回一个整形数值，表示该对象的哈希码值。
 
@@ -549,16 +539,16 @@ hashCode()具有如下约定：
 
 
 ### toString()方法
-7.public String toString();
+````
+public String toString();
 
     toString()方法返回该对象的字符串表示。先看一下Object中的具体方法体：
     
      public String toString() {  
         return getClass().getName() + "@" + Integer.toHexString(hashCode());  
     }  
-
- 
-
+    
+````
 
 > toString()方法相信大家都经常用到，即使没有显式调用，但当我们使用System.out.println(obj)时，其内部也是通过toString()来实现的。
 >  
@@ -570,7 +560,7 @@ hashCode()具有如下约定：
 
 
 ### wait() notify() notifAll()
-8/9/10/11/12. wait(...) / notify() / notifyAll()
+
 >  
 > 一说到wait(...) / notify() | notifyAll()几个方法，首先想到的是线程。确实，这几个方法主要用于java多线程之间的协作。先具体看下这几个方法的主要含义：
 >  
@@ -583,8 +573,7 @@ hashCode()具有如下约定：
 > wait(...) / notify() | notifyAll()一般情况下都是配套使用。下面来看一个简单的例子：
 
 这是一个生产者消费者的模型，只不过这里只用flag来标识哪个线程需要工作
-
-
+````
     public class wait和notify {
         //volatile保证线程可见性
         volatile static int flag = 1;
@@ -652,6 +641,7 @@ hashCode()具有如下约定：
     //    notify t2
     //不断循环
     }
+````
 
 >  从上述例子的输出结果中可以得出如下结论：
 >  
@@ -661,13 +651,11 @@ hashCode()具有如下约定：
 
 在Java源码中，可以看到wait()具体定义如下：
 
-
-    public final void wait() throws InterruptedException {  
-         wait(0);  
-    }  
-
- 
-
+````
+public final void wait() throws InterruptedException {  
+     wait(0);  
+}  
+````
 
 > 且wait(long timeout, int nanos)方法定义内部实质上也是通过调用wait(long timeout)完成。而wait(long timeout)是一个native方法。因此，wait(...)方法本质上都是native方式实现。
 
@@ -676,15 +664,11 @@ notify()/notifyAll()方法也都是native方法。
 Java中线程具有较多的知识点，是一块比较大且重要的知识点。后期会有博文专门针对Java多线程作出详细总结。此处不再细述。
 
 ### finalize()方法
-13. protected void finalize();
-
 finalize方法主要与Java垃圾回收机制有关。首先我们看一下finalized方法在Object中的具体定义：
 
-
-    protected void finalize() throws Throwable { }  
-
- 
-
+````
+protected void finalize() throws Throwable { }  
+````
 
 > 我们发现Object类中finalize方法被定义成一个空方法，为什么要如此定义呢？finalize方法的调用时机是怎么样的呢？
 >  
@@ -727,21 +711,11 @@ https://blog.csdn.net/dufufd/article/details/80537638
 https://blog.csdn.net/farsight1/article/details/80664104
 https://blog.csdn.net/xiaomingdetianxia/article/details/77429180
 
-## 微信公众号
-
 ### Java技术江湖
 
 如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
 
 **Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
 
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1.png)
 
diff --git "a/docs/java/basic/2\343\200\201Java\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213.md" "b/docs/Java/basic/Java\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213.md"
similarity index 83%
rename from "docs/java/basic/2\343\200\201Java\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213.md"
rename to "docs/Java/basic/Java\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213.md"
index d601d6e..b871b14 100644
--- "a/docs/java/basic/2\343\200\201Java\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213.md"
+++ "b/docs/Java/basic/Java\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213.md"
@@ -15,9 +15,7 @@
     * [存在栈中](#存在栈中)
     * [存在堆里](#存在堆里)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 
@@ -34,9 +32,6 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-
-
-
 <!-- more -->
 
 # Java 基本数据类型
@@ -53,7 +48,6 @@
 
 - 内置数据类型
 - 引用数据类型
-- - *
 
 ### 内置数据类型
 
@@ -128,50 +122,6 @@ Java语言提供了八种基本类型。六种数字类型（四个整数型，
 - char 数据类型可以储存任何字符；
 - 例子：char letter = 'A';。
 
-```
-//8位
-byte bx = Byte.MAX_VALUE;
-byte bn = Byte.MIN_VALUE;
-//16位
-short sx = Short.MAX_VALUE;
-short sn = Short.MIN_VALUE;
-//32位
-int ix = Integer.MAX_VALUE;
-int in = Integer.MIN_VALUE;
-//64位
-long lx = Long.MAX_VALUE;
-long ln = Long.MIN_VALUE;
-//32位
-float fx = Float.MAX_VALUE;
-float fn = Float.MIN_VALUE;
-//64位
-double dx = Double.MAX_VALUE;
-double dn = Double.MIN_VALUE;
-//16位
-char cx = Character.MAX_VALUE;
-char cn = Character.MIN_VALUE;
-//1位
-boolean bt = Boolean.TRUE;
-boolean bf = Boolean.FALSE;
-```
-
-    `127`
-    `-128`
-    `32767`
-    `-32768`
-    `2147483647`
-    `-2147483648`
-    `9223372036854775807`
-    `-9223372036854775808`
-    `3.4028235E38`
-    `1.4E-45`
-    `1.7976931348623157E308`
-    `4.9E-324`
-    `￿`
-    
-    `true`
-    `false`
-
 ### 引用类型
 
 - 在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
@@ -202,22 +152,24 @@ char a = 'A'
 ## 自动拆箱和装箱（详解）
 
 Java 5增加了自动装箱与自动拆箱机制，方便基本类型与包装类型的相互转换操作。在Java 5之前，如果要将一个int型的值转换成对应的包装器类型Integer，必须显式的使用new创建一个新的Integer对象，或者调用静态方法Integer.valueOf()。
-    
-    //在Java 5之前，只能这样做
-    Integer value = new Integer(10);
-    //或者这样做
-    Integer value = Integer.valueOf(10);
-    //直接赋值是错误的
-    //Integer value = 10;`
-
+````
+//在Java 5之前，只能这样做
+Integer value = new Integer(10);
+//或者这样做
+Integer value = Integer.valueOf(10);
+//直接赋值是错误的
+//Integer value = 10;
+````
 在Java 5中，可以直接将整型赋给Integer对象，由编译器来完成从int型到Integer类型的转换，这就叫自动装箱。
 
-    `//在Java 5中，直接赋值是合法的，由编译器来完成转换`
-    `Integer value = 10;`
-    `与此对应的，自动拆箱就是可以将包装类型转换为基本类型，具体的转换工作由编译器来完成。`
-    `//在Java 5 中可以直接这么做`
-    `Integer value = new Integer(10);`
-    `int i = value;`
+````
+//在Java 5中，直接赋值是合法的，由编译器来完成转换
+Integer value = 10;
+与此对应的，自动拆箱就是可以将包装类型转换为基本类型，具体的转换工作由编译器来完成。
+//在Java 5 中可以直接这么做
+Integer value = new Integer(10);
+int i = value;
+````
 
 自动装箱与自动拆箱为程序员提供了很大的方便，而在实际的应用中，自动装箱与拆箱也是使用最广泛的特性之一。自动装箱和自动拆箱其实是Java编译器提供的一颗语法糖（语法糖是指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通过可提高开发效率，增加代码可读性，增加代码的安全性）。
 
@@ -229,43 +181,41 @@ Java 5增加了自动装箱与自动拆箱机制，方便基本类型与包装
 
 实例方法xxxValue()：将具体的包装类型对象转换成基本类型；
 下面我们以int和Integer为例，说明Java中自动装箱与自动拆箱的实现机制。看如下代码：
-
-    class Auto //code1
-    {
-    	public static void main(String[] args) 
-    	{
-    		//自动装箱
-    		Integer inte = 10;
-    		//自动拆箱
-    		int i = inte;
-    
-    	//再double和Double来验证一下
-    	Double doub = 12.40;
-    	double d = doub;
-    	
-        }
-    
-    }
+````
+  class Auto //code1
+  {
+      public static void main(String[] args) 
+      {
+          //自动装箱
+          Integer inte = 10;
+          //自动拆箱
+          int i = inte;
+  
+      //再double和Double来验证一下
+      Double doub = 12.40;
+      double d = doub;
+      
+      }
+  
+  }
+````
 上面的代码先将int型转为Integer对象，再讲Integer对象转换为int型，毫无疑问，这是可以正确运行的。可是，这种转换是怎么进行的呢？使用反编译工具，将生成的Class文件在反编译为Java文件，让我们看看发生了什么：
 
+````
     class Auto//code2
     {
       public static void main(String[] paramArrayOfString)
       {
         Integer localInteger = Integer.valueOf(10);
-
-
-​    
-​    int i = localInteger.intValue();
-
-
-​     
-​    
-​    Double localDouble = Double.valueOf(12.4D);
-​    double d = localDouble.doubleValue();
-​    
-​      }
-​    }
+        
+        int i = localInteger.intValue();
+    
+        Double localDouble = Double.valueOf(12.4D);
+        double d = localDouble.doubleValue();
+    
+      }
+    }
+````
 
 我们可以看到经过javac编译之后，code1的代码被转换成了code2，实际运行时，虚拟机运行的就是code2的代码。也就是说，虚拟机根本不知道有自动拆箱和自动装箱这回事；在将Java源文件编译为class文件的过程中，javac编译器在自动装箱的时候，调用了Integer.valueOf()方法，在自动拆箱时，又调用了intValue()方法。我们可以看到，double和Double也是如此。
 实现总结：其实自动装箱和自动封箱是编译器为我们提供的一颗语法糖。在自动装箱时，编译器调用包装类型的valueOf()方法；在自动拆箱时，编译器调用了相应的xxxValue()方法。
@@ -276,7 +226,7 @@ Java 5增加了自动装箱与自动拆箱机制，方便基本类型与包装
 
 Integer源码
 
-```
+````
 public final class Integer extends Number implements Comparable<Integer> {
 	private final int value;
 	
@@ -343,7 +293,7 @@ public final class Integer extends Number implements Comparable<Integer> {
  
     private IntegerCache() {}
 }
-```
+````
 
 
 以上是Oracle(Sun)公司JDK 1.7中Integer源码的一部分，通过分析上面的代码，得到：
@@ -363,21 +313,22 @@ public final class Integer extends Number implements Comparable<Integer> {
 
 5）调用intValue()，直接返回value的值。
 通过3）和4）可以发现，默认情况下，在使用自动装箱时，VM会复用[-128,127]之间的Integer对象。
-
-    Integer  a1 = 1;
-    Integer  a2 = 1;
-    Integer  a3 = new Integer(1);
-    //会打印true，因为a1和a2是同一个对象,都是Integer.cache[129]
-    System.out.println(a1 == a2);
-    //false，a3构造了一个新的对象，不同于a1,a2
-    System.out.println(a1 == a3);
-
+````
+Integer  a1 = 1;
+Integer  a2 = 1;
+Integer  a3 = new Integer(1);
+//会打印true，因为a1和a2是同一个对象,都是Integer.cache[129]
+System.out.println(a1 == a2);
+//false，a3构造了一个新的对象，不同于a1,a2
+System.out.println(a1 == a3);
+````
 ### 了解基本类型缓存（常量池）的最佳实践
 
 ```
 //基本数据类型的常量池是-128到127之间。
 // 在这个范围中的基本数据类的包装类可以自动拆箱，比较时直接比较数值大小。
 public static void main(String[] args) {
+
     //int的自动拆箱和装箱只在-128到127范围中进行，超过该范围的两个integer的 == 判断是会返回false的。
     Integer a1 = 128;
     Integer a2 = -128;
@@ -394,7 +345,6 @@ public static void main(String[] args) {
     System.out.println(b1 == b2);
     System.out.println(b3 == b4);
 
-    //
     Long c1 = 128L;
     Long c2 = 128L;
     Long c3 = -128L;
@@ -411,7 +361,6 @@ public static void main(String[] args) {
     System.out.println(d1 == d2);
     System.out.println(d3 == d4);
 
-
     `结果`
     
     `false`
@@ -423,8 +372,6 @@ public static void main(String[] args) {
     `false`
     `true`
     
-    
-
     Integer i = 10;
     Byte b = 10;
     //比较Byte和Integer.两个对象无法直接比较，报错
@@ -460,17 +407,15 @@ public static void main(String[] args) {
 
 需要注意的是：“==”在没遇到算术运算时，不会自动拆箱；基本类型只会自动装箱为对应的包装类型，代码中最后一条说明的内容。
 
-
-
 在JDK 1.5中提供了自动装箱与自动拆箱，这其实是Java 编译器的语法糖，编译器通过调用包装类型的valueOf()方法实现自动装箱，调用xxxValue()方法自动拆箱。自动装箱和拆箱会有一些陷阱，那就是包装类型复用了某些对象。
 
 （1）Integer默认复用了[-128,127]这些对象，其中高位置可以修改；
 
 （2）Byte复用了全部256个对象[-128,127]；
 
-（3）Short服用了[-128,127]这些对象；
+（3）Short复用了[-128,127]这些对象；
 
-（4）Long服用了[-128,127];
+（4）Long复用了[-128,127];
 
 （5）Character复用了[0,127],Charater不能表示负数;
 
@@ -574,10 +519,6 @@ System.out.println(s3 == s4);
 JDK1.6以及以下：false false  
 JDK1.7以及以上：false true
 ```
-
-![image](https://img-blog.csdn.net/20180422231916788?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MjQ4ODg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
-
-![image](https://img-blog.csdn.net/20180422231929413?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MjQ4ODg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
 JDK1.6查找到常量池存在相同值的对象时会直接返回该对象的地址。
 
 JDK 1.7后，intern方法还是会先去查询常量池中是否有已经存在，如果存在，则返回常量池中的引用，这一点与之前没有区别，区别在于，如果在常量池找不到对应的字符串，则不会再将字符串拷贝到常量池，而只是在常量池中生成一个对原字符串的引用。
@@ -602,20 +543,4 @@ https://blog.csdn.net/a724888/article/details/80033043
 
 <https://blog.csdn.net/yuhongye111/article/details/31850779>
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/10\343\200\201Java\345\274\202\345\270\270.md" "b/docs/Java/basic/Java\345\274\202\345\270\270.md"
similarity index 64%
rename from "docs/java/basic/10\343\200\201Java\345\274\202\345\270\270.md"
rename to "docs/Java/basic/Java\345\274\202\345\270\270.md"
index c937417..4f77437 100644
--- "a/docs/java/basic/10\343\200\201Java\345\274\202\345\270\270.md"
+++ "b/docs/Java/basic/Java\345\274\202\345\270\270.md"
@@ -15,14 +15,7 @@
   * [当finally遇上return](#当finally遇上return)
   * [JAVA异常常见面试题](#java异常常见面试题)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
 
----
-
-    - Java异常
----
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -51,7 +44,7 @@
 >   3、 由调用函数来分析异常，这要求程序员对库函数有很深的了解。
 > 
 
- 在OO中提供的异常处理机制是提供代码健壮的强有力的方式。使用异常机制它能够降低错误处理代码的复杂度，如果不使用异常，那么就必须检查特定的错误，并在程序中的许多地方去处理它。
+在OO中提供的异常处理机制是提供代码健壮的强有力的方式。使用异常机制它能够降低错误处理代码的复杂度，如果不使用异常，那么就必须检查特定的错误，并在程序中的许多地方去处理它。
 
 而如果使用异常，那就不必在方法调用处进行检查，因为异常机制将保证能够捕获这个错误，并且，只需在一个地方处理错误，即所谓的异常处理程序中。
 
@@ -61,21 +54,20 @@
 
 ## 异常基本定义
 
->   在《Think in java》中是这样定义异常的：异常情形是指阻止当前方法或者作用域继续执行的问题。在这里一定要明确一点：异常代码某种程度的错误，尽管Java有异常处理机制，但是我们不能以“正常”的眼光来看待异常，异常处理机制的原因就是告诉你：这里可能会或者已经产生了错误，您的程序出现了不正常的情况，可能会导致程序失败！
+> 在《Think in java》中是这样定义异常的：异常情形是指阻止当前方法或者作用域继续执行的问题。在这里一定要明确一点：异常代码某种程度的错误，尽管Java有异常处理机制，但是我们不能以“正常”的眼光来看待异常，异常处理机制的原因就是告诉你：这里可能会或者已经产生了错误，您的程序出现了不正常的情况，可能会导致程序失败！
 
->   那么什么时候才会出现异常呢？只有在你当前的环境下程序无法正常运行下去，也就是说程序已经无法来正确解决问题了，这时它所就会从当前环境中跳出，并抛出异常。抛出异常后，它首先会做几件事。
+> 那么什么时候才会出现异常呢？只有在你当前的环境下程序无法正常运行下去，也就是说程序已经无法来正确解决问题了，这时它所就会从当前环境中跳出，并抛出异常。抛出异常后，它首先会做几件事。
 
 > 首先，它会使用new创建一个异常对象，然后在产生异常的位置终止程序，并且从当前环境中弹出对异常对象的引用，这时。异常处理机制就会接管程序，并开始寻找一个恰当的地方来继续执行程序，这个恰当的地方就是异常处理程序。
 
->  总的来说异常处理机制就是当程序发生异常时，它强制终止程序运行，记录异常信息并将这些信息反馈给我们，由我们来确定是否处理异常。
+> 总的来说异常处理机制就是当程序发生异常时，它强制终止程序运行，记录异常信息并将这些信息反馈给我们，由我们来确定是否处理异常。
 
 ## 异常体系
 
-[外链图片转存失败(img-KNxcBTK0-1569073569353)(https://images0.cnblogs.com/blog/381060/201311/22185952-834d92bc2bfe498f9a33414cc7a2c8a4.png)]
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/22185952-834d92bc2bfe498f9a33414cc7a2c8a4.png)
 
 从上面这幅图可以看出，Throwable是java语言中所有错误和异常的超类（万物即可抛）。它有两个子类：Error、Exception。
 
-
 Java标准库内建了一些通用的异常，这些类以Throwable为顶层父类。
 
 Throwable又派生出Error类和Exception类。
@@ -103,7 +95,7 @@ Throwable又派生出Error类和Exception类。
 异常是在执行某个函数时引发的，而函数又是层级调用，形成调用栈的，因为，只要一个函数发生了异常，那么他的所有的caller都会被异常影响。当这些被影响的函数以异常信息输出时，就形成的了异常追踪栈。
 
 异常最先发生的地方，叫做异常抛出点。
-
+````
     public class 异常 {
         public static void main (String [] args )
         {
@@ -130,9 +122,7 @@ Throwable又派生出Error类和Exception类。
     //    at com.javase.异常.异常.devide(异常.java:24)
     //    at com.javase.异常.异常.CMDCalculate(异常.java:19)
     //    at com.javase.异常.异常.main(异常.java:12)
-
-
-​    
+ 
     //  ----欢迎使用命令行除法计算器----
     //    r
     //    Exception in thread "main" java.util.InputMismatchException
@@ -143,8 +133,7 @@ Throwable又派生出Error类和Exception类。
     //    at com.javase.异常.异常.CMDCalculate(异常.java:17)
     //    at com.javase.异常.异常.main(异常.java:12)
 
-
-[外链图片转存失败(img-9rqUQJQj-1569073569354)(http://incdn1.b0.upaiyun.com/2017/09/0b3e4ca2f4cf8d7116c7ad354940601f.png)]
+````
 
 从上面的例子可以看出，当devide函数发生除0异常时，devide函数将抛出ArithmeticException异常，因此调用他的CMDCalculate函数也无法正常完成，因此也发送异常，而CMDCalculate的caller——main 因为CMDCalculate抛出异常，也发生了异常，这样一直向调用栈的栈底回溯。
 
@@ -157,7 +146,7 @@ Throwable又派生出Error类和Exception类。
 ## 异常和错误
 
 下面看一个例子
-    
+````    
     //错误即error一般指jvm无法处理的错误
     //异常是Java定义的用于简化错误处理流程和定位错误的一种工具。
     public class 错误和错误 {
@@ -198,7 +187,7 @@ Throwable又派生出Error类和Exception类。
     //    at com.javase.异常.错误.main(错误.java:11)
     
     }
-
+````
 ## 异常的处理方式
 
 在编写代码处理异常时，对于检查异常，有2种不同的处理方式：
@@ -213,7 +202,7 @@ Throwable又派生出Error类和Exception类。
 
 上面的例子是运行时异常，不需要显示捕获。
 下面这个例子是可检查异常需，要显示捕获或者抛出。
-
+````
     @Test
     public void testException() throws IOException
     {
@@ -309,6 +298,7 @@ Throwable又派生出Error类和Exception类。
     //        at com.javase.异常.异常处理方式.test(异常处理方式.java:62)
             throw new StringIndexOutOfBoundsException();
         }
+````
 
 其实有的语言在遇到异常后仍然可以继续运行
 
@@ -321,11 +311,12 @@ Throwable又派生出Error类和Exception类。
 throws是另一种处理异常的方式，它不同于try…catch…finally，throws仅仅是将函数中可能出现的异常向调用者声明，而自己则不具体处理。
 
 采取这种异常处理的原因可能是：方法本身不知道如何处理这样的异常，或者说让调用者处理更好，调用者需要为可能发生的异常负责。
-
-    public void foo() throws ExceptionType1 , ExceptionType2 ,ExceptionTypeN
-    { 
-         //foo内部可以抛出 ExceptionType1 , ExceptionType2 ,ExceptionTypeN 类的异常，或者他们的子类的异常对象。
-    }
+````
+public void foo() throws ExceptionType1 , ExceptionType2 ,ExceptionTypeN
+{ 
+     //foo内部可以抛出 ExceptionType1 , ExceptionType2 ,ExceptionTypeN 类的异常，或者他们的子类的异常对象。
+}
+````
 
 ## 纠结的finally
 
@@ -341,6 +332,7 @@ finally块不管异常是否发生，只要对应的try执行了，则它一定
 
 3、在同一try…catch…finally块中 ，try发生异常，且匹配的catch块中处理异常时也抛出异常，那么后面的finally也会执行：首先执行finally块，然后去外围调用者中寻找合适的catch块。
 
+````
     public class finally使用 {
         public static void main(String[] args) {
             try {
@@ -357,6 +349,7 @@ finally块不管异常是否发生，只要对应的try执行了，则它一定
             }
         }
     }
+````
 
 ## throw : JRE也使用的关键字
 
@@ -365,15 +358,14 @@ throw exceptionObject
 程序员也可以通过throw语句手动显式的抛出一个异常。throw语句的后面必须是一个异常对象。
 
 throw 语句必须写在函数中，执行throw 语句的地方就是一个异常抛出点，==它和由JRE自动形成的异常抛出点没有任何差别。==
-
-    public void save(User user)
-    {
-          if(user  == null) 
-              throw new IllegalArgumentException("User对象为空");
-          //......
-     
-    }
-
+````
+public void save(User user)
+{
+      if(user  == null) 
+          throw new IllegalArgumentException("User对象为空");
+      //......
+}
+````
 后面开始的大部分内容都摘自http://www.cnblogs.com/lulipro/p/7504267.html
 
 该文章写的十分细致到位，令人钦佩，是我目前为之看到关于异常最详尽的文章，可以说是站在巨人的肩膀上了。
@@ -389,88 +381,86 @@ throw 语句必须写在函数中，执行throw 语句的地方就是一个异
 > 异常链化:以一个异常对象为参数构造新的异常对象。新的异对象将包含先前异常的信息。这项技术主要是异常类的一个带Throwable参数的函数来实现的。这个当做参数的异常，我们叫他根源异常（cause）。
 
 查看Throwable类源码，可以发现里面有一个Throwable字段cause，就是它保存了构造时传递的根源异常参数。这种设计和链表的结点类设计如出一辙，因此形成链也是自然的了。
-
-    public class Throwable implements Serializable {
-        private Throwable cause = this;
-     
-        public Throwable(String message, Throwable cause) {
-            fillInStackTrace();
-            detailMessage = message;
-            this.cause = cause;
-        }
-         public Throwable(Throwable cause) {
-            fillInStackTrace();
-            detailMessage = (cause==null ? null : cause.toString());
-            this.cause = cause;
-        }
-     
-        //........
+````
+public class Throwable implements Serializable {
+    private Throwable cause = this;
+    public Throwable(String message, Throwable cause) {
+        fillInStackTrace();
+        detailMessage = message;
+        this.cause = cause;
     }
-
+     public Throwable(Throwable cause) {
+        fillInStackTrace();
+        detailMessage = (cause==null ? null : cause.toString());
+        this.cause = cause;
+    }
+    //........
+}
+````
 
 下面看一个比较实在的异常链例子哈
-
-    public class 异常链 {
-        @Test
-        public void test() {
-            C();
-        }
-        public void A () throws Exception {
-            try {
-                int i = 1;
-                i = i / 0;
-                //当我注释掉这行代码并使用B方法抛出一个error时，运行结果如下
-    //            四月 27, 2018 10:12:30 下午 org.junit.platform.launcher.core.ServiceLoaderTestEngineRegistry loadTestEngines
-    //            信息: Discovered TestEngines with IDs: [junit-jupiter]
-    //            java.lang.Error: B也犯了个错误
-    //            at com.javase.异常.异常链.B(异常链.java:33)
-    //            at com.javase.异常.异常链.C(异常链.java:38)
-    //            at com.javase.异常.异常链.test(异常链.java:13)
-    //            at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
-    //            Caused by: java.lang.Error
-    //            at com.javase.异常.异常链.B(异常链.java:29)
-    
-            }catch (ArithmeticException e) {
-                //这里通过throwable类的构造方法将最底层的异常重新包装并抛出，此时注入了A方法的信息。最后打印栈信息时可以看到caused by
-                A方法的异常。
-                //如果直接抛出，栈信息打印结果只能看到上层方法的错误信息，不能看到其实是A发生了错误。
-                //所以需要包装并抛出
-                throw new Exception("A方法计算错误", e);
-            }
-    
+````
+public class 异常链 {
+    @Test
+    public void test() {
+        C();
+    }
+    public void A () throws Exception {
+        try {
+            int i = 1;
+            i = i / 0;
+            //当我注释掉这行代码并使用B方法抛出一个error时，运行结果如下
+//            四月 27, 2018 10:12:30 下午 org.junit.platform.launcher.core.ServiceLoaderTestEngineRegistry loadTestEngines
+//            信息: Discovered TestEngines with IDs: [junit-jupiter]
+//            java.lang.Error: B也犯了个错误
+//            at com.javase.异常.异常链.B(异常链.java:33)
+//            at com.javase.异常.异常链.C(异常链.java:38)
+//            at com.javase.异常.异常链.test(异常链.java:13)
+//            at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
+//            Caused by: java.lang.Error
+//            at com.javase.异常.异常链.B(异常链.java:29)
+
+        }catch (ArithmeticException e) {
+            //这里通过throwable类的构造方法将最底层的异常重新包装并抛出，此时注入了A方法的信息。最后打印栈信息时可以看到caused by
+            A方法的异常。
+            //如果直接抛出，栈信息打印结果只能看到上层方法的错误信息，不能看到其实是A发生了错误。
+            //所以需要包装并抛出
+            throw new Exception("A方法计算错误", e);
         }
-        public void B () throws Exception,Error {
-            try {
-                //接收到A的异常，
-                A();
-                throw new Error();
-            }catch (Exception e) {
-                throw e;
-            }catch (Error error) {
-                throw new Error("B也犯了个错误", error);
-            }
+
+    }
+    public void B () throws Exception,Error {
+        try {
+            //接收到A的异常，
+            A();
+            throw new Error();
+        }catch (Exception e) {
+            throw e;
+        }catch (Error error) {
+            throw new Error("B也犯了个错误", error);
         }
-        public void C () {
-            try {
-                B();
-            }catch (Exception | Error e) {
-                e.printStackTrace();
-            }
-    
+    }
+    public void C () {
+        try {
+            B();
+        }catch (Exception | Error e) {
+            e.printStackTrace();
         }
-    
-        //最后结果
-    //    java.lang.Exception: A方法计算错误
-    //    at com.javase.异常.异常链.A(异常链.java:18)
-    //    at com.javase.异常.异常链.B(异常链.java:24)
-    //    at com.javase.异常.异常链.C(异常链.java:31)
-    //    at com.javase.异常.异常链.test(异常链.java:11)
-    //    省略
-    //    Caused by: java.lang.ArithmeticException: / by zero
-    //    at com.javase.异常.异常链.A(异常链.java:16)
-    //            ... 31 more
+
     }
 
+    //最后结果
+//    java.lang.Exception: A方法计算错误
+//    at com.javase.异常.异常链.A(异常链.java:18)
+//    at com.javase.异常.异常链.B(异常链.java:24)
+//    at com.javase.异常.异常链.C(异常链.java:31)
+//    at com.javase.异常.异常链.test(异常链.java:11)
+//    省略
+//    Caused by: java.lang.ArithmeticException: / by zero
+//    at com.javase.异常.异常链.A(异常链.java:16)
+//            ... 31 more
+}
+````
 ## 自定义异常
 
 如果要自定义异常类，则扩展Exception类即可，因此这样的自定义异常都属于检查异常（checked exception）。如果要自定义非检查异常，则扩展自RuntimeException。
@@ -482,7 +472,7 @@ throw 语句必须写在函数中，执行throw 语句的地方就是一个异
 一个带有String参数和Throwable参数，并都传递给父类构造函数
 一个带有Throwable 参数的构造函数，并传递给父类的构造函数。
 下面是IOException类的完整源代码，可以借鉴。
-
+````
     public class IOException extends Exception
     {
         static final long serialVersionUID = 7818375828146090155L;
@@ -507,7 +497,7 @@ throw 语句必须写在函数中，执行throw 语句的地方就是一个异
             super(cause);
         }
     }
-
+````
 ## 异常的注意事项
 
 异常的注意事项
@@ -517,47 +507,47 @@ throw 语句必须写在函数中，执行throw 语句的地方就是一个异
 > 例如，父类方法throws 的是2个异常，子类就不能throws 3个及以上的异常。父类throws IOException，子类就必须throws IOException或者IOException的子类。
 
 至于为什么？我想，也许下面的例子可以说明。
-
-    class Father
+````
+class Father
+{
+    public void start() throws IOException
     {
-        public void start() throws IOException
-        {
-            throw new IOException();
-        }
+        throw new IOException();
     }
-     
-    class Son extends Father
+}
+ 
+class Son extends Father
+{
+    public void start() throws Exception
     {
-        public void start() throws Exception
-        {
-            throw new SQLException();
-        }
+        throw new SQLException();
     }
+}
 /**********************假设上面的代码是允许的（实质是错误的）***********************/
 
-    class Test
+class Test
+{
+    public static void main(String[] args)
     {
-        public static void main(String[] args)
+        Father[] objs = new Father[2];
+        objs[0] = new Father();
+        objs[1] = new Son();
+ 
+        for(Father obj:objs)
         {
-            Father[] objs = new Father[2];
-            objs[0] = new Father();
-            objs[1] = new Son();
-     
-            for(Father obj:objs)
+        //因为Son类抛出的实质是SQLException，而IOException无法处理它。
+        //那么这里的try。。catch就不能处理Son中的异常。
+        //多态就不能实现了。
+            try {
+                 obj.start();
+            }catch(IOException)
             {
-            //因为Son类抛出的实质是SQLException，而IOException无法处理它。
-            //那么这里的try。。catch就不能处理Son中的异常。
-            //多态就不能实现了。
-                try {
-                     obj.start();
-                }catch(IOException)
-                {
-                     //处理IOException
-                }
-             }
-       }
-    }
-
+                 //处理IOException
+            }
+         }
+   }
+}
+````
 ==Java的异常执行流程是线程独立的，线程之间没有影响==
 
 > Java程序可以是多线程的。每一个线程都是一个独立的执行流，独立的函数调用栈。如果程序只有一个线程，那么没有被任何代码处理的异常 会导致程序终止。如果是多线程的，那么没有被任何代码处理的异常仅仅会导致异常所在的线程结束。
@@ -565,44 +555,44 @@ throw 语句必须写在函数中，执行throw 语句的地方就是一个异
 > 也就是说，Java中的异常是线程独立的，线程的问题应该由线程自己来解决，而不要委托到外部，也不会直接影响到其它线程的执行。
 
 下面看一个例子
-
-    public class 多线程的异常 {
-        @Test
-        public void test() {
-            go();
-        }
-        public void go () {
-            ExecutorService executorService = Executors.newFixedThreadPool(3);
-            for (int i = 0;i <= 2;i ++) {
-                int finalI = i;
-                try {
-                    Thread.sleep(2000);
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
-                executorService.execute(new Runnable() {
-                    @Override
-                    //每个线程抛出异常时并不会影响其他线程的继续执行
-                    public void run() {
-                        try {
-                            System.out.println("start thread" + finalI);
-                            throw new Exception();
-                        }catch (Exception e) {
-                            System.out.println("thread" + finalI + " go wrong");
-                        }
-                    }
-                });
+````
+public class 多线程的异常 {
+    @Test
+    public void test() {
+        go();
+    }
+    public void go () {
+        ExecutorService executorService = Executors.newFixedThreadPool(3);
+        for (int i = 0;i <= 2;i ++) {
+            int finalI = i;
+            try {
+                Thread.sleep(2000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
             }
-    //        结果：
-    //        start thread0
-    //        thread0 go wrong
-    //        start thread1
-    //        thread1 go wrong
-    //        start thread2
-    //        thread2 go wrong
-        }
+            executorService.execute(new Runnable() {
+                @Override
+                //每个线程抛出异常时并不会影响其他线程的继续执行
+                public void run() {
+                    try {
+                        System.out.println("start thread" + finalI);
+                        throw new Exception();
+                    }catch (Exception e) {
+                        System.out.println("thread" + finalI + " go wrong");
+                    }
+                }
+            });
+        }
+//        结果：
+//        start thread0
+//        thread0 go wrong
+//        start thread1
+//        thread1 go wrong
+//        start thread2
+//        thread2 go wrong
     }
-
+}
+````
 
 ## 当finally遇上return
 
@@ -610,163 +600,160 @@ throw 语句必须写在函数中，执行throw 语句的地方就是一个异
 首先一个不容易理解的事实：
 
 在 try块中即便有return，break，continue等改变执行流的语句，finally也会执行。
+````
+public static void main(String[] args)
+{
+    int re = bar();
+    System.out.println(re);
+}
+private static int bar() 
+{
+    try{
+        return 5;
+    } finally{
+        System.out.println("finally");
+    }
+}
+/*输出：
+finally
+*/
+````
 
-    public static void main(String[] args)
+也就是说：try…catch…finally中的return 只要能执行，就都执行了，他们共同向同一个内存地址（假设地址是0×80）写入返回值，后执行的将覆盖先执行的数据，而真正被调用者取的返回值就是最后一次写入的。那么，按照这个思想，下面的这个例子也就不难理解了。
+
+finally中的return 会覆盖 try 或者catch中的返回值。
+````
+public static void main(String[] args)
     {
-        int re = bar();
-        System.out.println(re);
+        int result;
+ 
+        result  =  foo();
+        System.out.println(result);     /////////2
+ 
+        result = bar();
+        System.out.println(result);    /////////2
     }
-    private static int bar() 
+ 
+    @SuppressWarnings("finally")
+    public static int foo()
     {
-        try{
-            return 5;
+        trz{
+            int a = 5 / 0;
+        } catch (Exception e){
+            return 1;
         } finally{
-            System.out.println("finally");
+            return 2;
         }
+ 
     }
-    /*输出：
-    finally
-    */
-很多人面对这个问题时，总是在归纳执行的顺序和规律，不过我觉得还是很难理解。我自己总结了一个方法。用如下GIF图说明。
-
-
-[外链图片转存失败(img-SceF4t85-1569073569354)(http://incdn1.b0.upaiyun.com/2017/09/0471c2805ebd5a463211ced478eaf7f8.gif)]
-
-也就是说：try…catch…finally中的return 只要能执行，就都执行了，他们共同向同一个内存地址（假设地址是0×80）写入返回值，后执行的将覆盖先执行的数据，而真正被调用者取的返回值就是最后一次写入的。那么，按照这个思想，下面的这个例子也就不难理解了。
-
-
-finally中的return 会覆盖 try 或者catch中的返回值。
-
-    public static void main(String[] args)
-        {
-            int result;
-     
-            result  =  foo();
-            System.out.println(result);     /////////2
-     
-            result = bar();
-            System.out.println(result);    /////////2
-        }
-     
-        @SuppressWarnings("finally")
-        public static int foo()
-        {
-            trz{
-                int a = 5 / 0;
-            } catch (Exception e){
-                return 1;
-            } finally{
-                return 2;
-            }
-     
-        }
-     
-        @SuppressWarnings("finally")
-        public static int bar()
-        {
-            try {
-                return 1;
-            }finally {
-                return 2;
-            }
+ 
+    @SuppressWarnings("finally")
+    public static int bar()
+    {
+        try {
+            return 1;
+        }finally {
+            return 2;
         }
-
+    }
+````
 finally中的return会抑制（消灭）前面try或者catch块中的异常
-
-    class TestException
+````
+class TestException
+{
+    public static void main(String[] args)
     {
-        public static void main(String[] args)
-        {
-            int result;
-            try{
-                result = foo();
-                System.out.println(result);           //输出100
-            } catch (Exception e){
-                System.out.println(e.getMessage());    //没有捕获到异常
-            }
-     
-            try{
-                result  = bar();
-                System.out.println(result);           //输出100
-            } catch (Exception e){
-                System.out.println(e.getMessage());    //没有捕获到异常
-            }
+        int result;
+        try{
+            result = foo();
+            System.out.println(result);           //输出100
+        } catch (Exception e){
+            System.out.println(e.getMessage());    //没有捕获到异常
         }
-     
-        //catch中的异常被抑制
-        @SuppressWarnings("finally")
-        public static int foo() throws Exception
-        {
-            try {
-                int a = 5/0;
-                return 1;
-            }catch(ArithmeticException amExp) {
-                throw new Exception("我将被忽略，因为下面的finally中使用了return");
-            }finally {
-                return 100;
-            }
+ 
+        try{
+            result  = bar();
+            System.out.println(result);           //输出100
+        } catch (Exception e){
+            System.out.println(e.getMessage());    //没有捕获到异常
         }
-     
-        //try中的异常被抑制
-        @SuppressWarnings("finally")
-        public static int bar() throws Exception
-        {
-            try {
-                int a = 5/0;
-                return 1;
-            }finally {
-                return 100;
-            }
+    }
+ 
+    //catch中的异常被抑制
+    @SuppressWarnings("finally")
+    public static int foo() throws Exception
+    {
+        try {
+            int a = 5/0;
+            return 1;
+        }catch(ArithmeticException amExp) {
+            throw new Exception("我将被忽略，因为下面的finally中使用了return");
+        }finally {
+            return 100;
         }
     }
+ 
+    //try中的异常被抑制
+    @SuppressWarnings("finally")
+    public static int bar() throws Exception
+    {
+        try {
+            int a = 5/0;
+            return 1;
+        }finally {
+            return 100;
+        }
+    }
+}
+````
 finally中的异常会覆盖（消灭）前面try或者catch中的异常
-
-    class TestException
+````
+class TestException
+{
+    public static void main(String[] args)
     {
-        public static void main(String[] args)
-        {
-            int result;
-            try{
-                result = foo();
-            } catch (Exception e){
-                System.out.println(e.getMessage());    //输出：我是finaly中的Exception
-            }
-     
-            try{
-                result  = bar();
-            } catch (Exception e){
-                System.out.println(e.getMessage());    //输出：我是finaly中的Exception
-            }
+        int result;
+        try{
+            result = foo();
+        } catch (Exception e){
+            System.out.println(e.getMessage());    //输出：我是finaly中的Exception
         }
-     
-        //catch中的异常被抑制
-        @SuppressWarnings("finally")
-        public static int foo() throws Exception
-        {
-            try {
-                int a = 5/0;
-                return 1;
-            }catch(ArithmeticException amExp) {
-                throw new Exception("我将被忽略，因为下面的finally中抛出了新的异常");
-            }finally {
-                throw new Exception("我是finaly中的Exception");
-            }
+ 
+        try{
+            result  = bar();
+        } catch (Exception e){
+            System.out.println(e.getMessage());    //输出：我是finaly中的Exception
         }
-     
-        //try中的异常被抑制
-        @SuppressWarnings("finally")
-        public static int bar() throws Exception
-        {
-            try {
-                int a = 5/0;
-                return 1;
-            }finally {
-                throw new Exception("我是finaly中的Exception");
-            }
-     
+    }
+ 
+    //catch中的异常被抑制
+    @SuppressWarnings("finally")
+    public static int foo() throws Exception
+    {
+        try {
+            int a = 5/0;
+            return 1;
+        }catch(ArithmeticException amExp) {
+            throw new Exception("我将被忽略，因为下面的finally中抛出了新的异常");
+        }finally {
+            throw new Exception("我是finaly中的Exception");
         }
     }
-
+ 
+    //try中的异常被抑制
+    @SuppressWarnings("finally")
+    public static int bar() throws Exception
+    {
+        try {
+            int a = 5/0;
+            return 1;
+        }finally {
+            throw new Exception("我是finaly中的Exception");
+        }
+ 
+    }
+}
+````
 上面的3个例子都异于常人的编码思维，因此我建议：
 
 > 不要在fianlly中使用return。
@@ -782,22 +769,24 @@ finally中的异常会覆盖（消灭）前面try或者catch中的异常
 　　下面是我个人总结的在Java和J2EE开发者在面试中经常被问到的有关Exception和Error的知识。在分享我的回答的时候，我也给这些问题作了快速修订，并且提供源码以便深入理解。我总结了各种难度的问题，适合新手码农和高级Java码农。如果你遇到了我列表中没有的问题，并且这个问题非常好，请在下面评论中分享出来。你也可以在评论中分享你面试时答错的情况。
 
 **1) Java中什么是Exception?**
-　　这个问题经常在第一次问有关异常的时候或者是面试菜鸟的时候问。我从来没见过面高级或者资深工程师的时候有人问这玩意，但是对于菜鸟，是很愿意问这个的。简单来说，异常是Java传达给你的系统和程序错误的方式。在java中，异常功能是通过实现比如Throwable，Exception，RuntimeException之类的类，然后还有一些处理异常时候的关键字，比如throw，throws，try，catch，finally之类的。 所有的异常都是通过Throwable衍生出来的。Throwable把错误进一步划分为 java.lang.Exception
-和 java.lang.Error.  java.lang.Error 用来处理系统错误，例如java.lang.StackOverFlowError 之类的。然后 Exception用来处理程序错误，请求的资源不可用等等。
+这个问题经常在第一次问有关异常的时候或者是面试菜鸟的时候问。我从来没见过面高级或者资深工程师的时候有人问这玩意，但是对于菜鸟，是很愿意问这个的。简单来说，异常是Java传达给你的系统和程序错误的方式。在java中，异常功能是通过实现比如Throwable，Exception，RuntimeException之类的类，然后还有一些处理异常时候的关键字，比如throw，throws，try，catch，finally之类的。所有的异常都是通过Throwable衍生出来的。Throwable把错误进一步划分为java.lang.Exception
+和 java.lang.Error. 
+
+java.lang.Error 用来处理系统错误，例如java.lang.StackOverFlowError 之类的。然后Exception用来处理程序错误，请求的资源不可用等等。
 
 **2) Java中的检查型异常和非检查型异常有什么区别？**
 
-　　这又是一个非常流行的Java异常面试题，会出现在各种层次的Java面试中。检查型异常和非检查型异常的主要区别在于其处理方式。检查型异常需要使用try, catch和finally关键字在编译期进行处理，否则会出现编译器会报错。对于非检查型异常则不需要这样做。Java中所有继承自java.lang.Exception类的异常都是检查型异常，所有继承自RuntimeException的异常都被称为非检查型异常。
+这又是一个非常流行的Java异常面试题，会出现在各种层次的Java面试中。检查型异常和非检查型异常的主要区别在于其处理方式。检查型异常需要使用try, catch和finally关键字在编译期进行处理，否则会出现编译器会报错。对于非检查型异常则不需要这样做。Java中所有继承自java.lang.Exception类的异常都是检查型异常，所有继承自RuntimeException的异常都被称为非检查型异常。
 
 **3) Java中的NullPointerException和ArrayIndexOutOfBoundException之间有什么相同之处？**
 
-　　在Java异常面试中这并不是一个很流行的问题，但会出现在不同层次的初学者面试中，用来测试应聘者对检查型异常和非检查型异常的概念是否熟悉。顺便说一下，该题的答案是，这两个异常都是非检查型异常，都继承自RuntimeException。该问题可能会引出另一个问题，即Java和C的数组有什么不同之处，因为C里面的数组是没有大小限制的，绝对不会抛出ArrayIndexOutOfBoundException。
+在Java异常面试中这并不是一个很流行的问题，但会出现在不同层次的初学者面试中，用来测试应聘者对检查型异常和非检查型异常的概念是否熟悉。顺便说一下，该题的答案是，这两个异常都是非检查型异常，都继承自RuntimeException。该问题可能会引出另一个问题，即Java和C的数组有什么不同之处，因为C里面的数组是没有大小限制的，绝对不会抛出ArrayIndexOutOfBoundException。
 
 **4)在Java异常处理的过程中，你遵循的那些最好的实践是什么？**
 
-　　这个问题在面试技术经理是非常常见的一个问题。因为异常处理在项目设计中是非常关键的，所以精通异常处理是十分必要的。异常处理有很多最佳实践，下面列举集中，它们提高你代码的健壮性和灵活性：
+这个问题在面试技术经理是非常常见的一个问题。因为异常处理在项目设计中是非常关键的，所以精通异常处理是十分必要的。异常处理有很多最佳实践，下面列举集中，它们提高你代码的健壮性和灵活性：
 
-　　1) 调用方法的时候返回布尔值来代替返回null，这样可以 NullPointerException。由于空指针是java异常里最恶心的异常
+　　1) 调用方法的时候返回布尔值来代替返回null，这样可以NullPointerException。由于空指针是java异常里最恶心的异常
 
 　　2) catch块里别不写代码。空catch块是异常处理里的错误事件，因为它只是捕获了异常，却没有任何处理或者提示。通常你起码要打印出异常信息，当然你最好根据需求对异常信息进行处理。
 
@@ -809,32 +798,20 @@ finally中的异常会覆盖（消灭）前面try或者catch中的异常
 
 **5) 既然我们可以用RuntimeException来处理错误，那么你认为为什么Java中还存在检查型异常?**
 
-　　这是一个有争议的问题，在回答该问题时你应当小心。虽然他们肯定愿意听到你的观点，但其实他们最感兴趣的还是有说服力的理由。我认为其中一个理由是，存在检查型异常是一个设计上的决定，受到了诸如C++等比Java更早编程语言设计经验的影响。绝大多数检查型异常位于java.io包内，这是合乎情理的，因为在你请求了不存在的系统资源的时候，一段强壮的程序必须能够优雅的处理这种情况。通过把IOException声明为检查型异常，Java 确保了你能够优雅的对异常进行处理。另一个可能的理由是，可以使用catch或finally来确保数量受限的系统资源（比如文件描述符）在你使用后尽早得到释放。 Joshua
-Bloch编写的 [Effective Java 一书](http://www.amazon.com/dp/0321356683/?tag=javamysqlanta-20) 中多处涉及到了该话题，值得一读。
-
-**6)  throw 和 throws这两个关键字在java中有什么不同?**
-
-　　一个java初学者应该掌握的面试问题。 throw 和 throws乍看起来是很相似的尤其是在你还是一个java初学者的时候。尽管他们看起来相似，都是在处理异常时候使用到的。但在代码里的使用方法和用到的地方是不同的。throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常, 你也可以申明未检查的异常，但这不是编译器强制的。如果方法抛出了异常那么调用这个方法的时候就需要将这个异常处理。另一个关键字  throw 是用来抛出任意异常的，按照语法你可以抛出任意 Throwable (i.e. Throwable
-或任何Throwable的衍生类) , throw可以中断程序运行，因此可以用来代替return . 最常见的例子是用 throw 在一个空方法中需要return的地方抛出 UnSupportedOperationException 代码如下 :
-
-
-
-
-
-| 123 | `private``static` `void` `show() {``throw``new` `UnsupportedOperationException(``"Notyet implemented"``);``}` |
-| --- | --- |
+这是一个有争议的问题，在回答该问题时你应当小心。虽然他们肯定愿意听到你的观点，但其实他们最感兴趣的还是有说服力的理由。我认为其中一个理由是，存在检查型异常是一个设计上的决定，受到了诸如C++等比Java更早编程语言设计经验的影响。绝大多数检查型异常位于java.io包内，这是合乎情理的，因为在你请求了不存在的系统资源的时候，一段强壮的程序必须能够优雅的处理这种情况。通过把IOException声明为检查型异常，Java 确保了你能够优雅的对异常进行处理。另一个可能的理由是，可以使用catch或finally来确保数量受限的系统资源（比如文件描述符）在你使用后尽早得到释放。Joshua
+Bloch编写的[Effective Java 一书](http://www.amazon.com/dp/0321356683/?tag=javamysqlanta-20)中多处涉及到了该话题，值得一读。
 
+**6) throw 和 throws这两个关键字在java中有什么不同?**
 
-
-
-
-　　可以看下这篇 [文章](http://javarevisited.blogspot.com/2012/02/difference-between-throw-and-throws-in.html)查看这两个关键字在java中更多的差异 。
+　　一个java初学者应该掌握的面试问题。throw 和 throws乍看起来是很相似的尤其是在你还是一个java初学者的时候。尽管他们看起来相似，都是在处理异常时候使用到的。但在代码里的使用方法和用到的地方是不同的。throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常, 你也可以申明未检查的异常，但这不是编译器强制的。如果方法抛出了异常那么调用这个方法的时候就需要将这个异常处理。另一个关键字 throw 是用来抛出任意异常的，按照语法你可以抛出任意 Throwable(i.e. Throwable
+或任何Throwable的衍生类) , throw可以中断程序运行，因此可以用来代替return . 最常见的例子是用 throw 在一个空方法中需要return的地方抛出 UnSupportedOperationException.
+可以看下这篇[文章](http://javarevisited.blogspot.com/2012/02/difference-between-throw-and-throws-in.html)查看这两个关键字在java中更多的差异 。
 
 **7) 什么是“异常链”?**
 
 　　“异常链”是Java中非常流行的异常处理概念，是指在进行一个异常处理时抛出了另外一个异常，由此产生了一个异常链条。该技术大多用于将“ 受检查异常” （ checked exception）封装成为“非受检查异常”（unchecked exception)或者RuntimeException。顺便说一下，如果因为因为异常你决定抛出一个新的异常，你一定要包含原有的异常，这样，处理程序才可以通过getCause()和initCause()方法来访问异常最终的根源。
 
-**) 你曾经自定义实现过异常吗？怎么写的?**
+**8) 你曾经自定义实现过异常吗？怎么写的?**
 
 　　很显然，我们绝大多数都写过自定义或者业务异常，像AccountNotFoundException。在面试过程中询问这个Java异常问题的主要原因是去发现你如何使用这个特性的。这可以更准确和精致的去处理异常，当然这也跟你选择checked 还是unchecked exception息息相关。通过为每一个特定的情况创建一个特定的异常，你就为调用者更好的处理异常提供了更好的选择。相比通用异常（general exception)，我更倾向更为精确的异常。大量的创建自定义异常会增加项目class的个数，因此，在自定义异常和通用异常之间维持一个平衡是成功的关键。
 
@@ -862,21 +839,4 @@ http://c.biancheng.net/view/1038.html
 https://blog.csdn.net/Lisiluan/article/details/88745820
 https://blog.csdn.net/michaelgo/article/details/82790253
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
 
diff --git "a/docs/java/basic/15\343\200\201Java\346\263\250\350\247\243\345\222\214\346\234\200\344\275\263\345\256\236\350\267\265.md" "b/docs/Java/basic/Java\346\263\250\350\247\243\345\222\214\346\234\200\344\275\263\345\256\236\350\267\265.md"
similarity index 85%
rename from "docs/java/basic/15\343\200\201Java\346\263\250\350\247\243\345\222\214\346\234\200\344\275\263\345\256\236\350\267\265.md"
rename to "docs/Java/basic/Java\346\263\250\350\247\243\345\222\214\346\234\200\344\275\263\345\256\236\350\267\265.md"
index ab4a401..435e587 100644
--- "a/docs/java/basic/15\343\200\201Java\346\263\250\350\247\243\345\222\214\346\234\200\344\275\263\345\256\236\350\267\265.md"
+++ "b/docs/Java/basic/Java\346\263\250\350\247\243\345\222\214\346\234\200\344\275\263\345\256\236\350\267\265.md"
@@ -22,21 +22,7 @@
     * [什么是元注解？](#什么是元注解？)
     * [下面的代码会编译吗？](#下面的代码会编译吗？)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-
----
-title: 夯实Java基础系列15：Java注解简介和最佳实践
-date: 2019-9-15 15:56:26 # 文章生成时间，一般不改
-categories:
-    - Java技术江湖
-    - Java基础
-tags:
-    - annotation
-    - Java注解
----
+
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -73,9 +59,7 @@ Annotation 中文译过来就是注解、标释的意思，在 Java 中注解是
 
 并且，往抽象地说，标签并不一定是一张纸，它可以是对人和事物的属性评价。也就是说，标签具备对于抽象事物的解释。
 
-![](https://img-blog.csdn.net/20170627213419176?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvYnJpYmx1ZQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230403213103.png)
 
 所以，基于如此，我完成了自我的知识认知升级，我决定用标签来解释注解。
 
@@ -166,8 +150,8 @@ java.lang.annotation提供了四种元注解，专门注解其他的注解（在
 JDK 内置注解
 先来看几个 Java 内置的注解，让大家热热身。
 
-   @Override 演示
-
+@Override 演示
+````
     class Parent {
         public void run() {
         }
@@ -182,7 +166,9 @@ JDK 内置注解
         public void run() {
         }
     }
+````
 @Deprecated 演示
+````
 class Parent {
 
     /**
@@ -201,7 +187,9 @@ class Parent {
             parent.run(); // 在编译器中此方法会显示过时标志
         }
     }
+````
 @SuppressWarnings 演示
+````
 class Parent {
 
     // 因为定义的 name 没有使用，那么编译器就会有警告，这时候使用此注解可以屏蔽掉警告
@@ -209,8 +197,10 @@ class Parent {
     @SuppressWarnings("all")
     private String name;
     }
-
+````
 @FunctionalInterface 演示
+
+````
 /**
  * 此注解是 Java8 提出的函数式接口，接口中只允许有一个抽象方法
  * 加上这个注解之后，类中多一个抽象方法或者少一个抽象方法都会报错
@@ -219,7 +209,7 @@ class Parent {
 interface Func {
     void run();
 }
-
+````
 
 ## 注解处理器实战
 
@@ -230,27 +220,30 @@ interface Func {
 我们先来了解下如何通过在运行时使用反射获取在程序中的使用的注解信息。如下类注解和方法注解。
 
 类注解
-    Class aClass = ApiController.class;
-    Annotation[] annotations = aClass.getAnnotations();
-    
-    for(Annotation annotation : annotations) {
-        if(annotation instanceof ApiAuthAnnotation) {
-            ApiAuthAnnotation apiAuthAnnotation = (ApiAuthAnnotation) annotation;
-            System.out.println("name: " + apiAuthAnnotation.name());
-            System.out.println("age: " + apiAuthAnnotation.age());
-        }
+
+````
+Class aClass = ApiController.class;
+Annotation[] annotations = aClass.getAnnotations();
+
+for(Annotation annotation : annotations) {
+    if(annotation instanceof ApiAuthAnnotation) {
+        ApiAuthAnnotation apiAuthAnnotation = (ApiAuthAnnotation) annotation;
+        System.out.println("name: " + apiAuthAnnotation.name());
+        System.out.println("age: " + apiAuthAnnotation.age());
     }
-    方法注解
-    Method method = ... //通过反射获取方法对象
-    Annotation[] annotations = method.getDeclaredAnnotations();
-    
-    for(Annotation annotation : annotations) {
-        if(annotation instanceof ApiAuthAnnotation) {
-            ApiAuthAnnotation apiAuthAnnotation = (ApiAuthAnnotation) annotation;
-            System.out.println("name: " + apiAuthAnnotation.name());
-            System.out.println("age: " + apiAuthAnnotation.age());
-        }
-    }   
+}
+方法注解
+Method method = ... //通过反射获取方法对象
+Annotation[] annotations = method.getDeclaredAnnotations();
+
+for(Annotation annotation : annotations) {
+    if(annotation instanceof ApiAuthAnnotation) {
+        ApiAuthAnnotation apiAuthAnnotation = (ApiAuthAnnotation) annotation;
+        System.out.println("name: " + apiAuthAnnotation.name());
+        System.out.println("age: " + apiAuthAnnotation.age());
+    }
+}   
+````
 此部分内容可参考: 通过反射获取注解信息
 
 注解处理器实战
@@ -260,33 +253,33 @@ interface Func {
 接下来要做的事情: 写一个切面，拦截浏览器访问带注解的接口，取出注解信息，判断年龄来确定是否可以继续访问。
 
 在 dispatcher-servlet.xml 文件中定义 aop 切面
-
-    <aop:config>
-        <!--定义切点，切的是我们自定义的注解-->
-        <aop:pointcut id="apiAuthAnnotation" expression="@annotation(cn.caijiajia.devops.aspect.ApiAuthAnnotation)"/>
-        <!--定义切面，切点是 apiAuthAnnotation，切面类即注解处理器是 apiAuthAspect，主处理逻辑在方法名为 auth 的方法中-->
-        <aop:aspect ref="apiAuthAspect">
-            <aop:around method="auth" pointcut-ref="apiAuthAnnotation"/>
-        </aop:aspect>
-    </aop:config>
+````
+<aop:config>
+    <!--定义切点，切的是我们自定义的注解-->
+    <aop:pointcut id="apiAuthAnnotation" expression="@annotation(cn.caijiajia.devops.aspect.ApiAuthAnnotation)"/>
+    <!--定义切面，切点是 apiAuthAnnotation，切面类即注解处理器是 apiAuthAspect，主处理逻辑在方法名为 auth 的方法中-->
+    <aop:aspect ref="apiAuthAspect">
+        <aop:around method="auth" pointcut-ref="apiAuthAnnotation"/>
+    </aop:aspect>
+</aop:config>
+````
 切面类处理逻辑即注解处理器代码如
-
-    @Component("apiAuthAspect")
-    public class ApiAuthAspect {
-    
-        public Object auth(ProceedingJoinPoint pjp) throws Throwable {
-            Method method = ((MethodSignature) pjp.getSignature()).getMethod();
-            ApiAuthAnnotation apiAuthAnnotation = method.getAnnotation(ApiAuthAnnotation.class);
-            Integer age = apiAuthAnnotation.age();
-            if (age > 18) {
-                return pjp.proceed();
-            } else {
-                throw new RuntimeException("你未满18岁，禁止访问");
-            }
+````
+@Component("apiAuthAspect")
+public class ApiAuthAspect {
+
+    public Object auth(ProceedingJoinPoint pjp) throws Throwable {
+        Method method = ((MethodSignature) pjp.getSignature()).getMethod();
+        ApiAuthAnnotation apiAuthAnnotation = method.getAnnotation(ApiAuthAnnotation.class);
+        Integer age = apiAuthAnnotation.age();
+        if (age > 18) {
+            return pjp.proceed();
+        } else {
+            throw new RuntimeException("你未满18岁，禁止访问");
         }
     }
-
-
+}
+````
 
 ## 不同类型的注解
 
@@ -295,7 +288,7 @@ interface Func {
 你可以在运行期访问类，方法或者变量的注解信息，下是一个访问类注解的例子：
 
 ```
- Class aClass = TheClass.class;
+Class aClass = TheClass.class;
 Annotation[] annotations = aClass.getAnnotations();
 
 for(Annotation annotation : annotations){
@@ -410,8 +403,8 @@ public class TheClass {
 你可以像这样来访问变量的注解：
 
 ```
-Field field = ... //获取方法对象</pre>
-<pre>Annotation[] annotations = field.getDeclaredAnnotations();
+Field field = ... //获取方法对象目录
+Annotation[] annotations = field.getDeclaredAnnotations();
 
 for(Annotation annotation : annotations){
  if(annotation instanceof MyAnnotation){
@@ -425,8 +418,8 @@ for(Annotation annotation : annotations){
 你可以像这样访问指定的变量注解：
 
 ```
-Field field = ...//获取方法对象</pre>
-<pre>
+Field field = ...//获取方法对象目录
+
 Annotation annotation = field.getAnnotation(MyAnnotation.class);
 
 if(annotation instanceof MyAnnotation){
@@ -668,20 +661,5 @@ https://blog.51cto.com/4247649/2109129
 https://www.jianshu.com/p/2f2460e6f8e7
 https://blog.csdn.net/yuzongtao/article/details/83306182
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
 
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/5\343\200\201Java\347\261\273\345\222\214\345\214\205.md" "b/docs/Java/basic/Java\347\261\273\345\222\214\345\214\205.md"
similarity index 67%
rename from "docs/java/basic/5\343\200\201Java\347\261\273\345\222\214\345\214\205.md"
rename to "docs/Java/basic/Java\347\261\273\345\222\214\345\214\205.md"
index 4084792..43d7244 100644
--- "a/docs/java/basic/5\343\200\201Java\347\261\273\345\222\214\345\214\205.md"
+++ "b/docs/Java/basic/Java\347\261\273\345\222\214\345\214\205.md"
@@ -1,27 +1,21 @@
 # 目录
 
-  * [Java中的包概念](#java中的包概念)
+* [Java中的包概念](#java中的包概念)
     * [包的作用](#包的作用)
     * [package 的目录结构](#package-的目录结构)
     * [设置 CLASSPATH 系统变量](#设置-classpath-系统变量)
-  * [常用jar包](#常用jar包)
+* [常用jar包](#常用jar包)
     * [java软件包的类型](#java软件包的类型)
     * [dt.jar](#dtjar)
     * [rt.jar](#rtjar)
-  * [*.java文件的奥秘](#java文件的奥秘)
+* [*.java文件的奥秘](#java文件的奥秘)
     * [*.Java文件简介](#java文件简介)
     * [为什么一个java源文件中只能有一个public类？](#为什么一个java源文件中只能有一个public类？)
     * [Main方法](#main方法)
     * [外部类的访问权限](#外部类的访问权限)
     * [Java包的命名规则](#java包的命名规则)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+* [参考文章](#参考文章)
 
----
-    - Java类
----
 
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -74,11 +68,7 @@ Java 使用包（package）这种机制是为了防止命名冲突，访问控
     
     package  net.java.util; public  class  Something{ ... }
 
-
-
-
-
-那么它的路径应该是 **net/java/util/Something.java** 这样保存的。 package(包) 的作用是把不同的 java 程序分类保存，更方便的被其他 java 程序调用。
+那么它的路径应该是**net/java/util/Something.java**这样保存的。 package(包) 的作用是把不同的 java 程序分类保存，更方便的被其他 java 程序调用。
 
 一个包（package）可以定义为一组相互联系的类型（类、接口、枚举和注释），为这些类型提供访问保护和命名空间管理的功能。
 
@@ -91,8 +81,6 @@ Java 使用包（package）这种机制是为了防止命名冲突，访问控
 
 由于包创建了新的命名空间（namespace），所以不会跟其他包中的任何名字产生命名冲突。使用包这种机制，更容易实现访问控制，并且让定位相关类更加简单。
 
-
-
 ### package 的目录结构
 
 类放在包中会有两种主要的结果：
@@ -104,28 +92,18 @@ Java 使用包（package）这种机制是为了防止命名冲突，访问控
 
 将类、接口等类型的源码放在一个文本中，这个文件的名字就是这个类型的名字，并以.java作为扩展名。例如：
 
-
-
-
-
-// 文件名 : Car.java  package  vehicle; public  class  Car  {  // 类实现 }
-
-
-
-
+````
+// 文件名 : Car.java  
+package  vehicle; 
+public  class  Car  {  
+// 类实现 
+}
+````
 
 接下来，把源文件放在一个目录中，这个目录要对应类所在包的名字。
 
-
-
-
-
 ....\vehicle\Car.java
 
-
-
-
-
 现在，正确的类名和路径将会是如下样子：
 
 *   类名 -> vehicle.Car
@@ -134,51 +112,49 @@ Java 使用包（package）这种机制是为了防止命名冲突，访问控
 
 通常，一个公司使用它互联网域名的颠倒形式来作为它的包名.例如：互联网域名是 runoob.com，所有的包名都以 com.runoob 开头。包名中的每一个部分对应一个子目录。
 
-例如：有一个 **com.runoob.test** 的包，这个包包含一个叫做 Runoob.java 的源文件，那么相应的，应该有如下面的一连串子目录：
-
-
-
-
+例如：有一个**com.runoob.test**的包，这个包包含一个叫做 Runoob.java 的源文件，那么相应的，应该有如下面的一连串子目录：
 
 ....\com\runoob\test\Runoob.java
 
-
-
-
-
 编译的时候，编译器为包中定义的每个类、接口等类型各创建一个不同的输出文件，输出文件的名字就是这个类型的名字，并加上 .class 作为扩展后缀。 例如：
-
-
-
-
-
-// 文件名: Runoob.java  package  com.runoob.test; public  class  Runoob  {  }  class  Google  {  }
-
-
-
+````
+// 文件名: Runoob.java  
+package  com.runoob.test; 
+public  class  Runoob  {  }  
+class  Google  {  }
+````
 
 
 现在，我们用-d选项来编译这个文件，如下：
-
-<pre>$javac -d .  Runoob.java</pre>
-
+````
+    $javac -d .  Runoob.java
+````
 这样会像下面这样放置编译了的文件：
 
-<pre>.\com\runoob\test\Runoob.class  .\com\runoob\test\Google.class</pre>
+````
+    .\com\runoob\test\Runoob.class  
+    .\com\runoob\test\Google.class
+````
 
-你可以像下面这样来导入所有** \com\runoob\test\ **中定义的类、接口等：
-
-<pre>import com.runoob.test.*;</pre>
+你可以像下面这样来导入所有**\com\runoob\test\**中定义的类、接口等：
+````
+    import com.runoob.test.*;
+````
 
 编译之后的 .class 文件应该和 .java 源文件一样，它们放置的目录应该跟包的名字对应起来。但是，并不要求 .class 文件的路径跟相应的 .java 的路径一样。你可以分开来安排源码和类的目录。
 
-<pre><path-one>\sources\com\runoob\test\Runoob.java <path-two>\classes\com\runoob\test\Google.class</pre>
+````
+    <path-one>\sources\com\runoob\test\Runoob.java 
+    <path-two>\classes\com\runoob\test\Google.class
+````
 
 这样，你可以将你的类目录分享给其他的编程人员，而不用透露自己的源码。用这种方法管理源码和类文件可以让编译器和java 虚拟机（JVM）可以找到你程序中使用的所有类型。
 
-类目录的绝对路径叫做 **class path**。设置在系统变量 **CLASSPATH** 中。编译器和 java 虚拟机通过将 package 名字加到 class path 后来构造 .class 文件的路径。
+类目录的绝对路径叫做**class path**。设置在系统变量**CLASSPATH**中。编译器和 java 虚拟机通过将 package 名字加到 class path 后来构造 .class 文件的路径。
 
-<path- two>\classes 是 class path，package 名字是 com.runoob.test,而编译器和 JVM 会在 <path-two>\classes\com\runoob\test 中找 .class 文件。
+````
+    <path- two>\classes 是 class path，package 名字是 com.runoob.test,而编译器和 JVM 会在 <path-two>\classes\com\runoob\test 中找 .class 文件。
+````
 
 一个 class path 可能会包含好几个路径，多路径应该用分隔符分开。默认情况下，编译器和 JVM 查找当前目录。JAR 文件按包含 Java 平台相关的类，所以他们的目录默认放在了 class path 中。
 
@@ -222,55 +198,54 @@ java包的作用是为了区别类名的命名空间　　
 
 在 animals 包中加入一个接口（interface）：
 
-    package animals;
-      
-    interface Animal {
-       public void eat();
-       public void travel();
-    }
-　　接下来，在同一个包中加入该接口的实现：
-
-    package animals;
-      
-    /* 文件名 : MammalInt.java */
-    public class MammalInt implements Animal{
-      
-       public void eat(){
-          System.out.println("Mammal eats");
-       }
-      
-       public void travel(){
-          System.out.println("Mammal travels");
-       }
-      
-       public int noOfLegs(){
-          return 0;
-       }
-      
-       public static void main(String args[]){
-          MammalInt m = new MammalInt();
-          m.eat();
-          m.travel();
-       }
-    }
-
+````
+package animals;
+interface Animal {
+   public void eat();
+   public void travel();
+}
+````
+
+接下来，在同一个包中加入该接口的实现：
+
+````
+package animals;
+/* 文件名 : MammalInt.java */
+public class MammalInt implements Animal{
+   public void eat(){
+      System.out.println("Mammal eats");
+   }
+   public void travel(){
+      System.out.println("Mammal travels");
+   }
+   public int noOfLegs(){
+      return 0;
+   }
+   public static void main(String args[]){
+      MammalInt m = new MammalInt();
+      m.eat();
+      m.travel();
+   }
+}
+````
 
 import 关键字
 为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 "import" 语句可完成此功能。
 
 在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：
 
-1
-import package1[.package2…].(classname|*);
-　　如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。
+````
+    import package1[.package2…].(classname|*);
+````
+
+如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。
 
 通常，一个公司使用它互联网域名的颠倒形式来作为它的包名.例如：互联网域名是 runoob.com，所有的包名都以 com.runoob 开头。包名中的每一个部分对应一个子目录。
 
 例如：有一个 com.runoob.test 的包，这个包包含一个叫做 Runoob.java 的源文件，那么相应的，应该有如下面的一连串子目录：
-
-1
-....\com\runoob\test\Runoob.java
-
+```
+    ....\com\runoob\test\Runoob.java
+```
 ## 常用jar包
 
 ### java软件包的类型
@@ -291,36 +266,30 @@ import package1[.package2…].(classname|*);
 6） java.net：包含支持网络操作的类。
 
 ### dt.jar
-> SUN对于dt.jar的定义：Also includes dt.jar, the DesignTime archive of BeanInfo files that tell interactive development environments (IDE's) how to display the Java components and how to let the developer customize them for the application。
-
-中文翻译过来就是：dt.jar是BeanInfo文件的DesignTime归档，BeanInfo文件用来告诉集成开发环境（IDE）如何显示Java组件还有如何让开发人员根据应用程序自定义它们。这段文字中提到了几个关键字：DesignTime,BeanInfo,IDE，Java components。其实dt.jar就是DesignTime Archive的缩写。那么何为DesignTime。
 
-    何为DesignTime?翻译过来就是设计时。其实了解JavaBean的人都知道design time和runtime（运行时）这两个术语的含义。设计时（DesignTIme）是指在开发环境中通过添加控件，设置控件或窗体属性等方法，建立应用程序的时间。
-    
-    与此相对应的运行时（RunTIme）是指可以象用户那样与应用程序交互作用的时间。那么现在再理解一下上面的翻译，其实dt.jar包含了swing控件中的BeanInfo，而IDE的GUI Designer需要这些信息。那让我们看一下dt.jar中到底有什么？下面是一张dt.jar下面的内容截图：
+> SUN对于dt.jar的定义：Also includesdt.jar, the DesignTime archive of BeanInfo files that tell interactive development environments (IDE's) how to display the Java components and how to let the developer customize them for the application。
 
-![image](http://www.blogjava.net/images/blogjava_net/landon/dt-jar.jpg)
+中文翻译过来就是：dt.jar是BeanInfo文件的DesignTime归档，BeanInfo文件用来告诉集成开发环境（IDE）如何显示Java组件还有如何让开发人员根据应用程序自定义它们。这段文字中提到了几个关键字：DesignTime,BeanInfo,IDE，Java components。其实dt.jar就是DesignTime Archive的缩写。那么何为DesignTime。
 
-    从上面的截图可以看出，dt.jar中全部是Swing组件的BeanInfo。那么到底什么是BeanInfo呢？
+何为DesignTime?翻译过来就是设计时。其实了解JavaBean的人都知道design time和runtime（运行时）这两个术语的含义。设计时（DesignTIme）是指在开发环境中通过添加控件，设置控件或窗体属性等方法，建立应用程序的时间。
 
-    何为BeanInfo?JavaBean和BeanInfo有很大的关系。Sun所制定的JavaBean规范，很大程度上是为IDE准备的——它让IDE能够以可视化的方式设置JavaBean的属性。如果在IDE中开发一个可视化应用程序，我们需要通过属性设置的方式对组成应用的各种组件进行定制，IDE通过属性编辑器让开发人员使用可视化的方式设置组件的属性。
+与此相对应的运行时（RunTIme）是指可以象用户那样与应用程序交互作用的时间。那么现在再理解一下上面的翻译，其实dt.jar包含了swing控件中的BeanInfo，而IDE的GUI Designer需要这些信息。那让我们看一下dt.jar中到底有什么？
 
-    一般的IDE都支持JavaBean规范所定义的属性编辑器，当组件开发商发布一个组件时，它往往将组件对应的属性编辑器捆绑发行，这样开发者就可以在IDE环境下方便地利用属性编辑器对组件进行定制工作。JavaBean规范通过java.beans.PropertyEditor定义了设置JavaBean属性的方法，通过BeanInfo描述了JavaBean哪些属性是可定制的，此外还描述了可定制属性与PropertyEditor的对应关系。
+dt.jar中全部是Swing组件的BeanInfo。那么到底什么是BeanInfo呢？
 
-    BeanInfo与JavaBean之间的对应关系，通过两者之间规范的命名确立：对应JavaBean的BeanInfo采用如下的命名规范：<Bean>BeanInfo。当JavaBean连同其属性编辑器相同的组件注册到IDE中后，当在开发界面中对JavaBean进行定制时，IDE就会根据JavaBean规范找到对应的BeanInfo，再根据BeanInfo中的描述信息找到JavaBean属性描述（是否开放、使用哪个属性编辑器），进而为JavaBean生成特定开发编辑界面。
+何为BeanInfo?JavaBean和BeanInfo有很大的关系。Sun所制定的JavaBean规范，很大程度上是为IDE准备的——它让IDE能够以可视化的方式设置JavaBean的属性。如果在IDE中开发一个可视化应用程序，我们需要通过属性设置的方式对组成应用的各种组件进行定制，IDE通过属性编辑器让开发人员使用可视化的方式设置组件的属性。
 
-    dt.jar里面主要是swing组件的BeanInfo。IDE根据这些BeanInfo显示这些组件以及开发人员如何定制他们。
+dt.jar里面主要是swing组件的BeanInfo。IDE根据这些BeanInfo显示这些组件以及开发人员如何定制他们。
 
 ### rt.jar
 rt.jar是runtime的归档。Java基础类库，也就是Java doc里面看到的所有的类的class文件。
 
-![image](https://img-blog.csdnimg.cn/20181115130130739.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1aGFuZ2hhbmc=,size_16,color_FFFFFF,t_70)
-
- rt.jar 默认就在Root Classloader的加载路径里面的，而在Claspath配置该变量是不需要的；同时jre/lib目录下的其他jar:jce.jar、jsse.jar、charsets.jar、resources.jar都在Root Classloader中。
+![image](https://www.pianshen.com/images/75/856cbbdf52da90fa4f9bbb7b0597ce63.png)
 
-## *.java文件的奥秘
+rt.jar 默认就在Root Classloader的加载路径里面的，而在Claspath配置该变量是不需要的；同时jre/lib目录下的其他jar:jce.jar、jsse.jar、charsets.jar、resources.jar都在Root Classloader中。
 
-### *.Java文件简介
+## java文件的奥秘
+### Java文件简介
 
 .java文件你可以认为只是一个文本文件， 这个文件即是用java语言写成的程序，或者说任务的代码块。
 
@@ -335,43 +304,41 @@ rt.jar是runtime的归档。Java基础类库，也就是Java doc里面看到的
 这里的.class文件在计算的体系结构中本质上对应的是一种机器语言（而这里的机器叫作JVM），所以JVM本身是可以直接运行这里的.class文件。所以 你可以进一步地认为，.java与.class与其它的编程语法一样，它们都是程序员用来描述自己的任务的一种语言，只是它们面向的对象不一样，而计算机本身只能识别它自已定义的那些指令什么的（再次强调，这里的计算机本身没有那么严格的定义）
 
 > In short：
-> 
+>
 > .java是Java的源文件后缀，里面存放程序员编写的功能代码。
-> 
+>
 > .class文件是字节码文件，由.java源文件通过javac命令编译后生成的文件。是可以运行在任何支持Java虚拟机的硬件平台和操作系统上的二进制文件。
-> 
+>
 > .class文件并不本地的可执行程序。Java虚拟机就是去运行.class文件从而实现程序的运行。
 
 
-
-
 ### 为什么一个java源文件中只能有一个public类？
 
-　　在java编程思想（第四版）一书中有这样3段话（6.4 类的访问权限）：
+在java编程思想（第四版）一书中有这样3段话（6.4 类的访问权限）：
 
 > 　　1.每个编译单元（文件）都只能有一个public类，这表示，每个编译单元都有单一的公共接口，用public类来表现。该接口可以按要求包含众多的支持包访问权限的类。如果在某个编译单元内有一个以上的public类，编译器就会给出错误信息。
-> 
+>
 > 　　2.public类的名称必须完全与含有该编译单元的文件名相同，包含大小写。如果不匹配，同样将得到编译错误。
-> 
+>
 > 　　3.虽然不是很常用，但编译单元内完全不带public类也是可能的。在这种情况下，可以随意对文件命名。
 
 总结相关的几个问题：
 
 1、一个”.java”源文件中是否可以包括多个类（不是内部类）？有什么限制？
 
->   答：可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。
+> 答：可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。
 
 2、为什么一个文件中只能有一个public的类
 
->   答：编译器在编译时，针对一个java源代码文件（也称为“编译单元”）只会接受一个public类。否则报错。
+> 答：编译器在编译时，针对一个java源代码文件（也称为“编译单元”）只会接受一个public类。否则报错。
 
 3、在java文件中是否可以没有public类
 
->   答：public类不是必须的，java文件中可以没有public类。
+> 答：public类不是必须的，java文件中可以没有public类。
 
 4、为什么这个public的类的类名必须和文件名相同
 
->   答： 是为了方便虚拟机在相应的路径中找到相应的类所对应的字节码文件。
+> 答： 是为了方便虚拟机在相应的路径中找到相应的类所对应的字节码文件。
 
 ### Main方法
 
@@ -400,27 +367,25 @@ rt.jar是runtime的归档。Java基础类库，也就是Java doc里面看到的
 
 为什么要对外部类或类做修饰呢？
 
-> 1.存在包概念：public 和 default 能区分这个外部类能对不同包作一个划分                       （default修饰的类，其他包中引入不了这个类，public修饰的类才能被import）   
-> 
+> 1.存在包概念：public 和 default 能区分这个外部类能对不同包作一个划分                       （default修饰的类，其他包中引入不了这个类，public修饰的类才能被import）
+>
 > 2.protected是包内可见并且子类可见，但是当一个外部类想要继承一个protected修饰的非同包类时，压根找不到这个类，更别提几层了
-> 
+>
 > 3.private修饰的外部类，其他任何外部类都无法导入它。
 
-
-    //Java中的文件名要和public修饰的类名相同，否则会报错
-    //如果没有public修饰的类，则文件可以随意命名
-    public class Java中的类文件 {
-    
-    }
-    
-    //非公共开类的访问权限默认是包访问权限，不能用private和protected
-    //一个外部类的访问权限只有两种，一种是包内可见，一种是包外可见。
-    //如果用private修饰，其他类根本无法看到这个类，也就没有意义了。
-    //如果用protected，虽然也是包内可见，但是如果有子类想要继承该类但是不同包时，
-    //压根找不到这个类，也不可能继承它了，所以干脆用default代替。
-    class A{
-    
-    }
+````
+//Java中的文件名要和public修饰的类名相同，否则会报错
+//如果没有public修饰的类，则文件可以随意命名
+public class Java中的类文件 {
+}
+//非公共开类的访问权限默认是包访问权限，不能用private和protected
+//一个外部类的访问权限只有两种，一种是包内可见，一种是包外可见。
+//如果用private修饰，其他类根本无法看到这个类，也就没有意义了。
+//如果用protected，虽然也是包内可见，但是如果有子类想要继承该类但是不同包时，
+//压根找不到这个类，也不可能继承它了，所以干脆用default代替。
+class A{
+}
+````
 
 ### Java包的命名规则
 
@@ -444,20 +409,3 @@ https://www.runoob.com/java/java-package.html
 https://www.breakyizhan.com/java/4260.html
 https://blog.csdn.net/qq_36626914/article/details/80627454
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/8\343\200\201Java\350\207\252\345\212\250\346\213\206\347\256\261\350\243\205\347\256\261\351\207\214\351\232\220\350\227\217\347\232\204\347\247\230\345\257\206.md" "b/docs/Java/basic/Java\350\207\252\345\212\250\346\213\206\347\256\261\350\243\205\347\256\261\351\207\214\351\232\220\350\227\217\347\232\204\347\247\230\345\257\206.md"
similarity index 63%
rename from "docs/java/basic/8\343\200\201Java\350\207\252\345\212\250\346\213\206\347\256\261\350\243\205\347\256\261\351\207\214\351\232\220\350\227\217\347\232\204\347\247\230\345\257\206.md"
rename to "docs/Java/basic/Java\350\207\252\345\212\250\346\213\206\347\256\261\350\243\205\347\256\261\351\207\214\351\232\220\350\227\217\347\232\204\347\247\230\345\257\206.md"
index c6ed3af..4d2dfac 100644
--- "a/docs/java/basic/8\343\200\201Java\350\207\252\345\212\250\346\213\206\347\256\261\350\243\205\347\256\261\351\207\214\351\232\220\350\227\217\347\232\204\347\247\230\345\257\206.md"
+++ "b/docs/Java/basic/Java\350\207\252\345\212\250\346\213\206\347\256\261\350\243\205\347\256\261\351\207\214\351\232\220\350\227\217\347\232\204\347\247\230\345\257\206.md"
@@ -14,14 +14,8 @@
     * [存在栈中：](#存在栈中：)
     * [存在堆里](#存在堆里)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
 
 
-    - Java基本数据类型
----
-
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
 
@@ -148,14 +142,14 @@ float fn = Float.MIN_VALUE;
 //64位
 double dx = Double.MAX_VALUE;
 double dn = Double.MIN_VALUE;
-//16位
-char cx = Character.MAX_VALUE;
-char cn = Character.MIN_VALUE;
 //1位
 boolean bt = Boolean.TRUE;
 boolean bf = Boolean.FALSE;
 ```
 
+```
+打印它们的结果可以得到
+
 `127`
 `-128`
 `32767`
@@ -168,10 +162,9 @@ boolean bf = Boolean.FALSE;
 `1.4E-45`
 `1.7976931348623157E308`
 `4.9E-324`
-`￿`
-
 `true`
 `false`
+```
 
 ### 引用类型
 
@@ -203,23 +196,23 @@ char a = 'A'
 ## 自动拆箱和装箱（详解）
 
 Java 5增加了自动装箱与自动拆箱机制，方便基本类型与包装类型的相互转换操作。在Java 5之前，如果要将一个int型的值转换成对应的包装器类型Integer，必须显式的使用new创建一个新的Integer对象，或者调用静态方法Integer.valueOf()。
-
+````
 //在Java 5之前，只能这样做
 Integer value = new Integer(10);
 //或者这样做
 Integer value = Integer.valueOf(10);
 //直接赋值是错误的
 //Integer value = 10;`
-
+````
 在Java 5中，可以直接将整型赋给Integer对象，由编译器来完成从int型到Integer类型的转换，这就叫自动装箱。
-
-`//在Java 5中，直接赋值是合法的，由编译器来完成转换`
-`Integer value = 10;`
-`与此对应的，自动拆箱就是可以将包装类型转换为基本类型，具体的转换工作由编译器来完成。`
-`//在Java 5 中可以直接这么做`
-`Integer value = new Integer(10);`
-`int i = value;`
-
+````
+//在Java 5中，直接赋值是合法的，由编译器来完成转换
+Integer value = 10;
+与此对应的，自动拆箱就是可以将包装类型转换为基本类型，具体的转换工作由编译器来完成。
+//在Java 5 中可以直接这么做
+Integer value = new Integer(10);
+int i = value;
+````
 自动装箱与自动拆箱为程序员提供了很大的方便，而在实际的应用中，自动装箱与拆箱也是使用最广泛的特性之一。自动装箱和自动拆箱其实是Java编译器提供的一颗语法糖（语法糖是指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通过可提高开发效率，增加代码可读性，增加代码的安全性）。
 
 ###  简易实现
@@ -231,6 +224,7 @@ Integer value = Integer.valueOf(10);
 实例方法xxxValue()：将具体的包装类型对象转换成基本类型；
 下面我们以int和Integer为例，说明Java中自动装箱与自动拆箱的实现机制。看如下代码：
 
+````
 class Auto //code1
 {
 	public static void main(String[] args) 
@@ -246,7 +240,10 @@ class Auto //code1
 		
 	}
 }
+````
+
 上面的代码先将int型转为Integer对象，再讲Integer对象转换为int型，毫无疑问，这是可以正确运行的。可是，这种转换是怎么进行的呢？使用反编译工具，将生成的Class文件在反编译为Java文件，让我们看看发生了什么：
+````
 class Auto//code2
 {
   public static void main(String[] paramArrayOfString)
@@ -254,17 +251,11 @@ class Auto//code2
     Integer localInteger = Integer.valueOf(10);
     
     int i = localInteger.intValue();
-
- 
-
-
-
-
-
     Double localDouble = Double.valueOf(12.4D);
     double d = localDouble.doubleValue();
   }
 }
+````
 我们可以看到经过javac编译之后，code1的代码被转换成了code2，实际运行时，虚拟机运行的就是code2的代码。也就是说，虚拟机根本不知道有自动拆箱和自动装箱这回事；在将Java源文件编译为class文件的过程中，javac编译器在自动装箱的时候，调用了Integer.valueOf()方法，在自动拆箱时，又调用了intValue()方法。我们可以看到，double和Double也是如此。
 实现总结：其实自动装箱和自动封箱是编译器为我们提供的一颗语法糖。在自动装箱时，编译器调用包装类型的valueOf()方法；在自动拆箱时，编译器调用了相应的xxxValue()方法。
 
@@ -274,128 +265,132 @@ class Auto//code2
 
 Integer源码
 
+````
 public final class Integer extends Number implements Comparable<Integer> {
-	private final int value;
-	
-	/*Integer的构造方法，接受一个整型参数,Integer对象表示的int值，保存在value中*/
-	 public Integer(int value) {
-	        this.value = value;
-	 }
-	 
-	/*equals()方法判断的是:所代表的int型的值是否相等*/
-	 public boolean equals(Object obj) {
-	        if (obj instanceof Integer) {
-	            return value == ((Integer)obj).intValue();
-	        }
-	        return false;
-	}
-	 
-	/*返回这个Integer对象代表的int值，也就是保存在value中的值*/
-	 public int intValue() {
-	        return value;
-	 }
-	 
-	 /**
-	  * 首先会判断i是否在[IntegerCache.low,Integer.high]之间
-	  * 如果是，直接返回Integer.cache中相应的元素
-	  * 否则，调用构造方法，创建一个新的Integer对象
-	  */
-	 public static Integer valueOf(int i) {
-	    assert IntegerCache.high >= 127;
-	    if (i >= IntegerCache.low && i <= IntegerCache.high)
-	        return IntegerCache.cache[i + (-IntegerCache.low)];
-	    return new Integer(i);
-	 }
-	
-	/**
-	  * 静态内部类，缓存了从[low,high]对应的Integer对象
-	  * low -128这个值不会被改变
-	  * high 默认是127，可以改变，最大不超过：Integer.MAX_VALUE - (-low) -1
-	  * cache 保存从[low,high]对象的Integer对象
-	 */
-	 private static class IntegerCache {
-	    static final int low = -128;
-	    static final int high;
-	    static final Integer cache[];
-	 
-	    static {
-	        // high value may be configured by property
-	        int h = 127;
-	        String integerCacheHighPropValue =
-	            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
-	        if (integerCacheHighPropValue != null) {
-	            int i = parseInt(integerCacheHighPropValue);
-	            i = Math.max(i, 127);
-	            // Maximum array size is Integer.MAX_VALUE
-	            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
-	        }
-	        high = h;
-	 
-	        cache = new Integer[(high - low) + 1];
-	        int j = low;
-	        for(int k = 0; k < cache.length; k++)
-	            cache[k] = new Integer(j++);
-	    }
-	 
-	    private IntegerCache() {}
-	}
+    private final int value;
+    
+    /*Integer的构造方法，接受一个整型参数,Integer对象表示的int值，保存在value中*/
+     public Integer(int value) {
+            this.value = value;
+     }
+     
+    /*equals()方法判断的是:所代表的int型的值是否相等*/
+     public boolean equals(Object obj) {
+            if (obj instanceof Integer) {
+                return value == ((Integer)obj).intValue();
+            }
+            return false;
+    }
+     
+    /*返回这个Integer对象代表的int值，也就是保存在value中的值*/
+     public int intValue() {
+            return value;
+     }
+     
+     /**
+      * 首先会判断i是否在[IntegerCache.low,Integer.high]之间
+      * 如果是，直接返回Integer.cache中相应的元素
+      * 否则，调用构造方法，创建一个新的Integer对象
+      */
+     public static Integer valueOf(int i) {
+        assert IntegerCache.high >= 127;
+        if (i >= IntegerCache.low && i <= IntegerCache.high)
+            return IntegerCache.cache[i + (-IntegerCache.low)];
+        return new Integer(i);
+     }
+    
+    /**
+      * 静态内部类，缓存了从[low,high]对应的Integer对象
+      * low -128这个值不会被改变
+      * high 默认是127，可以改变，最大不超过：Integer.MAX_VALUE - (-low) -1
+      * cache 保存从[low,high]对象的Integer对象
+     */
+     private static class IntegerCache {
+        static final int low = -128;
+        static final int high;
+        static final Integer cache[];
+     
+        static {
+            // high value may be configured by property
+            int h = 127;
+            String integerCacheHighPropValue =
+                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
+            if (integerCacheHighPropValue != null) {
+                int i = parseInt(integerCacheHighPropValue);
+                i = Math.max(i, 127);
+                // Maximum array size is Integer.MAX_VALUE
+                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
+            }
+            high = h;
+     
+            cache = new Integer[(high - low) + 1];
+            int j = low;
+            for(int k = 0; k < cache.length; k++)
+                cache[k] = new Integer(j++);
+        }
+     
+        private IntegerCache() {}
+    }
 }
-以上是Oracle(Sun)公司JDK 1.7中Integer源码的一部分，通过分析上面的代码，得到：
-1）Integer有一个实例域value，它保存了这个Integer所代表的int型的值，且它是final的，也就是说这个Integer对象一经构造完成，它所代表的值就不能再被改变。
-2）Integer重写了equals()方法，它通过比较两个Integer对象的value，来判断是否相等。
-3）重点是静态内部类IntegerCache，通过类名就可以发现：它是用来缓存数据的。它有一个数组，里面保存的是连续的Integer对象。
-   (a) low：代表缓存数据中最小的值，固定是-128。
-   (b) high：代表缓存数据中最大的值，它可以被该改变，默认是127。high最小是127，最大是Integer.MAX_VALUE-(-low)-1，如果high超过了这个值，那么cache[ ]的长度就超过Integer.MAX_VALUE了，也就溢出了。
-   (c) cache[]：里面保存着从[low,high]所对应的Integer对象，长度是high-low+1(因为有元素0，所以要加1)。
-4）调用valueOf(int i)方法时，首先判断i是否在[low,high]之间，如果是，则复用Integer.cache[i-low]。比如，如果Integer.valueOf(3)，直接返回Integer.cache[131]；如果i不在这个范围，则调用构造方法，构造出一个新的Integer对象。
-5）调用intValue()，直接返回value的值。
-通过3）和4）可以发现，默认情况下，在使用自动装箱时，VM会复用[-128,127]之间的Integer对象。
-
-Integer  a1 = 1;
-Integer  a2 = 1;
-Integer  a3 = new Integer(1);
-//会打印true，因为a1和a2是同一个对象,都是Integer.cache[129]
-System.out.println(a1 == a2);
-//false，a3构造了一个新的对象，不同于a1,a2
-System.out.println(a1 == a3);
+````
+
+    以上是Oracle(Sun)公司JDK 1.7中Integer源码的一部分，通过分析上面的代码，得到：
+    1）Integer有一个实例域value，它保存了这个Integer所代表的int型的值，且它是final的，也就是说这个Integer对象一经构造完成，它所代表的值就不能再被改变。
+    2）Integer重写了equals()方法，它通过比较两个Integer对象的value，来判断是否相等。
+    3）重点是静态内部类IntegerCache，通过类名就可以发现：它是用来缓存数据的。它有一个数组，里面保存的是连续的Integer对象。
+       (a) low：代表缓存数据中最小的值，固定是-128。
+       (b) high：代表缓存数据中最大的值，它可以被该改变，默认是127。high最小是127，最大是Integer.MAX_VALUE-(-low)-1，如果high超过了这个值，那么cache[ ]的长度就超过Integer.MAX_VALUE了，也就溢出了。
+       (c) cache[]：里面保存着从[low,high]所对应的Integer对象，长度是high-low+1(因为有元素0，所以要加1)。
+    4）调用valueOf(int i)方法时，首先判断i是否在[low,high]之间，如果是，则复用Integer.cache[i-low]。比如，如果Integer.valueOf(3)，直接返回Integer.cache[131]；如果i不在这个范围，则调用构造方法，构造出一个新的Integer对象。
+    5）调用intValue()，直接返回value的值。
+    通过3）和4）可以发现，默认情况下，在使用自动装箱时，VM会复用[-128,127]之间的Integer对象。
+    
+    Integer  a1 = 1;
+    Integer  a2 = 1;
+    Integer  a3 = new Integer(1);
+    //会打印true，因为a1和a2是同一个对象,都是Integer.cache[129]
+    System.out.println(a1 == a2);
+    //false，a3构造了一个新的对象，不同于a1,a2
+    System.out.println(a1 == a3);
 
 ### 了解基本类型缓存（常量池）的最佳实践
 
-    //基本数据类型的常量池是-128到127之间。
-    // 在这个范围中的基本数据类的包装类可以自动拆箱，比较时直接比较数值大小。
-    public static void main(String[] args) {
-        //int的自动拆箱和装箱只在-128到127范围中进行，超过该范围的两个integer的 == 判断是会返回false的。
-        Integer a1 = 128;
-        Integer a2 = -128;
-        Integer a3 = -128;
-        Integer a4 = 128;
-        System.out.println(a1 == a4);
-        System.out.println(a2 == a3);
-    
-        Byte b1 = 127;
-        Byte b2 = 127;
-        Byte b3 = -128;
-        Byte b4 = -128;
-        //byte都是相等的，因为范围就在-128到127之间
-        System.out.println(b1 == b2);
-        System.out.println(b3 == b4);
-    
-        //
-        Long c1 = 128L;
-        Long c2 = 128L;
-        Long c3 = -128L;
-        Long c4 = -128L;
-        System.out.println(c1 == c2);
-        System.out.println(c3 == c4);
-    
-        //char没有负值
-        //发现char也是在0到127之间自动拆箱
-        Character d1 = 128;
-        Character d2 = 128;
-        Character d3 = 127;
-        Character d4 = 127;
-        System.out.println(d1 == d2);
-        System.out.println(d3 == d4);
+````
+//基本数据类型的常量池是-128到127之间。
+// 在这个范围中的基本数据类的包装类可以自动拆箱，比较时直接比较数值大小。
+public static void main(String[] args) {
+
+//int的自动拆箱和装箱只在-128到127范围中进行，超过该范围的两个integer的 == 判断是会返回false的。
+Integer a1 = 128;
+Integer a2 = -128;
+Integer a3 = -128;
+Integer a4 = 128;
+System.out.println(a1 == a4);
+System.out.println(a2 == a3);
+
+Byte b1 = 127;
+Byte b2 = 127;
+Byte b3 = -128;
+Byte b4 = -128;
+//byte都是相等的，因为范围就在-128到127之间
+System.out.println(b1 == b2);
+System.out.println(b3 == b4);
+
+Long c1 = 128L;
+Long c2 = 128L;
+Long c3 = -128L;
+Long c4 = -128L;
+System.out.println(c1 == c2);
+System.out.println(c3 == c4);
+
+//char没有负值
+//发现char也是在0到127之间自动拆箱
+Character d1 = 128;
+Character d2 = 128;
+Character d3 = 127;
+Character d4 = 127;
+System.out.println(d1 == d2);
+System.out.println(d3 == d4);
 
 `结果`
 
@@ -409,27 +404,29 @@ System.out.println(a1 == a3);
 `true`
 
 
-        Integer i = 10;
-        Byte b = 10;
-        //比较Byte和Integer.两个对象无法直接比较，报错
-        //System.out.println(i == b);
-        System.out.println("i == b " + i.equals(b));
-        //答案是false,因为包装类的比较时先比较是否是同一个类，不是的话直接返回false.
-        int ii = 128;
-        short ss = 128;
-        long ll = 128;
-        char cc = 128;
-        System.out.println("ii == bb " + (ii == ss));
-        System.out.println("ii == ll " + (ii == ll));
-        System.out.println("ii == cc " + (ii == cc));
-        
-        结果
-        i == b false
-        ii == bb true
-        ii == ll true
-        ii == cc true
-        
-        //这时候都是true，因为基本数据类型直接比较值，值一样就可以。
+Integer i = 10;
+Byte b = 10;
+//比较Byte和Integer.两个对象无法直接比较，报错
+//System.out.println(i == b);
+System.out.println("i == b " + i.equals(b));
+//答案是false,因为包装类的比较时先比较是否是同一个类，不是的话直接返回false.
+
+int ii = 128;
+short ss = 128;
+long ll = 128;
+char cc = 128;
+System.out.println("ii == bb " + (ii == ss));
+System.out.println("ii == ll " + (ii == ll));
+System.out.println("ii == cc " + (ii == cc));
+
+结果
+i == b false
+ii == bb true
+ii == ll true
+ii == cc true
+
+//这时候都是true，因为基本数据类型直接比较值，值一样就可以。
+````
 
 ### 总结：
 
@@ -439,12 +436,10 @@ System.out.println(a1 == a3);
 
 （2）当需要一个基本类型时会自动拆箱，比如int a = new Integer(10);算术运算是在基本类型间进行的，所以当遇到算术运算时会自动拆箱，比如代码中的 c == (a + b);
 
-（3） 包装类型 == 基本类型时，包装类型自动拆箱；
+（3）包装类型 == 基本类型时，包装类型自动拆箱；
 
 需要注意的是：“==”在没遇到算术运算时，不会自动拆箱；基本类型只会自动装箱为对应的包装类型，代码中最后一条说明的内容。
 
-
-
 在JDK 1.5中提供了自动装箱与自动拆箱，这其实是Java 编译器的语法糖，编译器通过调用包装类型的valueOf()方法实现自动装箱，调用xxxValue()方法自动拆箱。自动装箱和拆箱会有一些陷阱，那就是包装类型复用了某些对象。
 
 （1）Integer默认复用了[-128,127]这些对象，其中高位置可以修改；
@@ -468,11 +463,13 @@ Boolean没有自动装箱与拆箱，它也复用了Boolean.TRUE和Boolean.FALSE
 上面自动拆箱和装箱的原理其实与常量池有关。
 
 ### 存在栈中：
-public void(int a)
-{
-int i = 1;
-int j = 1;
-}
+
+    public void(int a)
+    {
+    int i = 1;
+    int j = 1;
+    }
+
 方法中的i 存在虚拟机栈的局部变量表里，i是一个引用，j也是一个引用，它们都指向局部变量表里的整型值 1.
 int a是传值引用，所以a也会存在局部变量表。
 
@@ -485,50 +482,53 @@ i是类的成员变量。类实例化的对象存在堆中，所以成员变量
 
 3 包装类对象怎么存
 其实我们说的常量池也可以叫对象池。
+
 比如String a= new String("a").intern()时会先在常量池找是否有“a"对象如果有的话直接返回“a"对象在常量池的地址，即让引用a指向常量”a"对象的内存地址。
-public native String intern();
 Integer也是同理。
 
 下图是Integer类型在常量池中查找同值对象的方法。
 
-    public static Integer valueOf(int i) {
-        if (i >= IntegerCache.low && i <= IntegerCache.high)
-            return IntegerCache.cache[i + (-IntegerCache.low)];
-        return new Integer(i);
-    }
-    private static class IntegerCache {
-        static final int low = -128;
-        static final int high;
-        static final Integer cache[];
-    
-        static {
-            // high value may be configured by property
-            int h = 127;
-            String integerCacheHighPropValue =
-                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
-            if (integerCacheHighPropValue != null) {
-                try {
-                    int i = parseInt(integerCacheHighPropValue);
-                    i = Math.max(i, 127);
-                    // Maximum array size is Integer.MAX_VALUE
-                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
-                } catch( NumberFormatException nfe) {
-                    // If the property cannot be parsed into an int, ignore it.
-                }
+````
+public static Integer valueOf(int i) {
+    if (i >= IntegerCache.low && i <= IntegerCache.high)
+        return IntegerCache.cache[i + (-IntegerCache.low)];
+    return new Integer(i);
+}
+private static class IntegerCache {
+    static final int low = -128;
+    static final int high;
+    static final Integer cache[];
+
+    static {
+        // high value may be configured by property
+        int h = 127;
+        String integerCacheHighPropValue =
+            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
+        if (integerCacheHighPropValue != null) {
+            try {
+                int i = parseInt(integerCacheHighPropValue);
+                i = Math.max(i, 127);
+                // Maximum array size is Integer.MAX_VALUE
+                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
+            } catch( NumberFormatException nfe) {
+                // If the property cannot be parsed into an int, ignore it.
             }
-            high = h;
-    
-            cache = new Integer[(high - low) + 1];
-            int j = low;
-            for(int k = 0; k < cache.length; k++)
-                cache[k] = new Integer(j++);
-    
-            // range [-128, 127] must be interned (JLS7 5.1.7)
-            assert IntegerCache.high >= 127;
         }
-    
-        private IntegerCache() {}
+        high = h;
+
+        cache = new Integer[(high - low) + 1];
+        int j = low;
+        for(int k = 0; k < cache.length; k++)
+            cache[k] = new Integer(j++);
+
+        // range [-128, 127] must be interned (JLS7 5.1.7)
+        assert IntegerCache.high >= 127;
     }
+
+    private IntegerCache() {}
+}
+````
+
 所以基本数据类型的包装类型可以在常量池查找对应值的对象，找不到就会自动在常量池创建该值的对象。
 
 而String类型可以通过intern来完成这个操作。
@@ -537,7 +537,6 @@ JDK1.7后，常量池被放入到堆空间中，这导致intern()函数的功能
 
 
 ```
-[java] view plain copy
 String s = new String("1");  
 s.intern();  
 String s2 = "1";  
@@ -554,9 +553,6 @@ JDK1.6以及以下：false false
 JDK1.7以及以上：false true
 ```
 
-![image](https://img-blog.csdn.net/20180422231916788?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MjQ4ODg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
-
-![image](https://img-blog.csdn.net/20180422231929413?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MjQ4ODg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
 JDK1.6查找到常量池存在相同值的对象时会直接返回该对象的地址。
 
 JDK 1.7后，intern方法还是会先去查询常量池中是否有已经存在，如果存在，则返回常量池中的引用，这一点与之前没有区别，区别在于，如果在常量池找不到对应的字符串，则不会再将字符串拷贝到常量池，而只是在常量池中生成一个对原字符串的引用。
@@ -581,23 +577,6 @@ https://blog.csdn.net/a724888/article/details/80033043
 
 <https://blog.csdn.net/yuhongye111/article/details/31850779>
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
 
 
 
diff --git "a/docs/java/basic/19\343\200\201Java\351\233\206\345\220\210\346\241\206\346\236\266\346\242\263\347\220\206.md" "b/docs/Java/basic/Java\351\233\206\345\220\210\346\241\206\346\236\266\346\242\263\347\220\206.md"
similarity index 67%
rename from "docs/java/basic/19\343\200\201Java\351\233\206\345\220\210\346\241\206\346\236\266\346\242\263\347\220\206.md"
rename to "docs/Java/basic/Java\351\233\206\345\220\210\346\241\206\346\236\266\346\242\263\347\220\206.md"
index 8ad5827..16fe721 100644
--- "a/docs/java/basic/19\343\200\201Java\351\233\206\345\220\210\346\241\206\346\236\266\346\242\263\347\220\206.md"
+++ "b/docs/Java/basic/Java\351\233\206\345\220\210\346\241\206\346\236\266\346\242\263\347\220\206.md"
@@ -26,9 +26,7 @@
       * [线程安全的阻塞队列](#线程安全的阻塞队列)
       * [同步队列](#同步队列)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 ---
 title: 夯实Java基础系列19：一文搞懂Java集合类框架，以及常见面试题
 date: 2019-9-19  15:56:26 # 文章生成时间，一般不改
@@ -61,8 +59,7 @@ tags:
 
 在编写java程序中，我们最常用的除了八种基本数据类型，String对象外还有一个集合类，在我们的的程序中到处充斥着集合类的身影！
 
-![image](https://img-blog.csdnimg.cn/20190222094403579.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dzE1MzE0MzkwOTA=,size_16,color_FFFFFF,t_70)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230403214433.png)
 java中集合大家族的成员实在是太丰富了，有常用的ArrayList、HashMap、HashSet，也有不常用的Stack、Queue，有线程安全的Vector、HashTable，也有线程不安全的LinkedList、TreeMap等等！
 
 ![](https://images0.cnblogs.com/blog/381060/201312/28124707-3a873160808e457686d67c118af6fa70.png)
@@ -90,63 +87,63 @@ java中集合大家族的成员实在是太丰富了，有常用的ArrayList、H
   在Java中所有实现了Collection接口的类都必须提供两套标准的构造函数，一个是无参，用于创建一个空的Collection，一个是带有Collection参数的有参构造函数，用于创建一个新的Collection，这个新的Collection与传入进来的Collection具备相同的元素。
 //要求实现基本的增删改查方法，并且需要能够转换为数组类型
 
+````
+public class Collection接口 {
+    class collect implements Collection {
 
-    public class Collection接口 {
-        class collect implements Collection {
-    
-            @Override
-            public int size() {
-                return 0;
-            }
-    
-            @Override
-            public boolean isEmpty() {
-                return false;
-            }
-    
-            @Override
-            public boolean contains(Object o) {
-                return false;
-            }
-    
-            @Override
-            public Iterator iterator() {
-                return null;
-            }
-    
-            @Override
-            public Object[] toArray() {
-                return new Object[0];
-            }
-    
-            @Override
-            public boolean add(Object o) {
-                return false;
-            }
-    
-            @Override
-            public boolean remove(Object o) {
-                return false;
-            }
-    
-            @Override
-            public boolean addAll(Collection c) {
-                return false;
-            }
-    
-            @Override
-            public void clear() {
-    
-            }
-    //省略部分代码  
-    
-            @Override
-            public Object[] toArray(Object[] a) {
-                return new Object[0];
-            }
+        @Override
+        public int size() {
+            return 0;
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return false;
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return false;
+        }
+
+        @Override
+        public Iterator iterator() {
+            return null;
+        }
+
+        @Override
+        public Object[] toArray() {
+            return new Object[0];
+        }
+
+        @Override
+        public boolean add(Object o) {
+            return false;
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            return false;
+        }
+
+        @Override
+        public boolean addAll(Collection c) {
+            return false;
         }
-    }
 
+        @Override
+        public void clear() {
+
+        }
+//省略部分代码  
+
+        @Override
+        public Object[] toArray(Object[] a) {
+            return new Object[0];
+        }
+    }
+}
+````
 ## List接口
 
 >   List接口为Collection直接接口。List所代表的是有序的Collection，即它用某种特定的插入顺序来维护元素顺序。用户可以对列表中每个元素的插入位置进行精确地控制，同时可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。实现List接口的集合主要有：ArrayList、LinkedList、Vector、Stack。
@@ -173,84 +170,84 @@ java中集合大家族的成员实在是太丰富了，有常用的ArrayList、H
 >
 > 2.4、Stack
 >    Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop 方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。。
+````
+public class List接口 {
+    //下面是List的继承关系，由于List接口规定了包括诸如索引查询，迭代器的实现，所以实现List接口的类都会有这些方法。
+    //所以不管是ArrayList和LinkedList底层都可以使用数组操作，但一般不提供这样外部调用方法。
+    //    public interface Iterable<T>
+//    public interface Collection<E> extends Iterable<E>
+//    public interface List<E> extends Collection<E>
+    class MyList implements List {
+
+        @Override
+        public int size() {
+            return 0;
+        }
 
-    public class List接口 {
-        //下面是List的继承关系，由于List接口规定了包括诸如索引查询，迭代器的实现，所以实现List接口的类都会有这些方法。
-        //所以不管是ArrayList和LinkedList底层都可以使用数组操作，但一般不提供这样外部调用方法。
-        //    public interface Iterable<T>
-    //    public interface Collection<E> extends Iterable<E>
-    //    public interface List<E> extends Collection<E>
-        class MyList implements List {
-    
-            @Override
-            public int size() {
-                return 0;
-            }
-    
-            @Override
-            public boolean isEmpty() {
-                return false;
-            }
-    
-            @Override
-            public boolean contains(Object o) {
-                return false;
-            }
-    
-            @Override
-            public Iterator iterator() {
-                return null;
-            }
-    
-            @Override
-            public Object[] toArray() {
-                return new Object[0];
-            }
-    
-            @Override
-            public boolean add(Object o) {
-                return false;
-            }
-    
-            @Override
-            public boolean remove(Object o) {
-                return false;
-            }
-    
-            @Override
-            public void clear() {
-    
-            }
-    
-           //省略部分代码
-           
-            @Override
-            public Object get(int index) {
-                return null;
-            }
-    
-            @Override
-            public ListIterator listIterator() {
-                return null;
-            }
-    
-            @Override
-            public ListIterator listIterator(int index) {
-                return null;
-            }
-    
-            @Override
-            public List subList(int fromIndex, int toIndex) {
-                return null;
-            }
-    
-            @Override
-            public Object[] toArray(Object[] a) {
-                return new Object[0];
-            }
+        @Override
+        public boolean isEmpty() {
+            return false;
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return false;
+        }
+
+        @Override
+        public Iterator iterator() {
+            return null;
+        }
+
+        @Override
+        public Object[] toArray() {
+            return new Object[0];
+        }
+
+        @Override
+        public boolean add(Object o) {
+            return false;
         }
-    }
 
+        @Override
+        public boolean remove(Object o) {
+            return false;
+        }
+
+        @Override
+        public void clear() {
+
+        }
+
+       //省略部分代码
+       
+        @Override
+        public Object get(int index) {
+            return null;
+        }
+
+        @Override
+        public ListIterator listIterator() {
+            return null;
+        }
+
+        @Override
+        public ListIterator listIterator(int index) {
+            return null;
+        }
+
+        @Override
+        public List subList(int fromIndex, int toIndex) {
+            return null;
+        }
+
+        @Override
+        public Object[] toArray(Object[] a) {
+            return new Object[0];
+        }
+    }
+}
+````
 ## Set接口
 
 > Set是一种不包括重复元素的Collection。它维持它自己的内部排序，所以随机访问没有任何意义。与List一样，它同样运行null的存在但是仅有一个。由于Set接口的特殊性，所有传入Set集合中的元素都必须不同，同时要注意任何可变对象，如果在对集合中元素进行操作时，导致e1.equals(e2)==true，则必定会产生某些问题。实现了Set接口的集合有：EnumSet、HashSet、TreeSet。
@@ -261,83 +258,84 @@ java中集合大家族的成员实在是太丰富了，有常用的ArrayList、H
 > 3.2、HashSet
 >    HashSet堪称查询速度最快的集合，因为其内部是以HashCode来实现的。它内部元素的顺序是由哈希码来决定的，所以它不保证set 的迭代顺序；特别是它不保证该顺序恒久不变。
 
-    public class Set接口 {
-        // Set接口规定将set看成一个集合，并且使用和数组类似的增删改查方式，同时提供iterator迭代器
-        //    public interface Set<E> extends Collection<E>
-        //    public interface Collection<E> extends Iterable<E>
-        //    public interface Iterable<T>
-        class MySet implements Set {
-    
-            @Override
-            public int size() {
-                return 0;
-            }
-    
-            @Override
-            public boolean isEmpty() {
-                return false;
-            }
-    
-            @Override
-            public boolean contains(Object o) {
-                return false;
-            }
-    
-            @Override
-            public Iterator iterator() {
-                return null;
-            }
-    
-            @Override
-            public Object[] toArray() {
-                return new Object[0];
-            }
-    
-            @Override
-            public boolean add(Object o) {
-                return false;
-            }
-    
-            @Override
-            public boolean remove(Object o) {
-                return false;
-            }
-    
-            @Override
-            public boolean addAll(Collection c) {
-                return false;
-            }
-    
-            @Override
-            public void clear() {
-    
-            }
-    
-            @Override
-            public boolean removeAll(Collection c) {
-                return false;
-            }
-    
-            @Override
-            public boolean retainAll(Collection c) {
-                return false;
-            }
-    
-            @Override
-            public boolean containsAll(Collection c) {
-                return false;
-            }
-    
-            @Override
-            public Object[] toArray(Object[] a) {
-                return new Object[0];
-            }
+````
+public class Set接口 {
+    // Set接口规定将set看成一个集合，并且使用和数组类似的增删改查方式，同时提供iterator迭代器
+    //    public interface Set<E> extends Collection<E>
+    //    public interface Collection<E> extends Iterable<E>
+    //    public interface Iterable<T>
+    class MySet implements Set {
+
+        @Override
+        public int size() {
+            return 0;
         }
-    }
 
+        @Override
+        public boolean isEmpty() {
+            return false;
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return false;
+        }
+
+        @Override
+        public Iterator iterator() {
+            return null;
+        }
+
+        @Override
+        public Object[] toArray() {
+            return new Object[0];
+        }
+
+        @Override
+        public boolean add(Object o) {
+            return false;
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            return false;
+        }
+
+        @Override
+        public boolean addAll(Collection c) {
+            return false;
+        }
+
+        @Override
+        public void clear() {
+
+        }
+
+        @Override
+        public boolean removeAll(Collection c) {
+            return false;
+        }
+
+        @Override
+        public boolean retainAll(Collection c) {
+            return false;
+        }
+
+        @Override
+        public boolean containsAll(Collection c) {
+            return false;
+        }
+
+        @Override
+        public Object[] toArray(Object[] a) {
+            return new Object[0];
+        }
+    }
+}
+````
 ## Map接口
 
->   Map与List、Set接口不同，它是由一系列键值对组成的集合，提供了key到Value的映射。同时它也没有继承Collection。在Map中它保证了key与value之间的一一对应关系。也就是说一个key对应一个value，所以它不能存在相同的key值，当然value值可以相同。实现map的有：HashMap、TreeMap、HashTable、Properties、EnumMap。
+> Map与List、Set接口不同，它是由一系列键值对组成的集合，提供了key到Value的映射。同时它也没有继承Collection。在Map中它保证了key与value之间的一一对应关系。也就是说一个key对应一个value，所以它不能存在相同的key值，当然value值可以相同。实现map的有：HashMap、TreeMap、HashTable、Properties、EnumMap。
 
 > 4.1、HashMap
 >    以哈希表数据结构实现，查找对象时通过哈希函数计算其位置，它是为快速查询而设计的，其内部定义了一个hash表数组（Entry[] table），元素会通过哈希转换函数将元素的哈希地址转换成数组中存放的索引，如果有冲突，则使用散列链表的形式将所有相同哈希地址的元素串起来，可能通过查看HashMap.Entry的源码它是一个单链表结构。
@@ -347,152 +345,152 @@ java中集合大家族的成员实在是太丰富了，有常用的ArrayList、H
 >
 > 4.3、HashTable
 >    也是以哈希表数据结构实现的，解决冲突时与HashMap也一样也是采用了散列链表的形式，不过性能比HashMap要低
+````
+public class Map接口 {
+    //Map接口是最上层接口，Map接口实现类必须实现put和get等哈希操作。
+    //并且要提供keyset和values，以及entryset等查询结构。
+    //public interface Map<K,V>
+    class MyMap implements Map {
+
+        @Override
+        public int size() {
+            return 0;
+        }
 
-    public class Map接口 {
-        //Map接口是最上层接口，Map接口实现类必须实现put和get等哈希操作。
-        //并且要提供keyset和values，以及entryset等查询结构。
-        //public interface Map<K,V>
-        class MyMap implements Map {
-    
-            @Override
-            public int size() {
-                return 0;
-            }
-    
-            @Override
-            public boolean isEmpty() {
-                return false;
-            }
-    
-            @Override
-            public boolean containsKey(Object key) {
-                return false;
-            }
-    
-            @Override
-            public boolean containsValue(Object value) {
-                return false;
-            }
-    
-            @Override
-            public Object get(Object key) {
-                return null;
-            }
-    
-            @Override
-            public Object put(Object key, Object value) {
-                return null;
-            }
-    
-            @Override
-            public Object remove(Object key) {
-                return null;
-            }
-    
-            @Override
-            public void putAll(Map m) {
-    
-            }
-    
-            @Override
-            public void clear() {
-    
-            }
-    
-            @Override
-            public Set keySet() {
-                return null;
-            }
-    
-            @Override
-            public Collection values() {
-                return null;
-            }
-    
-            @Override
-            public Set<Entry> entrySet() {
-                return null;
-            }
+        @Override
+        public boolean isEmpty() {
+            return false;
+        }
+
+        @Override
+        public boolean containsKey(Object key) {
+            return false;
+        }
+
+        @Override
+        public boolean containsValue(Object value) {
+            return false;
         }
-    }
 
+        @Override
+        public Object get(Object key) {
+            return null;
+        }
+
+        @Override
+        public Object put(Object key, Object value) {
+            return null;
+        }
+
+        @Override
+        public Object remove(Object key) {
+            return null;
+        }
+
+        @Override
+        public void putAll(Map m) {
+
+        }
+
+        @Override
+        public void clear() {
+
+        }
+
+        @Override
+        public Set keySet() {
+            return null;
+        }
+
+        @Override
+        public Collection values() {
+            return null;
+        }
+
+        @Override
+        public Set<Entry> entrySet() {
+            return null;
+        }
+    }
+}
+````
 ## Queue
 
 >   队列，它主要分为两大类，一类是阻塞式队列，队列满了以后再插入元素则会抛出异常，主要包括ArrayBlockQueue、PriorityBlockingQueue、LinkedBlockingQueue。另一种队列则是双端队列，支持在头、尾两端插入和移除元素，主要包括：ArrayDeque、LinkedBlockingDeque、LinkedList。
+````
+public class Queue接口 {
+    //queue接口是对队列的一个实现，需要提供队列的进队出队等方法。一般使用linkedlist作为实现类
+    class MyQueue implements Queue {
+
+        @Override
+        public int size() {
+            return 0;
+        }
 
-    public class Queue接口 {
-        //queue接口是对队列的一个实现，需要提供队列的进队出队等方法。一般使用linkedlist作为实现类
-        class MyQueue implements Queue {
-    
-            @Override
-            public int size() {
-                return 0;
-            }
-    
-            @Override
-            public boolean isEmpty() {
-                return false;
-            }
-    
-            @Override
-            public boolean contains(Object o) {
-                return false;
-            }
-    
-            @Override
-            public Iterator iterator() {
-                return null;
-            }
-    
-            @Override
-            public Object[] toArray() {
-                return new Object[0];
-            }
-    
-            @Override
-            public Object[] toArray(Object[] a) {
-                return new Object[0];
-            }
-    
-            @Override
-            public boolean add(Object o) {
-                return false;
-            }
-    
-            @Override
-            public boolean remove(Object o) {
-                return false;
-            }
-    
-            //省略部分代码
-            @Override
-            public boolean offer(Object o) {
-                return false;
-            }
-    
-            @Override
-            public Object remove() {
-                return null;
-            }
-    
-            @Override
-            public Object poll() {
-                return null;
-            }
-    
-            @Override
-            public Object element() {
-                return null;
-            }
-    
-            @Override
-            public Object peek() {
-                return null;
-            }
+        @Override
+        public boolean isEmpty() {
+            return false;
         }
-    }
 
+        @Override
+        public boolean contains(Object o) {
+            return false;
+        }
 
+        @Override
+        public Iterator iterator() {
+            return null;
+        }
+
+        @Override
+        public Object[] toArray() {
+            return new Object[0];
+        }
+
+        @Override
+        public Object[] toArray(Object[] a) {
+            return new Object[0];
+        }
+
+        @Override
+        public boolean add(Object o) {
+            return false;
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            return false;
+        }
+
+        //省略部分代码
+        @Override
+        public boolean offer(Object o) {
+            return false;
+        }
+
+        @Override
+        public Object remove() {
+            return null;
+        }
+
+        @Override
+        public Object poll() {
+            return null;
+        }
+
+        @Override
+        public Object element() {
+            return null;
+        }
+
+        @Override
+        public Object peek() {
+            return null;
+        }
+    }
+}
+
+````
 ## 关于Java集合的小抄
 
 这部分内容转自我偶像 江南白衣 的博客：http://calvin1978.blogcn.com/articles/collection.html
@@ -712,20 +710,3 @@ https://www.cnblogs.com/uodut/p/7067162.html
 https://www.jb51.net/article/135672.htm
 https://www.cnblogs.com/suiyue-/p/6052456.html
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/4\343\200\201final\345\205\263\351\224\256\345\255\227\347\211\271\346\200\247.md" "b/docs/Java/basic/final\345\205\263\351\224\256\345\255\227\347\211\271\346\200\247.md"
similarity index 90%
rename from "docs/java/basic/4\343\200\201final\345\205\263\351\224\256\345\255\227\347\211\271\346\200\247.md"
rename to "docs/Java/basic/final\345\205\263\351\224\256\345\255\227\347\211\271\346\200\247.md"
index f9c0f39..6b28474 100644
--- "a/docs/java/basic/4\343\200\201final\345\205\263\351\224\256\345\255\227\347\211\271\346\200\247.md"
+++ "b/docs/Java/basic/final\345\205\263\351\224\256\345\255\227\347\211\271\346\200\247.md"
@@ -18,9 +18,7 @@
     * [读 final 域的重排序规则](#读-final-域的重排序规则)
     * [如果 final 域是引用类型](#如果-final-域是引用类型)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -184,7 +182,7 @@ final方法的好处:
 2.  final变量在多线程中并发安全，无需额外的同步开销
 3.  final方法是静态编译的，提高了调用速度
 4.  **final类创建的对象是只可读的，在多线程可以安全共享**
-5.  
+
 ## final关键字的最佳实践
 
 ### final的用法 
@@ -198,7 +196,7 @@ final修饰的变量有三种：静态变量、实例变量和局部变量，分
 　另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。
 　
 但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。 
-
+````
     public class FinalTest { 
     final int p; 
     final int q=3; 
@@ -210,19 +208,20 @@ final修饰的变量有三种：静态变量、实例变量和局部变量，分
     q=i;//不能为一个final变量赋值 
     } 
     } 
-
+````
 ### final内存分配 
 刚提到了内嵌机制，现在详细展开。 
 要知道调用一个函数除了函数本身的执行时间之外，还需要额外的时间去寻找这个函数（类内部有一个函数签名和函数地址的映射表）。所以减少函数调用次数就等于降低了性能消耗。 
 
 final修饰的函数会被编译器优化，优化的结果是减少了函数调用的次数。如何实现的，举个例子给你看：
-
+````
     public class Test{ 
     final void func(){System.out.println("g");}; 
     public void main(String[] args){ 
     for(int j=0;j<1000;j++)   
     func(); 
     }} 
+
     经过编译器优化之后，这个类变成了相当于这样写： 
     public class Test{ 
     final void func(){System.out.println("g");}; 
@@ -230,7 +229,7 @@ final修饰的函数会被编译器优化，优化的结果是减少了函数调
     for(int j=0;j<1000;j++)  
     {System.out.println("g");} 
     }} 
-
+````
 看出来区别了吧？编译器直接将func的函数体内嵌到了调用函数的地方，这样的结果是节省了1000次函数调用，当然编译器处理成字节码，只是我们可以想象成这样，看个明白。 
 
 不过，当函数体太长的话，用final可能适得其反，因为经过编译器内嵌之后代码长度大大增加，于是就增加了jvm解释字节码的时间。
@@ -243,7 +242,7 @@ final修饰的函数会被编译器优化，优化的结果是减少了函数调
 
 见下面的测试代码，我会执行五次：
 
-
+````
     public class Test   
     {   
         public static void getJava()   
@@ -283,6 +282,7 @@ final修饰的函数会被编译器优化，优化的结果是减少了函数调
         }   
     }  
 
+````
 
     结果为： 
     第一次： 
@@ -308,13 +308,13 @@ final修饰的函数会被编译器优化，优化的结果是减少了函数调
     
     由以上运行结果不难看出，执行最快的是“正常的执行”即代码直接编写，而使用final修饰的方法，不像有些书上或者文章上所说的那样，速度与效率与“正常的执行”无异，而是位于第二位，最差的是调用不加final修饰的方法。 
 
-观点：加了比不加好一点。 
+    观点：加了比不加好一点。 
 
 
 ### 使用final修饰变量会让变量的值不能被改变吗； 
 见代码：
 
-
+````
     public class Final   
     {   
         public static void main(String[] args)   
@@ -335,18 +335,18 @@ final修饰的函数会被编译器优化，优化的结果是减少了函数调
     red blue yellow white 
     看！，黑色变成了白色。 
 
-
-​    
-​    在使用findbugs插件时，就会提示public static String[] color = { "red", "blue", "yellow", "black" };这行代码不安全，但加上final修饰，这行代码仍然是不安全的，因为final没有做到保证变量的值不会被修改！
-​    
-​    原因是：final关键字只能保证变量本身不能被赋与新值，而不能保证变量的内部结构不被修改。例如在main方法有如下代码Color.color = new String[]{""};就会报错了。
+````
+    
+    在使用findbugs插件时，就会提示public static String[] color = { "red", "blue", "yellow", "black" };这行代码不安全，但加上final修饰，这行代码仍然是不安全的，因为final没有做到保证变量的值不会被修改！
+    
+    原因是：final关键字只能保证变量本身不能被赋与新值，而不能保证变量的内部结构不被修改。例如在main方法有如下代码Color.color = new String[]{""};就会报错了。
 
 ### 如何保证数组内部不被修改
 
     那可能有的同学就会问了，加上final关键字不能保证数组不会被外部修改，那有什么方法能够保证呢？答案就是降低访问级别，把数组设为private。这样的话，就解决了数组在外部被修改的不安全性，但也产生了另一个问题，那就是这个数组要被外部使用的。 
 
 解决这个问题见代码：
-
+````
     import java.util.AbstractList;   
     import java.util.List;   
     
@@ -384,7 +384,7 @@ final修饰的函数会被编译器优化，优化的结果是减少了函数调
 
 
     }
-
+````
 这样就OK了，既保证了代码安全，又能让数组中的元素被访问了。
 
 
@@ -397,7 +397,7 @@ final修饰的函数会被编译器优化，优化的结果是减少了函数调
 规则3：父类中private final方法，子类可以重新定义，这种情况不是重写。
 
 代码示例
-
+````
     规则1代码
     
     public class FinalMethodTest
@@ -429,7 +429,7 @@ final修饰的函数会被编译器优化，优化的结果是减少了函数调
     	// 下面方法定义将不会出现问题
     	public void test(){}
     }
-
+````
 
 ## final 和 jvm的关系
 
@@ -439,8 +439,8 @@ final修饰的函数会被编译器优化，优化的结果是减少了函数调
 2.  初次读一个包含 final 域的对象的引用，与随后初次读这个 final 域，这两个操作之间不能重排序。
 
 下面，我们通过一些示例性的代码来分别说明这两个规则：
-
-<pre>public class FinalExample {
+````
+public class FinalExample {
     int i;                            // 普通变量 
     final int j;                      //final 变量 
     static FinalExample obj;
@@ -460,7 +460,7 @@ final修饰的函数会被编译器优化，优化的结果是减少了函数调
         int b = object.j;                // 读 final 域 
     }
 }
-</pre>
+````
 
 这里假设一个线程 A 执行 writer () 方法，随后另一个线程 B 执行 reader () 方法。下面我们通过这两个线程的交互来说明这两个规则。
 
@@ -478,11 +478,11 @@ final修饰的函数会被编译器优化，优化的结果是减少了函数调
 
 假设线程 B 读对象引用与读对象的成员域之间没有重排序（马上会说明为什么需要这个假设），下图是一种可能的执行时序：
 
-![](https://static001.infoq.cn/resource/image/66/3a/6628576a54f0ba625c8c3af4586cef3a.jpg)
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/6628576a54f0ba625c8c3af4586cef3a.jpg)
 
 在上图中，写普通域的操作被编译器重排序到了构造函数之外，读线程 B 错误的读取了普通变量 i 初始化之前的值。而写 final 域的操作，被写 final 域的重排序规则“限定”在了构造函数之内，读线程 B 正确的读取了 final 变量初始化之后的值。
 
-写 final 域的重排序规则可以确保：在对象引用为任意线程可见之前，对象的 final 域已经被正确初始化过了，而普通域不具有这个保障。以上图为例，在读线程 B“看到”对象引用 obj 时，很可能 obj 对象还没有构造完成（对普通域 i 的写操作被重排序到构造函数外，此时初始值 2 还没有写入普通域 i）。
+写 final 域的重排序规则可以确保：在对象引用为任意线程可见之前，对象的 final 域已经被正确初始化过了，而普通域不具有这个保障。以上图为例，在读线程 B“看到”对象引用 obj 时，很可能 obj 对象还没有构造完成（对普通域 i 的写操作被重排序到构造函数外，此时初始值 1 还没有写入普通域 i）。
 
 ### 读 final 域的重排序规则
 
@@ -495,8 +495,8 @@ final修饰的函数会被编译器优化，优化的结果是减少了函数调
 reader() 方法包含三个操作：
 
 1.  初次读引用变量 obj;
-2.  初次读引用变量 obj 指向对象的普通域 j。
-3.  初次读引用变量 obj 指向对象的 final 域 i。
+2.  初次读引用变量 obj 指向对象的普通域 i。
+3.  初次读引用变量 obj 指向对象的 final 域 j。
 
 现在我们假设写线程 A 没有发生任何重排序，同时程序在不遵守间接依赖的处理器上执行，下面是一种可能的执行时序：
 
@@ -511,8 +511,8 @@ reader() 方法包含三个操作：
 上面我们看到的 final 域是基础数据类型，下面让我们看看如果 final 域是引用类型，将会有什么效果？
 
 请看下列示例代码：
-
-<pre>public class FinalReferenceExample {
+````
+public class FinalReferenceExample {
 final int[] intArray;                     //final 是引用类型 
 static FinalReferenceExample obj;
 
@@ -535,7 +535,7 @@ public static void reader () {              // 读线程 C 执行
     }
 }
 }
-</pre>
+````
 
 这里 final 域为一个引用类型，它引用一个 int 型的数组对象。对于引用类型，写 final 域的重排序规则对编译器和处理器增加了如下约束：
 
@@ -543,14 +543,14 @@ public static void reader () {              // 读线程 C 执行
 
 对上面的示例程序，我们假设首先线程 A 执行 writerOne() 方法，执行完后线程 B 执行 writerTwo() 方法，执行完后线程 C 执行 reader () 方法。下面是一种可能的线程执行时序：
 
-![](https://static001.infoq.cn/resource/image/29/db/29b097c36fd531028991826bb7c835db.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/29b097c36fd531028991826bb7c835db.png)
 在上图中，1 是对 final 域的写入，2 是对这个 final 域引用的对象的成员域的写入，3 是把被构造的对象的引用赋值给某个引用变量。这里除了前面提到的 1 不能和 3 重排序外，2 和 3 也不能重排序。
 
 JMM 可以确保读线程 C 至少能看到写线程 A 在构造函数中对 final 引用对象的成员域的写入。即 C 至少能看到数组下标 0 的值为 1。而写线程 B 对数组元素的写入，读线程 C 可能看的到，也可能看不到。JMM 不保证线程 B 的写入对读线程 C 可见，因为写线程 B 和读线程 C 之间存在数据竞争，此时的执行结果不可预知。
 
 如果想要确保读线程 C 看到写线程 B 对数组元素的写入，写线程 B 和读线程 C 之间需要使用同步原语（lock 或 volatile）来确保内存可见性。
 
+
 ## 参考文章
 
 https://www.infoq.cn/article/java-memory-model-6
@@ -561,20 +561,4 @@ https://www.iteye.com/blog/cakin24-2334965
 https://blog.csdn.net/chengqiuming/article/details/70139503
 https://blog.csdn.net/hupuxiang/article/details/7362267
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/20\343\200\201javac\345\222\214javap.md" "b/docs/Java/basic/javac\345\222\214javap.md"
similarity index 74%
rename from "docs/java/basic/20\343\200\201javac\345\222\214javap.md"
rename to "docs/Java/basic/javac\345\222\214javap.md"
index dde513d..f797af7 100644
--- "a/docs/java/basic/20\343\200\201javac\345\222\214javap.md"
+++ "b/docs/Java/basic/javac\345\222\214javap.md"
@@ -18,28 +18,10 @@
       * [-encoding](#-encoding)
       * [-verbose](#-verbose)
       * [其他命令](#其他命令)
-  * [使用javac构建项目](#使用javac构建项目)
-                    * [](#)
-* [java文件列表目录](#java文件列表目录)
-                        * [放入列表文件中](#放入列表文件中)
-                * [生成bin目录](#生成bin目录)
-                * [列表](#列表)
-    * [通过-cp指定所有的引用jar包，将src下的所有java文件进行编译](#通过-cp指定所有的引用jar包，将src下的所有java文件进行编译)
-    * [通过-cp指定所有的引用jar包，指定入口函数运行](#通过-cp指定所有的引用jar包，指定入口函数运行)
+    * [使用javac构建项目](#使用javac构建项目)
   * [javap 的使用](#javap-的使用)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
----
-title: 夯实Java基础系列20：从IDE的实现原理聊起，谈谈那些年我们用过的Java命令
-date: 2019-9-20 15:56:26 # 文章生成时间，一般不改
-categories:
-    - Java技术江湖
-    - Java基础
-tags:
-    - Java命令行
----
+
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -81,119 +63,119 @@ java提供了JavaCompiler，我们可以通过它来编译java源文件为class
 通过上面一个查找class，得到Class对象后，可以通过newInstance()或构造器的newInstance()得到对象。然后得到Method，最后调用方法，传入相关参数即可。
 
 示例代码：
-
-    public class MyIDE {
-    
-        public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
-            // 定义java代码，并保存到文件（Test.java）
-            StringBuilder sb = new StringBuilder();
-            sb.append("package com.tommy.core.test.reflect;\n");
-            sb.append("public class Test {\n");
-            sb.append("    private String name;\n");
-            sb.append("    public Test(String name){\n");
-            sb.append("        this.name = name;\n");
-            sb.append("        System.out.println(\"hello,my name is \" + name);\n");
-            sb.append("    }\n");
-            sb.append("    public String sayHello(String name) {\n");
-            sb.append("        return \"hello,\" + name;\n");
-            sb.append("    }\n");
-            sb.append("}\n");
-    
-            System.out.println(sb.toString());
-    
-            String baseOutputDir = "F:\\output\\classes\\";
-            String baseDir = baseOutputDir + "com\\tommy\\core\\test\\reflect\\";
-            String targetJavaOutputPath = baseDir + "Test.java";
-            // 保存为java文件
-            FileWriter fileWriter = new FileWriter(targetJavaOutputPath);
-            fileWriter.write(sb.toString());
-            fileWriter.flush();
-            fileWriter.close();
-    
-            // 编译为class文件
-            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
-            StandardJavaFileManager manager = compiler.getStandardFileManager(null,null,null);
-            List<File> files = new ArrayList<>();
-            files.add(new File(targetJavaOutputPath));
-            Iterable compilationUnits = manager.getJavaFileObjectsFromFiles(files);
-    
-            // 编译
-            // 设置编译选项，配置class文件输出路径
-            Iterable<String> options = Arrays.asList("-d",baseOutputDir);
-            JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, options, null, compilationUnits);
-            // 执行编译任务
-            task.call();
-
-
-​    
-​            // 通过反射得到对象
-​    //        Class clazz = Class.forName("com.tommy.core.test.reflect.Test");
-​            // 使用自定义的类加载器加载class
-​            Class clazz = new MyClassLoader(baseOutputDir).loadClass("com.tommy.core.test.reflect.Test");
-​            // 得到构造器
-​            Constructor constructor = clazz.getConstructor(String.class);
-​            // 通过构造器new一个对象
-​            Object test = constructor.newInstance("jack.tsing");
-​            // 得到sayHello方法
-​            Method method = clazz.getMethod("sayHello", String.class);
-​            // 调用sayHello方法
-​            String result = (String) method.invoke(test, "jack.ma");
-​            System.out.println(result);
-​        }
-​    }
-
+````
+public class MyIDE {
+
+    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
+        // 定义java代码，并保存到文件（Test.java）
+        StringBuilder sb = new StringBuilder();
+        sb.append("package com.tommy.core.test.reflect;\n");
+        sb.append("public class Test {\n");
+        sb.append("    private String name;\n");
+        sb.append("    public Test(String name){\n");
+        sb.append("        this.name = name;\n");
+        sb.append("        System.out.println(\"hello,my name is \" + name);\n");
+        sb.append("    }\n");
+        sb.append("    public String sayHello(String name) {\n");
+        sb.append("        return \"hello,\" + name;\n");
+        sb.append("    }\n");
+        sb.append("}\n");
+
+        System.out.println(sb.toString());
+
+        String baseOutputDir = "F:\\output\\classes\\";
+        String baseDir = baseOutputDir + "com\\tommy\\core\\test\\reflect\\";
+        String targetJavaOutputPath = baseDir + "Test.java";
+        // 保存为java文件
+        FileWriter fileWriter = new FileWriter(targetJavaOutputPath);
+        fileWriter.write(sb.toString());
+        fileWriter.flush();
+        fileWriter.close();
+
+        // 编译为class文件
+        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+        StandardJavaFileManager manager = compiler.getStandardFileManager(null,null,null);
+        List<File> files = new ArrayList<>();
+        files.add(new File(targetJavaOutputPath));
+        Iterable compilationUnits = manager.getJavaFileObjectsFromFiles(files);
+
+        // 编译
+        // 设置编译选项，配置class文件输出路径
+        Iterable<String> options = Arrays.asList("-d",baseOutputDir);
+        JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, options, null, compilationUnits);
+        // 执行编译任务
+        task.call();
+
+
+   
+        // 通过反射得到对象
+//        Class clazz = Class.forName("com.tommy.core.test.reflect.Test");
+        // 使用自定义的类加载器加载class
+        Class clazz = new MyClassLoader(baseOutputDir).loadClass("com.tommy.core.test.reflect.Test");
+        // 得到构造器
+        Constructor constructor = clazz.getConstructor(String.class);
+        // 通过构造器new一个对象
+        Object test = constructor.newInstance("jack.tsing");
+        // 得到sayHello方法
+        Method method = clazz.getMethod("sayHello", String.class);
+        // 调用sayHello方法
+        String result = (String) method.invoke(test, "jack.ma");
+        System.out.println(result);
+    }
+}
+````
 自定义类加载器代码：
 
+````
+    
+public class MyClassLoader extends ClassLoader {
+    private String baseDir;
+    public MyClassLoader(String baseDir) {
+        this.baseDir = baseDir;
+    }
+    @Override
+    protected Class<?> findClass(String name) throws ClassNotFoundException {
+        String fullClassFilePath = this.baseDir + name.replace("\\.","/") + ".class";
+        File classFilePath = new File(fullClassFilePath);
+        if (classFilePath.exists()) {
+            FileInputStream fileInputStream = null;
+            ByteArrayOutputStream byteArrayOutputStream = null;
+            try {
+                fileInputStream = new FileInputStream(classFilePath);
+                byte[] data = new byte[1024];
+                int len = -1;
+                byteArrayOutputStream = new ByteArrayOutputStream();
+                while ((len = fileInputStream.read(data)) != -1) {
+                    byteArrayOutputStream.write(data,0,len);
+                }
 
-​    
-​    public class MyClassLoader extends ClassLoader {
-​        private String baseDir;
-​        public MyClassLoader(String baseDir) {
-​            this.baseDir = baseDir;
-​        }
-​        @Override
-​        protected Class<?> findClass(String name) throws ClassNotFoundException {
-​            String fullClassFilePath = this.baseDir + name.replace("\\.","/") + ".class";
-​            File classFilePath = new File(fullClassFilePath);
-​            if (classFilePath.exists()) {
-​                FileInputStream fileInputStream = null;
-​                ByteArrayOutputStream byteArrayOutputStream = null;
-​                try {
-​                    fileInputStream = new FileInputStream(classFilePath);
-​                    byte[] data = new byte[1024];
-​                    int len = -1;
-​                    byteArrayOutputStream = new ByteArrayOutputStream();
-​                    while ((len = fileInputStream.read(data)) != -1) {
-​                        byteArrayOutputStream.write(data,0,len);
-​                    }
-​    
-                    return defineClass(name,byteArrayOutputStream.toByteArray(),0,byteArrayOutputStream.size());
-                } catch (FileNotFoundException e) {
-                    e.printStackTrace();
-                } catch (IOException e) {
-                    e.printStackTrace();
-                } finally {
-                    if (null != fileInputStream) {
-                        try {
-                            fileInputStream.close();
-                        } catch (IOException e) {
-                            e.printStackTrace();
-                        }
+                return defineClass(name,byteArrayOutputStream.toByteArray(),0,byteArrayOutputStream.size());
+            } catch (FileNotFoundException e) {
+                e.printStackTrace();
+            } catch (IOException e) {
+                e.printStackTrace();
+            } finally {
+                if (null != fileInputStream) {
+                    try {
+                        fileInputStream.close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
                     }
-    
-                    if (null != byteArrayOutputStream) {
-                        try {
-                            byteArrayOutputStream.close();
-                        } catch (IOException e) {
-                            e.printStackTrace();
-                        }
+                }
+
+                if (null != byteArrayOutputStream) {
+                    try {
+                        byteArrayOutputStream.close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
                     }
                 }
             }
-            return super.findClass(name);
         }
-    }    
-
+        return super.findClass(name);
+    }
+}    
+````
 ## javac命令初窥
 
 注：以下红色标记的参数在下文中有所讲解。
@@ -316,7 +298,7 @@ javac：如果当前你要编译的java文件中引用了其它的类(比如说
 > 这里展示一个web项目的.classpath
 
 Xml代码
-
+````
     <?xml version="1.0" encoding="UTF-8"?>
     <classpath>
     <classpathentry kind="src" path="src"/>
@@ -328,7 +310,7 @@ Xml代码
          ……
     <classpathentry kind="output" path="webapp/WEB-INF/classes"/>
     </classpath>
-
+````
 > XML文档包含一个根元素，就是classpath，类路径，那么这里面包含了什么信息呢？子元素是classpathentry，kind属性区别了种 类信息，src源码，con你看看后面的path就知道是JRE容器的信息。lib是项目依赖的第三方类库，output是src编译后的位置。
 
 > 既然是web项目，那么就是WEB-INF/classes目录，可能用MyEclipse的同学会说他们那里是WebRoot或者是WebContext而不是webapp，有区别么？回答：完全没有！
@@ -393,27 +375,27 @@ Xml代码
 举个例子，
 
 
-
-    public class A
-    {
-        public static void main(String[] args) {
-            B b = new B();
-            b.print();
-        }
+````
+public class A
+{
+    public static void main(String[] args) {
+        B b = new B();
+        b.print();
     }
+}
 
 
-​    
-​    
-​    public class B
-​    {
-​        public void print()
-​        {
-​            System.out.println("old");
-​        }
-​    }
 
 
+public class B
+{
+    public void print()
+    {
+        System.out.println("old");
+    }
+}
+````
+
 目录结构如下：
 
 
@@ -451,19 +433,19 @@ sourcepath          //此处为当前目录
 这里我用来实现一下这个功能，假设项目名称为project，此目录为当前目录，且在src/com目录中有一个Main.java文件。‘
 
 
-​    
-​    package com;
-​    public class Main
-​    {
-​        public static void main(String[] args) {
-​            System.out.println("Hello");
-​        }
-​    }
+````  
+    package com;
+    public class Main
+    {
+        public static void main(String[] args) {
+            System.out.println("Hello");
+        }
+    }
 
 
-​    
-​    
-​    javac -d bin src/com/Main.java
+````    
+    
+javac -d bin src/com/Main.java
 
 上面的语句将Main.class生成在bin/com目录下。
 
@@ -472,23 +454,23 @@ sourcepath          //此处为当前目录
 •如果有文件为A.java（其中有类A），且在类A中使用了类B，类B在B.java中，则编译A.java时，默认会自动编译B.java，且生成B.class。
 •implicit:none：不自动生成隐式引用的类文件。
 •implicit:class（默认）：自动生成隐式引用的类文件。
-
-    public class A
-    {
-        public static void main(String[] args) {
-            B b = new B();
-        }
+````
+public class A
+{
+    public static void main(String[] args) {
+        B b = new B();
     }
-    
-    public class B
-    {
-    }
-    
-    如果使用：
+}
+
+public class B
+{
+}
+````
+如果使用：
 
 
-​    
-​     javac -implicit:none A.java
+    
+javac -implicit:none A.java
 
 则不会生成 B.class。
 
@@ -578,18 +560,18 @@ src/com/yp/test/HelloWorld.java
 build/
 
 
-```
+````
 ├─build
 └─src
     └─com
         └─yp
             └─test
                     HelloWorld.java
-```
+````
 
 
 java文件非常简单
-
+````
     package com.yp.test;
     public class HelloWorld {
     
@@ -597,12 +579,14 @@ java文件非常简单
             System.out.println("helloWorld");
         }
     }
+````
+
 编译:
 javac src/com/yp/test/HelloWorld.java -d build
 
 -d 表示编译到 build文件夹下
 
-```
+````
 查看build文件夹
 ├─build
 │  └─com
@@ -615,10 +599,11 @@ javac src/com/yp/test/HelloWorld.java -d build
         └─yp
             └─test
                     HelloWorld.java
-```
+````
 
 
 运行文件
+
 > E:\codeplace\n_learn\java\javacmd> java com/yp/test/HelloWorld.class
 > 错误: 找不到或无法加载主类 build.com.yp.test.HelloWorld.class
 >
@@ -677,27 +662,28 @@ javac src/com/yp/test/HelloWorld.java -d build
 
 先下一个jar包 这里直接下 log4j 
     
-    * main函数改成
-    
-    import com.yp.test.entity.Cat;
-    import org.apache.log4j.Logger;
-    
-    public class HelloWorld {
-    
-        static Logger log = Logger.getLogger(HelloWorld.class);
-    
-        public static void main(String[] args) {
-            Cat c = new Cat("keyboard");
-            log.info("这是log4j");
-            System.out.println("hello," + c.getName());
-        }
-    
+* main函数改成
+
+````    
+import com.yp.test.entity.Cat;
+import org.apache.log4j.Logger;
+
+public class HelloWorld {
+
+    static Logger log = Logger.getLogger(HelloWorld.class);
+
+    public static void main(String[] args) {
+        Cat c = new Cat("keyboard");
+        log.info("这是log4j");
+        System.out.println("hello," + c.getName());
     }
 
+}
+````
 现的文件是这样的
 
 
-```
+````
 ├─build
 ├─lib
 │      log4j-1.2.17.jar
@@ -710,8 +696,7 @@ javac src/com/yp/test/HelloWorld.java -d build
                 │
                 └─entity
                         Cat.java
-```
-
+````
 
     这个时候 javac命令要接上 -cp ./lib/*.jar
     E:\codeplace\n_learn\java\javacmd>javac -encoding "utf8" src/com/yp/test/HelloWorld.java -sourcepath src -d build -g -cp ./lib/*.jar
@@ -729,21 +714,22 @@ javac src/com/yp/test/HelloWorld.java -d build
 
 由于没有 log4j的配置文件，所以提示上面的问题,往 build 里面加上 log4j.xml
 
-    <?xml version="1.0" encoding="UTF-8" ?>
-    <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
-    <log4j:configuration xmlns:log4j='http://jakarta.apache.org/log4j/'>
-        <appender name="stdout" class="org.apache.log4j.ConsoleAppender">
-            <layout class="org.apache.log4j.PatternLayout">
-                <param name="ConversionPattern" value="%d{ABSOLUTE} %-5p [%c{1}] %m%n" />
-            </layout>
-        </appender>
-    
-        <root>
-            <level value="info" />
-            <appender-ref ref="stdout" />
-        </root>
-    </log4j:configuration>
-
+````
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
+<log4j:configuration xmlns:log4j='http://jakarta.apache.org/log4j/'>
+    <appender name="stdout" class="org.apache.log4j.ConsoleAppender">
+        <layout class="org.apache.log4j.PatternLayout">
+            <param name="ConversionPattern" value="%d{ABSOLUTE} %-5p [%c{1}] %m%n" />
+        </layout>
+    </appender>
+
+    <root>
+        <level value="info" />
+        <appender-ref ref="stdout" />
+    </root>
+</log4j:configuration>
+````
 再运行
 
     E:\codeplace\n_learn\java\javacmd>java -cp lib/log4j-1.2.17.jar;build com.yp.tes t.HelloWorld
@@ -757,7 +743,7 @@ ok 一个简单的java 工程就运行完了
 但是  貌似有些繁琐,  需要手动键入 java文件 以及相应的jar包 很是麻烦,
 so 可以用 shell 来脚本来简化相关操作 
 shell 文件整理如下:
-
+````
     #!/bin/bash  
     echo "build start"  
       
@@ -788,6 +774,7 @@ shell 文件整理如下:
       
     #运行 通过-cp指定所有的引用jar包，指定入口函数运行
     java -cp $BIN_PATH$jarfile com.zuiapps.danmaku.server.Main  
+````
 
 > 有一点需要注意的是,  javac -d $BIN_PATH/ -cp $jarfile @$SRC_FILE_LIST_PATH
 > 在要编译的文件很多时候，一个个敲命令会显得很长，也不方便修改，
@@ -805,7 +792,7 @@ shell 文件整理如下:
        1.需要吧 编译时设置的bin目录和 所有jar包加入到 classpath 中去
 
 
-​    
+    
 ## javap 的使用
 
 > javap是jdk自带的一个工具，可以对代码反编译，也可以查看java编译器生成的字节码。
@@ -815,37 +802,37 @@ shell 文件整理如下:
 > 
 >
 > javap命令分解一个class文件，它根据options来决定到底输出什么。如果没有使用options,那么javap将会输出包，类里的protected和public域以及类里的所有方法。javap将会把它们输出在标准输出上。来看这个例子，先编译(javac)下面这个类。
-
-    import java.awt.*;
-    import java.applet.*;
-     
-    public class DocFooter extends Applet {
-            String date;
-            String email;
-     
-            public void init() {
-                    resize(500,100);
-                    date = getParameter("LAST_UPDATED");
-                    email = getParameter("EMAIL");
-            }
-    }
-
+````
+import java.awt.*;
+import java.applet.*;
+ 
+public class DocFooter extends Applet {
+        String date;
+        String email;
+ 
+        public void init() {
+                resize(500,100);
+                date = getParameter("LAST_UPDATED");
+                email = getParameter("EMAIL");
+        }
+}
+````
 在命令行上键入javap DocFooter后，输出结果如下
 
 
 Compiled from "DocFooter.java"
-
-    public class DocFooter extends java.applet.Applet {
-      java.lang.String date;
-      java.lang.String email;
-      public DocFooter();
-      public void init();
-    }
-
+````
+public class DocFooter extends java.applet.Applet {
+  java.lang.String date;
+  java.lang.String email;
+  public DocFooter();
+  public void init();
+}
+````
 如果加入了-c，即javap -c DocFooter，那么输出结果如下
 
 Compiled from "DocFooter.java"
-
+````
     public class DocFooter extends java.applet.Applet {
       java.lang.String date;
      
@@ -876,6 +863,7 @@ Compiled from "DocFooter.java"
           29: return       
     
     }
+````
 上面输出的内容就是字节码。
 
 用法摘要
@@ -903,20 +891,3 @@ https://www.jianshu.com/p/6a8997560b05
 https://blog.csdn.net/w372426096/article/details/81664431
 https://blog.csdn.net/qincidong/article/details/82492140
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/3\343\200\201string\345\222\214\345\214\205\350\243\205\347\261\273.md" "b/docs/Java/basic/string\345\222\214\345\214\205\350\243\205\347\261\273.md"
similarity index 50%
rename from "docs/java/basic/3\343\200\201string\345\222\214\345\214\205\350\243\205\347\261\273.md"
rename to "docs/Java/basic/string\345\222\214\345\214\205\350\243\205\347\261\273.md"
index 13dfe0a..9adf53e 100644
--- "a/docs/java/basic/3\343\200\201string\345\222\214\345\214\205\350\243\205\347\261\273.md"
+++ "b/docs/Java/basic/string\345\222\214\345\214\205\350\243\205\347\261\273.md"
@@ -27,9 +27,7 @@
     * [不可变有什么好处？](#不可变有什么好处？)
   * [String常用工具类](#string常用工具类)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 
@@ -46,11 +44,8 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-
-
 <!-- more -->
 
-
 ## string基础
 
 ### Java String 类
@@ -70,9 +65,14 @@ String greeting = "菜鸟教程";
 String 类有 11 种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数:
 
 ### StringDemo.java 文件代码：
-
-    public class StringDemo{    public static void main(String args[]){       char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};       String helloString = new String(helloArray);         System.out.println( helloString );    } }
-
+````
+public class StringDemo{    
+public static void main(String args[]){       
+char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};       
+String helloString = new String(helloArray);         
+System.out.println( helloString );    
+} }
+````
 以上实例编译运行结果如下：
 
 ```
@@ -87,35 +87,37 @@ runoob
 
 ###  创建String对象的常用方法
 
-（1） String s1 = "mpptest"
+(1) String s1 = "mpptest"
 
-  (2)  String s2 = new String();
+(2) String s2 = new String();
 
-  (3) String s3 = new String("mpptest")
+(3) String s3 = new String("mpptest")
 
 ### String中常用的方法，用法如图所示，具体问度娘
 
 ![](https://img2018.cnblogs.com/blog/710412/201902/710412-20190213220237169-1966705420.png)
 
 ### 三个方法的使用： lenth()   substring()   charAt()
-
-
-
-<pre>package com.mpp.string; public class StringDemo1 { public static void main(String[] args) { //定义一个字符串"晚来天欲雪 能饮一杯无"
+````
+package com.mpp.string; 
+public class StringDemo1 {
+    public static void main(String[] args) { //定义一个字符串"晚来天欲雪 能饮一杯无"
         String str = "晚来天欲雪 能饮一杯无";
         System.out.println("字符串的长度是："+str.length()); //字符串的雪字打印输出  charAt(int index)
         System.out.println(str.charAt(4)); //取出子串  天欲
         System.out.println(str.substring(2));   //取出从index2开始直到最后的子串，包含2
         System.out.println(str.substring(2,4));  //取出index从2到4的子串，包含2不包含4  顾头不顾尾
- }
-}</pre>
-
-
+    }
+}
+````
 
- 两个方法的使用,求字符或子串第一次/最后一次在字符串中出现的位置： indexOf()   lastIndexOf()  
 
+两个方法的使用,求字符或子串第一次/最后一次在字符串中出现的位置： 
+indexOf()   lastIndexOf()  
 
-<pre>package com.mpp.string; public class StringDemo2 { public static void main(String[] args) {
+````
+package com.mpp.string; public class StringDemo2 { 
+    public static void main(String[] args) {
         String str = new String("赵客缦胡缨 吴钩胡缨霜雪明"); //查找胡在字符串中第一次出现的位置
         System.out.println("\"胡\"在字符串中第一次出现的位置："+str.indexOf("胡")); //查找子串"胡缨"在字符串中第一次出现的位置
         System.out.println("\"胡缨\"在字符串中第一次出现的位置"+str.indexOf("胡缨")); //查找胡在字符串中最后一次次出现的位置
@@ -123,35 +125,40 @@ runoob
         System.out.println(str.lastIndexOf("胡缨")); //从indexof为5的位置，找第一次出现的"吴"
         System.out.println(str.indexOf("吴",5));
     }
-}</pre>
-
+}
+````
 
 
 
 ### 字符串与byte数组间的相互转换
 
-
-<pre>package com.mpp.string; import java.io.UnsupportedEncodingException; public class StringDemo3 { public static void main(String[] args) throws UnsupportedEncodingException { //字符串和byte数组之间的相互转换
- String str = new String("hhhabc银鞍照白马 飒沓如流星"); //将字符串转换为byte数组，并打印输出
-        byte[] arrs = str.getBytes("GBK"); for(int i=0;i){
+````
+package com.mpp.string; import java.io.UnsupportedEncodingException; 
+public class StringDemo3 { 
+    public static void main(String[] args) throws UnsupportedEncodingException { 
+        
+        //字符串和byte数组之间的相互转换
+        String str = new String("hhhabc银鞍照白马 飒沓如流星"); //将字符串转换为byte数组，并打印输出
+        byte[] arrs = str.getBytes("GBK"); 
+        for(int i=0;i){
             System.out.print(arrs[i]);
-        } //将byte数组转换成字符串
- System.out.println();
+        } 
+        
+        //将byte数组转换成字符串
+        System.out.println();
         String str1 = new String(arrs,"GBK");  //保持字符集的一致，否则会出现乱码
- System.out.println(str1);
+        System.out.println(str1);
     }
-}</pre>
-
+}
+````
 
 ### ==运算符和equals之间的区别：
 
-<pre>引用指向的内容和引用指向的地址</pre>
+引用指向的内容和引用指向的地址
 
-![](https://img2018.cnblogs.com/blog/710412/201902/710412-20190214223341972-1204335921.png)
-
-
-
-<pre>package com.mpp.string; public class StringDemo5 { public static void main(String[] args) {
+````
+package com.mpp.string; public class StringDemo5 { 
+    public static void main(String[] args) {
         String str1 = "mpp";
         String str2 = "mpp";
         String str3 = new String("mpp");
@@ -160,9 +167,9 @@ runoob
         System.out.println(str1.equals(str3));   //true  内容相同
         System.out.println(str1==str2);   //true   地址相同
         System.out.println(str1==str3);   //false  地址不同
- }
-}</pre>
-
+    }
+}
+````
 
 ### 字符串的不可变性
 
@@ -170,7 +177,7 @@ String的对象一旦被创建，则不能修改，是不可变的
 
 所谓的修改其实是创建了新的对象，所指向的内存空间不变
 
-![](https://img2018.cnblogs.com/blog/710412/201902/710412-20190214224055939-746946317.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/blog/Java%E6%8A%80%E6%9C%AF%E6%B1%9F%E6%B9%96/%E4%BA%8C%E7%BB%B4%E7%A0%81/710412-20190214224055939-746946317.png)
 
 上图中，s1不再指向imooc所在的内存空间，而是指向了hello,imooc
 ### String的连接
@@ -218,85 +225,86 @@ String str = "aa"+"bb"+"cc";
 ## String类的源码分析
 
 ### String类型的intern
-
-    public void intern () {
-        //2：string的intern使用
-        //s1是基本类型，比较值。s2是string实例，比较实例地址
-        //字符串类型用equals方法比较时只会比较值
-        String s1 = "a";
-        String s2 = new String("a");
-        //调用intern时,如果s2中的字符不在常量池，则加入常量池并返回常量的引用
-        String s3 = s2.intern();
-        System.out.println(s1 == s2);
-        System.out.println(s1 == s3);
-    }
-
+````
+public void intern () {
+    //2：string的intern使用
+    //s1是基本类型，比较值。s2是string实例，比较实例地址
+    //字符串类型用equals方法比较时只会比较值
+    String s1 = "a";
+    String s2 = new String("a");
+    //调用intern时,如果s2中的字符不在常量池，则加入常量池并返回常量的引用
+    String s3 = s2.intern();
+    System.out.println(s1 == s2);
+    System.out.println(s1 == s3);
+}
+````
 ### String类型的equals
-
-    //字符串的equals方法
-    //    public boolean equals(Object anObject) {
-    //            if (this == anObject) {
-    //                return true;
-    //            }
-    //            if (anObject instanceof String) {
-    //                String anotherString = (String)anObject;
-    //                int n = value.length;
-    //                if (n == anotherString.value.length) {
-    //                    char v1[] = value;
-    //                    char v2[] = anotherString.value;
-    //                    int i = 0;
-    //                    while (n-- != 0) {
-    //                        if (v1[i] != v2[i])
-    //                            return false;
-    //                        i++;
-    //                    }
-    //                    return true;
-    //                }
-    //            }
-    //            return false;
-    //        }
-
+````
+//字符串的equals方法
+//    public boolean equals(Object anObject) {
+//            if (this == anObject) {
+//                return true;
+//            }
+//            if (anObject instanceof String) {
+//                String anotherString = (String)anObject;
+//                int n = value.length;
+//                if (n == anotherString.value.length) {
+//                    char v1[] = value;
+//                    char v2[] = anotherString.value;
+//                    int i = 0;
+//                    while (n-- != 0) {
+//                        if (v1[i] != v2[i])
+//                            return false;
+//                        i++;
+//                    }
+//                    return true;
+//                }
+//            }
+//            return false;
+//        }
+````
 ### StringBuffer和Stringbuilder
 底层是继承父类的可变字符数组value
+````
+/**
+
+- The value is used for character storage.
+  */
+  char[] value;
+  初始化容量为16
+
+/**
+
+- Constructs a string builder with no characters in it and an
+- initial capacity of 16 characters.
+  */
+  public StringBuilder() {
+  super(16);
+  }
+  这两个类的append方法都是来自父类AbstractStringBuilder的方法
+
+public AbstractStringBuilder append(String str) {
+    if (str == null)
+        return appendNull();
+    int len = str.length();
+    ensureCapacityInternal(count + len);
+    str.getChars(0, len, value, count);
+    count += len;
+    return this;
+}
+@Override
+public StringBuilder append(String str) {
+    super.append(str);
+    return this;
+}
 
-    /**
-    
-    - The value is used for character storage.
-      */
-      char[] value;
-      初始化容量为16
-    
-    /**
-    
-    - Constructs a string builder with no characters in it and an
-    - initial capacity of 16 characters.
-      */
-      public StringBuilder() {
-      super(16);
-      }
-      这两个类的append方法都是来自父类AbstractStringBuilder的方法
-    
-    public AbstractStringBuilder append(String str) {
-        if (str == null)
-            return appendNull();
-        int len = str.length();
-        ensureCapacityInternal(count + len);
-        str.getChars(0, len, value, count);
-        count += len;
-        return this;
-    }
-    @Override
-    public StringBuilder append(String str) {
-        super.append(str);
-        return this;
-    }
-    
-    @Override
-    public synchronized StringBuffer append(String str) {
-        toStringCache = null;
-        super.append(str);
-        return this;
-    }
+@Override
+public synchronized StringBuffer append(String str) {
+    toStringCache = null;
+    super.append(str);
+    return this;
+}
+````
 
 ### append方法
 Stringbuffer在大部分涉及字符串修改的操作上加了synchronized关键字来保证线程安全，效率较低。
@@ -312,19 +320,19 @@ a = a + a;时，实际上先把a封装成stringbuilder，调用append方法后
 
 ensureCapacityInternal(count + len);
 该方法是计算append之后的空间是否足够，不足的话需要进行扩容
-
-    public void ensureCapacity(int minimumCapacity) {
-        if (minimumCapacity > 0)
-            ensureCapacityInternal(minimumCapacity);
-    }
-    private void ensureCapacityInternal(int minimumCapacity) {
-        // overflow-conscious code
-        if (minimumCapacity - value.length > 0) {
-            value = Arrays.copyOf(value,
-                    newCapacity(minimumCapacity));
-        }
+````
+public void ensureCapacity(int minimumCapacity) {
+    if (minimumCapacity > 0)
+        ensureCapacityInternal(minimumCapacity);
+}
+private void ensureCapacityInternal(int minimumCapacity) {
+    // overflow-conscious code
+    if (minimumCapacity - value.length > 0) {
+        value = Arrays.copyOf(value,
+                newCapacity(minimumCapacity));
     }
-
+}
+````
 如果新字符串长度大于value数组长度则进行扩容
 
 扩容后的长度一般为原来的两倍 + 2；
@@ -334,42 +342,39 @@ ensureCapacityInternal(count + len);
 考虑两种情况
 
 如果新的字符串长度超过int最大值，则抛出异常，否则直接使用数组最大长度作为新数组的长度。
-
-    private int hugeCapacity(int minCapacity) {
-        if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
-            throw new OutOfMemoryError();
-        }
-        return (minCapacity > MAX_ARRAY_SIZE)
-            ? minCapacity : MAX_ARRAY_SIZE;
+````
+private int hugeCapacity(int minCapacity) {
+    if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
+        throw new OutOfMemoryError();
     }
-
+    return (minCapacity > MAX_ARRAY_SIZE)
+        ? minCapacity : MAX_ARRAY_SIZE;
+}
+````
 ### 删除
 这两个类型的删除操作：
 
 都是调用父类的delete方法进行删除
-
-    public AbstractStringBuilder delete(int start, int end) {
-        if (start < 0)
-            throw new StringIndexOutOfBoundsException(start);
-        if (end > count)
-            end = count;
-        if (start > end)
-            throw new StringIndexOutOfBoundsException();
-        int len = end - start;
-        if (len > 0) {
-            System.arraycopy(value, start+len, value, start, count-end);
-            count -= len;
-        }
-        return this;
-    }
-
+````
+public AbstractStringBuilder delete(int start, int end) {
+    if (start < 0)
+        throw new StringIndexOutOfBoundsException(start);
+    if (end > count)
+        end = count;
+    if (start > end)
+        throw new StringIndexOutOfBoundsException();
+    int len = end - start;
+    if (len > 0) {
+        System.arraycopy(value, start+len, value, start, count-end);
+        count -= len;
+    }
+    return this;
+}
+````
 事实上是将剩余的字符重新拷贝到字符数组value。
 
 这里用到了system.arraycopy来拷贝数组，速度是比较快的
 
-
-
-
 ### system.arraycopy方法
 转自知乎：
 
@@ -386,37 +391,26 @@ ensureCapacityInternal(count + len);
 
 ## String和JVM的关系
 
-
-
-
 下面我们了解下Java栈、Java堆、方法区和常量池：
 
- 
-
 Java栈（线程私有数据区）：
 
 ```
     每个Java虚拟机线程都有自己的Java虚拟机栈，Java虚拟机栈用来存放栈帧，每个方法被执行的时候都会同时创建一个栈帧（Stack Frame）用于存储局部变量表、操作栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。
 ```
 
- 
-
 Java堆（线程共享数据区）：
 
 ```
    在虚拟机启动时创建，此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配。
 ```
 
- 
-
 方法区（线程共享数据区）：
 
 ```
    方法区在虚拟机启动的时候被创建，它存储了每一个类的结构信息，例如运行时常量池、字段和方法数据、构造函数和普通方法的字节码内容、还包括在类、实例、接口初始化时用到的特殊方法。在JDK8之前永久代是方法区的一种实现，而JDK8元空间替代了永久代，永久代被移除，也可以理解为元空间是方法区的一种实现。
 ```
 
- 
-
 常量池（线程共享数据区）：
 
 ```
@@ -437,23 +431,18 @@ Java堆（线程共享数据区）：
     使用字符串常量池，每当我们使用字面量（String s=”1”;）创建字符串常量时，JVM会首先检查字符串常量池，如果该字符串已经存在常量池中，那么就将此字符串对象的地址赋值给引用s（引用s在Java栈中）。如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中，并将此字符串对象的地址赋值给引用s（引用s在Java栈中）。
 ```
 
- 
-
 ```
     使用字符串常量池，每当我们使用关键字new（String s=new String(”1”);）创建字符串常量时，JVM会首先检查字符串常量池，如果该字符串已经存在常量池中，那么不再在字符串常量池创建该字符串对象，而直接堆中复制该对象的副本，然后将堆中对象的地址赋值给引用s，如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中，然后在堆中复制该对象的副本，然后将堆中对象的地址赋值给引用s。
 ```
 
-
-
-
 ## String为什么不可变？
 翻开JDK源码，java.lang.String类起手前三行，是这样写的：
-
-    public final class String implements java.io.Serializable, Comparable<String>, CharSequence {   
-      /** String本质是个char数组. 而且用final关键字修饰.*/     
-    private final char value[];  ...  ...
-     } 
-
+````
+public final class String implements java.io.Serializable, Comparable<String>, CharSequence {   
+  /** String本质是个char数组. 而且用final关键字修饰.*/     
+private final char value[];  ...  ...
+ } 
+````
 首先String类是用final关键字修饰，这说明String不可继承。再看下面，String类的主力成员字段value是个char[]数组，而且是用final修饰的。
 
 final修饰的字段创建以后就不可改变。 有的人以为故事就这样完了，其实没有。因为虽然value是不可变，也只是value这个引用地址不可变。挡不住Array数组是可变的事实。
@@ -463,16 +452,16 @@ Array的数据结构看下图。
 也就是说Array变量只是stack上的一个引用，数组的本体结构在heap堆。
 
 String类里的value用final修饰，只是说stack里的这个叫value的引用地址不可变。没有说堆里array本身数据不可变。看下面这个例子，
-
-    final int[] value={1,2,3} ；
-    int[] another={4,5,6};
-     value=another;    //编译器报错，final不可变 value用final修饰，编译器不允许我把value指向堆区另一个地址。
-    但如果我直接对数组元素动手，分分钟搞定。
-    
-     final int[] value={1,2,3};
-     value[2]=100;  //这时候数组里已经是{1,2,100}   所以String是不可变，关键是因为SUN公司的工程师。
-     在后面所有String的方法里很小心的没有去动Array里的元素，没有暴露内部成员字段。private final char value[]这一句里，private的私有访问权限的作用都比final大。而且设计师还很小心地把整个String设成final禁止继承，避免被其他人继承后破坏。所以String是不可变的关键都在底层的实现，而不是一个final。考验的是工程师构造数据类型，封装数据的功力。 
-
+````
+final int[] value={1,2,3} ；
+int[] another={4,5,6};
+ value=another;    //编译器报错，final不可变 value用final修饰，编译器不允许我把value指向堆区另一个地址。
+但如果我直接对数组元素动手，分分钟搞定。
+
+ final int[] value={1,2,3};
+ value[2]=100;  //这时候数组里已经是{1,2,100}   所以String是不可变，关键是因为SUN公司的工程师。
+ 在后面所有String的方法里很小心的没有去动Array里的元素，没有暴露内部成员字段。private final char value[]这一句里，private的私有访问权限的作用都比final大。而且设计师还很小心地把整个String设成final禁止继承，避免被其他人继承后破坏。所以String是不可变的关键都在底层的实现，而不是一个final。考验的是工程师构造数据类型，封装数据的功力。 
+````
 ### 不可变有什么好处？
 这个最简单地原因，就是为了安全。看下面这个场景（有评论反应例子不够清楚，现在完整地写出来），一个函数appendStr( )在不可变的String参数后面加上一段“bbb”后返回。appendSb( )负责在可变的StringBuilder后面加“bbb”。
 
@@ -485,28 +474,28 @@ String类里的value用final修饰，只是说stack里的这个叫value的引用
 > 3 final修饰的char数组保证了char数组的引用不可变。但是可以通过char[0] = 'a’来修改值。不过String内部并不提供方法来完成这一操作，所以String的不可变也是基于代码封装和访问控制的。
 
 举个例子
+````
+final class Fi {
+    int a;
+    final int b = 0;
+    Integer s;
 
-    final class Fi {
-        int a;
-        final int b = 0;
-        Integer s;
-    
-    }
-    final char[]a = {'a'};
-    final int[]b = {1};
-    @Test
-    public void final修饰类() {
-        //引用没有被final修饰，所以是可变的。
-        //final只修饰了Fi类型，即Fi实例化的对象在堆中内存地址是不可变的。
-        //虽然内存地址不可变，但是可以对内部的数据做改变。
-        Fi f = new Fi();
-        f.a = 1;
-        System.out.println(f);
-        f.a = 2;
-        System.out.println(f);
-        //改变实例中的值并不改变内存地址。
-
-```
+}
+final char[]a = {'a'};
+final int[]b = {1};
+@Test
+public void final修饰类() {
+    //引用没有被final修饰，所以是可变的。
+    //final只修饰了Fi类型，即Fi实例化的对象在堆中内存地址是不可变的。
+    //虽然内存地址不可变，但是可以对内部的数据做改变。
+    Fi f = new Fi();
+    f.a = 1;
+    System.out.println(f);
+    f.a = 2;
+    System.out.println(f);
+    //改变实例中的值并不改变内存地址。
+````
+````
 Fi ff = f;
 //让引用指向新的Fi对象，原来的f对象由新的引用ff持有。
 //引用的指向改变也不会改变原来对象的地址
@@ -515,7 +504,7 @@ System.out.println(f);
 System.out.println(ff);
 
 }
-```
+````
 
 这里的对f.a的修改可以理解为char[0] = 'a'这样的操作。只改变数据值，不改变内存值。
 
@@ -523,301 +512,288 @@ System.out.println(ff);
 问题描述
 很多时候我们需要对字符串进行很多固定的操作,而这些操作在JDK/JRE中又没有预置,于是我们想到了apache-commons组件,但是它也不能完全覆盖我们的业务需求,所以很多时候还是要自己写点代码的,下面就是基于apache-commons组件写的部分常用方法:
 
-    MAVEN依赖
+
+````
     <dependency>
     	<groupId>org.apache.commons</groupId>
     	<artifactId>commons-lang3</artifactId>
     	<version>${commons-lang3.version}</version>
      </dependency>
+````
 
 代码成果
 
-    public class StringUtils extends org.apache.commons.lang3.StringUtils {
-    
-    /** 值为"NULL"的字符串 */
-    private static final String NULL_STRING = "NULL";
-    
-    private static final char SEPARATOR = '_';
-
-
-    /**
-     * 满足一下情况返回true<br/>
-     * ①.入参为空
-     * ②.入参为空字符串
-     * ③.入参为"null"字符串
-     *
-     * @param string 需要判断的字符型
-     * @return boolean
-     */
-    public static boolean isNullOrEmptyOrNULLString(String string) {
-        return isBlank(string) || NULL_STRING.equalsIgnoreCase(string);
-    }
-    
-    /**
-     * 把字符串转为二进制码<br/>
-     * 本方法不会返回null
-     *
-     * @param str 需要转换的字符串
-     * @return 二进制字节码数组
-     */
-    public static byte[] toBytes(String str) {
-        return isBlank(str) ? new byte[]{} : str.getBytes();
-    }
-    
-    /**
-     * 把字符串转为二进制码<br/>
-     * 本方法不会返回null
-     *
-     * @param str     需要转换的字符串
-     * @param charset 编码类型
-     * @return 二进制字节码数组
-     * @throws UnsupportedEncodingException 字符串转换的时候编码不支持时出现
-     */
-    public static byte[] toBytes(String str, Charset charset) throws UnsupportedEncodingException {
-        return isBlank(str) ? new byte[]{} : str.getBytes(charset.displayName());
-    }
-    
-    /**
-     * 把字符串转为二进制码<br/>
-     * 本方法不会返回null
-     *
-     * @param str     需要转换的字符串
-     * @param charset 编码类型
-     * @param locale  编码类型对应的地区
-     * @return 二进制字节码数组
-     * @throws UnsupportedEncodingException 字符串转换的时候编码不支持时出现
-     */
-    public static byte[] toBytes(String str, Charset charset, Locale locale) throws UnsupportedEncodingException {
-        return isBlank(str) ? new byte[]{} : str.getBytes(charset.displayName(locale));
-    }
-    
-    /**
-     * 二进制码转字符串<br/>
-     * 本方法不会返回null
-     *
-     * @param bytes 二进制码
-     * @return 字符串
-     */
-    public static String bytesToString(byte[] bytes) {
-        return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes);
-    }
-    
-    /**
-     * 二进制码转字符串<br/>
-     * 本方法不会返回null
-     *
-     * @param bytes   二进制码
-     * @param charset 编码集
-     * @return 字符串
-     * @throws UnsupportedEncodingException 当前二进制码可能不支持传入的编码
-     */
-    public static String byteToString(byte[] bytes, Charset charset) throws UnsupportedEncodingException {
-        return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes, charset.displayName());
-    }
-    
-    /**
-     * 二进制码转字符串<br/>
-     * 本方法不会返回null
-     *
-     * @param bytes   二进制码
-     * @param charset 编码集
-     * @param locale  本地化
-     * @return 字符串
-     * @throws UnsupportedEncodingException 当前二进制码可能不支持传入的编码
-     */
-    public static String byteToString(byte[] bytes, Charset charset, Locale locale) throws UnsupportedEncodingException {
-        return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes, charset.displayName(locale));
-    }
-    
-    /**
-     * 把对象转为字符串
-     *
-     * @param object 需要转化的字符串
-     * @return 字符串, 可能为空
-     */
-    public static String parseString(Object object) {
-        if (object == null) {
-            return null;
-        }
-        if (object instanceof byte[]) {
-            return bytesToString((byte[]) object);
-        }
-        return object.toString();
-    }
-    
-    /**
-     * 把字符串转为int类型
-     *
-     * @param str 需要转化的字符串
-     * @return int
-     * @throws NumberFormatException 字符串格式不正确时抛出
-     */
-    public static int parseInt(String str) throws NumberFormatException {
-        return isBlank(str) ? 0 : Integer.parseInt(str);
-    }
-    
-    /**
-     * 把字符串转为double类型
-     *
-     * @param str 需要转化的字符串
-     * @return double
-     * @throws NumberFormatException 字符串格式不正确时抛出
-     */
-    public static double parseDouble(String str) throws NumberFormatException {
-        return isBlank(str) ? 0D : Double.parseDouble(str);
-    }
-    
-    /**
-     * 把字符串转为long类型
-     *
-     * @param str 需要转化的字符串
-     * @return long
-     * @throws NumberFormatException 字符串格式不正确时抛出
-     */
-    public static long parseLong(String str) throws NumberFormatException {
-        return isBlank(str) ? 0L : Long.parseLong(str);
+````
+public class StringUtils extends org.apache.commons.lang3.StringUtils {
+
+/** 值为"NULL"的字符串 */
+private static final String NULL_STRING = "NULL";
+
+private static final char SEPARATOR = '_';
+
+
+/**
+ * 满足一下情况返回true<br/>
+ * ①.入参为空
+ * ②.入参为空字符串
+ * ③.入参为"null"字符串
+ *
+ * @param string 需要判断的字符型
+ * @return boolean
+ */
+public static boolean isNullOrEmptyOrNULLString(String string) {
+    return isBlank(string) || NULL_STRING.equalsIgnoreCase(string);
+}
+
+/**
+ * 把字符串转为二进制码<br/>
+ * 本方法不会返回null
+ *
+ * @param str 需要转换的字符串
+ * @return 二进制字节码数组
+ */
+public static byte[] toBytes(String str) {
+    return isBlank(str) ? new byte[]{} : str.getBytes();
+}
+
+/**
+ * 把字符串转为二进制码<br/>
+ * 本方法不会返回null
+ *
+ * @param str     需要转换的字符串
+ * @param charset 编码类型
+ * @return 二进制字节码数组
+ * @throws UnsupportedEncodingException 字符串转换的时候编码不支持时出现
+ */
+public static byte[] toBytes(String str, Charset charset) throws UnsupportedEncodingException {
+    return isBlank(str) ? new byte[]{} : str.getBytes(charset.displayName());
+}
+
+/**
+ * 把字符串转为二进制码<br/>
+ * 本方法不会返回null
+ *
+ * @param str     需要转换的字符串
+ * @param charset 编码类型
+ * @param locale  编码类型对应的地区
+ * @return 二进制字节码数组
+ * @throws UnsupportedEncodingException 字符串转换的时候编码不支持时出现
+ */
+public static byte[] toBytes(String str, Charset charset, Locale locale) throws UnsupportedEncodingException {
+    return isBlank(str) ? new byte[]{} : str.getBytes(charset.displayName(locale));
+}
+
+/**
+ * 二进制码转字符串<br/>
+ * 本方法不会返回null
+ *
+ * @param bytes 二进制码
+ * @return 字符串
+ */
+public static String bytesToString(byte[] bytes) {
+    return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes);
+}
+
+/**
+ * 二进制码转字符串<br/>
+ * 本方法不会返回null
+ *
+ * @param bytes   二进制码
+ * @param charset 编码集
+ * @return 字符串
+ * @throws UnsupportedEncodingException 当前二进制码可能不支持传入的编码
+ */
+public static String byteToString(byte[] bytes, Charset charset) throws UnsupportedEncodingException {
+    return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes, charset.displayName());
+}
+
+/**
+ * 二进制码转字符串<br/>
+ * 本方法不会返回null
+ *
+ * @param bytes   二进制码
+ * @param charset 编码集
+ * @param locale  本地化
+ * @return 字符串
+ * @throws UnsupportedEncodingException 当前二进制码可能不支持传入的编码
+ */
+public static String byteToString(byte[] bytes, Charset charset, Locale locale) throws UnsupportedEncodingException {
+    return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes, charset.displayName(locale));
+}
+
+/**
+ * 把对象转为字符串
+ *
+ * @param object 需要转化的字符串
+ * @return 字符串, 可能为空
+ */
+public static String parseString(Object object) {
+    if (object == null) {
+        return null;
     }
-    
-    /**
-     * 把字符串转为float类型
-     *
-     * @param str 需要转化的字符串
-     * @return float
-     * @throws NumberFormatException 字符串格式不正确时抛出
-     */
-    public static float parseFloat(String str) throws NumberFormatException {
-        return isBlank(str) ? 0L : Float.parseFloat(str);
+    if (object instanceof byte[]) {
+        return bytesToString((byte[]) object);
     }
-    
-    /**
-     * 获取i18n字符串
-     *
-     * @param code
-     * @param args
-     * @return
-     */
-    public static String getI18NMessage(String code, Object[] args) {
-        //LocaleResolver localLocaleResolver = (LocaleResolver) SpringContextHolder.getBean(LocaleResolver.class);
-        //HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
-        //Locale locale = localLocaleResolver.resolveLocale(request);
-        //return SpringContextHolder.getApplicationContext().getMessage(code, args, locale);
+    return object.toString();
+}
+
+/**
+ * 把字符串转为int类型
+ *
+ * @param str 需要转化的字符串
+ * @return int
+ * @throws NumberFormatException 字符串格式不正确时抛出
+ */
+public static int parseInt(String str) throws NumberFormatException {
+    return isBlank(str) ? 0 : Integer.parseInt(str);
+}
+
+/**
+ * 把字符串转为double类型
+ *
+ * @param str 需要转化的字符串
+ * @return double
+ * @throws NumberFormatException 字符串格式不正确时抛出
+ */
+public static double parseDouble(String str) throws NumberFormatException {
+    return isBlank(str) ? 0D : Double.parseDouble(str);
+}
+
+/**
+ * 把字符串转为long类型
+ *
+ * @param str 需要转化的字符串
+ * @return long
+ * @throws NumberFormatException 字符串格式不正确时抛出
+ */
+public static long parseLong(String str) throws NumberFormatException {
+    return isBlank(str) ? 0L : Long.parseLong(str);
+}
+
+/**
+ * 把字符串转为float类型
+ *
+ * @param str 需要转化的字符串
+ * @return float
+ * @throws NumberFormatException 字符串格式不正确时抛出
+ */
+public static float parseFloat(String str) throws NumberFormatException {
+    return isBlank(str) ? 0L : Float.parseFloat(str);
+}
+
+/**
+ * 获取i18n字符串
+ *
+ * @param code
+ * @param args
+ * @return
+ */
+public static String getI18NMessage(String code, Object[] args) {
+    //LocaleResolver localLocaleResolver = (LocaleResolver) SpringContextHolder.getBean(LocaleResolver.class);
+    //HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
+    //Locale locale = localLocaleResolver.resolveLocale(request);
+    //return SpringContextHolder.getApplicationContext().getMessage(code, args, locale);
+    return "";
+}
+
+/**
+ * 获得用户远程地址
+ *
+ * @param request 请求头
+ * @return 用户ip
+ */
+public static String getRemoteAddr(HttpServletRequest request) {
+    String remoteAddr = request.getHeader("X-Real-IP");
+    if (isNotBlank(remoteAddr)) {
+        remoteAddr = request.getHeader("X-Forwarded-For");
+    } else if (isNotBlank(remoteAddr)) {
+        remoteAddr = request.getHeader("Proxy-Client-IP");
+    } else if (isNotBlank(remoteAddr)) {
+        remoteAddr = request.getHeader("WL-Proxy-Client-IP");
+    }
+    return remoteAddr != null ? remoteAddr : request.getRemoteAddr();
+}
+
+/**
+ * 驼峰命名法工具
+ *
+ * @return toCamelCase(" hello_world ") == "helloWorld"
+ * toCapitalizeCamelCase("hello_world") == "HelloWorld"
+ * toUnderScoreCase("helloWorld") = "hello_world"
+ */
+public static String toCamelCase(String s, Locale locale, char split) {
+    if (isBlank(s)) {
         return "";
     }
-    
-    /**
-     * 获得用户远程地址
-     *
-     * @param request 请求头
-     * @return 用户ip
-     */
-    public static String getRemoteAddr(HttpServletRequest request) {
-        String remoteAddr = request.getHeader("X-Real-IP");
-        if (isNotBlank(remoteAddr)) {
-            remoteAddr = request.getHeader("X-Forwarded-For");
-        } else if (isNotBlank(remoteAddr)) {
-            remoteAddr = request.getHeader("Proxy-Client-IP");
-        } else if (isNotBlank(remoteAddr)) {
-            remoteAddr = request.getHeader("WL-Proxy-Client-IP");
-        }
-        return remoteAddr != null ? remoteAddr : request.getRemoteAddr();
-    }
-    
-    /**
-     * 驼峰命名法工具
-     *
-     * @return toCamelCase(" hello_world ") == "helloWorld"
-     * toCapitalizeCamelCase("hello_world") == "HelloWorld"
-     * toUnderScoreCase("helloWorld") = "hello_world"
-     */
-    public static String toCamelCase(String s, Locale locale, char split) {
-        if (isBlank(s)) {
-            return "";
-        }
-    
-        s = s.toLowerCase(locale);
-    
-        StringBuilder sb = new StringBuilder();
-        for (char c : s.toCharArray()) {
-            sb.append(c == split ? Character.toUpperCase(c) : c);
-        }
-    
-        return sb.toString();
-    }
-    
-    public static String toCamelCase(String s) {
-        return toCamelCase(s, Locale.getDefault(), SEPARATOR);
-    }
-    
-    public static String toCamelCase(String s, Locale locale) {
-        return toCamelCase(s, locale, SEPARATOR);
-    }
-    
-    public static String toCamelCase(String s, char split) {
-        return toCamelCase(s, Locale.getDefault(), split);
-    }
-    
-    public static String toUnderScoreCase(String s, char split) {
-        if (isBlank(s)) {
-            return "";
-        }
-    
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < s.length(); i++) {
-            char c = s.charAt(i);
-            boolean nextUpperCase = (i < (s.length() - 1)) && Character.isUpperCase(s.charAt(i + 1));
-            boolean upperCase = (i > 0) && Character.isUpperCase(c);
-            sb.append((!upperCase || !nextUpperCase) ? split : "").append(Character.toLowerCase(c));
-        }
-    
-        return sb.toString();
-    }
-    
-    public static String toUnderScoreCase(String s) {
-        return toUnderScoreCase(s, SEPARATOR);
-    }
-    
-    /**
-     * 把字符串转换为JS获取对象值的三目运算表达式
-     *
-     * @param objectString 对象串
-     *                     例如：入参:row.user.id/返回：!row?'':!row.user?'':!row.user.id?'':row.user.id
-     */
-    public static String toJsGetValueExpression(String objectString) {
-        StringBuilder result = new StringBuilder();
-        StringBuilder val = new StringBuilder();
-        String[] fileds = split(objectString, ".");
-        for (int i = 0; i < fileds.length; i++) {
-            val.append("." + fileds[i]);
-            result.append("!" + (val.substring(1)) + "?'':");
-        }
-        result.append(val.substring(1));
-        return result.toString();
-    }
 
+    s = s.toLowerCase(locale);
 
+    StringBuilder sb = new StringBuilder();
+    for (char c : s.toCharArray()) {
+        sb.append(c == split ? Character.toUpperCase(c) : c);
     }
 
-## 参考文章
-https://blog.csdn.net/qq_34490018/article/details/82110578
-https://www.runoob.com/java/java-string.html
-https://www.cnblogs.com/zhangyinhua/p/7689974.html
-https://blog.csdn.net/sinat_21925975/article/details/86493248
-https://www.cnblogs.com/niew/p/9597379.html
+    return sb.toString();
+}
 
-## 微信公众号
+public static String toCamelCase(String s) {
+    return toCamelCase(s, Locale.getDefault(), SEPARATOR);
+}
 
-### Java技术江湖
+public static String toCamelCase(String s, Locale locale) {
+    return toCamelCase(s, locale, SEPARATOR);
+}
 
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
+public static String toCamelCase(String s, char split) {
+    return toCamelCase(s, Locale.getDefault(), split);
+}
 
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
+public static String toUnderScoreCase(String s, char split) {
+    if (isBlank(s)) {
+        return "";
+    }
 
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < s.length(); i++) {
+        char c = s.charAt(i);
+        boolean nextUpperCase = (i < (s.length() - 1)) && Character.isUpperCase(s.charAt(i + 1));
+        boolean upperCase = (i > 0) && Character.isUpperCase(c);
+        sb.append((!upperCase || !nextUpperCase) ? split : "").append(Character.toLowerCase(c));
+    }
 
-### 个人公众号：黄小斜
+    return sb.toString();
+}
 
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
+public static String toUnderScoreCase(String s) {
+    return toUnderScoreCase(s, SEPARATOR);
+}
 
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
+/**
+ * 把字符串转换为JS获取对象值的三目运算表达式
+ *
+ * @param objectString 对象串
+ * 例如：入参:row.user.id/返回：!row?'':!row.user?'':!row.user.id?'':row.user.id
+ */
+public static String toJsGetValueExpression(String objectString) {
+    StringBuilder result = new StringBuilder();
+    StringBuilder val = new StringBuilder();
+    String[] fileds = split(objectString, ".");
+    for (int i = 0; i < fileds.length; i++) {
+        val.append("." + fileds[i]);
+        result.append("!" + (val.substring(1)) + "?'':");
+    }
+    result.append(val.substring(1));
+    return result.toString();
+}
+
+
+}
+````
+
+## 参考文章
+https://blog.csdn.net/qq_34490018/article/details/82110578
+https://www.runoob.com/java/java-string.html
+https://www.cnblogs.com/zhangyinhua/p/7689974.html
+https://blog.csdn.net/sinat_21925975/article/details/86493248
+https://www.cnblogs.com/niew/p/9597379.html
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/7\343\200\201\344\273\243\347\240\201\345\235\227\345\222\214\344\273\243\347\240\201\346\211\247\350\241\214\351\241\272\345\272\217.md" "b/docs/Java/basic/\344\273\243\347\240\201\345\235\227\345\222\214\344\273\243\347\240\201\346\211\247\350\241\214\351\241\272\345\272\217.md"
similarity index 89%
rename from "docs/java/basic/7\343\200\201\344\273\243\347\240\201\345\235\227\345\222\214\344\273\243\347\240\201\346\211\247\350\241\214\351\241\272\345\272\217.md"
rename to "docs/Java/basic/\344\273\243\347\240\201\345\235\227\345\222\214\344\273\243\347\240\201\346\211\247\350\241\214\351\241\272\345\272\217.md"
index 09dc5b5..7ebb784 100644
--- "a/docs/java/basic/7\343\200\201\344\273\243\347\240\201\345\235\227\345\222\214\344\273\243\347\240\201\346\211\247\350\241\214\351\241\272\345\272\217.md"
+++ "b/docs/Java/basic/\344\273\243\347\240\201\345\235\227\345\222\214\344\273\243\347\240\201\346\211\247\350\241\214\351\241\272\345\272\217.md"
@@ -17,9 +17,7 @@
     * [静态代码块](#静态代码块)
   * [Java代码块、构造方法（包含继承关系）的执行顺序](#java代码块、构造方法（包含继承关系）的执行顺序)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -40,20 +38,20 @@
 ## Java中的构造方法
 ### 构造方法简介
 
-构造方法是类的一种特殊方法，用来初始化类的一个新的对象。[Java](http://c.biancheng.net/java/) 中的每个类都有一个默认的构造方法，它必须具有和类名相同的名称，而且没有返回类型。构造方法的默认返回类型就是对象类型本身，并且构造方法不能被 static、final、synchronized、abstract 和 native 修饰。
+构造方法是类的一种特殊方法，用来初始化类的一个新的对象。[Java](http://c.biancheng.net/java/)中的每个类都有一个默认的构造方法，它必须具有和类名相同的名称，而且没有返回类型。构造方法的默认返回类型就是对象类型本身，并且构造方法不能被 static、final、synchronized、abstract 和 native 修饰。
 
 提示：构造方法用于初始化一个新对象，所以用 static 修饰没有意义；构造方法不能被子类继承，所以用 final 和 abstract 修饰没有意义；多个线程不会同时创建内存地址相同的同一个对象，所以用 synchronized 修饰没有必要。
 
 构造方法的语法格式如下：
-
-<pre>class class_name
+````
+class class_name
 {
     public class_name(){}    //默认无参构造方法
     public ciass_name([paramList]){}    //定义构造方法
     …
     //类主体
-}</pre>
-
+}
+````
 在一个类中，与类名相同的方法就是构造方法。每个类可以具有多个构造方法，但要求它们各自包含不同的方法参数。
 
 ### 构造方法实例
@@ -61,8 +59,8 @@
 #### 例 1
 
 构造方法主要有无参构造方法和有参构造方法两种，示例如下：
-
-<pre>public class MyClass
+````
+public class MyClass
 {
     private int m;    //定义私有变量
     MyClass()
@@ -75,8 +73,8 @@
         //定义有参的构造方法
         this.m=m;
     }
-}</pre>
-
+}
+````
 该示例定义了两个构造方法，分别是无参构造方法和有参构造方法。在一个类中定义多个具有不同参数的同名方法，这就是方法的重载。这两个构造方法的名称都与类名相同，均为 MyClass。在实例化该类时可以调用不同的构造方法进行初始化。
 
 注意：类的构造方法不是要求必须定义的。如果在类中没有定义任何一个构造方法，则 Java 会自动为该类生成一个默认的构造方法。默认的构造方法不包含任何参数，并且方法体为空。如果类中显式地定义了一个或多个构造方法，则 Java 不再提供默认构造方法。
@@ -86,8 +84,8 @@
 要在不同的条件下使用不同的初始化行为创建类的对象，这时候就需要在一个类中创建多个构造方法。下面通过一个示例来演示构造方法的使用。
 
 (1) 首先在员工类 Worker 中定义两个构造方法，代码如下：
-
-<pre>public class Worker
+````
+public class Worker
 {
     public String name;    //姓名
     private int age;    //年龄
@@ -106,15 +104,15 @@
     {
         return"大家好！我是新来的员工，我叫"+name+"，今年"+age+"岁。";
     }
-}</pre>
-
+}
+````
 在 Worker 类中定义了两个属性，其中 name 属性不可改变。分别定义了带有一个参数和带有两个参数的构造方法，并对其属性进行初始化。最后定义了该类的 toString() 方法，返回一条新进员工的介绍语句。
 
 提示：Object 类具有一个 toString() 方法，该方法是个特殊的方法，创建的每个类都会继承该方法，它返回一个 String 类型的字符串。如果一个类中定义了该方法，则在调用该类对象时，将会自动调用该类对象的 toString() 方法返回一个字符串，然后使用“System.out.println(对象名)”就可以将返回的字符串内容打印出来。
 
 (2) 在 TestWorker 类中创建 main() 方法作为程序的入口处，在 main() 方法中调用不同的构造方法实例化 Worker 对象，并对该对象中的属性进行初始化，代码如下：
-
-<pre>public class TestWorker
+````
+public class TestWorker
 {
     public static void main(String[] args)
     {
@@ -127,16 +125,16 @@
         Worker worker2=new Worker("李丽",25);
         System.out.println(worker2);
     }
-}</pre>
-
+}
+````
 在上述代码中，创建了两个不同的 Worker 对象：一个是姓名为张强的员工对象，一个是姓名为李丽、年龄为 25 的员工对象。对于第一个 Worker 对象 Worker1，并未指定 age 属性值，因此程序会将其值采用默认值 0。对于第二个 Worker 对象 Worker2，分别对其指定了 name 属性值和 age 属性值，因此程序会将传递的参数值重新赋值给 Worker 类中的属性值。
 
 运行 TestWorker 类，输出的结果如下：
 
-<pre>-----------带有一个参数的构造方法-----------
-大家好！我是新来的员工，我叫张强，今年0岁。
------------带有两个参数的构造方法------------
-大家好！我是新来的员工，我叫李丽，今年25岁。</pre>
+    -----------带有一个参数的构造方法-----------
+    大家好！我是新来的员工，我叫张强，今年0岁。
+    -----------带有两个参数的构造方法------------
+    大家好！我是新来的员工，我叫李丽，今年25岁。
 
 通过调用带参数的构造方法，在创建对象时，一并完成了对象成员的初始化工作，简化了对象初始化的代码。
 
@@ -152,7 +150,7 @@
 不能被static、final、abstract修饰（有final和static修饰的是不能被子类继承的，abstract修饰的是抽象类，抽象类是不能实例化的，也就是不能new）
 
 可以被private修饰，可以在本类里面实例化，但是外部不能实例化对象（注意！！！）
-
+````
     public class A{
         int i=0;
         public A(){
@@ -162,25 +160,26 @@
             this.i=i;
         }
     }
-
+````
 ### 默认构造方法
 如果没有任何的构造方法，编译时系统会自动添加一个默认无参构造方法
 
 隐含的默认构造方法
-
+````
         public A(){}
-
+````
 显示的默认构造方法
-
+````
         public A(){
         System.out.print("显示的默认构造方法")
         }
+````
 
 ### 重载构造方法
 比如原本的类里的构造方法是一个参数的，现在新建的对象是有三个参数，此时就要重载构造方法
 
 当一个类中有多个构造方法，有可能会出现重复性操作，这时可以用this语句调用其他的构造方法。
-
+````
     public class A{
         private int age;
         private String name;
@@ -209,6 +208,7 @@
     System.out.println(name);
     System.out.println(name1);
     System.out.println(age);
+````
 
 ### java子类构造方法调用父类构造方法
 
@@ -265,9 +265,9 @@
 
 > 调用：调用其所在的方法时执行
 
-​     
-
-     public class 局部代码块 {
+     
+````
+public class 局部代码块 {
     @Test
     public void test (){
         B b = new B();
@@ -294,7 +294,7 @@
             System.out.println("hello");
         }
     }
-
+````
 ### 构造代码块
 
  >位置：类成员的位置，就是类中方法之外的位置
@@ -302,7 +302,7 @@
  >作用：把多个构造方法共同的部分提取出来，共用构造代码块
 
  >调用：每次调用构造方法时，都会优先于构造方法执行，也就是每次new一个对象时自动调用，对  对象的初始化
-
+````
     class A{
         int i = 1;
         int initValue;//成员变量的初始化交给代码块来完成
@@ -340,7 +340,7 @@
             A a = new A();
         }
     }
-
+````
 ### 静态代码块
 
      位置：类成员位置，用static修饰的代码块
@@ -348,7 +348,8 @@
      作用：对类进行一些初始化  只加载一次，当new多个对象时，只有第一次会调用静态代码块，因为，静态代码块                  是属于类的，所有对象共享一份
     
      调用: new 一个对象时自动调用
-    
+
+ ````   
      public class 静态代码块 {
     
     @Test
@@ -376,7 +377,7 @@
             System.out.println("静态代码块调用");
         }
     }
-
+````
 ## Java代码块、构造方法（包含继承关系）的执行顺序
 
 这是一道常见的面试题，要回答这个问题，先看看这个实例吧。
@@ -385,7 +386,7 @@
 其中A是B的父类，C无继承仅作为输出
 
 A类：
-
+````
     public class A {
     
     static {
@@ -408,8 +409,9 @@ A类：
     }
     
     }
+````
 B类：
-
+````
     public class B extends A {
     
     private static C c1 = new C("B静态成员");
@@ -434,14 +436,16 @@ B类：
     }
     
     }
+````
 C类：
-
+````
     public class C {
     
     public C(String str) {
         Log.i("HIDETAG", str + "构造方法");
     }
     }
+````
 执行语句：new B();
 
 输出结果如下：
@@ -473,7 +477,7 @@ C类：
 **看完上面这个demo，再来看看下面这道题，看看你搞得定吗？**
 
 看下面一段代码，求执行顺序：
-
+````
     class A {
         public A() {
             System.out.println("1A类的构造方法");
@@ -485,7 +489,7 @@ C类：
             System.out.println("3A类的静态块");
         }
     }
-     
+  
     public class B extends A {
         public B() {
             System.out.println("4B类的构造方法");
@@ -503,6 +507,7 @@ C类：
             System.out.println("8");
         }
     }
+````
 
 执行顺序结果为：367215421548
 
@@ -535,20 +540,3 @@ http://c.biancheng.net/view/976.html
 https://blog.csdn.net/evilcry2012/article/details/79499786
 https://www.jb51.net/article/129990.htm
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/12\343\200\201\345\217\215\345\260\204.md" "b/docs/Java/basic/\345\217\215\345\260\204.md"
similarity index 51%
rename from "docs/java/basic/12\343\200\201\345\217\215\345\260\204.md"
rename to "docs/Java/basic/\345\217\215\345\260\204.md"
index 0513f67..14629eb 100644
--- "a/docs/java/basic/12\343\200\201\345\217\215\345\260\204.md"
+++ "b/docs/Java/basic/\345\217\215\345\260\204.md"
@@ -22,18 +22,6 @@
     * [Java反射机制的作用](#java反射机制的作用)
     * [如何使用Java的反射?](#如何使用java的反射)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
----
-title: 夯实Java基础系列12：深入理解Java中的反射机制
-date: 2019-9-12 15:56:26 # 文章生成时间，一般不改
-categories:
-    - Java技术江湖
-    - Java基础
-tags:
-    - Java反射
----
 
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -61,11 +49,11 @@ Oracle官方对反射的解释是
 
 > The API accommodates applications that need access to either the public members of a target object (based on its runtime class) or the members declared by a given class. It also allows programs to suppress default reflective access control.
 > 
->  简而言之，通过反射，我们可以在运行时获得程序或程序集中每一个类型的成员和成员的信息。
+> 简而言之，通过反射，我们可以在运行时获得程序或程序集中每一个类型的成员和成员的信息。
 >
 > 程序中一般的对象的类型都是在编译期就确定下来的，而Java反射机制可以动态地创建对象并调用其属性，这样的对象的类型在编译期是未知的。所以我们可以通过反射机制直接创建对象，即使这个对象的类型在编译期是未知的。
 > 
->  反射的核心是JVM在运行时才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁。
+> 反射的核心是JVM在运行时才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁。
 
 Java反射框架主要提供以下功能：
 
@@ -82,27 +70,15 @@ Java反射框架主要提供以下功能：
 
 ## 反射的主要用途
 
->  很多人都认为反射在实际的Java开发应用中并不广泛，其实不然。
+> 很多人都认为反射在实际的Java开发应用中并不广泛，其实不然。
 
->  当我们在使用IDE(如Eclipse，IDEA)时，当我们输入一个对象或类并想调用它的属性或方法时，一按点号，编译器就会自动列出它的属性或方法，这里就会用到反射。
+> 当我们在使用IDE(如Eclipse，IDEA)时，当我们输入一个对象或类并想调用它的属性或方法时，一按点号，编译器就会自动列出它的属性或方法，这里就会用到反射。
 
->  反射最重要的用途就是开发各种通用框架。
+> 反射最重要的用途就是开发各种通用框架。
 
->  很多框架（比如Spring）都是配置化的（比如通过XML文件配置JavaBean,Action之类的），为了保证框架的通用性，它们可能需要根据配置文件加载不同的对象或类，调用不同的方法，这个时候就必须用到反射——运行时动态加载需要加载的对象。
+> 很多框架（比如Spring）都是配置化的（比如通过XML文件配置JavaBean,Action之类的），为了保证框架的通用性，它们可能需要根据配置文件加载不同的对象或类，调用不同的方法，这个时候就必须用到反射——运行时动态加载需要加载的对象。
 
->  举一个例子，在运用Struts 2框架的开发中我们一般会在struts.xml里去配置Action，比如：
-
-    <action name="login"
-                   class="org.ScZyhSoft.test.action.SimpleLoginAction"
-                   method="execute">
-               <result>/shop/shop-index.jsp</result>
-               <result name="error">login.jsp</result>
-           </action>
-配置文件与Action建立了一种映射关系，当View层发出请求时，请求会被StrutsPrepareAndExecuteFilter拦截，然后StrutsPrepareAndExecuteFilter会去动态地创建Action实例。
-
-——比如我们请求login.action，那么StrutsPrepareAndExecuteFilter就会去解析struts.xml文件，检索action中name为login的Action，并根据class属性创建SimpleLoginAction实例，并用invoke方法来调用execute方法，这个过程离不开反射。
-
-> 对与框架开发人员来说，反射虽小但作用非常大，它是各种容器实现的核心。而对于一般的开发者来说，不深入框架开发则用反射用的就会少一点，不过了解一下框架的底层机制有助于丰富自己的编程思想，也是很有益的。
+> 对于框架开发人员来说，反射虽小但作用非常大，它是各种容器实现的核心。而对于一般的开发者来说，不深入框架开发则用反射用的就会少一点，不过了解一下框架的底层机制有助于丰富自己的编程思想，也是很有益的。
 
 ## 反射的基础：关于Class类
 
@@ -117,25 +93,26 @@ Java反射框架主要提供以下功能：
 > 4、Class 对象只能由系统建立对象
 > 
 > 5、一个类在 JVM 中只会有一个Class实例
-
-    //总结一下就是，JDK有一个类叫做Class，这个类用来封装所有Java类型，包括这些类的所有信息，JVM中类信息是放在方法区的。
-    
-    //所有类在加载后，JVM会为其在堆中创建一个Class<类名称>的对象，并且每个类只会有一个Class对象，这个类的所有对象都要通过Class<类名称>来进行实例化。
-    
-    //上面说的是JVM进行实例化的原理，当然实际上在Java写代码时只需要用 类名称就可以进行实例化了。
-    
-    public final class Class<T> implements java.io.Serializable,
-                              GenericDeclaration,
-                              Type,
-                              AnnotatedElement {
-    虚拟机会保持唯一一
-                //通过类名.class获得唯一的Class对象。
-                Class<UserBean> cls = UserBean.class;
-                //通过integer.TYPEl来获取Class对象
-                Class<Integer> inti = Integer.TYPE;
-              //接口本质也是一个类，一样可以通过.class获取
-                Class<User> userClass = User.class;
-
+> 
+````
+//总结一下就是，JDK有一个类叫做Class，这个类用来封装所有Java类型，包括这些类的所有信息，JVM中类信息是放在方法区的。
+
+//所有类在加载后，JVM会为其在堆中创建一个Class<类名称>的对象，并且每个类只会有一个Class对象，这个类的所有对象都要通过Class<类名称>来进行实例化。
+
+//上面说的是JVM进行实例化的原理，当然实际上在Java写代码时只需要用 类名称就可以进行实例化了。
+
+public final class Class<T> implements java.io.Serializable,
+                          GenericDeclaration,
+                          Type,
+                          AnnotatedElement {
+            //通过类名.class获得唯一的Class对象。
+            Class<UserBean> cls = UserBean.class;
+            //通过integer.TYPEl来获取Class对象
+            Class<Integer> inti = Integer.TYPE;
+          //接口本质也是一个类，一样可以通过.class获取
+            Class<User> userClass = User.class;
+}
+````
 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
 
 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.
@@ -146,8 +123,7 @@ JAVA反射机制是在运行状态中，对于任意一个类，都能够知道
 如图是类的正常加载过程：反射的原理在与class对象。
 熟悉一下加载的时候：Class对象的由来是将class文件读入内存，并为之创建一个Class对象。
 
-![](https://img-blog.csdn.net/20170513133210763)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230403211245.png)
 ## Java为什么需要反射？反射要解决什么问题？
 Java中编译类型有两种：
 
@@ -176,29 +152,31 @@ Array类：提供了动态创建数组，以及访问数组的元素的静态方
 1、获得Class对象方法有三种
 
 (1)使用Class类的forName静态方法:
-    
-     public static Class<?> forName(String className)
-    ```
-    在JDBC开发中常用此方法加载数据库驱动:
-    要使用全类名来加载这个类，一般数据库驱动的配置信息会写在配置文件中。加载这个驱动前要先导入jar包
-    ```java
-     Class.forName(driver);
+````  
+public static Class<?> forName(String className)
+````
+在JDBC开发中常用此方法加载数据库驱动:
+要使用全类名来加载这个类，一般数据库驱动的配置信息会写在配置文件中。加载这个驱动前要先导入jar包
+````
+Class.forName(driver);
+````
 (2)直接获取某一个对象的class，比如:
-
-    //Class<?>是一个泛型表示，用于获取一个类的类型。
-    Class<?> klass = int.class;
-    Class<?> classInt = Integer.TYPE;
+````
+//Class<?>是一个泛型表示，用于获取一个类的类型。
+Class<?> klass = int.class;
+Class<?> classInt = Integer.TYPE;
+````
 (3)调用某个对象的getClass()方法,比如:
-    
-    StringBuilder str = new StringBuilder("123");
-    Class<?> klass = str.getClass();
-
+````    
+StringBuilder str = new StringBuilder("123");
+Class<?> klass = str.getClass();
+````
 ## 判断是否为某个类的实例
 
 一般地，我们用instanceof关键字来判断是否为某个类的实例。同时我们也可以借助反射中Class对象的isInstance()方法来判断是否为某个类的实例，它是一个Native方法：
-
-==public native boolean isInstance(Object obj);==
-
+````
+public native boolean isInstance(Object obj);
+````
 ## 创建实例
 
 通过反射来生成对象主要有两种方式。
@@ -206,20 +184,20 @@ Array类：提供了动态创建数组，以及访问数组的元素的静态方
 （1）使用Class对象的newInstance()方法来创建Class对象对应类的实例。
 
 注意：利用newInstance创建对象：调用的类必须有无参的构造器
-
-    //Class<?>代表任何类的一个类对象。
-    //使用这个类对象可以为其他类进行实例化
-    //因为jvm加载类以后自动在堆区生成一个对应的*.Class对象
-    //该对象用于让JVM对进行所有*对象实例化。
-    Class<?> c = String.class;
-    
-    //Class<?> 中的 ? 是通配符，其实就是表示任意符合泛类定义条件的类，和直接使用 Class
-    //效果基本一致，但是这样写更加规范，在某些类型转换时可以避免不必要的 unchecked 错误。
-    
-    Object str = c.newInstance();
-
+````
+//Class<?>代表任何类的一个类对象。
+//使用这个类对象可以为其他类进行实例化
+//因为jvm加载类以后自动在堆区生成一个对应的*.Class对象
+//该对象用于让JVM对进行所有*对象实例化。
+Class<?> c = String.class;
+
+//Class<?> 中的 ? 是通配符，其实就是表示任意符合泛类定义条件的类，和直接使用 Class
+//效果基本一致，但是这样写更加规范，在某些类型转换时可以避免不必要的 unchecked 错误。
+
+Object str = c.newInstance();
+````
 （2）先通过Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建实例。这种方法可以用指定的构造器构造类的实例。
-
+````
     //获取String所对应的Class对象
     Class<?> c = String.class;
     //获取String类带一个String参数的构造器
@@ -227,33 +205,35 @@ Array类：提供了动态创建数组，以及访问数组的元素的静态方
     //根据构造器创建实例
     Object obj = constructor.newInstance("23333");
     System.out.println(obj);
-
+````
 ## 获取方法
 获取某个Class对象的方法集合，主要有以下几个方法：
 
 getDeclaredMethods()方法返回类或接口声明的所有方法，==包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法==。
-
-    public Method[] getDeclaredMethods() throws SecurityException
-
+````
+public Method[] getDeclaredMethods() throws SecurityException
+````
 getMethods()方法返回某个类的所有公用（public）方法，==包括其继承类的公用方法。==
-    
-    public Method[] getMethods() throws SecurityException
+````    
+public Method[] getMethods() throws SecurityException
+````
 getMethod方法返回一个特定的方法，其中第一个参数为方法名称，后面的参数为方法的参数对应Class的对象
-
-
-    public Method getMethod(String name, Class<?>... parameterTypes)
+````
+public Method getMethod(String name, Class<?>... parameterTypes)
+````
 只是这样描述的话可能难以理解，我们用例子来理解这三个方法：
 本文中的例子用到了以下这些类，用于反射的测试。
 
+````
     //注解类，可可用于表示方法，可以通过反射获取注解的内容。
         //Java注解的实现是很多注框架实现注解配置的基础
     @Target(ElementType.METHOD)
     @Retention(RetentionPolicy.RUNTIME)
     public @interface Invoke {
     }
-
+````
 userbean的父类personbean
-
+````
     public class PersonBean {
     private String name;
     
@@ -266,20 +246,17 @@ userbean的父类personbean
     public void setName(String name) {
         this.name = name;
     }
-
-
-​    
 }
-
+````
 接口user
-
+````
     public interface User {
         public void login ();
     
     }
-
+````
 userBean实现user接口，继承personbean
-
+````
     public class UserBean extends PersonBean implements User{
         @Override
         public void login() {
@@ -318,100 +295,100 @@ userBean实现user接口，继承personbean
             System.out.println("I'm a private method");
         }
     }
-
+````
 1 getMethods和getDeclaredMethods的区别
-    
-    public class 动态加载类的反射 {
-        public static void main(String[] args) {
-            try {
-                Class clazz = Class.forName("com.javase.反射.UserBean");
-                for (Field field : clazz.getDeclaredFields()) {
-    //                field.setAccessible(true);
-                    System.out.println(field);
-                }
-                //getDeclaredMethod*()获取的是类自身声明的所有方法，包含public、protected和private方法。
-                System.out.println("------共有方法------");
-    //        getDeclaredMethod*()获取的是类自身声明的所有方法，包含public、protected和private方法。
-    //            getMethod*()获取的是类的所有共有方法，这就包括自身的所有public方法，和从基类继承的、从接口实现的所有public方法。
-                for (Method method : clazz.getMethods()) {
-                    String name = method.getName();
-                    System.out.println(name);
-                    //打印出了UserBean.java的所有方法以及父类的方法
-                }
-                System.out.println("------独占方法------");
-    
-                for (Method method : clazz.getDeclaredMethods()) {
-                    String name = method.getName();
-                    System.out.println(name);
-                }
-            } catch (ClassNotFoundException e) {
-                e.printStackTrace();
+```` 
+public class 动态加载类的反射 {
+    public static void main(String[] args) {
+        try {
+            Class clazz = Class.forName("com.javase.反射.UserBean");
+            for (Field field : clazz.getDeclaredFields()) {
+//                field.setAccessible(true);
+                System.out.println(field);
             }
+            //getDeclaredMethod*()获取的是类自身声明的所有方法，包含public、protected和private方法。
+            System.out.println("------共有方法------");
+//        getDeclaredMethod*()获取的是类自身声明的所有方法，包含public、protected和private方法。
+//            getMethod*()获取的是类的所有共有方法，这就包括自身的所有public方法，和从基类继承的、从接口实现的所有public方法。
+            for (Method method : clazz.getMethods()) {
+                String name = method.getName();
+                System.out.println(name);
+                //打印出了UserBean.java的所有方法以及父类的方法
+            }
+            System.out.println("------独占方法------");
+
+            for (Method method : clazz.getDeclaredMethods()) {
+                String name = method.getName();
+                System.out.println(name);
+            }
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
         }
     }
+}
 
-
+````
 
 2 打印一个类的所有方法及详细信息：
-
-    public class 打印所有方法 {
-    
-        public static void main(String[] args) {
-            Class userBeanClass = UserBean.class;
-            Field[] fields = userBeanClass.getDeclaredFields();
-            //注意，打印方法时无法得到局部变量的名称，因为jvm只知道它的类型
-            Method[] methods = userBeanClass.getDeclaredMethods();
-            for (Method method : methods) {
-                //依次获得方法的修饰符，返回类型和名称，外加方法中的参数
-                String methodString = Modifier.toString(method.getModifiers()) + " " ; // private static
-                methodString += method.getReturnType().getSimpleName() + " "; // void
-                methodString += method.getName() + "("; // staticMethod
-                Class[] parameters = method.getParameterTypes();
-                Parameter[] p = method.getParameters();
-    
-                for (Class parameter : parameters) {
-                    methodString += parameter.getSimpleName() + " " ; // String
-                }
-                methodString += ")";
-                System.out.println(methodString);
+````
+public class 打印所有方法 {
+
+    public static void main(String[] args) {
+        Class userBeanClass = UserBean.class;
+        Field[] fields = userBeanClass.getDeclaredFields();
+        //注意，打印方法时无法得到局部变量的名称，因为jvm只知道它的类型
+        Method[] methods = userBeanClass.getDeclaredMethods();
+        for (Method method : methods) {
+            //依次获得方法的修饰符，返回类型和名称，外加方法中的参数
+            String methodString = Modifier.toString(method.getModifiers()) + " " ; // private static
+            methodString += method.getReturnType().getSimpleName() + " "; // void
+            methodString += method.getName() + "("; // staticMethod
+            Class[] parameters = method.getParameterTypes();
+            Parameter[] p = method.getParameters();
+
+            for (Class parameter : parameters) {
+                methodString += parameter.getSimpleName() + " " ; // String
             }
-            //注意方法只能获取到其类型，拿不到变量名
-    /*        public String getName()
-            public long getId()
-            public static void staticMethod(String int )
-            public void publicMethod()
-            private void privateMethod()*/
+            methodString += ")";
+            System.out.println(methodString);
         }
+        //注意方法只能获取到其类型，拿不到变量名
+/*        public String getName()
+        public long getId()
+        public static void staticMethod(String int )
+        public void publicMethod()
+        private void privateMethod()*/
     }
-
+}
+````
 ## 获取构造器信息
 
 获取类构造器的用法与上述获取方法的用法类似。主要是通过Class类的getConstructor方法得到Constructor类的一个实例，而Constructor类有一个newInstance方法可以创建一个对象实例:
-
-    public class 打印构造方法 {
-        public static void main(String[] args) {
-            // constructors
-            Class<?> clazz = UserBean.class;
-    
-            Class userBeanClass = UserBean.class;
-            //获得所有的构造方法
-            Constructor[] constructors = userBeanClass.getDeclaredConstructors();
-            for (Constructor constructor : constructors) {
-                String s = Modifier.toString(constructor.getModifiers()) + " ";
-                s += constructor.getName() + "(";
-                //构造方法的参数类型
-                Class[] parameters = constructor.getParameterTypes();
-                for (Class parameter : parameters) {
-                    s += parameter.getSimpleName() + ", ";
-                }
-                s += ")";
-                System.out.println(s);
-                //打印结果//public com.javase.反射.UserBean(String, long, )
-    
+````
+public class 打印构造方法 {
+    public static void main(String[] args) {
+        // constructors
+        Class<?> clazz = UserBean.class;
+
+        Class userBeanClass = UserBean.class;
+        //获得所有的构造方法
+        Constructor[] constructors = userBeanClass.getDeclaredConstructors();
+        for (Constructor constructor : constructors) {
+            String s = Modifier.toString(constructor.getModifiers()) + " ";
+            s += constructor.getName() + "(";
+            //构造方法的参数类型
+            Class[] parameters = constructor.getParameterTypes();
+            for (Class parameter : parameters) {
+                s += parameter.getSimpleName() + ", ";
             }
+            s += ")";
+            System.out.println(s);
+            //打印结果//public com.javase.反射.UserBean(String, long, )
+
         }
     }
-
+}
+````
 ## 获取类的成员变量（字段）信息
 主要是这几个方法，在此不再赘述：
 
@@ -419,140 +396,138 @@ getFiled: 访问公有的成员变量
 getDeclaredField：所有已声明的成员变量。但不能得到其父类的成员变量
 getFileds和getDeclaredFields用法同上（参照Method）
 
-    public class 打印成员变量 {
-        public static void main(String[] args) {
-            Class userBeanClass = UserBean.class;
-            //获得该类的所有成员变量，包括static private
-            Field[] fields = userBeanClass.getDeclaredFields();
-    
-            for(Field field : fields) {
-                //private属性即使不用下面这个语句也可以访问
-    //            field.setAccessible(true);
-    
-                //因为类的私有域在反射中默认可访问，所以flag默认为true。
-                String fieldString = "";
-                fieldString += Modifier.toString(field.getModifiers()) + " "; // `private`
-                fieldString += field.getType().getSimpleName() + " "; // `String`
-                fieldString += field.getName(); // `userName`
-                fieldString += ";";
-                System.out.println(fieldString);
-                
-                //打印结果
-    //            public String userName;
-    //            protected int i;
-    //            static int j;
-    //            private int l;
-    //            private long userId;
-            }
-    
+````
+public class 打印成员变量 {
+    public static void main(String[] args) {
+        Class userBeanClass = UserBean.class;
+        //获得该类的所有成员变量，包括static private
+        Field[] fields = userBeanClass.getDeclaredFields();
+
+        for(Field field : fields) {
+            //private属性即使不用下面这个语句也可以访问
+//            field.setAccessible(true);
+
+            //因为类的私有域在反射中默认可访问，所以flag默认为true。
+            String fieldString = "";
+            fieldString += Modifier.toString(field.getModifiers()) + " "; // `private`
+            fieldString += field.getType().getSimpleName() + " "; // `String`
+            fieldString += field.getName(); // `userName`
+            fieldString += ";";
+            System.out.println(fieldString);
+            
+            //打印结果
+//            public String userName;
+//            protected int i;
+//            static int j;
+//            private int l;
+//            private long userId;
         }
-    }
 
+    }
+}
+````
 ## 调用方法
 当我们从类中获取了一个方法后，我们就可以用invoke()方法来调用这个方法。invoke方法的原型为:
-
-    public Object invoke(Object obj, Object... args)
-            throws IllegalAccessException, IllegalArgumentException,
-               InvocationTargetException
-           
-    public class 使用反射调用方法 {
-        public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, InstantiationException, NoSuchMethodException {
-            Class userBeanClass = UserBean.class;
-            //获取该类所有的方法，包括静态方法，实例方法。
-            //此处也包括了私有方法，只不过私有方法在用invoke访问之前要设置访问权限
-            //也就是使用setAccessible使方法可访问，否则会抛出异常
-    //       // IllegalAccessException的解释是
-    //        * An IllegalAccessException is thrown when an application tries
-    // * to reflectively create an instance (other than an array),
-    // * set or get a field, or invoke a method, but the currently
-    // * executing method does not have access to the definition of
-    // * the specified class, field, method or constructor.
-    
-    //        getDeclaredMethod*()获取的是类自身声明的所有方法，包含public、protected和private方法。
-    //            getMethod*()获取的是类的所有共有方法，这就包括自身的所有public方法，和从基类继承的、从接口实现的所有public方法。
-    
-            //就是说，当这个类，域或者方法被设为私有访问，使用反射调用但是却没有权限时会抛出异常。
-            Method[] methods = userBeanClass.getDeclaredMethods(); // 获取所有成员方法
-            for (Method method : methods) {
-                //反射可以获取方法上的注解，通过注解来进行判断
-                if (method.isAnnotationPresent(Invoke.class)) { // 判断是否被 @Invoke 修饰
-                    //判断方法的修饰符是是static
-                    if (Modifier.isStatic(method.getModifiers())) { // 如果是 static 方法
-                        //反射调用该方法
-                        //类方法可以直接调用，不必先实例化
-                        method.invoke(null, "wingjay",2); // 直接调用，并传入需要的参数 devName
-                    } else {
-                        //如果不是类方法，需要先获得一个实例再调用方法
-                        //传入构造方法需要的变量类型
-                        Class[] params = {String.class, long.class};
-                        //获取该类指定类型的构造方法
-                        //如果没有这种类型的方法会报错
-                        Constructor constructor = userBeanClass.getDeclaredConstructor(params); // 获取参数格式为 String,long 的构造函数
-                        //通过构造方法的实例来进行实例化
-                        Object userBean = constructor.newInstance("wingjay", 11); // 利用构造函数进行实例化，得到 Object
-                        if (Modifier.isPrivate(method.getModifiers())) {
-                            method.setAccessible(true); // 如果是 private 的方法，需要获取其调用权限
-    //                        Set the {@code accessible} flag for this object to
-    //     * the indicated boolean value.  A value of {@code true} indicates that
-    //     * the reflected object should suppress Java language access
-    //     * checking when it is used.  A value of {@code false} indicates
-    //                                * that the reflected object should enforce Java language access checks.
-                            //通过该方法可以设置其可见或者不可见，不仅可以用于方法
-                            //后面例子会介绍将其用于成员变量
-                                                //打印结果
-    //            I'm a public method
-    // Hi wingjay, I'm a static methodI'm a private method
-                        }
-                        method.invoke(userBean); // 调用 method，无须参数
-
-
-​                        
-
+````
+public Object invoke(Object obj, Object... args)
+        throws IllegalAccessException, IllegalArgumentException,
+           InvocationTargetException
+       
+public class 使用反射调用方法 {
+    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, InstantiationException, NoSuchMethodException {
+        Class userBeanClass = UserBean.class;
+        //获取该类所有的方法，包括静态方法，实例方法。
+        //此处也包括了私有方法，只不过私有方法在用invoke访问之前要设置访问权限
+        //也就是使用setAccessible使方法可访问，否则会抛出异常
+//       // IllegalAccessException的解释是
+//        * An IllegalAccessException is thrown when an application tries
+// * to reflectively create an instance (other than an array),
+// * set or get a field, or invoke a method, but the currently
+// * executing method does not have access to the definition of
+// * the specified class, field, method or constructor.
+
+//        getDeclaredMethod*()获取的是类自身声明的所有方法，包含public、protected和private方法。
+//            getMethod*()获取的是类的所有共有方法，这就包括自身的所有public方法，和从基类继承的、从接口实现的所有public方法。
+
+        //就是说，当这个类，域或者方法被设为私有访问，使用反射调用但是却没有权限时会抛出异常。
+        Method[] methods = userBeanClass.getDeclaredMethods(); // 获取所有成员方法
+        for (Method method : methods) {
+            //反射可以获取方法上的注解，通过注解来进行判断
+            if (method.isAnnotationPresent(Invoke.class)) { // 判断是否被 @Invoke 修饰
+                //判断方法的修饰符是是static
+                if (Modifier.isStatic(method.getModifiers())) { // 如果是 static 方法
+                    //反射调用该方法
+                    //类方法可以直接调用，不必先实例化
+                    method.invoke(null, "wingjay",2); // 直接调用，并传入需要的参数 devName
+                } else {
+                    //如果不是类方法，需要先获得一个实例再调用方法
+                    //传入构造方法需要的变量类型
+                    Class[] params = {String.class, long.class};
+                    //获取该类指定类型的构造方法
+                    //如果没有这种类型的方法会报错
+                    Constructor constructor = userBeanClass.getDeclaredConstructor(params); // 获取参数格式为 String,long 的构造函数
+                    //通过构造方法的实例来进行实例化
+                    Object userBean = constructor.newInstance("wingjay", 11); // 利用构造函数进行实例化，得到 Object
+                    if (Modifier.isPrivate(method.getModifiers())) {
+                        method.setAccessible(true); // 如果是 private 的方法，需要获取其调用权限
+//                        Set the {@code accessible} flag for this object to
+//     * the indicated boolean value.  A value of {@code true} indicates that
+//     * the reflected object should suppress Java language access
+//     * checking when it is used.  A value of {@code false} indicates
+//                                * that the reflected object should enforce Java language access checks.
+                        //通过该方法可以设置其可见或者不可见，不仅可以用于方法
+                        //后面例子会介绍将其用于成员变量
+                                            //打印结果
+//            I'm a public method
+// Hi wingjay, I'm a static methodI'm a private method
                     }
+                    method.invoke(userBean); // 调用 method，无须参数  
                 }
             }
         }
     }
-
+}
+````
 ## 利用反射创建数组
 
 数组在Java里是比较特殊的一种类型，它可以赋值给一个Object Reference。下面我们看一看利用反射创建数组的例子：
-
-    public class 用反射创建数组 {
-        public static void main(String[] args) {
-            Class<?> cls = null;
-            try {
-                cls = Class.forName("java.lang.String");
-            } catch (ClassNotFoundException e) {
-                e.printStackTrace();
-            }
-            Object array = Array.newInstance(cls,25);
-            //往数组里添加内容
-            Array.set(array,0,"hello");
-            Array.set(array,1,"Java");
-            Array.set(array,2,"fuck");
-            Array.set(array,3,"Scala");
-            Array.set(array,4,"Clojure");
-            //获取某一项的内容
-            System.out.println(Array.get(array,3));
-            //Scala
+````
+public class 用反射创建数组 {
+    public static void main(String[] args) {
+        Class<?> cls = null;
+        try {
+            cls = Class.forName("java.lang.String");
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
         }
-    
+        Object array = Array.newInstance(cls,25);
+        //往数组里添加内容
+        Array.set(array,0,"hello");
+        Array.set(array,1,"Java");
+        Array.set(array,2,"fuck");
+        Array.set(array,3,"Scala");
+        Array.set(array,4,"Clojure");
+        //获取某一项的内容
+        System.out.println(Array.get(array,3));
+        //Scala
     }
 
+}
+````
 其中的Array类为java.lang.reflect.Array类。我们通过Array.newInstance()创建数组对象，它的原型是:
-
-    public static Object newInstance(Class<?> componentType, int length)
-            throws NegativeArraySizeException {
-            return newArray(componentType, length);
+````
+public static Object newInstance(Class<?> componentType, int length)
+        throws NegativeArraySizeException {
+        return newArray(componentType, length);
         }
+````
 而newArray()方法是一个Native方法，它在Hotspot JVM里的具体实现我们后边再研究，这里先把源码贴出来
+````
+private static native Object newArray(Class<?> componentType, int length)
+        throws NegativeArraySizeException;
 
-    private static native Object newArray(Class<?> componentType, int length)
-            throws NegativeArraySizeException;
-
-
-​            
+````
+            
 
 ## Java反射常见面试题
 
@@ -637,20 +612,3 @@ https://blog.csdn.net/grandgrandpa/article/details/84832343
 http://blog.csdn.net/lylwo317/article/details/52163304
 https://blog.csdn.net/qq_37875585/article/details/89340495
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/17\343\200\201\345\244\232\347\272\277\347\250\213.md" "b/docs/Java/basic/\345\244\232\347\272\277\347\250\213.md"
similarity index 94%
rename from "docs/java/basic/17\343\200\201\345\244\232\347\272\277\347\250\213.md"
rename to "docs/Java/basic/\345\244\232\347\272\277\347\250\213.md"
index e2cc758..35e3ada 100644
--- "a/docs/java/basic/17\343\200\201\345\244\232\347\272\277\347\250\213.md"
+++ "b/docs/Java/basic/\345\244\232\347\272\277\347\250\213.md"
@@ -16,18 +16,7 @@
   * [Java多线程优先级](#java多线程优先级)
   * [Java多线程面试题](#java多线程面试题)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
----
-title: 夯实Java基础系列17：一文搞懂Java多线程使用方式、实现原理以及常见面试题
-date: 2019-9-17 15:56:26 # 文章生成时间，一般不改
-categories:
-    - Java技术江湖
-    - Java基础
-tags:
-    - 多线程
----
+
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -91,7 +80,7 @@ Java 给多线程编程提供了内置的支持。 一条线程指的是进程
 
 *   **新建状态:**
 
-    使用 **new** 关键字和 **Thread** 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 **start()** 这个线程。
+    使用**new**关键字和**Thread**类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序**start()**这个线程。
 
 *   **就绪状态:**
 
@@ -99,7 +88,7 @@ Java 给多线程编程提供了内置的支持。 一条线程指的是进程
 
 *   **运行状态:**
 
-    如果就绪状态的线程获取 CPU 资源，就可以执行 **run()**，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
+    如果就绪状态的线程获取 CPU 资源，就可以执行**run()**，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
 
 *   **阻塞状态:**
 
@@ -642,21 +631,4 @@ https://blog.csdn.net/qq_38038480/article/details/80584715
 https://blog.csdn.net/tongxuexie/article/details/80145663
 https://www.cnblogs.com/snow-flower/p/6114765.html
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
 
diff --git "a/docs/java/basic/22\343\200\201\345\272\217\345\210\227\345\214\226\345\222\214\345\217\215\345\272\217\345\210\227\345\214\226.md" "b/docs/Java/basic/\345\272\217\345\210\227\345\214\226\345\222\214\345\217\215\345\272\217\345\210\227\345\214\226.md"
similarity index 57%
rename from "docs/java/basic/22\343\200\201\345\272\217\345\210\227\345\214\226\345\222\214\345\217\215\345\272\217\345\210\227\345\214\226.md"
rename to "docs/Java/basic/\345\272\217\345\210\227\345\214\226\345\222\214\345\217\215\345\272\217\345\210\227\345\214\226.md"
index 6de5ffb..c6d33a7 100644
--- "a/docs/java/basic/22\343\200\201\345\272\217\345\210\227\345\214\226\345\222\214\345\217\215\345\272\217\345\210\227\345\214\226.md"
+++ "b/docs/Java/basic/\345\272\217\345\210\227\345\214\226\345\222\214\345\217\215\345\272\217\345\210\227\345\214\226.md"
@@ -9,18 +9,7 @@
   * [为什么要实现Serializable](#为什么要实现serializable)
   * [序列化知识点总结](#序列化知识点总结)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
----
-title: 夯实Java基础系列22：一文读懂Java序列化和反序列化
-date: 2019-9-22 15:56:26 # 文章生成时间，一般不改
-categories:
-    - Java技术江湖
-    - Java基础
-tags:
-    - Java序列化
----
+
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -37,7 +26,6 @@ tags:
 
 <!-- more -->
 
-
 本文参考 http://www.importnew.com/17964.html和
 https://www.ibm.com/developerworks/cn/java/j-lo-serial/
 
@@ -86,96 +74,93 @@ Java为了方便开发人员将Java对象进行序列化及反序列化提供了
 如果要序列化的类有父类，要想同时将在父类中定义过的变量持久化下来，那么父类也应该集成java.io.Serializable接口。
 
 下面是一个实现了java.io.Serializable接口的类
+````
+public class 序列化和反序列化 {
+    public static void main(String[] args) {
 
-    public class 序列化和反序列化 {
-
-
-​    
-​        public static void main(String[] args) {
-​    
-        }
-        //注意，内部类不能进行序列化，因为它依赖于外部类
-        @Test
-        public void test() throws IOException {
-            A a = new A();
-            a.i = 1;
-            a.s = "a";
-            FileOutputStream fileOutputStream = null;
-            FileInputStream fileInputStream = null;
-            try {
-                //将obj写入文件
-                fileOutputStream = new FileOutputStream("temp");
-                ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
-                objectOutputStream.writeObject(a);
-                fileOutputStream.close();
-                //通过文件读取obj
-                fileInputStream = new FileInputStream("temp");
-                ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
-                A a2 = (A) objectInputStream.readObject();
-                fileInputStream.close();
-                System.out.println(a2.i);
-                System.out.println(a2.s);
-                //打印结果和序列化之前相同
-            } catch (IOException e) {
-                e.printStackTrace();
-            } catch (ClassNotFoundException e) {
-                e.printStackTrace();
-            }
-        }
     }
-    
-    class A implements Serializable {
-    
-        int i;
-        String s;
+    //注意，内部类不能进行序列化，因为它依赖于外部类
+    @Test
+    public void test() throws IOException {
+        A a = new A();
+        a.i = 1;
+        a.s = "a";
+        FileOutputStream fileOutputStream = null;
+        FileInputStream fileInputStream = null;
+        try {
+            //将obj写入文件
+            fileOutputStream = new FileOutputStream("temp");
+            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
+            objectOutputStream.writeObject(a);
+            fileOutputStream.close();
+            //通过文件读取obj
+            fileInputStream = new FileInputStream("temp");
+            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
+            A a2 = (A) objectInputStream.readObject();
+            fileInputStream.close();
+            System.out.println(a2.i);
+            System.out.println(a2.s);
+            //打印结果和序列化之前相同
+        } catch (IOException e) {
+            e.printStackTrace();
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
     }
+}
+
+class A implements Serializable {
 
+    int i;
+    String s;
+}
+````
 **Externalizable接口**
 
 除了Serializable 之外，java中还提供了另一个序列化接口Externalizable
 
 为了了解Externalizable接口和Serializable接口的区别，先来看代码，我们把上面的代码改成使用Externalizable的形式。
+````
+class B implements Externalizable {
+    //必须要有公开无参构造函数。否则报错
+    public B() {
 
-    class B implements Externalizable {
-        //必须要有公开无参构造函数。否则报错
-        public B() {
-    
-        }
-        int i;
-        String s;
-        @Override
-        public void writeExternal(ObjectOutput out) throws IOException {
-    
-        }
-    
-        @Override
-        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
-    
-        }
     }
-    
-    @Test
-        public void test2() throws IOException, ClassNotFoundException {
-            B b = new B();
-            b.i = 1;
-            b.s = "a";
-            //将obj写入文件
-            FileOutputStream fileOutputStream = new FileOutputStream("temp");
-            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
-            objectOutputStream.writeObject(b);
-            fileOutputStream.close();
-            //通过文件读取obj
-            FileInputStream fileInputStream = new FileInputStream("temp");
-            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
-            B b2 = (B) objectInputStream.readObject();
-            fileInputStream.close();
-            System.out.println(b2.i);
-            System.out.println(b2.s);
-            //打印结果为0和null，即初始值，没有被赋值
-            //0
-            //null
-        }
+    int i;
+    String s;
+    @Override
+    public void writeExternal(ObjectOutput out) throws IOException {
+
+    }
+
+    @Override
+    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
 
+    }
+}
+
+@Test
+    public void test2() throws IOException, ClassNotFoundException {
+        B b = new B();
+        b.i = 1;
+        b.s = "a";
+        //将obj写入文件
+        FileOutputStream fileOutputStream = new FileOutputStream("temp");
+        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
+        objectOutputStream.writeObject(b);
+        fileOutputStream.close();
+        //通过文件读取obj
+        FileInputStream fileInputStream = new FileInputStream("temp");
+        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
+        B b2 = (B) objectInputStream.readObject();
+        fileInputStream.close();
+        System.out.println(b2.i);
+        System.out.println(b2.s);
+        //打印结果为0和null，即初始值，没有被赋值
+        //0
+        //null
+    }
+````
 通过上面的实例可以发现，对B类进行序列化及反序列化之后得到的对象的所有属性的值都变成了默认值。也就是说，之前的那个对象的状态并没有被持久化下来。这就是Externalizable接口和Serializable接口的区别：
 
 Externalizable继承了Serializable，该接口中定义了两个抽象方法：writeExternal()与readExternal()。
@@ -184,54 +169,56 @@ Externalizable继承了Serializable，该接口中定义了两个抽象方法：
 
 > 还有一点值得注意：在使用Externalizable进行序列化的时候，在读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。所以，实现Externalizable接口的类必须要提供一个public的无参的构造器。
 
-    class C implements Externalizable {
-        int i;
-        int j;
-        String s;
-        public C() {
-    
-        }
-        //实现下面两个方法可以选择序列化中需要被复制的成员。
-        //并且，写入顺序和读取顺序要一致，否则报错。
-        //可以写入多个同类型变量，顺序保持一致即可。
-        @Override
-        public void writeExternal(ObjectOutput out) throws IOException {
-            out.writeInt(i);
-            out.writeInt(j);
-            out.writeObject(s);
-        }
-    
-        @Override
-        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
-            i = in.readInt();
-            j = in.readInt();
-            s = (String) in.readObject();
-        }
+````
+class C implements Externalizable {
+    int i;
+    int j;
+    String s;
+    public C() {
+
+    }
+    //实现下面两个方法可以选择序列化中需要被复制的成员。
+    //并且，写入顺序和读取顺序要一致，否则报错。
+    //可以写入多个同类型变量，顺序保持一致即可。
+    @Override
+    public void writeExternal(ObjectOutput out) throws IOException {
+        out.writeInt(i);
+        out.writeInt(j);
+        out.writeObject(s);
     }
-    
-    @Test
-        public void test3() throws IOException, ClassNotFoundException {
-            C c = new C();
-            c.i = 1;
-            c.j = 2;
-            c.s = "a";
-            //将obj写入文件
-            FileOutputStream fileOutputStream = new FileOutputStream("temp");
-            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
-            objectOutputStream.writeObject(c);
-            fileOutputStream.close();
-            //通过文件读取obj
-            FileInputStream fileInputStream = new FileInputStream("temp");
-            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
-            C c2 = (C) objectInputStream.readObject();
-            fileInputStream.close();
-            System.out.println(c2.i);
-            System.out.println(c2.j);
-            System.out.println(c2.s);
-            //打印结果为0和null，即初始值，没有被赋值
-            //0
-            //null
-        }
+
+    @Override
+    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+        i = in.readInt();
+        j = in.readInt();
+        s = (String) in.readObject();
+    }
+}
+
+@Test
+public void test3() throws IOException, ClassNotFoundException {
+    C c = new C();
+    c.i = 1;
+    c.j = 2;
+    c.s = "a";
+    //将obj写入文件
+    FileOutputStream fileOutputStream = new FileOutputStream("temp");
+    ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
+    objectOutputStream.writeObject(c);
+    fileOutputStream.close();
+    //通过文件读取obj
+    FileInputStream fileInputStream = new FileInputStream("temp");
+    ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
+    C c2 = (C) objectInputStream.readObject();
+    fileInputStream.close();
+    System.out.println(c2.i);
+    System.out.println(c2.j);
+    System.out.println(c2.s);
+    //打印结果为0和null，即初始值，没有被赋值
+    //0
+    //null
+}
+````
 
 ## 序列化ID
 
@@ -241,87 +228,89 @@ Externalizable继承了Serializable，该接口中定义了两个抽象方法：
 问题：C 对象的全类路径假设为 com.inout.Test，在 A 和 B 端都有这么一个类文件，功能代码完全一致。也都实现了 Serializable 接口，但是反序列化时总是提示不成功。
 
 解决：虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID = 1L）。清单 1 中，虽然两个类的功能代码完全一致，但是序列化 ID 不同，他们无法相互序列化和反序列化。
-
-    package com.inout; 
-     
-    import java.io.Serializable; 
-     
-    public class A implements Serializable { 
-     
-        private static final long serialVersionUID = 1L; 
-     
-        private String name; 
-        
-        public String getName() 
-        { 
-            return name; 
-        } 
-        
-        public void setName(String name) 
-        { 
-            this.name = name; 
-        } 
+````
+package com.inout; 
+ 
+import java.io.Serializable; 
+ 
+public class A implements Serializable { 
+ 
+    private static final long serialVersionUID = 1L; 
+ 
+    private String name; 
+    
+    public String getName() 
+    { 
+        return name; 
     } 
-     
-    package com.inout; 
-     
-    import java.io.Serializable; 
-     
-    public class A implements Serializable { 
-     
-        private static final long serialVersionUID = 2L; 
-        
-        private String name; 
-        
-        public String getName() 
-        { 
-            return name; 
-        } 
-        
-        public void setName(String name) 
-        { 
-            this.name = name; 
-        } 
-    }
+    
+    public void setName(String name) 
+    { 
+        this.name = name; 
+    } 
+} 
+ 
+package com.inout; 
+ 
+import java.io.Serializable; 
+ 
+public class A implements Serializable { 
+ 
+    private static final long serialVersionUID = 2L; 
+    
+    private String name; 
+    
+    public String getName() 
+    { 
+        return name; 
+    } 
+    
+    public void setName(String name) 
+    { 
+        this.name = name; 
+    } 
+}
+````
 
 ### 静态变量不参与序列化
 
 清单 2 中的 main 方法，将对象序列化后，修改静态变量的数值，再将序列化对象读取出来，然后通过读取出来的对象获得静态变量的数值并打印出来。依照清单 2，这个 System.out.println(t.staticVar) 语句输出的是 10 还是 5 呢？
-
-    public class Test implements Serializable {
-     
-        private static final long serialVersionUID = 1L;
-     
-        public static int staticVar = 5;
-     
-        public static void main(String[] args) {
-            try {
-                //初始时staticVar为5
-                ObjectOutputStream out = new ObjectOutputStream(
-                        new FileOutputStream("result.obj"));
-                out.writeObject(new Test());
-                out.close();
-     
-                //序列化后修改为10
-                Test.staticVar = 10;
-     
-                ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
-                        "result.obj"));
-                Test t = (Test) oin.readObject();
-                oin.close();
-                 
-                //再读取，通过t.staticVar打印新的值
-                System.out.println(t.staticVar);
-                 
-            } catch (FileNotFoundException e) {
-                e.printStackTrace();
-            } catch (IOException e) {
-                e.printStackTrace();
-            } catch (ClassNotFoundException e) {
-                e.printStackTrace();
-            }
+````
+public class Test implements Serializable {
+ 
+    private static final long serialVersionUID = 1L;
+ 
+    public static int staticVar = 5;
+ 
+    public static void main(String[] args) {
+        try {
+            //初始时staticVar为5
+            ObjectOutputStream out = new ObjectOutputStream(
+                    new FileOutputStream("result.obj"));
+            out.writeObject(new Test());
+            out.close();
+ 
+            //序列化后修改为10
+            Test.staticVar = 10;
+ 
+            ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
+                    "result.obj"));
+            Test t = (Test) oin.readObject();
+            oin.close();
+             
+            //再读取，通过t.staticVar打印新的值
+            System.out.println(t.staticVar);
+             
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
         }
     }
+}
+````
 
 最后的输出是 10，对于无法理解的读者认为，打印的 staticVar 是从读取的对象里获得的，应该是保存时的状态才对。之所以打印 10 的原因在于序列化时，并不保存静态变量，这其实比较容易理解，序列化保存的是对象的状态，静态变量属于类的状态，因此 序列化并不保存静态变量。
 
@@ -334,6 +323,7 @@ ArrayList的序列化
 
 带着这个问题，我们来看java.util.ArrayList的源码
 
+````
     public class ArrayList<E> extends AbstractList<E>
             implements List<E>, RandomAccess, Cloneable, java.io.Serializable
     {
@@ -341,26 +331,27 @@ ArrayList的序列化
         transient Object[] elementData; // non-private to simplify nested class access
         private int size;
     }
+````
 
 笔者省略了其他成员变量，从上面的代码中可以知道ArrayList实现了java.io.Serializable接口，那么我们就可以对它进行序列化及反序列化。
 
 因为elementData是transient的（1.8好像改掉了这一点)，所以我们认为这个成员变量不会被序列化而保留下来。我们写一个Demo，验证一下我们的想法：
-
-    public class ArrayList的序列化 {
-        public static void main(String[] args) throws IOException, ClassNotFoundException {
-            ArrayList list = new ArrayList();
-            list.add("a");
-            list.add("b");
-            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("arr"));
-            objectOutputStream.writeObject(list);
-            objectOutputStream.close();
-            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("arr"));
-            ArrayList list1 = (ArrayList) objectInputStream.readObject();
-            objectInputStream.close();
-            System.out.println(Arrays.toString(list.toArray()));
-            //序列化成功，里面的元素保持不变。
-        }
-
+````
+public class ArrayList的序列化 {
+    public static void main(String[] args) throws IOException, ClassNotFoundException {
+        ArrayList list = new ArrayList();
+        list.add("a");
+        list.add("b");
+        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("arr"));
+        objectOutputStream.writeObject(list);
+        objectOutputStream.close();
+        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("arr"));
+        ArrayList list1 = (ArrayList) objectInputStream.readObject();
+        objectInputStream.close();
+        System.out.println(Arrays.toString(list.toArray()));
+        //序列化成功，里面的元素保持不变。
+    }
+````
 了解ArrayList的人都知道，ArrayList底层是通过数组实现的。那么数组elementData其实就是用来保存列表中的元素的。通过该属性的声明方式我们知道，他是无法通过序列化持久化下来的。那么为什么code 4的结果却通过序列化和反序列化把List中的元素保留下来了呢？
 
 **writeObject和readObject方法**
@@ -376,50 +367,48 @@ ArrayList的序列化
 > 用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值。
 
 来看一下这两个方法的具体实现：
+````
+private void readObject(java.io.ObjectInputStream s)
+    throws java.io.IOException, ClassNotFoundException {
+    elementData = EMPTY_ELEMENTDATA;
 
-    private void readObject(java.io.ObjectInputStream s)
-            throws java.io.IOException, ClassNotFoundException {
-            elementData = EMPTY_ELEMENTDATA;
-    
-            // Read in size, and any hidden stuff
-            s.defaultReadObject();
-    
-            // Read in capacity
-            s.readInt(); // ignored
-    
-            if (size > 0) {
-                // be like clone(), allocate array based upon size not capacity
-                ensureCapacityInternal(size);
-    
-                Object[] a = elementData;
-                // Read in all elements in the proper order.
-                for (int i=0; i<size; i++) {
-                    a[i] = s.readObject();
-                }
-            }
-        }
+    // Read in size, and any hidden stuff
+    s.defaultReadObject();
 
+    // Read in capacity
+    s.readInt(); // ignored
 
-​        
-​    private void writeObject(java.io.ObjectOutputStream s)
-​            throws java.io.IOException{
-​            // Write out element count, and any hidden stuff
-​            int expectedModCount = modCount;
-​            s.defaultWriteObject();
-​    
-            // Write out size as capacity for behavioural compatibility with clone()
-            s.writeInt(size);
-    
-            // Write out all elements in the proper order.
-            for (int i=0; i<size; i++) {
-                s.writeObject(elementData[i]);
-            }
-    
-            if (modCount != expectedModCount) {
-                throw new ConcurrentModificationException();
-            }
+    if (size > 0) {
+        // be like clone(), allocate array based upon size not capacity
+        ensureCapacityInternal(size);
+
+        Object[] a = elementData;
+        // Read in all elements in the proper order.
+        for (int i=0; i<size; i++) {
+            a[i] = s.readObject();
         }
+    }
+}
 
+private void writeObject(java.io.ObjectOutputStream s)
+    throws java.io.IOException{
+    // Write out element count, and any hidden stuff
+    int expectedModCount = modCount;
+    s.defaultWriteObject();
+
+    // Write out size as capacity for behavioural compatibility with clone()
+    s.writeInt(size);
+
+    // Write out all elements in the proper order.
+    for (int i=0; i<size; i++) {
+        s.writeObject(elementData[i]);
+    }
+
+    if (modCount != expectedModCount) {
+        throw new ConcurrentModificationException();
+    }
+}
+````
 那么为什么ArrayList要用这种方式来实现序列化呢？
 
     why transient
@@ -456,28 +445,29 @@ ObjectOutputStream
 writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData--->invokeWriteObject
 
 这里看一下invokeWriteObject：
-
-    void invokeWriteObject(Object obj, ObjectOutputStream out)
-            throws IOException, UnsupportedOperationException
-        {
-            if (writeObjectMethod != null) {
-                try {
-                    writeObjectMethod.invoke(obj, new Object[]{ out });
-                } catch (InvocationTargetException ex) {
-                    Throwable th = ex.getTargetException();
-                    if (th instanceof IOException) {
-                        throw (IOException) th;
-                    } else {
-                        throwMiscException(th);
-                    }
-                } catch (IllegalAccessException ex) {
-                    // should not occur, as access checks have been suppressed
-                    throw new InternalError(ex);
+````
+void invokeWriteObject(Object obj, ObjectOutputStream out)
+        throws IOException, UnsupportedOperationException
+    {
+        if (writeObjectMethod != null) {
+            try {
+                writeObjectMethod.invoke(obj, new Object[]{ out });
+            } catch (InvocationTargetException ex) {
+                Throwable th = ex.getTargetException();
+                if (th instanceof IOException) {
+                    throw (IOException) th;
+                } else {
+                    throwMiscException(th);
                 }
-            } else {
-                throw new UnsupportedOperationException();
+            } catch (IllegalAccessException ex) {
+                // should not occur, as access checks have been suppressed
+                throw new InternalError(ex);
             }
+        } else {
+            throw new UnsupportedOperationException();
         }
+    }
+````
 其中writeObjectMethod.invoke(obj, new Object[]{ out });是关键，通过反射的方式调用writeObjectMethod方法。官方是这么解释这个writeObjectMethod的：
 
 class-defined writeObject method, or null if none
@@ -489,45 +479,45 @@ class-defined writeObject method, or null if none
     如果一个类中包含writeObject 和 readObject 方法，那么这两个方法是怎么被调用的?
     
     答：在使用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法时，会通过反射的方式调用。
-
-
-​    
+    
 ## 为什么要实现Serializable
 至此，我们已经介绍完了ArrayList的序列化方式。那么，不知道有没有人提出这样的疑问：
 
 Serializable明明就是一个空的接口，它是怎么保证只有实现了该接口的方法才能进行序列化与反序列化的呢？
+````
+Serializable接口的定义：
 
-    Serializable接口的定义：
-    
-    public interface Serializable {
-    }
-    读者可以尝试把code 1中的继承Serializable的代码去掉，再执行code 2，会抛出java.io.NotSerializableException。
+public interface Serializable {
+}
+````
+
+读者可以尝试把code 1中的继承Serializable的代码去掉，再执行code 2，会抛出java.io.NotSerializableException。
 
 其实这个问题也很好回答，我们再回到刚刚ObjectOutputStream的writeObject的调用栈：
 
     writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData--->invokeWriteObject
 
 writeObject0方法中有这么一段代码：
-
-    if (obj instanceof String) {
-                    writeString((String) obj, unshared);
-                } else if (cl.isArray()) {
-                    writeArray(obj, desc, unshared);
-                } else if (obj instanceof Enum) {
-                    writeEnum((Enum<?>) obj, desc, unshared);
-                } else if (obj instanceof Serializable) {
-                    writeOrdinaryObject(obj, desc, unshared);
-                } else {
-                    if (extendedDebugInfo) {
-                        throw new NotSerializableException(
-                            cl.getName() + "\n" + debugInfoStack.toString());
-                    } else {
-                        throw new NotSerializableException(cl.getName());
-                    }
-                }
+````
+if (obj instanceof String) {
+    writeString((String) obj, unshared);
+} else if (cl.isArray()) {
+    writeArray(obj, desc, unshared);
+} else if (obj instanceof Enum) {
+    writeEnum((Enum<?>) obj, desc, unshared);
+} else if (obj instanceof Serializable) {
+    writeOrdinaryObject(obj, desc, unshared);
+} else {
+    if (extendedDebugInfo) {
+        throw new NotSerializableException(
+            cl.getName() + "\n" + debugInfoStack.toString());
+    } else {
+        throw new NotSerializableException(cl.getName());
+    }
+}
+````
 在进行序列化操作时，会判断要被序列化的类是否是Enum、Array和Serializable类型，如果不是则直接抛出NotSerializableException。
 
-
 ## 序列化知识点总结
 
 > 1、如果一个类想被序列化，需要实现Serializable接口。否则将抛出NotSerializableException异常，这是因为，在序列化操作过程中会对类型进行检查，要求被序列化的类必须属于Enum、Array和Serializable类型其中的任何一种。
@@ -558,20 +548,3 @@ https://segmentfault.com/a/1190000012220863
 https://my.oschina.net/wuxinshui/blog/1511484
 https://blog.csdn.net/hukailee/article/details/81107412
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/6\343\200\201\346\212\275\350\261\241\347\261\273\345\222\214\346\216\245\345\217\243.md" "b/docs/Java/basic/\346\212\275\350\261\241\347\261\273\345\222\214\346\216\245\345\217\243.md"
similarity index 91%
rename from "docs/java/basic/6\343\200\201\346\212\275\350\261\241\347\261\273\345\222\214\346\216\245\345\217\243.md"
rename to "docs/Java/basic/\346\212\275\350\261\241\347\261\273\345\222\214\346\216\245\345\217\243.md"
index e3bd41a..40cd496 100644
--- "a/docs/java/basic/6\343\200\201\346\212\275\350\261\241\347\261\273\345\222\214\346\216\245\345\217\243.md"
+++ "b/docs/Java/basic/\346\212\275\350\261\241\347\261\273\345\222\214\346\216\245\345\217\243.md"
@@ -15,9 +15,7 @@
     * [设计思想区别](#设计思想区别)
     * [如何回答面试题：接口和抽象类的区别?](#如何回答面试题：接口和抽象类的区别)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -32,8 +30,6 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-
-
 <!-- more -->
 
 
@@ -50,7 +46,7 @@
 包含一个或多个抽象方法的类也必须被声明为抽象类。
 
 使用abstract修饰符来表示抽象方法以及抽象类。
-
+````
     //有抽象方法的类也必须被声明为abstract
     public abstract class Test1 {
      
@@ -58,10 +54,11 @@
     	public abstract void f();
     	
     }
+````
 抽象类除了包含抽象方法外，还可以包含具体的变量和具体的方法。类即使不包含抽象方法，也可以被声明为抽象类，防止被实例化。
 
 抽象类不能被实例化，也就是不能使用new关键字来得到一个抽象类的实例，抽象方法必须在子类中被实现。
-
+````
     //有抽象方法的类也必须被声明为abstract
     public class Test1 {
      
@@ -72,7 +69,6 @@
     		Driver driver=new Driver("驾驶员");
     		driver.work();
     	}
-    	
     }
     //一个抽象类
     abstract class People{
@@ -87,8 +83,7 @@
     	@Override
     	public void work() {
     		System.out.println("我的职业是"+this.work);
-    	}
-    	
+    	}	
     }
     class Driver extends People{
     	private String work;
@@ -99,29 +94,30 @@
     	public void work() {
     		System.out.println("我的职业是"+this.work);
     	}
-    	
     }
+````
+
 > 运行结果：
 > 我的职业是教师
 > 我的职业是驾驶员
 > 几点说明:
 
 抽象类不能直接使用，需要子类去实现抽象类，然后使用其子类的实例。然而可以创建一个变量，其类型也是一个抽象类，并让他指向具体子类的一个实例，也就是可以使用抽象类来充当形参，实际实现类为实参，也就是多态的应用。
-
+````
     People people=new Teacher("教师");
     people.work();
-
+````
 不能有抽象构造方法或抽象静态方法。
 
 如果非要使用new关键在来创建一个抽象类的实例的话，可以这样：
-
+````
     People people=new People() {
     	@Override
     	public void work() {
     	    //实现这个方法的具体功能
     	}
     		};
-
+````
 个人不推荐这种方法，代码读起来有点累。
 
 在下列情况下，一个类将成为抽象类：
@@ -147,14 +143,14 @@
 ### 一个抽象类小故事
 
 下面看一个关于抽象类的小故事
-
-<pre id="best-answer-content" name="code">问你个问题，你知道什么是“东西”吗？什么是“物体”吗？ 
-“麻烦你，小王。帮我把那个东西拿过来好吗” 
-在生活中，你肯定用过这个词－－东西。 
-小王：“你要让我帮你拿那个水杯吗？” 
-你要的是水杯类的对象。而东西是水杯的父类。通常东西类没有实例对象，但我们有时需要东西的引用指向它的子类实例。 
-
-你看你的房间乱成什么样子了，以后不要把东西乱放了，知道么？ 
+    
+    问你个问题，你知道什么是“东西”吗？什么是“物体”吗？ 
+    “麻烦你，小王。帮我把那个东西拿过来好吗” 
+    在生活中，你肯定用过这个词－－东西。 
+    小王：“你要让我帮你拿那个水杯吗？” 
+    你要的是水杯类的对象。而东西是水杯的父类。通常东西类没有实例对象，但我们有时需要东西的引用指向它的子类实例。 
+    
+    你看你的房间乱成什么样子了，以后不要把东西乱放了，知道么？ 
 
 上面讲的只是子类和父类。而没有说明抽象类的作用。抽象类是据有一个或多个抽象方法的类，必须声明为抽象类。抽象类的特点是，不能创建实例。 
 
@@ -165,6 +161,7 @@
 ### 一个抽象类小游戏
 
 接下来，我们来写一个小游戏。俄罗斯方块！我们来分析一下它需要什么类？
+
 我知道它要在一个矩形的房子里完成。这个房子的上面出现一个方块，慢慢的下落，当它接触到地面或是其它方块的尸体时，它就停止下落了。然后房子的上面又会出现一个新的方块，与前一个方块一样，也会慢慢的下落。在它还没有死亡之前，我可以尽量的移动和翻转它。这样可以使它起到落地时起到一定的作用，如果好的话，还可以减下少几行呢。这看起来好象人生一样，它在为后来人努力着。
 当然，我们不是真的要写一个游戏。所以我们简化它。我抽象出两个必须的类，一个是那个房间，或者就它地图也行。另一个是方块。我发现方块有很多种，数一下，共6种。它们都是四个小矩形构成的。但是它们还有很多不同，例如：它们的翻转方法不同。先把这个问题放到一边去，我们回到房子这个类中。
 
@@ -182,7 +179,7 @@
 
 把那些和“东西”差不多的类写成抽象的。而水杯一样的类就可以不是抽象的了。当然水杯也有几千块钱一个的和几块钱一个的。水杯也有子类，例如，我用的水杯都很高档，大多都是一次性的纸水杯。
 
-记住一点，面向对象不是来自于Java，面向对象就在你的生活中。而Java的面向对象是方便你解决复杂的问题。这不是说面向对象很简单，虽然面向对象很复杂，但Java知道，你很了解面向对象，因为它就在你身边。</pre>
+记住一点，面向对象不是来自于Java，面向对象就在你的生活中。而Java的面向对象是方便你解决复杂的问题。这不是说面向对象很简单，虽然面向对象很复杂，但Java知道，你很了解面向对象，因为它就在你身边。
 
 ## 接口介绍
 
@@ -230,7 +227,7 @@
   我们来举个例子，定义一个抽象类People，一个普通子类Student，两个接口。子类Student继承父类People,并实现接口Study，Write
 
 代码演示：
-
+````
     package demo;
     //构建一个抽象类People
     abstract class People{
@@ -307,7 +304,7 @@
     		student.stu();
     	}
     }
-
+````
 代码讲解：上述例子结合了抽象类和接口的知识，内容较多，同学们可以多看多敲一下，学习学习。
 
 接口的实现：类名 implements 接口名，有多个接口名，用“，”隔开即可。
@@ -320,7 +317,7 @@
     如电脑可以和各个设备连接，提供统一的USB接口，其他设备只能通过USB接口和电脑相连
     
     代码实现：
-    
+````   
     package demo;
      
     interface USB 
@@ -378,12 +375,12 @@
             computer.plugin(usb) ;   //实例化接口类， 在电脑上使用U盘
         }
     }
+````
 代码讲解：我们修改了主函数后，发现，使用了两次的向上转型给了USB，虽然使用的都是usb对象，但赋值的子类对象不一样，实现的方法体也不同，这就很像现实生活，无论我使用的是打印机，还是U盘，我都是通过USB接口和电脑连接的，这就是接口的作用之一——制定标准
 
 我们来个图继续帮助大家理解一下：
 
-![image](https://img-blog.csdn.net/20180429143444890?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NzQxOTcx/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230403203707.png)
 上面的图：我们学习前面的章节多态可以知道对象的多态可以通过动态绑定来实现，即使用向上转型，我们知道类，数组，接口都是引用类型变量，什么是引用类型变量？
 
 引用类型变量都会有一个地址的概念，即指向性的概念，当USB usb = new Print(),此时usb对象是指向new Print()的，当usb = new Flash()后，这时候usb变量就会指向new Flash()，我们会说这是子类对象赋值给了父类对象usb，而在内存中，我们应该说，usb指向了new Flash();
@@ -397,7 +394,7 @@
     由于创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要找到所有需要创建B的地方去逐个修正，只需要在工厂里修改即可，降低维护成本。同理，想把所有调用B的地方改成B的子类C，只需要在对应生产B的工厂中或者工厂的方法中修改其生产的对象为C即可，而不需要找到所有的new B（）改为newC()。
 
 代码演示：
-
+````
     package demo;
      
     import java.util.Scanner;
@@ -452,9 +449,12 @@
     		sc.close();
     	}
     }
+````
 代码讲解：上述代码部分我们讲一下factory这个类，类中有一个getInstance方法，我们用了static关键字修饰，在使用的时候我们就在main中使用类名.方法名调用。
-
+````
 Fruit f = factory.getInstance(ans);   //初始化参数
+
+````
 在Factory的getInstance()方法中，我们就可以通过逻辑的实现，将对象的创建和使用的过程分开了。
 
 
@@ -466,50 +466,57 @@ Fruit f = factory.getInstance(ans);   //初始化参数
 ### 基本语法区别
 
 在 Java 中，接口和抽象类的定义语法是不一样的。这里以动物类为例来说明，其中定义接口的示意代码如下：
-
-<pre>public interface Animal
+````
+public interface Animal
 {
     //所有动物都会吃
     public void eat();
 
     //所有动物都会飞
     public void fly();
-}</pre>
+}
+````
 
 定义抽象类的示意代码如下：
 
-<pre>public abstract class Animal
+````
+public abstract class Animal
 {
     //所有动物都会吃
     public abstract void eat();
 
     //所有动物都会飞
     public void fly(){};
-}</pre>
+}
+````
 
 可以看到，在接口内只能是功能的定义，而抽象类中则可以包括功能的定义和功能的实现。在接口中，所有的属性肯定是 public、static 和 final，所有的方法都是 abstract，所以可以默认不写上述标识符；在抽象类中，既可以包含抽象的定义，也可以包含具体的实现方法。
 
 在具体的实现类上，接口和抽象类的实 现类定义方式也是不一样的，其中接口实现类的示意代码如下：
 
-<pre>public class concreteAnimal implements Animal
+````
+public class concreteAnimal implements Animal
 {
     //所有动物都会吃
     public void eat(){}
 
     //所有动物都会飞
     public void fly(){}
-}</pre>
+}
+````
 
 抽象类的实现类示意代码如下：
 
-<pre>public class concreteAnimal extends Animal
+````
+public class concreteAnimal extends Animal
 {
     //所有动物都会吃
     public void eat(){}
 
     //所有动物都会飞
     public void fly(){}
-}</pre>
+}
+````
 
 可以看到，在接口的实现类中使用 implements 关键字；而在抽象类的实现类中，则使用 extends 关键字。一个接口的实现类可以实现多个接口，而一个抽象类的实现类则只能实现一个抽象类。
 
@@ -521,48 +528,53 @@ Fruit f = factory.getInstance(ans);   //初始化参数
 
 仍然以前面动物类的设计为例来说明接口和抽象类关于设计思想的区别，该动物类默认所有的动物都具有吃的功能，其中定义接口的示意代码如下：
 
-<pre>public interface Animal
+````
+public interface Animal
 {
     //所有动物都会吃
     public void eat();
-}</pre>
+}
+````
 
 定义抽象类的示意代码如下：
 
-<pre>public abstract class Animal
+````
+public abstract class Animal
 {
     //所有动物都会吃
     public abstract void eat();
-}</pre>
+}
+````
 
 不管是实现接口，还是继承抽象类的具体动物，都具有吃的功能，具体的动物类的示意代码如下。
 
 接口实现类的示意代码如下：
 
-<pre>public class concreteAnimal implements Animal
+````
+public class concreteAnimal implements Animal
 {
     //所有动物都会吃
     public void eat(){}
-}</pre>
+}
 
 抽象类的实现类示意代码如下：
 
-<pre>public class concreteAnimal extends Animal
+public class concreteAnimal extends Animal
 {
     //所有动物都会吃
     public void eat(){}
-}</pre>
+}
 
 当然，具体的动物类不光具有吃的功能，比如有些动物还会飞，而有些动物却会游泳，那么该如何设计这个抽象的动物类呢？可以别在接口和抽象类中增加飞的功能，其中定义接口的示意代码如下：
 
-<pre>public interface Animal
+public interface Animal
 {
     //所有动物都会吃
     public void eat();
 
     //所有动物都会飞
     public void fly();
-}</pre>
+}
 
 定义抽象类的示意代码如下：
 
@@ -577,38 +589,38 @@ Fruit f = factory.getInstance(ans);   //初始化参数
 
 这样一来，不管是接口还是抽象类的实现类，都具有飞的功能，这显然不能满足要求，因为只有一部分动物会飞，而会飞的却不一定是动物，比如飞机也会飞。那该如何设计呢？有很多种方案，比如再设计一个动物的接口类，该接口具有飞的功能，示意代码如下：
 
-<pre>public interface AnimaiFly
+public interface AnimaiFly
 {
     //所有动物都会飞
     public void fly();
-}</pre>
+}
 
 那些具体的动物类，如果有飞的功能的话，除了实现吃的接口外，再实现飞的接口，示意代码如下：
 
-<pre>public class concreteAnimal implements Animal,AnimaiFly
+public class concreteAnimal implements Animal,AnimaiFly
 {
     //所有动物都会吃
     public void eat(){}
 
     //动物会飞
     public void fly();
-}</pre>
+}
 
 那些不需要飞的功能的具体动物类只实现具体吃的功能的接口即可。另外一种解决方案是再设计一个动物的抽象类，该抽象类具有飞的功能，示意代码如下：
 
-<pre>public abstract class AnimaiFly
+public abstract class AnimaiFly
 {
     //动物会飞
     public void fly();
-}</pre>
+}
 
 但此时没有办法实现那些既有吃的功能，又有飞的功能的具体动物类。因为在 Java 中具体的实现类只能实现一个抽象类。一个折中的解决办法是，让这个具有飞的功能的抽象类，继承具有吃的功能的抽象类，示意代码如下：
 
-<pre>public abstract class AnimaiFly extends Animal
+public abstract class AnimaiFly extends Animal
 {
     //动物会飞
     public void fly();
-}</pre>
+}
 
 此时，对那些只需要吃的功能的具体动物类来说，继承 Animal 抽象类即可。对那些既有吃的功能又有飞的功能的具体动物类来说，则需要继承 AnimalFly 抽象类。
 
@@ -618,57 +630,58 @@ Fruit f = factory.getInstance(ans);   //初始化参数
 
 具有吃的功能的抽象动物类用抽象类来实现，示意代码如下：
 
-<pre>public abstract class Animal
+public abstract class Animal
 {
     //所有动物都会吃
     public abstract void eat();
-}</pre>
+}
 
 具有飞的功能的类用接口实现，示意代码如下：
 
-<pre>public interface AnimaiFly
+public interface AnimaiFly
 {
     //动物会飞
     public void fly();
-}</pre>
+}
 
 既具有吃的功能又具有飞的功能的具体的动物类，则继承 Animal 动物抽象类，实现 AnimalFly 接口，示意代码如下：
 
-<pre>public class concreteAnimal extends Animal implements AnimaiFly
+public class concreteAnimal extends Animal implements AnimaiFly
 {
     //所有动物都会吃
     public void eat(){}
 
     //动物会飞
     public void fly();
-}</pre>
+}
 
 或者具有吃的功能的抽象动物类用接口来实现，示意代码如下：
 
-<pre>public interface Animal
+public interface Animal
 {
     //所有动物都会吃
     public abstract void eat();
-}</pre>
+}
 
 具有飞的功能的类用抽象类实现，示意代码如下：
 
-<pre>public abstract class AnimaiFly
+public abstract class AnimaiFly
 {
     //动物会飞
     public void fly(){};
-}</pre>
+}
 
 既具有吃的功能又具有飞的功能的具体的动物类，则实现 Animal 动物类接口，继承 AnimaiFly 抽象类，示意代码如下：
 
-<pre>public class concreteAnimal extends AnimaiFly implements Animal
+public class concreteAnimal extends AnimaiFly implements Animal
 {
     //所有动物都会吃
     public void eat(){}
 
     //动物会飞
     public void fly();
-}</pre>
+}
+````
 
 这些解决方案有什么不同呢？再回过头来看接口和抽象类的区别：抽象类是对一组具有相同属性和方法的逻辑上有关系的事物的一种抽象，而接口则是对一组具有相同属性和方法的逻辑上不相关的事物的一种抽象，因此抽象类表示的是“is a”关系，接口表示的是“like a”关系。
 
@@ -717,21 +730,4 @@ https://www.runoob.com/java/java-interfaces.html
 https://blog.csdn.net/fengyunjh/article/details/6605085
 https://blog.csdn.net/xkfanhua/article/details/80567557
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
 
diff --git "a/docs/java/basic/14\343\200\201\346\236\232\344\270\276\347\261\273.md" "b/docs/Java/basic/\346\236\232\344\270\276\347\261\273.md"
similarity index 69%
rename from "docs/java/basic/14\343\200\201\346\236\232\344\270\276\347\261\273.md"
rename to "docs/Java/basic/\346\236\232\344\270\276\347\261\273.md"
index 2891f98..5fc7cb6 100644
--- "a/docs/java/basic/14\343\200\201\346\236\232\344\270\276\347\261\273.md"
+++ "b/docs/Java/basic/\346\236\232\344\270\276\347\261\273.md"
@@ -1,5 +1,4 @@
 # 目录
-
   * [初探枚举类](#初探枚举类)
     * [枚举类-语法](#枚举类-语法)
     * [枚举类的具体使用](#枚举类的具体使用)
@@ -20,9 +19,7 @@
   * [枚举 API](#枚举-api)
   * [总结](#总结)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 ---
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -94,136 +91,136 @@
 ### 枚举类的具体使用
 这部分内容参考https://blog.csdn.net/qq_27093465/article/details/52180865
 #### 常量
-
-    public class 常量 {
-    }
-    enum Color {
-        Red, Green, Blue, Yellow
-    }
-
+````
+public class 常量 {
+}
+enum Color {
+    Red, Green, Blue, Yellow
+}
+````
 #### switch
 
 JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。
-
-    public static void showColor(Color color) {
-            switch (color) {
-                case Red:
-                    System.out.println(color);
-                    break;
-                case Blue:
-                    System.out.println(color);
-                    break;
-                case Yellow:
-                    System.out.println(color);
-                    break;
-                case Green:
-                    System.out.println(color);
-                    break;
-            }
-        }
-
+````
+public static void showColor(Color color) {
+    switch (color) {
+        case Red:
+            System.out.println(color);
+            break;
+        case Blue:
+            System.out.println(color);
+            break;
+        case Yellow:
+            System.out.println(color);
+            break;
+        case Green:
+            System.out.println(color);
+            break;
+    }
+}
+````
 #### 向枚举中添加新方法
 
 如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。
-
-    enum Color {
-        //每个颜色都是枚举类的一个实例，并且构造方法要和枚举类的格式相符合。
-        //如果实例后面有其他内容，实例序列结束时要加分号。
-        Red("红色", 1), Green("绿色", 2), Blue("蓝色", 3), Yellow("黄色", 4);
-        String name;
-        int index;
-        Color(String name, int index) {
-            this.name = name;
-            this.index = index;
-        }
-        public void showAllColors() {
-            //values是Color实例的数组，在通过index和name可以获取对应的值。
-            for (Color color : Color.values()) {
-                System.out.println(color.index + ":" + color.name);
-            }
+````
+enum Color {
+    //每个颜色都是枚举类的一个实例，并且构造方法要和枚举类的格式相符合。
+    //如果实例后面有其他内容，实例序列结束时要加分号。
+    Red("红色", 1), Green("绿色", 2), Blue("蓝色", 3), Yellow("黄色", 4);
+    String name;
+    int index;
+    Color(String name, int index) {
+        this.name = name;
+        this.index = index;
+    }
+    public void showAllColors() {
+        //values是Color实例的数组，在通过index和name可以获取对应的值。
+        for (Color color : Color.values()) {
+            System.out.println(color.index + ":" + color.name);
         }
     }
-
+}
+````
 #### 覆盖枚举的方法
 所有枚举类都继承自Enum类，所以可以重写该类的方法
 下面给出一个toString()方法覆盖的例子。 
-
-    @Override
-    public String toString() {
-        return this.index + ":" + this.name;
-    }
-
+````
+@Override
+public String toString() {
+    return this.index + ":" + this.name;
+}
+````
 #### 实现接口
 
 所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。
-
-    enum Color implements Print{
-        @Override
-        public void print() {
-            System.out.println(this.name);
-        }
+````
+enum Color implements Print{
+    @Override
+    public void print() {
+        System.out.println(this.name);
     }
-
+}
+````
 #### 使用接口组织枚举  
 
  搞个实现接口，来组织枚举，简单讲，就是分类吧。如果大量使用枚举的话，这么干，在写代码的时候，就很方便调用啦。  
-     
-    public class 用接口组织枚举 {
-        public static void main(String[] args) {
-            Food cf = chineseFood.dumpling;
-            Food jf = Food.JapaneseFood.fishpiece;
-            for (Food food : chineseFood.values()) {
-                System.out.println(food);
-            }
-            for (Food food : Food.JapaneseFood.values()) {
-                System.out.println(food);
-            }
+````     
+public class 用接口组织枚举 {
+    public static void main(String[] args) {
+        Food cf = chineseFood.dumpling;
+        Food jf = Food.JapaneseFood.fishpiece;
+        for (Food food : chineseFood.values()) {
+            System.out.println(food);
         }
-    }
-    interface Food {
-        enum JapaneseFood implements Food {
-            suse, fishpiece
+        for (Food food : Food.JapaneseFood.values()) {
+            System.out.println(food);
         }
     }
-    enum chineseFood implements Food {
-        dumpling, tofu
+}
+interface Food {
+    enum JapaneseFood implements Food {
+        suse, fishpiece
     }
-
+}
+enum chineseFood implements Food {
+    dumpling, tofu
+}
+````
 #### 枚举类集合
 
 java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的 key是enum类型，而value则可以是任意类型。
 
 EnumSet在JDK中没有找到实现类，这里写一个EnumMap的例子
-    
-    public class 枚举类集合 {
-        public static void main(String[] args) {
-            EnumMap<Color, String> map = new EnumMap<Color, String>(Color.class);
-            map.put(Color.Blue, "Blue");
-            map.put(Color.Yellow, "Yellow");
-            map.put(Color.Red, "Red");
-            System.out.println(map.get(Color.Red));
-        }
+````    
+public class 枚举类集合 {
+    public static void main(String[] args) {
+        EnumMap<Color, String> map = new EnumMap<Color, String>(Color.class);
+        map.put(Color.Blue, "Blue");
+        map.put(Color.Yellow, "Yellow");
+        map.put(Color.Red, "Red");
+        System.out.println(map.get(Color.Red));
     }
-
+}
+````
 ## 使用枚举类的注意事项
-![image](https://img-blog.csdn.net/20170112172420090)
+![image](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230403212903.png)
 
 枚举类型对象之间的值比较，是可以使用==，直接来比较值，是否相等的，不是必须使用equals方法的哟。
 
 因为枚举类Enum已经重写了equals方法
-
-    /**
-     * Returns true if the specified object is equal to this
-     * enum constant.
-     *
-     * @param other the object to be compared for equality with this object.
-     * @return  true if the specified object is equal to this
-     *          enum constant.
-     */
-    public final boolean equals(Object other) {
-        return this==other;
-    }
-
+````
+/**
+ * Returns true if the specified object is equal to this
+ * enum constant.
+ *
+ * @param other the object to be compared for equality with this object.
+ * @return  true if the specified object is equal to this
+ *          enum constant.
+ */
+public final boolean equals(Object other) {
+    return this==other;
+}
+````
 ## 枚举类的实现原理
 
 这部分参考https://blog.csdn.net/mhmyqn/article/details/48087247
@@ -235,46 +232,46 @@ EnumSet在JDK中没有找到实现类，这里写一个EnumMap的例子
 > Java在1.5中添加了java.lang.Enum抽象类，它是所有枚举类型基类。提供了一些基础属性和基础方法。同时，对把枚举用作Set和Map也提供了支持，即java.util.EnumSet和java.util.EnumMap。
 
 接下来定义一个简单的枚举类
-
-    public enum Day {
-        MONDAY {
-            @Override
-            void say() {
-                System.out.println("MONDAY");
-            }
+````
+public enum Day {
+    MONDAY {
+        @Override
+        void say() {
+            System.out.println("MONDAY");
         }
-        , TUESDAY {
-            @Override
-            void say() {
-                System.out.println("TUESDAY");
-            }
-        }, FRIDAY("work"){
-            @Override
-            void say() {
-                System.out.println("FRIDAY");
-            }
-        }, SUNDAY("free"){
-            @Override
-            void say() {
-                System.out.println("SUNDAY");
-            }
-        };
-        String work;
-        //没有构造参数时，每个实例可以看做常量。
-        //使用构造参数时，每个实例都会变得不一样，可以看做不同的类型，所以编译后会生成实例个数对应的class。
-        private Day(String work) {
-            this.work = work;
+    }
+    , TUESDAY {
+        @Override
+        void say() {
+            System.out.println("TUESDAY");
         }
-        private Day() {
-    
+    }, FRIDAY("work"){
+        @Override
+        void say() {
+            System.out.println("FRIDAY");
         }
-        //枚举实例必须实现枚举类中的抽象方法
-        abstract void say ();
-    
+    }, SUNDAY("free"){
+        @Override
+        void say() {
+            System.out.println("SUNDAY");
+        }
+    };
+    String work;
+    //没有构造参数时，每个实例可以看做常量。
+    //使用构造参数时，每个实例都会变得不一样，可以看做不同的类型，所以编译后会生成实例个数对应的class。
+    private Day(String work) {
+        this.work = work;
     }
+    private Day() {
 
-反编译结果
+    }
+    //枚举实例必须实现枚举类中的抽象方法
+    abstract void say ();
 
+}
+````
+反编译结果
+````
     D:\MyTech\out\production\MyTech\com\javase\枚举类>javap Day.class
     Compiled from "Day.java"
     
@@ -291,43 +288,43 @@ EnumSet在JDK中没有找到实现类，这里写一个EnumMap的例子
       com.javase.枚举类.Day(java.lang.String, int, java.lang.String, com.javase.枚举类.Day$1);
       static {};
     }
-
+````
 > 可以看到，一个枚举在经过编译器编译过后，变成了一个抽象类，它继承了java.lang.Enum；而枚举中定义的枚举常量，变成了相应的public static final属性，而且其类型就抽象类的类型，名字就是枚举常量的名字.
 >
 > 同时我们可以在Operator.class的相同路径下看到四个内部类的.class文件com/mikan/Day$1.class、com/mikan/Day$2.class、com/mikan/Day$3.class、com/mikan/Day$4.class，也就是说这四个命名字段分别使用了内部类来实现的；同时添加了两个方法values()和valueOf(String)；我们定义的构造方法本来只有一个参数，但却变成了三个参数；同时还生成了一个静态代码块。这些具体的内容接下来仔细看看。
 
 下面分析一下字节码中的各部分，其中：
-
-    InnerClasses:
-         static #23; //class com/javase/枚举类/Day$4
-         static #18; //class com/javase/枚举类/Day$3
-         static #14; //class com/javase/枚举类/Day$2
-         static #10; //class com/javase/枚举类/Day$1
-
+````
+InnerClasses:
+     static #23; //class com/javase/枚举类/Day$4
+     static #18; //class com/javase/枚举类/Day$3
+     static #14; //class com/javase/枚举类/Day$2
+     static #10; //class com/javase/枚举类/Day$1
+````
 从中可以看到它有4个内部类，这四个内部类的详细信息后面会分析。
-
-    static {};
-        descriptor: ()V
-        flags: ACC_STATIC
-        Code:
-          stack=5, locals=0, args_size=0
-             0: new           #10                 // class com/javase/枚举类/Day$1
-             3: dup
-             4: ldc           #11                 // String MONDAY
-             6: iconst_0
-             7: invokespecial #12                 // Method com/javase/枚举类/Day$1."<init>":(Ljava/lang/String;I)V
-            10: putstatic     #13                 // Field MONDAY:Lcom/javase/枚举类/Day;
-            13: new           #14                 // class com/javase/枚举类/Day$2
-            16: dup
-            17: ldc           #15                 // String TUESDAY
-            19: iconst_1
-            20: invokespecial #16                 // Method com/javase/枚举类/Day$2."<init>":(Ljava/lang/String;I)V
-            //后面类似，这里省略
-    }
-
+````
+static {};
+    descriptor: ()V
+    flags: ACC_STATIC
+    Code:
+      stack=5, locals=0, args_size=0
+         0: new           #10                 // class com/javase/枚举类/Day$1
+         3: dup
+         4: ldc           #11                 // String MONDAY
+         6: iconst_0
+         7: invokespecial #12                 // Method com/javase/枚举类/Day$1."<init>":(Ljava/lang/String;I)V
+        10: putstatic     #13                 // Field MONDAY:Lcom/javase/枚举类/Day;
+        13: new           #14                 // class com/javase/枚举类/Day$2
+        16: dup
+        17: ldc           #15                 // String TUESDAY
+        19: iconst_1
+        20: invokespecial #16                 // Method com/javase/枚举类/Day$2."<init>":(Ljava/lang/String;I)V
+        //后面类似，这里省略
+}
+````
 其实编译器生成的这个静态代码块做了如下工作：分别设置生成的四个公共静态常量字段的值，同时编译器还生成了一个静态字段$VALUES，保存的是枚举类型定义的所有枚举常量
 编译器添加的values方法：
-
+````
     public static com.javase.Day[] values();  
       flags: ACC_PUBLIC, ACC_STATIC  
       Code:  
@@ -336,16 +333,17 @@ EnumSet在JDK中没有找到实现类，这里写一个EnumMap的例子
            3: invokevirtual #3                  // Method "[Lcom/mikan/Day;".clone:()Ljava/lang/Object;  
            6: checkcast     #4                  // class "[Lcom/javase/Day;"  
            9: areturn  
-    这个方法是一个公共的静态方法，所以我们可以直接调用该方法（Day.values()）,返回这个枚举值的数组，另外，这个方法的实现是，克隆在静态代码块中初始化的$VALUES字段的值，并把类型强转成Day[]类型返回。
+````   
+这个方法是一个公共的静态方法，所以我们可以直接调用该方法（Day.values()）,返回这个枚举值的数组，另外，这个方法的实现是，克隆在静态代码块中初始化的$VALUES字段的值，并把类型强转成Day[]类型返回。
 
 造方法为什么增加了两个参数？
 
 
 有一个问题，构造方法我们明明只定义了一个参数，为什么生成的构造方法是三个参数呢？
 
-    从Enum类中我们可以看到，为每个枚举都定义了两个属性，name和ordinal，name表示我们定义的枚举常量的名称，如FRIDAY、TUESDAY，而ordinal是一个顺序号，根据定义的顺序分别赋予一个整形值，从0开始。在枚举常量初始化时，会自动为初始化这两个字段，设置相应的值，所以才在构造方法中添加了两个参数。即：
-    
-    另外三个枚举常量生成的内部类基本上差不多，这里就不重复说明了。
+从Enum类中我们可以看到，为每个枚举都定义了两个属性，name和ordinal，name表示我们定义的枚举常量的名称，如FRIDAY、TUESDAY，而ordinal是一个顺序号，根据定义的顺序分别赋予一个整形值，从0开始。在枚举常量初始化时，会自动为初始化这两个字段，设置相应的值，所以才在构造方法中添加了两个参数。即：
+
+另外三个枚举常量生成的内部类基本上差不多，这里就不重复说明了。
 
 > 我们可以从Enum类的代码中看到，定义的name和ordinal属性都是final的，而且大部分方法也都是final的，特别是clone、readObject、writeObject这三个方法，这三个方法和枚举通过静态代码块来进行初始化一起。
 
@@ -507,20 +505,3 @@ https://segmentfault.com/a/1190000012220863
 https://my.oschina.net/wuxinshui/blog/1511484
 https://blog.csdn.net/hukailee/article/details/81107412
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/13\343\200\201\346\263\233\345\236\213.md" "b/docs/Java/basic/\346\263\233\345\236\213.md"
similarity index 58%
rename from "docs/java/basic/13\343\200\201\346\263\233\345\236\213.md"
rename to "docs/Java/basic/\346\263\233\345\236\213.md"
index 2251e75..f9a9ba6 100644
--- "a/docs/java/basic/13\343\200\201\346\263\233\345\236\213.md"
+++ "b/docs/Java/basic/\346\263\233\345\236\213.md"
@@ -15,9 +15,7 @@
   * [泛型上下边界](#泛型上下边界)
   * [泛型常见面试题](#泛型常见面试题)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -44,48 +42,45 @@
 > 
 > 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
 
-
-
 ### 一个栗子
 
 一个被举了无数次的例子：
-
-    List arrayList = new ArrayList();
-    arrayList.add("aaaa");
-    arrayList.add(100);
-    
-    for(int i = 0; i< arrayList.size();i++){
-        String item = (String)arrayList.get(i);
-        Log.d("泛型测试","item = " + item);
-    }
-
+````
+List arrayList = new ArrayList();
+arrayList.add("aaaa");
+arrayList.add(100);
+
+for(int i = 0; i< arrayList.size();i++){
+    String item = (String)arrayList.get(i);
+    Log.d("泛型测试","item = " + item);
+}
+````
 毫无疑问，程序的运行结果会以崩溃结束：
 
-java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
+    java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
 
 ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。
 
 我们将第一行声明初始化list的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题。
-
+````
 List<String> arrayList = new ArrayList<String>();
 ...
 //arrayList.add(100); 在编译阶段，编译器就会报错
-
+````
 ### 特性
 
 泛型只在编译阶段有效。看下面的代码：
+````
+List<String> stringArrayList = new ArrayList<String>();
+List<Integer> integerArrayList = new ArrayList<Integer>();
 
-    List<String> stringArrayList = new ArrayList<String>();
-    List<Integer> integerArrayList = new ArrayList<Integer>();
-    
-    Class classStringArrayList = stringArrayList.getClass();
-    Class classIntegerArrayList = integerArrayList.getClass();
-    
-    if(classStringArrayList.equals(classIntegerArrayList)){
-        Log.d("泛型测试","类型相同");
-    }
-
+Class classStringArrayList = stringArrayList.getClass();
+Class classIntegerArrayList = integerArrayList.getClass();
 
+if(classStringArrayList.equals(classIntegerArrayList)){
+    Log.d("泛型测试","类型相同");
+}
+````
 > 通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。
 > 
 对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。
@@ -101,49 +96,49 @@ List<String> arrayList = new ArrayList<String>();
 > 泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。
 > 
 > 泛型类的最基本写法（这么看可能会有点晕，会在下面的例子中详解）：
-
+````
     class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
       private 泛型标识 /*（成员变量类型）*/ var; 
       .....
     
       }
-
+````
 一个最普通的泛型类：
 
 //此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
+````
+//在实例化泛型类时，必须指定T的具体类型
+public class Generic<T>{
+    //在类中声明的泛型整个类里面都可以用，除了静态部分，因为泛型是实例化时声明的。
+    //静态区域的代码在编译时就已经确定，只与类相关
+    class A <E>{
+        T t;
+    }
+    //类里面的方法或类中再次声明同名泛型是允许的，并且该泛型会覆盖掉父类的同名泛型T
+    class B <T>{
+        T t;
+    }
+    //静态内部类也可以使用泛型，实例化时赋予泛型实际类型
+    static class C <T> {
+        T t;
+    }
+    public static void main(String[] args) {
+        //报错，不能使用T泛型，因为泛型T属于实例不属于类
+//        T t = null;
+    }
 
-    //在实例化泛型类时，必须指定T的具体类型
-    public class Generic<T>{
-        //在类中声明的泛型整个类里面都可以用，除了静态部分，因为泛型是实例化时声明的。
-        //静态区域的代码在编译时就已经确定，只与类相关
-        class A <E>{
-            T t;
-        }
-        //类里面的方法或类中再次声明同名泛型是允许的，并且该泛型会覆盖掉父类的同名泛型T
-        class B <T>{
-            T t;
-        }
-        //静态内部类也可以使用泛型，实例化时赋予泛型实际类型
-        static class C <T> {
-            T t;
-        }
-        public static void main(String[] args) {
-            //报错，不能使用T泛型，因为泛型T属于实例不属于类
-    //        T t = null;
-        }
-    
-        //key这个成员变量的类型为T,T的类型由外部指定
-        private T key;
-    
-        public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
-            this.key = key;
-        }
-    
-        public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
-            return key;
-        }
+    //key这个成员变量的类型为T,T的类型由外部指定
+    private T key;
+
+    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
+        this.key = key;
     }
 
+    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
+        return key;
+    }
+}
+````
 > 12-27 09:20:04.432 13063-13063/? D/泛型测试: key is 123456
 
 > 12-27 09:20:04.432 13063-13063/? D/泛型测试: key is key_vlaue
@@ -151,22 +146,22 @@ List<String> arrayList = new ArrayList<String>();
 > 定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。
 
 看一个例子：
-
-    Generic generic = new Generic("111111");
-    Generic generic1 = new Generic(4444);
-    Generic generic2 = new Generic(55.55);
-    Generic generic3 = new Generic(false);
-    
-    Log.d("泛型测试","key is " + generic.getKey());
-    Log.d("泛型测试","key is " + generic1.getKey());
-    Log.d("泛型测试","key is " + generic2.getKey());
-    Log.d("泛型测试","key is " + generic3.getKey());
-    
-    D/泛型测试: key is 111111
-    D/泛型测试: key is 4444
-    D/泛型测试: key is 55.55
-    D/泛型测试: key is false
-
+````
+Generic generic = new Generic("111111");
+Generic generic1 = new Generic(4444);
+Generic generic2 = new Generic(55.55);
+Generic generic3 = new Generic(false);
+
+Log.d("泛型测试","key is " + generic.getKey());
+Log.d("泛型测试","key is " + generic1.getKey());
+Log.d("泛型测试","key is " + generic2.getKey());
+Log.d("泛型测试","key is " + generic3.getKey());
+
+D/泛型测试: key is 111111
+D/泛型测试: key is 4444
+D/泛型测试: key is 55.55
+D/泛型测试: key is false
+````
 注意：
 泛型的类型参数只能是类类型，不能是简单类型。
 不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。
@@ -176,78 +171,78 @@ List<String> arrayList = new ArrayList<String>();
 ### 泛型接口
 
 泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中，可以看一个例子：
-
-    //定义一个泛型接口
-    public interface Generator<T> {
-        public T next();
-    }
-
+````
+//定义一个泛型接口
+public interface Generator<T> {
+    public T next();
+}
+````
 当实现泛型接口的类，未传入泛型实参时：
-
-    /**
-     * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
-     * 即：class FruitGenerator<T> implements Generator<T>{
-     * 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
-     */
-    class FruitGenerator<T> implements Generator<T>{
-        @Override
-        public T next() {
-            return null;
-        }
+````
+/**
+ * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
+ * 即：class FruitGenerator<T> implements Generator<T>{
+ * 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
+ */
+class FruitGenerator<T> implements Generator<T>{
+    @Override
+    public T next() {
+        return null;
     }
-
+}
+````
 当实现泛型接口的类，传入泛型实参时：
-
-    /**
-     * 传入泛型实参时：
-     * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
-     * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
-     * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
-     * 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
-     */
-    public class FruitGenerator implements Generator<String> {
-    
-        private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
-    
-        @Override
-        public String next() {
-            Random rand = new Random();
-            return fruits[rand.nextInt(3)];
-        }
+````
+/**
+ * 传入泛型实参时：
+ * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
+ * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
+ * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
+ * 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
+ */
+public class FruitGenerator implements Generator<String> {
+
+    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
+
+    @Override
+    public String next() {
+        Random rand = new Random();
+        return fruits[rand.nextInt(3)];
     }
-
+}
+````
 ### 泛型通配符
 
 我们知道Ingeter是Number的一个子类，同时在特性章节中我们也验证过Generic<Ingeter>与Generic<Number>实际上是相同的一种基本类型。那么问题来了，在使用Generic<Number>作为形参的方法中，能否使用Generic<Ingeter>的实例传入呢？在逻辑上类似于Generic<Number>和Generic<Ingeter>是否可以看成具有父子关系的泛型类型呢？
 
 为了弄清楚这个问题，我们使用Generic<T>这个泛型类继续看下面的例子：
+````
+public void showKeyValue1(Generic<Number> obj){
+    Log.d("泛型测试","key value is " + obj.getKey());
+}
 
-    public void showKeyValue1(Generic<Number> obj){
-        Log.d("泛型测试","key value is " + obj.getKey());
-    }
-    
-    Generic<Integer> gInteger = new Generic<Integer>(123);
-    Generic<Number> gNumber = new Generic<Number>(456);
-    
-    showKeyValue(gNumber);
-    
-    // showKeyValue这个方法编译器会为我们报错：Generic<java.lang.Integer> 
-    // cannot be applied to Generic<java.lang.Number>
-    // showKeyValue(gInteger);
+Generic<Integer> gInteger = new Generic<Integer>(123);
+Generic<Number> gNumber = new Generic<Number>(456);
+
+showKeyValue(gNumber);
 
+// showKeyValue这个方法编译器会为我们报错：Generic<java.lang.Integer> 
+// cannot be applied to Generic<java.lang.Number>
+// showKeyValue(gInteger);
+````
 通过提示信息我们可以看到Generic<Integer>不能被看作为`Generic<Number>的子类。由此可以看出:同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
 
 回到上面的例子，如何解决上面的问题？总不能为了定义一个新的方法来处理Generic<Integer>类型的类，这显然与java中的多台理念相违背。因此我们需要一个在逻辑上可以表示同时是Generic<Integer>和Generic<Number>父类的引用类型。由此类型通配符应运而生。
 
 我们可以将上面的方法改一下：
-
-    public void showKeyValue1(Generic<?> obj){
-        Log.d("泛型测试","key value is " + obj.getKey());
-
+````
+public void showKeyValue1(Generic<?> obj){
+    Log.d("泛型测试","key value is " + obj.getKey());
+````
 类型通配符一般是使用？代替具体的类型实参，注意， 此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。
 
 可以解决当具体类型不确定的时候，这个通配符就是 ?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型
-
+````
 public void showKeyValue(Generic<Number> obj){
         System.out.println(obj);
     }
@@ -266,7 +261,7 @@ public void showKeyValue(Generic<Number> obj){
     // showKeyValue这个方法编译器会为我们报错：Generic<java.lang.Integer>
     // cannot be applied to Generic<java.lang.Number>
     // showKeyValue(gInteger);
-。
+````
 
 ### 泛型方法
 
@@ -274,167 +269,165 @@ public void showKeyValue(Generic<Number> obj){
 
 尤其是我们见到的大多数泛型类中的成员方法也都使用了泛型，有的甚至泛型类中也包含着泛型方法，这样在初学者中非常容易将泛型方法理解错了。
 泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。
+````
+/**
+ * 泛型方法的基本介绍
+ * @param tClass 传入的泛型实参
+ * @return T 返回值为T类型
+ * 说明：
+ *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
+ *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
+ *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
+ *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
+ */
+    public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
+      IllegalAccessException{
+            T instance = tClass.newInstance();
+            return instance;
+    }
 
-    /**
-     * 泛型方法的基本介绍
-     * @param tClass 传入的泛型实参
-     * @return T 返回值为T类型
-     * 说明：
-     *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
-     *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
-     *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
-     *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
-     */
-        public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
-          IllegalAccessException{
-                T instance = tClass.newInstance();
-                return instance;
-        }
-    
-    Object obj = genericMethod(Class.forName("com.test.test"));
-
+Object obj = genericMethod(Class.forName("com.test.test"));
+````
 ### 泛型方法的基本用法
 
 光看上面的例子有的同学可能依然会非常迷糊，我们再通过一个例子，把我泛型方法再总结一下。
-
-    /** 
-     * 这才是一个真正的泛型方法。
-     * 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
-     * 这个T可以出现在这个泛型方法的任意位置.
-     * 泛型的数量也可以为任意多个 
-     *    如：public <T,K> K showKeyName(Generic<T> container){
-     *        ...
-     *        }
-     */
-    
-        public class 泛型方法 {
-        @Test
-        public void test() {
-            test1();
-            test2(new Integer(2));
-            test3(new int[3],new Object());
-    
-            //打印结果
-    //        null
-    //        2
-    //        [I@3d8c7aca
-    //        java.lang.Object@5ebec15
-        }
-        //该方法使用泛型T
-        public <T> void test1() {
-            T t = null;
-            System.out.println(t);
-        }
-        //该方法使用泛型T
-        //并且参数和返回值都是T类型
-        public <T> T test2(T t) {
-            System.out.println(t);
-            return t;
-        }
-    
-        //该方法使用泛型T,E
-        //参数包括T,E
-        public <T, E> void test3(T t, E e) {
-            System.out.println(t);
-            System.out.println(e);
-        }
+````
+/** 
+ * 这才是一个真正的泛型方法。
+ * 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
+ * 这个T可以出现在这个泛型方法的任意位置.
+ * 泛型的数量也可以为任意多个 
+ *    如：public <T,K> K showKeyName(Generic<T> container){
+ *        ...
+ *        }
+ */
+
+    public class 泛型方法 {
+    @Test
+    public void test() {
+        test1();
+        test2(new Integer(2));
+        test3(new int[3],new Object());
+
+        //打印结果
+        //null
+        //2
+        //[I@3d8c7aca
+        //java.lang.Object@5ebec15
+    }
+    //该方法使用泛型T
+    public <T> void test1() {
+        T t = null;
+        System.out.println(t);
+    }
+    //该方法使用泛型T
+    //并且参数和返回值都是T类型
+    public <T> T test2(T t) {
+        System.out.println(t);
+        return t;
     }
 
-
-​    
+    //该方法使用泛型T,E
+    //参数包括T,E
+    public <T, E> void test3(T t, E e) {
+        System.out.println(t);
+        System.out.println(e);
+    }
+}
+````
 
 ### 类中的泛型方法
 
 当然这并不是泛型方法的全部，泛型方法可以出现杂任何地方和任何场景中使用。但是有一种情况是非常特殊的，当泛型方法出现在泛型类中时，我们再通过一个例子看一下
-
-    //注意泛型类先写类名再写泛型，泛型方法先写泛型再写方法名
-    //类中声明的泛型在成员和方法中可用
-    class A <T, E>{
-        {
-            T t1 ;
-        }
-        A (T t){
-            this.t = t;
-        }
-        T t;
-    
-        public void test1() {
-            System.out.println(this.t);
-        }
-    
-        public void test2(T t,E e) {
-            System.out.println(t);
-            System.out.println(e);
-        }
+````
+//注意泛型类先写类名再写泛型，泛型方法先写泛型再写方法名
+//类中声明的泛型在成员和方法中可用
+class A <T, E>{
+    {
+        T t1 ;
     }
-    @Test
-    public void run () {
-        A <Integer,String > a = new A<>(1);
-        a.test1();
-        a.test2(2,"ds");
-    //        1
-    //        2
-    //        ds
+    A (T t){
+        this.t = t;
     }
-    
-    static class B <T>{
-        T t;
-        public void go () {
-            System.out.println(t);
-        }
+    T t;
+
+    public void test1() {
+        System.out.println(this.t);
     }
 
+    public void test2(T t,E e) {
+        System.out.println(t);
+        System.out.println(e);
+    }
+}
+@Test
+public void run () {
+    A <Integer,String > a = new A<>(1);
+    a.test1();
+    a.test2(2,"ds");
+//        1
+//        2
+//        ds
+}
+
+static class B <T>{
+    T t;
+    public void go () {
+        System.out.println(t);
+    }
+}
+````
 ### 泛型方法与可变参数
 
 再看一个泛型方法和可变参数的例子：
-
-    public class 泛型和可变参数 {
-        @Test
-        public void test () {
-            printMsg("dasd",1,"dasd",2.0,false);
-            print("dasdas","dasdas", "aa");
-        }
-        //普通可变参数只能适配一种类型
-        public void print(String ... args) {
-            for(String t : args){
-                System.out.println(t);
-            }
+````
+public class 泛型和可变参数 {
+    @Test
+    public void test () {
+        printMsg("dasd",1,"dasd",2.0,false);
+        print("dasdas","dasdas", "aa");
+    }
+    //普通可变参数只能适配一种类型
+    public void print(String ... args) {
+        for(String t : args){
+            System.out.println(t);
         }
-        //泛型的可变参数可以匹配所有类型的参数。。有点无敌
-        public <T> void printMsg( T... args){
-            for(T t : args){
-                System.out.println(t);
-            }
+    }
+    //泛型的可变参数可以匹配所有类型的参数。。有点无敌
+    public <T> void printMsg( T... args){
+        for(T t : args){
+            System.out.println(t);
         }
-            //打印结果：
-        //dasd
-        //1
-        //dasd
-        //2.0
-        //false
-    
     }
+        //打印结果：
+    //dasd
+    //1
+    //dasd
+    //2.0
+    //false
 
+}
+````
 ### 静态方法与泛型
 
 静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。
 
 即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。
+````
+public class StaticGenerator<T> {
+    ....
+    ....
+    /**
+     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
+     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
+     * 如：public static void show(T t){..},此时编译器会提示错误信息：
+          "StaticGenerator cannot be refrenced from static context"
+     */
+    public static <T> void show(T t){
 
-    public class StaticGenerator<T> {
-        ....
-        ....
-        /**
-         * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
-         * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
-         * 如：public static void show(T t){..},此时编译器会提示错误信息：
-              "StaticGenerator cannot be refrenced from static context"
-         */
-        public static <T> void show(T t){
-    
-        }
     }
-
+}
+````
 ## 泛型方法总结
 
 泛型方法能使方法独立于类而产生变化，以下是一个基本的指导原则：
@@ -445,90 +438,93 @@ public void showKeyValue(Generic<Number> obj){
 在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。
 
 为泛型添加上边界，即传入的类型实参必须是指定类型的子类型
+````
+public class 泛型通配符与边界 {
+    public void showKeyValue(Generic<Number> obj){
+        System.out.println("key value is " + obj.getKey());
+    }
+    @Test
+    public void main() {
+        Generic<Integer> gInteger = new Generic<Integer>(123);
+        Generic<Number> gNumber = new Generic<Number>(456);
+        showKeyValue(gNumber);
+        //泛型中的子类也无法作为父类引用传入
+//        showKeyValue(gInteger);
+    }
+    //直接使用？通配符可以接受任何类型作为泛型传入
+    public void showKeyValueYeah(Generic<?> obj) {
+        System.out.println(obj);
+    }
+    //只能传入number的子类或者number
+    public void showKeyValue1(Generic<? extends Number> obj){
+        System.out.println(obj);
+    }
 
-    public class 泛型通配符与边界 {
-        public void showKeyValue(Generic<Number> obj){
-            System.out.println("key value is " + obj.getKey());
-        }
-        @Test
-        public void main() {
-            Generic<Integer> gInteger = new Generic<Integer>(123);
-            Generic<Number> gNumber = new Generic<Number>(456);
-            showKeyValue(gNumber);
-            //泛型中的子类也无法作为父类引用传入
-    //        showKeyValue(gInteger);
-        }
-        //直接使用？通配符可以接受任何类型作为泛型传入
-        public void showKeyValueYeah(Generic<?> obj) {
-            System.out.println(obj);
-        }
-        //只能传入number的子类或者number
-        public void showKeyValue1(Generic<? extends Number> obj){
-            System.out.println(obj);
-        }
-    
-        //只能传入Integer的父类或者Integer
-        public void showKeyValue2(Generic<? super Integer> obj){
-            System.out.println(obj);
-        }
-    
-        @Test
-        public void testup () {
-            //这一行代码编译器会提示错误，因为String类型并不是Number类型的子类
-            //showKeyValue1(generic1);
-            Generic<String> generic1 = new Generic<String>("11111");
-            Generic<Integer> generic2 = new Generic<Integer>(2222);
-            Generic<Float> generic3 = new Generic<Float>(2.4f);
-            Generic<Double> generic4 = new Generic<Double>(2.56);
-    
-            showKeyValue1(generic2);
-            showKeyValue1(generic3);
-            showKeyValue1(generic4);
-        }
-    
-        @Test
-        public void testdown () {
-    
-            Generic<String> generic1 = new Generic<String>("11111");
-            Generic<Integer> generic2 = new Generic<Integer>(2222);
-            Generic<Number> generic3 = new Generic<Number>(2);
-    //        showKeyValue2(generic1);本行报错，因为String并不是Integer的父类
-            showKeyValue2(generic2);
-            showKeyValue2(generic3);
-        }
+    //只能传入Integer的父类或者Integer
+    public void showKeyValue2(Generic<? super Integer> obj){
+        System.out.println(obj);
+    }
+
+    @Test
+    public void testup () {
+        //这一行代码编译器会提示错误，因为String类型并不是Number类型的子类
+        //showKeyValue1(generic1);
+        Generic<String> generic1 = new Generic<String>("11111");
+        Generic<Integer> generic2 = new Generic<Integer>(2222);
+        Generic<Float> generic3 = new Generic<Float>(2.4f);
+        Generic<Double> generic4 = new Generic<Double>(2.56);
+
+        showKeyValue1(generic2);
+        showKeyValue1(generic3);
+        showKeyValue1(generic4);
     }
 
+    @Test
+    public void testdown () {
+
+        Generic<String> generic1 = new Generic<String>("11111");
+        Generic<Integer> generic2 = new Generic<Integer>(2222);
+        Generic<Number> generic3 = new Generic<Number>(2);
+//        showKeyValue2(generic1);本行报错，因为String并不是Integer的父类
+        showKeyValue2(generic2);
+        showKeyValue2(generic3);
+    }
+}
+````
 == 关于泛型数组要提一下 ==
 
 看到了很多文章中都会提起泛型数组，经过查看sun的说明文档，在java中是”不能创建一个确切的泛型类型的数组”的。
 
-    也就是说下面的这个例子是不可以的：
-    
-    List<String>[] ls = new ArrayList<String>[10];  
-    
-    而使用通配符创建泛型数组是可以的，如下面这个例子：
-    
-    List<?>[] ls = new ArrayList<?>[10];  
-    
-    这样也是可以的：
-    
-    List<String>[] ls = new ArrayList[10];
+也就是说下面的这个例子是不可以的：
+````    
+List<String>[] ls = new ArrayList<String>[10];  
+
+而使用通配符创建泛型数组是可以的，如下面这个例子：
+
+List<?>[] ls = new ArrayList<?>[10];  
 
+这样也是可以的：
+
+List<String>[] ls = new ArrayList[10];
+````
 下面使用Sun的一篇文档的一个例子来说明这个问题：
 
-    List<String>[] lsa = new List<String>[10]; // Not really allowed.    
-    Object o = lsa;    
-    Object[] oa = (Object[]) o;    
-    List<Integer> li = new ArrayList<Integer>();    
-    li.add(new Integer(3));    
-    oa[1] = li; // Unsound, but passes run time store check    
-    String s = lsa[1].get(0); // Run-time error: ClassCastException.
+````
+List<String>[] lsa = new List<String>[10]; // Not really allowed.    
+Object o = lsa;    
+Object[] oa = (Object[]) o;    
+List<Integer> li = new ArrayList<Integer>();    
+li.add(new Integer(3));    
+oa[1] = li; // Unsound, but passes run time store check    
+String s = lsa[1].get(0); // Run-time error: ClassCastException.
+````
 
 > 这种情况下，由于JVM泛型的擦除机制，在运行时JVM是不知道泛型信息的，所以可以给oa[1]赋上一个ArrayList而不会出现异常，但是在取出数据的时候却要做一次类型转换，所以就会出现ClassCastException，如果可以进行泛型数组的声明，上面说的这种情况在编译期将不会出现任何的警告和错误，只有在运行时才会出错。
 > 
 > 而对泛型数组的声明进行限制，对于这样的情况，可以在编译期提示代码有类型安全问题，比没有任何提示要强很多。
 > 下面采用通配符的方式是被允许的:数组的类型不可以是类型变量，除非是采用通配符的方式，因为对于通配符的方式，最后取出数据是要做显式的类型转换的。
 
+````
     List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.    
     Object o = lsa;    
     Object[] oa = (Object[]) o;    
@@ -536,6 +532,7 @@ public void showKeyValue(Generic<Number> obj){
     li.add(new Integer(3));    
     oa[1] = li; // Correct.    
     Integer i = (Integer) lsa[1].get(0); // OK 
+````
 
 最后
 
@@ -580,13 +577,13 @@ return cache.put(key, value);
 8. 你可以把List<String>传递给一个接受List<Object>参数的方法吗？
 
 对任何一个不太熟悉泛型的人来说，这个Java泛型题目看起来令人疑惑，因为乍看起来String是一种Object，所以 List<String>应当可以用在需要List<Object>的地方，但是事实并非如此。真这样做的话会导致编译错误。如 果你再深一步考虑，你会发现Java这样做是有意义的，因为List<Object>可以存储任何类型的对象包括String, Integer等等，而List<String>却只能用来存储Strings。
-
+````
 List<Object> objectList;
 
 List<String> stringList;
 
 objectList = stringList; //compilation error incompatible types
-
+````
 9. Array中可以用泛型吗?
 
 这可能是Java泛型面试题中最简单的一个了，当然前提是你要知道Array事实上并不支持泛型，这也是为什么Joshua Bloch在Effective Java一书中建议使用List来代替Array，因为List可以提供编译期的类型安全保证，而Array却不能。
@@ -594,9 +591,9 @@ objectList = stringList; //compilation error incompatible types
 10. 如何阻止Java中的类型未检查的警告?
 
 如果你把泛型和原始类型混合起来使用，例如下列代码，Java 5的javac编译器会产生类型未检查的警告，例如
-
+````
 List<String> rawList = new ArrayList()
-
+````
 注意: Hello.java使用了未检查或称为不安全的操作;
 
 这种警告可以使用@SuppressWarnings(“unchecked”)注解来屏蔽。
@@ -609,23 +606,3 @@ https://www.cnblogs.com/dengchengchao/p/9717097.html
 https://www.cnblogs.com/cat520/p/9353291.html
 https://www.cnblogs.com/coprince/p/8603492.html
 
-
-
-
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/18\343\200\201\346\267\261\345\205\245\347\220\206\350\247\243\345\206\205\351\203\250\347\261\273.md" "b/docs/Java/basic/\346\267\261\345\205\245\347\220\206\350\247\243\345\206\205\351\203\250\347\261\273.md"
similarity index 56%
rename from "docs/java/basic/18\343\200\201\346\267\261\345\205\245\347\220\206\350\247\243\345\206\205\351\203\250\347\261\273.md"
rename to "docs/Java/basic/\346\267\261\345\205\245\347\220\206\350\247\243\345\206\205\351\203\250\347\261\273.md"
index 0ce799d..f716fb3 100644
--- "a/docs/java/basic/18\343\200\201\346\267\261\345\205\245\347\220\206\350\247\243\345\206\205\351\203\250\347\261\273.md"
+++ "b/docs/Java/basic/\346\267\261\345\205\245\347\220\206\350\247\243\345\206\205\351\203\250\347\261\273.md"
@@ -12,20 +12,7 @@
   * [内部类初始化](#内部类初始化)
   * [内部类的重载](#内部类的重载)
   * [内部类的继承](#内部类的继承)
-  * [Java内部类的实现原理](#java内部类的实现原理)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
----
-title: 夯实Java基础系列18：深入理解Java内部类及其实现原理
-date: 2019-9-18 15:56:26 # 文章生成时间，一般不改
-categories:
-    - Java技术江湖
-    - Java基础
-tags:
-    - Java内部类
----
 
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -58,8 +45,6 @@ tags:
 > 
 > (4)外部类不能直接访问内部类的的成员，但可以通过内部类对象来访问
 
- 
-
 　　内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。
 
 　　因为当某个外围类的对象创建内部类的对象时，此内部类会捕获一个隐式引用，它引用了实例化该内部对象的外围类对象。通过这个指针，可以访问外围类对象的全部状态。
@@ -121,125 +106,125 @@ tags:
 
 3 外部类和它的内部类之间的关系
 
+````
+//本节讨论内部类以及不同访问权限的控制
+//内部类只有在使用时才会被加载。
+//外部类B
+public class B{
+    int i = 1;
+    int j = 1;
+    static int s = 1;
+    static int ss = 1;
+    A a;
+    AA aa;
+    AAA aaa;
+    //内部类A
+
+    public class A {
+//        static void go () {
+//
+//        }
+//        static {
+//
+//        }
+//      static int b = 1;//非静态内部类不能有静态成员变量和静态代码块和静态方法，
+        // 因为内部类在外部类加载时并不会被加载和初始化。
+        //所以不会进行静态代码的调用
+        int i = 2;//外部类无法读取内部类的成员，而内部类可以直接访问外部类成员
 
-    //本节讨论内部类以及不同访问权限的控制
-    //内部类只有在使用时才会被加载。
-    //外部类B
-    public class B{
-        int i = 1;
-        int j = 1;
-        static int s = 1;
-        static int ss = 1;
-        A a;
-        AA aa;
-        AAA aaa;
-        //内部类A
-    
-        public class A {
-    //        static void go () {
-    //
-    //        }
-    //        static {
-    //
-    //        }
-    //      static int b = 1;//非静态内部类不能有静态成员变量和静态代码块和静态方法，
-            // 因为内部类在外部类加载时并不会被加载和初始化。
-            //所以不会进行静态代码的调用
-            int i = 2;//外部类无法读取内部类的成员，而内部类可以直接访问外部类成员
-    
-            public void test() {
-                System.out.println(j);
-                j = 2;
-                System.out.println(j);
-                System.out.println(s);//可以访问类的静态成员变量
-            }
-            public void test2() {
-                AA aa = new AA();
-                AAA aaa = new AAA();
-            }
-    
-        }
-        //静态内部类S，可以被外部访问
-        public static class S {
-            int i = 1;//访问不到非静态变量。
-            static int s = 0;//可以有静态变量
-    
-            public static void main(String[] args) {
-                System.out.println(s);
-            }
-            @Test
-            public void test () {
-    //            System.out.println(j);//报错，静态内部类不能读取外部类的非静态变量
-                System.out.println(s);
-                System.out.println(ss);
-                s = 2;
-                ss = 2;
-                System.out.println(s);
-                System.out.println(ss);
-            }
-        }
-    
-        //内部类AA，其实这里加protected相当于default
-        //因为外部类要调用内部类只能通过B。并且无法直接继承AA，所以必须在同包
-        //的类中才能调用到(这里不考虑静态内部类)，那么就和default一样了。
-        protected class AA{
-            int i = 2;//内部类之间不共享变量
-            public void test (){
-                A a = new A();
-                AAA aaa = new AAA();
-                //内部类之间可以互相访问。
-            }
+        public void test() {
+            System.out.println(j);
+            j = 2;
+            System.out.println(j);
+            System.out.println(s);//可以访问类的静态成员变量
         }
-        //包外部依然无法访问，因为包没有继承关系，所以找不到这个类
-        protected static class SS{
-            int i = 2;//内部类之间不共享变量
-            public void test (){
-    
-                //内部类之间可以互相访问。
-            }
+        public void test2() {
+            AA aa = new AA();
+            AAA aaa = new AAA();
         }
-        //私有内部类A，对外不可见，但对内部类和父类可见
-        private class AAA {
-            int i = 2;//内部类之间不共享变量
-    
-            public void test() {
-                A a = new A();
-                AA aa = new AA();
-                //内部类之间可以互相访问。
-            }
+
+    }
+    //静态内部类S，可以被外部访问
+    public static class S {
+        int i = 1;//访问不到非静态变量。
+        static int s = 0;//可以有静态变量
+
+        public static void main(String[] args) {
+            System.out.println(s);
         }
         @Test
-        public void test(){
+        public void test () {
+//            System.out.println(j);//报错，静态内部类不能读取外部类的非静态变量
+            System.out.println(s);
+            System.out.println(ss);
+            s = 2;
+            ss = 2;
+            System.out.println(s);
+            System.out.println(ss);
+        }
+    }
+
+    //内部类AA，其实这里加protected相当于default
+    //因为外部类要调用内部类只能通过B。并且无法直接继承AA，所以必须在同包
+    //的类中才能调用到(这里不考虑静态内部类)，那么就和default一样了。
+    protected class AA{
+        int i = 2;//内部类之间不共享变量
+        public void test (){
             A a = new A();
-            a.test();
-            //内部类可以修改外部类的成员变量
-            //打印出 1 2
-            B b = new B();
-    
+            AAA aaa = new AAA();
+            //内部类之间可以互相访问。
         }
     }
+    //包外部依然无法访问，因为包没有继承关系，所以找不到这个类
+    protected static class SS{
+        int i = 2;//内部类之间不共享变量
+        public void test (){
 
+            //内部类之间可以互相访问。
+        }
+    }
+    //私有内部类A，对外不可见，但对内部类和父类可见
+    private class AAA {
+        int i = 2;//内部类之间不共享变量
 
-​    
-    //另一个外部类
-    class C {
-        @Test
         public void test() {
-            //首先，其他类内部类只能通过外部类来获取其实例。
-            B.S s = new B.S();
-            //静态内部类可以直接通过B类直接获取，不需要B的实例，和静态成员变量类似。
-            //B.A a = new B.A();
-            //当A不是静态类时这行代码会报错。
-            //需要使用B的实例来获取A的实例
-            B b = new B();
-            B.A a = b.new A();
-            B.AA aa = b.new AA();//B和C同包，所以可以访问到AA
-    //      B.AAA aaa = b.new AAA();AAA为私有内部类，外部类不可见
-            //当A使用private修饰时，使用B的实例也无法获取A的实例，这一点和私有变量是一样的。
-            //所有普通的内部类与类中的一个变量是类似的。静态内部类则与静态成员类似。
+            A a = new A();
+            AA aa = new AA();
+            //内部类之间可以互相访问。
         }
     }
+    @Test
+    public void test(){
+        A a = new A();
+        a.test();
+        //内部类可以修改外部类的成员变量
+        //打印出 1 2
+        B b = new B();
 
+    }
+}
+````
+
+````   
+//另一个外部类
+class C {
+    @Test
+    public void test() {
+        //首先，其他类内部类只能通过外部类来获取其实例。
+        B.S s = new B.S();
+        //静态内部类可以直接通过B类直接获取，不需要B的实例，和静态成员变量类似。
+        //B.A a = new B.A();
+        //当A不是静态类时这行代码会报错。
+        //需要使用B的实例来获取A的实例
+        B b = new B();
+        B.A a = b.new A();
+        B.AA aa = b.new AA();//B和C同包，所以可以访问到AA
+//      B.AAA aaa = b.new AAA();AAA为私有内部类，外部类不可见
+        //当A使用private修饰时，使用B的实例也无法获取A的实例，这一点和私有变量是一样的。
+        //所有普通的内部类与类中的一个变量是类似的。静态内部类则与静态成员类似。
+    }
+}
+````
 ## 内部类的加载
 可能刚才的例子中没办法直观地看到内部类是如何加载的，接下来用例子展示一下内部类加载的过程。
 
@@ -277,43 +262,43 @@ tags:
 
 需要注意的是：
 局部内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
+````
+public class 局部内部类 {
+    class A {//局部内部类就是写在方法里的类，只在方法执行时加载，一次性使用。
+        public void test() {
+            class B {
+                public void test () {
+                    class C {
 
-    public class 局部内部类 {
-        class A {//局部内部类就是写在方法里的类，只在方法执行时加载，一次性使用。
-            public void test() {
-                class B {
-                    public void test () {
-                        class C {
-    
-                        }
                     }
                 }
             }
         }
-        @Test
-        public void test () {
-            int i = 1;
-            final int j = 2;
-            class A {
-                @Test
-                public void test () {
-                    System.out.println(i);
-                    System.out.println(j);
-                }
-            }
-            A a = new A();
-            System.out.println(a);
-        }
-    
-        static class B {
-            public static void test () {
-                //static class A报错，方法里不能定义静态内部类。
-                //因为只有在方法调用时才能进行类加载和初始化。
-    
+    }
+    @Test
+    public void test () {
+        int i = 1;
+        final int j = 2;
+        class A {
+            @Test
+            public void test () {
+                System.out.println(i);
+                System.out.println(j);
             }
         }
+        A a = new A();
+        System.out.println(a);
     }
 
+    static class B {
+        public static void test () {
+            //static class A报错，方法里不能定义静态内部类。
+            //因为只有在方法调用时才能进行类加载和初始化。
+
+        }
+    }
+}
+````
 ### 匿名内部类
 
 简单地说：匿名内部类就是没有名字的内部类，并且，匿名内部类是局部内部类的一种特殊形式。什么情况下需要使用匿名内部类？如果满足下面的一些条件，使用匿名内部类是比较合适的：
@@ -336,61 +321,61 @@ tags:
 >6 　因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
 
 一个匿名内部类的例子：
+````
+public class 匿名内部类 {
+
+}
+interface D{
+    void run ();
+}
+abstract class E{
+    E (){
 
-        public class 匿名内部类 {
-    
-    }
-    interface D{
-        void run ();
-    }
-    abstract class E{
-        E (){
-    
-        }
-        abstract void work();
     }
-    class A {
-    
-            @Test
-            public void test (int k) {
-                //利用接口写出一个实现该接口的类的实例。
-                //有且仅有一个实例，这个类无法重用。
-                new Runnable() {
-                    @Override
-                    public void run() {
-    //                    k = 1;报错，当外部方法中的局部变量在内部类使用中必须改为final类型。
-                        //因为方外部法中即使改变了这个变量也不会反映到内部类中。
-                        //所以对于内部类来讲这只是一个常量。
-                        System.out.println(100);
-                        System.out.println(k);
-                    }
-                };
-                new D(){
-                    //实现接口的匿名类
-                    int i =1;
-                    @Override
-                    public void run() {
-                        System.out.println("run");
-                        System.out.println(i);
-                        System.out.println(k);
-                    }
-                }.run();
-                new E(){
-                    //继承抽象类的匿名类
-                    int i = 1;
-                    void run (int j) {
-                        j = 1;
-                    }
-    
-                    @Override
-                    void work() {
-    
-                    }
-                };
+    abstract void work();
+}
+class A {
+
+    @Test
+    public void test (int k) {
+        //利用接口写出一个实现该接口的类的实例。
+        //有且仅有一个实例，这个类无法重用。
+        new Runnable() {
+            @Override
+            public void run() {
+//                    k = 1;报错，当外部方法中的局部变量在内部类使用中必须改为final类型。
+                //因为方外部法中即使改变了这个变量也不会反映到内部类中。
+                //所以对于内部类来讲这只是一个常量。
+                System.out.println(100);
+                System.out.println(k);
             }
-    
+        };
+        new D(){
+            //实现接口的匿名类
+            int i =1;
+            @Override
+            public void run() {
+                System.out.println("run");
+                System.out.println(i);
+                System.out.println(k);
+            }
+        }.run();
+        new E(){
+            //继承抽象类的匿名类
+            int i = 1;
+            void run (int j) {
+                j = 1;
+            }
+
+            @Override
+            void work() {
+
+            }
+        };
     }
 
+}
+````
 ### 匿名内部类里的final
 使用的形参为何要为final
 
@@ -401,37 +386,36 @@ tags:
 > 为什么必须要为final呢？
 > 
 > 首先我们知道在内部类编译成功后，它会产生一个class文件，该class文件与外部类并不是同一class文件，仅仅只保留对外部类的引用。当外部类传入的参数需要被内部类调用时，从java程序的角度来看是直接被调用：
-> 
-> 
-    public class OuterClass {
-        public void display(final String name,String age){
-            class InnerClass{
-                void display(){
-                    System.out.println(name);
-                }
+````  
+public class OuterClass {
+    public void display(final String name,String age){
+        class InnerClass{
+            void display(){
+                System.out.println(name);
             }
         }
     }
-
+}
+````
 从上面代码中看好像name参数应该是被内部类直接调用？其实不然，在java编译之后实际的操作如下：
 
-
-    public class OuterClass$InnerClass {
-        public InnerClass(String name,String age){
-            this.InnerClass$name = name;
-            this.InnerClass$age = age;
-        }
+````
+public class OuterClass$InnerClass {
+    public InnerClass(String name,String age){
+        this.InnerClass$name = name;
+        this.InnerClass$age = age;
+    }
 
 
-​        
-        public void display(){
-            System.out.println(this.InnerClass$name + "----" + this.InnerClass$age );
-        }
+    
+    public void display(){
+        System.out.println(this.InnerClass$name + "----" + this.InnerClass$age );
     }
-
+}
+````
   所以从上面代码来看，内部类并不是直接调用方法传递的参数，而是利用自身的构造器对传入的参数进行备份，自己内部方法调用的实际上时自己的属性而不是外部方法传递进来的参数。
 
->   直到这里还没有解释为什么是final
+> 直到这里还没有解释为什么是final
 
 > 在内部类中的属性和外部方法的参数两者从外表上看是同一个东西，但实际上却不是，所以他们两者是可以任意变化的，也就是说在内部类中我对属性的改变并不会影响到外部的形参，而然这从程序员的角度来看这是不可行的。
 > 
@@ -444,63 +428,62 @@ tags:
 ## 内部类初始化
 
 我们一般都是利用构造器来完成某个实例的初始化工作的，但是匿名内部类是没有构造器的！那怎么来初始化匿名内部类呢？使用构造代码块！利用构造代码块能够达到为匿名内部类创建一个构造器的效果。
-
-    public class OutClass {
-        public InnerClass getInnerClass(final int age,final String name){
-            return new InnerClass() {
-                int age_ ;
-                String name_;
-                //构造代码块完成初始化工作
-                {
-                    if(0 < age && age < 200){
-                        age_ = age;
-                        name_ = name;
-                    }
+````
+public class OutClass {
+    public InnerClass getInnerClass(final int age,final String name){
+        return new InnerClass() {
+            int age_ ;
+            String name_;
+            //构造代码块完成初始化工作
+            {
+                if(0 < age && age < 200){
+                    age_ = age;
+                    name_ = name;
                 }
-                public String getName() {
-                    return name_;
-                }
-                
-                public int getAge() {
-                    return age_;
-                }
-            };
-        }
-
-
-​        
+            }
+            public String getName() {
+                return name_;
+            }
+            
+            public int getAge() {
+                return age_;
+            }
+        };
+    }
+````
+        
 ## 内部类的重载
+如果你创建了一个内部类，然后继承其外围类并重新定义此内部类时，会发生什么呢？也就是说，内部类可以被重载吗？这看起来似乎是个很有用的点子，但是“重载”内部类就好像它是外围类的一个方法，其实并不起什么作用：
 
+````
+class Egg {
+       private Yolk y;
+ 
+       protected class Yolk {
+              public Yolk() {
+                     System.out.println("Egg.Yolk()");
+              }
+       }
+ 
+       public Egg() {
+              System.out.println("New Egg()");
+              y = new Yolk();
+       }
+}
+ 
+public class BigEgg extends Egg {
+       public class Yolk {
+              public Yolk() {
+                     System.out.println("BigEgg.Yolk()");
+              }
+       }
+ 
+       public static void main(String[] args) {
+              new BigEgg();
+       }
+}
 
-　　如果你创建了一个内部类，然后继承其外围类并重新定义此内部类时，会发生什么呢？也就是说，内部类可以被重载吗？这看起来似乎是个很有用的点子，但是“重载”内部类就好像它是外围类的一个方法，其实并不起什么作用：
-
-
-    class Egg {
-           private Yolk y;
-     
-           protected class Yolk {
-                  public Yolk() {
-                         System.out.println("Egg.Yolk()");
-                  }
-           }
-     
-           public Egg() {
-                  System.out.println("New Egg()");
-                  y = new Yolk();
-           }
-    }
-     
-    public class BigEgg extends Egg {
-           public class Yolk {
-                  public Yolk() {
-                         System.out.println("BigEgg.Yolk()");
-                  }
-           }
-     
-           public static void main(String[] args) {
-                  new BigEgg();
-           }
-    }
+````
     复制代码
     输出结果为：
     New Egg()
@@ -512,7 +495,7 @@ tags:
 ## 内部类的继承
 
 因为内部类的构造器要用到其外围类对象的引用，所以在你继承一个内部类的时候，事情变得有点复杂。问题在于，那个“秘密的”外围类对象的引用必须被初始化，而在被继承的类中并不存在要联接的缺省对象。要解决这个问题，需使用专门的语法来明确说清它们之间的关联：
-
+````
     class WithInner {
             class Inner {
                     Inner(){
@@ -533,10 +516,11 @@ tags:
                     InheritInner ii = new InheritInner(wi);
             }
     }
-复制代码
-输出结果为：
-this is a constructor in WithInner.Inner
-this is a constructor in InheritInner
+````
+    复制代码
+    输出结果为：
+    this is a constructor in WithInner.Inner
+    this is a constructor in InheritInner
 
 可以看到，InheritInner 只继承自内部类，而不是外围类。但是当要生成一个构造器时，缺省的构造器并不算好，而且你不能只是传递一个指向外围类对象的引用。此外，你必须在构造器内使用如下语法：
 enclosingClassReference.super();
@@ -544,38 +528,6 @@ enclosingClassReference.super();
 
 有关匿名内部类实现回调，事件驱动，委托等机制的文章将在下一节讲述。
 
-## Java内部类的实现原理
-
-内部类为什么能够访问外部类的成员？
-
-定义内部类如下：
-
-![Java 内部类](http://p3.pstatp.com/large/pgc-image/1539338093053104f5529ec)
-
-使用javap命令进行反编译。
-
-编译后得到Main.class Main$Inner.class两个文件，反编译Main$Inner.class文件如下：
-
-![Java 内部类](http://p1.pstatp.com/large/pgc-image/1539338144888f57662c7bc)
-
-可以看到，内部类其实拥有外部类的一个引用，在构造函数中将外部类的引用传递进来。
-
-匿名内部类为什么只能访问局部的final变量？
-
-其实可以这样想，当方法执行完毕后，局部变量的生命周期就结束了，而局部内部类对象的生命周期可能还没有结束，那么在局部内部类中访问局部变量就不可能了，所以将局部变量改为final，改变其生命周期。
-
-编写代码如下：
-
-![Java 内部类](http://p1.pstatp.com/large/pgc-image/15393408957685bcddd1c64)
-
-这段代码编译为Main.class Main$1.class两个文件，反编译Main$1.class文件如下：
-
-![Java 内部类](http://p3.pstatp.com/large/pgc-image/1539341219661a629a53b8c)
-
-可以看到，java将编译时已经确定的值直接复制，进行替换，将无法确定的值放到了内部类的常量池中，并在构造函数中将其从常量池取出到字段中。
-
-可以看出，java将局部变量m直接进行复制，所以其并不是原来的值，若在内部类中将m更改，局部变量的m值不会变，就会出现数据不一致，所以java就将其限制为final，使其不能进行更改，这样数据不一致的问题就解决了。
-
 ## 参考文章
 
 https://www.cnblogs.com/hujingnb/p/10181621.html
@@ -584,20 +536,4 @@ https://www.cnblogs.com/woshimrf/p/java-inner-class.html
 https://www.cnblogs.com/dengchengchao/p/9713979.html
 
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/Java/basic/\347\273\247\346\211\277\343\200\201\345\260\201\350\243\205\343\200\201\345\244\232\346\200\201\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md" "b/docs/Java/basic/\347\273\247\346\211\277\343\200\201\345\260\201\350\243\205\343\200\201\345\244\232\346\200\201\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
new file mode 100644
index 0000000..b41aac0
--- /dev/null
+++ "b/docs/Java/basic/\347\273\247\346\211\277\343\200\201\345\260\201\350\243\205\343\200\201\345\244\232\346\200\201\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
@@ -0,0 +1,373 @@
+# 目录
+  * [从JVM结构开始谈多态](#从jvm结构开始谈多态)
+    * [JVM 的结构](#jvm-的结构)
+    * [Java 的方法调用方式](#java-的方法调用方式)
+    * [常量池（constant pool）](#常量池（constant-pool）)
+  * [继承的实现原理](#继承的实现原理)
+  * [重载和重写的实现原理](#重载和重写的实现原理)
+  * [参考文章](#参考文章)
+
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+文章首发于我的个人博客：
+> www.how2playlife.com
+
+本文是微信公众号【Java技术江湖】的《夯实Java基础系列博文》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+该系列博文会告诉你如何从入门到进阶，一步步地学习Java基础知识，并上手进行实战，接着了解每个Java知识点背后的实现原理，更完整地了解整个Java技术体系，形成自己的知识框架。为了更好地总结和检验你的学习成果，本系列文章也会提供每个知识点对应的面试题以及参考答案。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+<!-- more -->
+
+## 从JVM结构开始谈多态
+
+Java 对于方法调用动态绑定的实现主要依赖于方法表，但通过类引用调用和接口引用调用的实现则有所不同。总体而言，当某个方法被调用时，JVM 首先要查找相应的常量池，得到方法的符号引用，并查找调用类的方法表以确定该方法的直接引用，最后才真正调用该方法。以下分别对该过程中涉及到的相关部分做详细介绍。
+
+### JVM 的结构
+
+典型的 Java 虚拟机的运行时结构如下图所示
+
+ 图 1.JVM 运行时结构
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230403220955.png)
+
+此结构中，我们只探讨和本文密切相关的方法区 (method area)。当程序运行需要某个类的定义时，载入子系统 (class loader subsystem) 装入所需的 class 文件，并在内部建立该类的类型信息，这个类型信息就存贮在方法区。类型信息一般包括该类的方法代码、类变量、成员变量的定义等等。可以说，类型信息就是类的 Java 文件在运行时的内部结构，包含了改类的所有在 Java 文件中定义的信息。
+
+注意到，该类型信息和 class 对象是不同的。class 对象是 JVM 在载入某个类后于堆 (heap) 中创建的代表该类的对象，可以通过该 class 对象访问到该类型信息。比如最典型的应用，在 Java 反射中应用 class 对象访问到该类支持的所有方法，定义的成员变量等等。可以想象，JVM 在类型信息和 class 对象中维护着它们彼此的引用以便互相访问。两者的关系可以类比于进程对象与真正的进程之间的关系。
+
+### Java 的方法调用方式
+
+Java 的方法调用有两类，动态方法调用与静态方法调用。静态方法调用是指对于类的静态方法的调用方式，是静态绑定的；而动态方法调用需要有方法调用所作用的对象，是动态绑定的。类调用 (invokestatic) 是在编译时刻就已经确定好具体调用方法的情况，而实例调用 (invokevirtual) 则是在调用的时候才确定具体的调用方法，这就是动态绑定，也是多态要解决的核心问题。
+
+JVM 的方法调用指令有四个，分别是 invokestatic，invokespecial，invokesvirtual 和 invokeinterface。前两个是静态绑定，后两个是动态绑定的。本文也可以说是对于 JVM 后两种调用实现的考察。
+
+### 常量池（constant pool）
+
+常量池中保存的是一个 Java 类引用的一些常量信息，包含一些字符串常量及对于类的符号引用信息等。Java 代码编译生成的类文件中的常量池是静态常量池，当类被载入到虚拟机内部的时候，在内存中产生类的常量池叫运行时常量池。
+
+常量池在逻辑上可以分成多个表，每个表包含一类的常量信息，本文只探讨对于 Java 调用相关的常量池表。
+
+CONSTANT_Utf8_info
+
+字符串常量表，该表包含该类所使用的所有字符串常量，比如代码中的字符串引用、引用的类名、方法的名字、其他引用的类与方法的字符串描述等等。其余常量池表中所涉及到的任何常量字符串都被索引至该表。
+
+CONSTANT_Class_info
+
+类信息表，包含任何被引用的类或接口的符号引用，每一个条目主要包含一个索引，指向 CONSTANT_Utf8_info 表，表示该类或接口的全限定名。
+
+CONSTANT_NameAndType_info
+
+名字类型表，包含引用的任意方法或字段的名称和描述符信息在字符串常量表中的索引。
+
+CONSTANT_InterfaceMethodref_info
+
+接口方法引用表，包含引用的任何接口方法的描述信息，主要包括类信息索引和名字类型索引。
+
+CONSTANT_Methodref_info
+
+类方法引用表，包含引用的任何类型方法的描述信息，主要包括类信息索引和名字类型索引。
+
+图2. 常量池各表的关系
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230403221053.png)
+
+可以看到，给定任意一个方法的索引，在常量池中找到对应的条目后，可以得到该方法的类索引（class_index）和名字类型索引 (name_and_type_index), 进而得到该方法所属的类型信息和名称及描述符信息（参数，返回值等）。注意到所有的常量字符串都是存储在 CONSTANT_Utf8_info 中供其他表索引的。
+
+## 继承的实现原理
+
+Java 的继承机制是一种复用类的技术，从原理上来说，是更好的使用了组合技术，因此要理解继承，首先需要了解类的组合技术是如何实现类的复用的。
+
+使用组合技术复用类
+假设现在的需求是要创建一个具有基本类型，String 类型以及一个其他非基本类型的对象。该如何处理呢？
+
+对于基本类型的变量，在新类中成员变量处直接定义即可，但对于非基本类型变量，不仅需要在类中声明其引用，并且还需要手动初始化这个对象。
+
+这里需要注意的是，编译器并不会默认将所有的引用都创建对象，因为这样的话在很多情况下会增加不必要的负担，因此，在合适的时机初始化合适的对象，可以通过以下几个位置做初始化操作：
+
+在定义对象的地方，先于构造方法执行。
+在构造方法中。
+在正要使用之前，这个被称为惰性初始化。
+使用实例初始化。
+````
+class Soap {
+    private String s;
+    Soap() {
+        System.out.println("Soap()");
+        s = "Constructed";
+    }
+    public String tiString(){
+        return s;
+    }
+}
+
+public class Bath {
+    // s1 初始化先于构造函数
+    private String s1 = "Happy", s2 = "Happy", s3, s4;
+    private Soap soap;
+    private int i;
+    private float f;
+    
+    public Both() {
+        System.out.println("inSide Both");
+        s3 = "Joy";
+        f = 3.14f;
+        soap = new Soap();
+    }
+    
+    {
+        i = 88;
+    }
+    
+    public String toString() {
+        if(s4 == null){
+            s4 = "Joy"
+        }
+        return "s1 = " + s1 +"\n" +
+               "s2 = " + s2 +"\n" +
+               "s3 = " + s3 +"\n" +
+               "s4 = " + s4 +"\n" +
+               "i = " + i +"\n" +
+               "f = " + f +"\n" +
+               "soap = " + soap;
+    }
+}
+````
+继承
+Java 中的继承由 extend 关键字实现，组合的语法比较平实，而继承是一种特殊的语法。当一个类继承自另一个类时，那么这个类就可以拥有另一个类的域和方法。
+````
+class Cleanser{
+    private String s = "Cleanser";
+    
+    public void append(String a){
+        s += a;
+    }
+    public void apply(){
+        append("apply");
+    }
+    public void scrub(){
+        append("scrub");
+    }
+    public String toString(){
+        return s;
+    }
+    public static void main(String args){
+        Cleanser c = new Cleanser();
+        
+        c.apply();
+        System.out.println(c);
+    }
+}
+
+public class Deter extends Cleanser{
+    public void apply(){
+        append("Deter.apply");
+        super.scrub();
+    }
+    public void foam(){
+        append("foam");
+    }
+    public static void main(String args){
+        Deter d = new Deter();
+        
+        d.apply();
+        d.scrub();
+        d.foam();
+        System.out.println(d);
+        Cleanser.main(args);
+    }
+}
+````
+上面的代码中，展示了继承语法中的一些特性：
+
+子类可以直接使用父类中公共的方法和成员变量（通常为了保护数据域，成员变量均为私有）
+子类中可以覆盖父类中的方法，也就是子类重写了父类的方法，此时若还需要调用被覆盖的父类的方法，则需要用到 super 来指定是调用父类中的方法。
+子类中可以自定义父类中没有的方法。
+可以发现上面两个类中均有 main 方法，命令行中调用的哪个类就执行哪个类的 main 方法，例如：java Deter。
+继承语法的原理
+接下来我们将通过创建子类对象来分析继承语法在我们看不到的地方做了什么样的操作。
+
+可以先思考一下，如何理解使用子类创建的对象呢，首先这个对象中包含子类的所有信息，但是也包含父类的所有公共的信息。
+
+下面来看一段代码，观察一下子类在创建对象初始化的时候，会不会用到父类相关的方法。
+````
+class Art{
+    Art() {
+        System.out.println("Art Construct");
+    }
+}
+
+class Drawing extends Art {
+    Drawing() {
+        System.out.println("Drawing Construct");
+    }
+}
+
+public class Cartoon extends Drawing {
+    public Cartoon() {
+        System.out.println("Cartoon construct");
+    }
+    public void static main(String args) {
+        Cartoon c = new Cartoon();
+    }
+}
+/*output:
+Art Construct
+Drawing Construct
+Cartoon construct
+*/
+````
+通过观察代码可以发现，在实例化Cartoon时，事实上是从最顶层的父类开始向下逐个实例化，也就是最终实例化了三个对象。编译器会默认在子类的构造方法中增加调用父类默认构造方法的代码。
+
+因此，继承可以理解为编译器帮我们完成了类的特殊组合技术，即在子类中存在一个父类的对象，使得我们可以用子类对象调用父类的方法。而在开发者看来只不过是使用了一个关键字。
+
+注意：虽然继承很接近组合技术，但是继承拥有其他更多的区别于组合的特性，例如父类的对象我们是不可见的，对于父类中的方法也做了相应的权限校验等。
+
+那么，如果类中的构造方法是带参的，该如何操作呢？（使用super关键字显示调用）
+
+见代码：
+````
+class Game {
+    Game(int i){
+        System.out.println("Game Construct");
+    }
+}
+
+class BoardGame extends Game {
+    BoardGame(int j){
+        super(j);
+        System.out.println("BoardGame Construct");
+    }
+}
+public class Chess extends BoardGame{
+    Chess(){
+        super(99);
+        System.out.println("Chess construct");
+    }
+    public static void main(String args) {
+        Chess c = new Chess();
+    }
+}
+
+/*output:
+Game Construct
+BoardGame Construct
+Chess construc
+*/
+
+````
+## 重载和重写的实现原理
+
+刚开始学习Java的时候，就了解了Java这个比较有意思的特性：重写 和 重载。开始的有时候从名字上还总是容易弄混。我相信熟悉Java这门语言的同学都应该了解这两个特性，可能只是从语言层面上了解这种写法，但是jvm是如何实现他们的呢 ?
+
+重载官方给出的介绍：
+
+>  verload:
+> The Java programming language supports overloading methods, and Java can distinguish between methods with different method signatures. This means that methods within a class can have the same name if they have different parameter lists .
+> 
+> Overloaded methods are differentiated by the number and the type of the arguments passed into the method.
+> 
+> You cannot declare more than one method with the same name and the same number and type of arguments, because the compiler cannot tell them apart.
+> 
+> The compiler does not consider return type when differentiating methods, so you cannot declare two methods with the same signature even if they have a different return type.
+> 
+首先看一段代码，来看看代码的执行结果：
+````
+public class OverrideTest {
+ 
+    class Father{}
+ 
+    class Sun extends Father {}
+ 
+    public void doSomething(Father father){
+        System.out.println("Father do something");
+    }
+ 
+    public void doSomething(Sun father){
+        System.out.println("Sun do something");
+    }
+ 
+    public static void main(String [] args){
+        OverrideTest overrideTest = new OverrideTest();
+        Father sun = overrideTest.new Sun();
+        Father father = overrideTest.new Father();
+        overrideTest.doSomething(father);
+        overrideTest.doSomething(sun);
+    }
+}
+````
+看下这段代码的执行结果，最后会打印：
+
+    Father do something
+    Father do something
+
+为什么会打印出这样的结果呢？ 首先要介绍两个概念：静态分派和动态分派
+
+静态分派：依赖静态类型来定位方法执行版本的分派动作称为静态分派
+
+动态分派：运行期根据实际类型确定方法执行版本的分派过程。
+
+他们的区别是：
+
+1.静态分派发生在编译期，动态分派发生在运行期；
+
+2.private,static,final 方法发生在编译期，并且不能被重写，一旦发生了重写，将会在运行期处理。
+
+3.重载是静态分派，重写是动态分派
+
+回到上面的问题，因为重载是发生在编译期，所以在编译期已经确定两次 doSomething 方法的参数都是Father类型，在class文件中已经指向了Father类的符号引用，所以最后会打印两次Father do something。
+
+> 二. override:
+> An instance method in a subclass with the same signature (name, plus the number and the type of its parameters) and return type as an instance method in the superclassoverridesthe superclass's method.
+> 
+> The ability of a subclass to override a method allows a class to inherit from a superclass whose behavior is "close enough" and then to modify behavior as needed. The overriding method has the same name, number and type of parameters, and return type as the method that it overrides. An overriding method can also return a subtype of the type returned by the overridden method. This subtype is called acovariant return type.
+
+还是上面那个代码，稍微改动下
+````
+public class OverrideTest {
+ 
+    class Father{}
+ 
+    class Sun extends Father {}
+ 
+    public void doSomething(){
+        System.out.println("Father do something");
+    }
+ 
+    public void doSomething(){
+        System.out.println("Sun do something");
+    }
+ 
+    public static void main(String [] args){
+        OverrideTest overrideTest = new OverrideTest();
+        Father sun = overrideTest.new Sun();
+        Father father = overrideTest.new Father();
+        overrideTest.doSomething();
+        overrideTest.doSomething();
+    }
+}
+````
+
+最后会打印：
+
+    Father do something
+    
+    Sun do something
+
+相信大家都会知道这个结果，那么这个结果jvm是怎么实现的呢？
+
+在编译期，只会识别到是调用Father类的doSomething方法，到运行期才会真正找到对象的实际类型。
+
+首先该方法的执行，jvm会调用invokevirtual指令，该指令会找栈顶第一个元素所指向的对象的实际类型，如果该类型存在调用的方法，则会走验证流程，否则继续找其父类。这也是为什么子类可以直接调用父类具有访问权限的方法的原因。简而言之，就是在运行期才会去确定对象的实际类型，根据这个实际类型确定方法执行版本，这个过程称为动态分派。override 的实现依赖jvm的动态分派。
+
+## 参考文章
+https://blog.csdn.net/dj_dengjian/article/details/80811348
+https://blog.csdn.net/chenssy/article/details/12757911
+https://blog.csdn.net/fan2012huan/article/details/51007517
+https://blog.csdn.net/fan2012huan/article/details/50999777
+https://www.cnblogs.com/serendipity-fly/p/9469289.html
+https://blog.csdn.net/m0_37264516/article/details/86709537
+
diff --git "a/docs/java/basic/11\343\200\201\350\247\243\350\257\273Java\344\270\255\347\232\204\345\233\236\350\260\203.md" "b/docs/Java/basic/\350\247\243\350\257\273Java\344\270\255\347\232\204\345\233\236\350\260\203.md"
similarity index 67%
rename from "docs/java/basic/11\343\200\201\350\247\243\350\257\273Java\344\270\255\347\232\204\345\233\236\350\260\203.md"
rename to "docs/Java/basic/\350\247\243\350\257\273Java\344\270\255\347\232\204\345\233\236\350\260\203.md"
index 1af4d91..57e5237 100644
--- "a/docs/java/basic/11\343\200\201\350\247\243\350\257\273Java\344\270\255\347\232\204\345\233\236\350\260\203.md"
+++ "b/docs/Java/basic/\350\247\243\350\257\273Java\344\270\255\347\232\204\345\233\236\350\260\203.md"
@@ -3,26 +3,11 @@
   * [多线程中的“回调”](#多线程中的回调)
   * [Java回调机制实战](#java回调机制实战)
     * [实例一 ： 同步调用](#实例一-：-同步调用)
-      * [1.1 同步调用代码](#11-同步调用代码)
-  * [实例二：由浅入深](#实例二：由浅入深)
-  * [实例三：Tom做题](#实例三：tom做题)
+    * [实例二：由浅入深](#实例二：由浅入深)
+    * [实例三：Tom做题](#实例三：tom做题)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
 
 
-
----
-title: 夯实Java基础系列11：深入理解Java中的回调机制
-date: 2019-9-11 15:56:26 # 文章生成时间，一般不改
-categories:
-    - Java技术江湖
-    - Java基础
-tags:
-    - 回调机制
----
-
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
 
@@ -73,49 +58,49 @@ tags:
 Java多线程中可以通过callable和future或futuretask结合来获取线程执行后的返回值。实现方法是通过get方法来调用callable的call方法获取返回值。
 
 其实这种方法本质上不是回调，回调要求的是任务完成以后被调用者主动回调调用者的接口。而这里是调用者主动使用get方法阻塞获取返回值。
-
-    public class 多线程中的回调 {
-        //这里简单地使用future和callable实现了线程执行完后
-        public static void main(String[] args) throws ExecutionException, InterruptedException {
-            ExecutorService executor = Executors.newCachedThreadPool();
-            Future<String> future = executor.submit(new Callable<String>() {
-                @Override
-                public String call() throws Exception {
-                    System.out.println("call");
-                    TimeUnit.SECONDS.sleep(1);
-                    return "str";
-                }
-            });
-            //手动阻塞调用get通过call方法获得返回值。
-            System.out.println(future.get());
-            //需要手动关闭，不然线程池的线程会继续执行。
-            executor.shutdown();
-
-        //使用futuretask同时作为线程执行单元和数据请求单元。
-        FutureTask<Integer> futureTask = new FutureTask(new Callable<Integer>() {
+````
+public class 多线程中的回调 {
+    //这里简单地使用future和callable实现了线程执行完后
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+        ExecutorService executor = Executors.newCachedThreadPool();
+        Future<String> future = executor.submit(new Callable<String>() {
             @Override
-            public Integer call() throws Exception {
-                System.out.println("dasds");
-                return new Random().nextInt();
+            public String call() throws Exception {
+                System.out.println("call");
+                TimeUnit.SECONDS.sleep(1);
+                return "str";
             }
         });
-        new Thread(futureTask).start();
-        //阻塞获取返回值
-        System.out.println(futureTask.get());
-    }
-    @Test
-    public void test () {
-        Callable callable = new Callable() {
-            @Override
-            public Object call() throws Exception {
-                return null;
-            }
-        };
-        FutureTask futureTask = new FutureTask(callable);
+        //手动阻塞调用get通过call方法获得返回值。
+        System.out.println(future.get());
+        //需要手动关闭，不然线程池的线程会继续执行。
+        executor.shutdown();
 
-    }
-    }
+    //使用futuretask同时作为线程执行单元和数据请求单元。
+    FutureTask<Integer> futureTask = new FutureTask(new Callable<Integer>() {
+        @Override
+        public Integer call() throws Exception {
+            System.out.println("dasds");
+            return new Random().nextInt();
+        }
+    });
+    new Thread(futureTask).start();
+    //阻塞获取返回值
+    System.out.println(futureTask.get());
+}
+@Test
+public void test () {
+    Callable callable = new Callable() {
+        @Override
+        public Object call() throws Exception {
+            return null;
+        }
+    };
+    FutureTask futureTask = new FutureTask(callable);
 
+}
+}
+````
 ## Java回调机制实战
 
 曾经自己偶尔听说过回调机制，隐隐约约能够懂一些意思，但是当让自己写一个简单的示例程序时，自己就傻眼了。随着工作经验的增加，自己经常听到这儿使用了回调，那儿使用了回调，自己是时候好好研究一下Java回调机制了。网上关于Java回调的文章一抓一大把，但是看完总是云里雾里，不知所云，特别是看到抓取别人的代码走两步时，总是现眼。于是自己决定写一篇关于Java机制的文章，以方便大家和自己更深入的学习Java回调机制。
@@ -138,22 +123,12 @@ Java多线程中可以通过callable和future或futuretask结合来获取线程
 
 同步调用时序图：
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/3796264-6a5b5b898aa3930e.png?imageMogr2/auto-orient/strip|imageView2/2/w/1031/format/webp)
-
-
-
-同步调用时序图
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230403210703.png)
 
 
 **1.1.1 底层服务类:BottomService.java**
 
-```
-
+````
 package synchronization.demo;
 
 /**
@@ -182,11 +157,11 @@ return param +" BottomService.bottom() execute -->";
 
 }
 
-```
+
 
 **1.1.2 上层服务接口: UpperService.java**
 
-```
+
 package synchronization.demo;
 
 /**
@@ -203,11 +178,11 @@ public String callBottomService(final String param);
 
 }
 
-```
+
 
 **1.1.3 上层服务接口实现类:UpperServiceImpl.java**
 
-```
+
 package synchronization.demo;
 
 /**
@@ -244,11 +219,11 @@ return bottomService.bottom(param + " callBottomService.bottom() execute --> ");
 
 }
 
-```
+
 
 **1.1.4 Test测试类:Test.java**
 
-```
+
 package synchronization.demo;
 
 import java.util.Date;
@@ -281,7 +256,7 @@ System.out.println("=============== callBottomService end ====================:"
 
 }
 
-```
+````
 
 **1.1.5 输出结果:**
 
@@ -306,37 +281,37 @@ callBottomService start -->  callBottomService.bottom() execute -->  BottomServi
 解答：回调更像是一个约定，就是如果我调用了b()方法，那么就必须要回调，而不需要显示调用
 一、Java的回调-浅
 我们用例子来解释：小明和小李相约一起去吃早饭，但是小李起的有点晚要先洗漱，等小李洗漱完成后，通知小明再一起去吃饭。小明就是类A，小李就是类B。一起去吃饭这个事件就是方法a(),小李去洗漱就是方法b()。
-
-    public class XiaoMing { 
-       //小明和小李一起吃饭
-       public void eatFood() {
-          XiaoLi xl = new XiaoLi();
-          //A调用B的方法
-          xl.washFace();
-       }
-     
-       public void eat() {
-          System.out.print("小明和小李一起去吃大龙虾");
-       }
-    }
-    那么怎么让小李洗漱完后在通知小明一起去吃饭呢
-    
-    public class XiaoMing { 
-       //小明和小李一起吃饭
-       public void eatFood() {
-          XiaoLi xl = new XiaoLi();
-          //A调用B的方法
-          xl.washFace();
-          eat();
-       }
-     
-       public void eat() {
-          System.out.print("小明和小李一起去吃大龙虾");
-       }
-    }
-    
+````
+public class XiaoMing { 
+   //小明和小李一起吃饭
+   public void eatFood() {
+      XiaoLi xl = new XiaoLi();
+      //A调用B的方法
+      xl.washFace();
+   }
+ 
+   public void eat() {
+      System.out.print("小明和小李一起去吃大龙虾");
+   }
+}
+那么怎么让小李洗漱完后在通知小明一起去吃饭呢
+
+public class XiaoMing { 
+   //小明和小李一起吃饭
+   public void eatFood() {
+      XiaoLi xl = new XiaoLi();
+      //A调用B的方法
+      xl.washFace();
+      eat();
+   }
+ 
+   public void eat() {
+      System.out.print("小明和小李一起去吃大龙虾");
+   }
+}
+````   
 不过上面已经说过了这个不是回调函数，所以不能这样子，正确的方式如下
-
+````
     public class XiaoLi{//小李
        public void washFace() {
         System.out.print("小李要洗漱");
@@ -345,7 +320,7 @@ callBottomService start -->  callBottomService.bottom() execute -->  BottomServi
         xm.eat();//洗漱完后，一起去吃饭
        }
     }
-    
+````   
 这样子就可以实现washFace()同时也能实现eat()。小李洗漱完后，再通知小明一起去吃饭，这就是回调。
 
 二、Java的回调-中
@@ -354,50 +329,50 @@ callBottomService start -->  callBottomService.bottom() execute -->  BottomServi
 小明和小李相约一起去吃早饭，但是小李起的有点晚要先洗漱，等小李洗漱完成后，通知小明再一起去吃饭。小明就是类A，小李就是类B。不同的是我们新建一个吃饭的接口EatRice，接口中有个抽象方法eat()。在小明中调用这个接口，并实现eat()；小李声明这个接口对象，并且调用这个接口的抽象方法。这里可能有点绕口，不过没关系，看看例子就很清楚了。
 
 EatRice接口：
+````
+public interface EatRice {
+   public void eat(String food);
+}
+小明：
 
-    public interface EatRice {
-       public void eat(String food);
-    }
-    小明：
-    
-    public class XiaoMing implements EatRice{//小明
-        
-       //小明和小李一起吃饭
-       public void eatFood() {
-        XiaoLi xl = new XiaoLi();
-        //A调用B的方法
-        xl.washFace("大龙虾", this);//this指的是小明这个类实现的EatRice接口
-       }
-     
-       @Override
-       public void eat(String food) {
-        // TODO Auto-generated method stub
-        System.out.println("小明和小李一起去吃" + food);
-       }
-    }
-    小李:
-    
-    public class XiaoLi{//小李
-       public void washFace(String food,EatRice er) {
-        System.out.println("小李要洗漱");
-            //B调用了A的方法
-        er.eat(food);
-       }
-    }
-    测试Demo:
-    
-    public class demo {
-       public static void main(String args[]) {
-        XiaoMing xm = new XiaoMing();
-        xm.eatFood();
-       }
-    }
+public class XiaoMing implements EatRice{//小明
     
+   //小明和小李一起吃饭
+   public void eatFood() {
+    XiaoLi xl = new XiaoLi();
+    //A调用B的方法
+    xl.washFace("大龙虾", this);//this指的是小明这个类实现的EatRice接口
+   }
+ 
+   @Override
+   public void eat(String food) {
+    // TODO Auto-generated method stub
+    System.out.println("小明和小李一起去吃" + food);
+   }
+}
+小李:
+
+public class XiaoLi{//小李
+   public void washFace(String food,EatRice er) {
+    System.out.println("小李要洗漱");
+        //B调用了A的方法
+    er.eat(food);
+   }
+}
+测试Demo:
+
+public class demo {
+   public static void main(String args[]) {
+    XiaoMing xm = new XiaoMing();
+    xm.eatFood();
+   }
+}
+````   
 测试结果：
 
 
 这样子就通过接口的形式实现了软编码。通过接口的形式我可以实现小李洗漱完后，和小王一起去上网。代码如下
-
+````
     public class XiaoWang implements EatRice{//小王
         
        //小王和小李一起去上网
@@ -413,7 +388,7 @@ EatRice接口：
         System.out.println("小王和小李一起去" + bar);
        }
     }
-
+````
 ## 实例三：Tom做题
 
 数学老师让Tom做一道题，并且Tom做题期间数学老师不用盯着Tom，而是在玩手机，等Tom把题目做完后再把答案告诉老师。
@@ -425,64 +400,64 @@ EatRice接口：
 > 3 Tom需要数学老师的一个引用，以便Tom把答案给这位老师，而不是隔壁的体育老师。
 
 回调接口，可以理解为老师接口
+````
+//回调指的是A调用B来做一件事，B做完以后将结果告诉给A，这期间A可以做别的事情。
+//这个接口中有一个方法，意为B做完题目后告诉A时使用的方法。
+//所以我们必须提供这个接口以便让B来回调。
+//回调接口，
+public interface CallBack {
+    void tellAnswer(int res);
+}
+````
 
-        //回调指的是A调用B来做一件事，B做完以后将结果告诉给A，这期间A可以做别的事情。
-        //这个接口中有一个方法，意为B做完题目后告诉A时使用的方法。
-        //所以我们必须提供这个接口以便让B来回调。
-        //回调接口，
-        public interface CallBack {
-            void tellAnswer(int res);
-        }
-        
-        
 数学老师类
-        
-        //老师类实例化回调接口，即学生写完题目之后通过老师的提供的方法进行回调。
-        //那么学生如何调用到老师的方法呢，只要在学生类的方法中传入老师的引用即可。
-        //而老师需要指定学生答题，所以也要传入学生的实例。
-    public class Teacher implements CallBack{
-        private Student student;
-    
-        Teacher(Student student) {
-            this.student = student;
-        }
-    
-        void askProblem (Student student, Teacher teacher) {
-            //main方法是主线程运行，为了实现异步回调，这里开启一个线程来操作
-            new Thread(new Runnable() {
-                @Override
-                public void run() {
-                    student.resolveProblem(teacher);
-                }
-            }).start();
-            //老师让学生做题以后，等待学生回答的这段时间，可以做别的事，比如玩手机.\
-            //而不需要同步等待，这就是回调的好处。
-            //当然你可以说开启一个线程让学生做题就行了，但是这样无法让学生通知老师。
-            //需要另外的机制去实现通知过程。
-            // 当然，多线程中的future和callable也可以实现数据获取的功能。
-            for (int i = 1;i < 4;i ++) {
-                System.out.println("等学生回答问题的时候老师玩了 " + i + "秒的手机");
+````        
+    //老师类实例化回调接口，即学生写完题目之后通过老师的提供的方法进行回调。
+    //那么学生如何调用到老师的方法呢，只要在学生类的方法中传入老师的引用即可。
+    //而老师需要指定学生答题，所以也要传入学生的实例。
+public class Teacher implements CallBack{
+    private Student student;
+
+    Teacher(Student student) {
+        this.student = student;
+    }
+
+    void askProblem (Student student, Teacher teacher) {
+        //main方法是主线程运行，为了实现异步回调，这里开启一个线程来操作
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                student.resolveProblem(teacher);
             }
-        }
-    
-        @Override
-        public void tellAnswer(int res) {
-            System.out.println("the answer is " + res);
+        }).start();
+        //老师让学生做题以后，等待学生回答的这段时间，可以做别的事，比如玩手机.\
+        //而不需要同步等待，这就是回调的好处。
+        //当然你可以说开启一个线程让学生做题就行了，但是这样无法让学生通知老师。
+        //需要另外的机制去实现通知过程。
+        // 当然，多线程中的future和callable也可以实现数据获取的功能。
+        for (int i = 1;i < 4;i ++) {
+            System.out.println("等学生回答问题的时候老师玩了 " + i + "秒的手机");
         }
     }
-    
-学生接口
 
+    @Override
+    public void tellAnswer(int res) {
+        System.out.println("the answer is " + res);
+    }
+}
+````
+学生接口
+````
         //学生的接口，解决问题的方法中要传入老师的引用，否则无法完成对具体实例的回调。
         //写为接口的好处就是，很多个学生都可以实现这个接口，并且老师在提问题时可以通过
         //传入List<Student>来聚合学生，十分方便。
     public interface Student {
         void resolveProblem (Teacher teacher);
     }
-
+````
 学生Tom
 
-
+````
     public class Tom implements Student{
     
         @Override
@@ -496,9 +471,9 @@ EatRice接口：
                 e.printStackTrace();
             }
         }
-        
+````        
 测试类
-
+````
     public class Test {
         public static void main(String[] args) {
             //测试
@@ -513,9 +488,7 @@ EatRice接口：
     //        the answer is 111
         }
     }
-    
-
-
+````
 ## 参考文章
 
 https://blog.csdn.net/fengye454545/article/details/80198446
@@ -524,20 +497,3 @@ https://www.cnblogs.com/prayjourney/p/9667835.html
 https://blog.csdn.net/qq_25652949/article/details/86572948
 https://my.oschina.net/u/3703858/blog/1798627
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/basic/1\343\200\201\351\235\242\345\220\221\345\257\271\350\261\241\345\237\272\347\241\200.md" "b/docs/Java/basic/\351\235\242\345\220\221\345\257\271\350\261\241\345\237\272\347\241\200.md"
similarity index 79%
rename from "docs/java/basic/1\343\200\201\351\235\242\345\220\221\345\257\271\350\261\241\345\237\272\347\241\200.md"
rename to "docs/Java/basic/\351\235\242\345\220\221\345\257\271\350\261\241\345\237\272\347\241\200.md"
index 1ce17ab..670b95f 100644
--- "a/docs/java/basic/1\343\200\201\351\235\242\345\220\221\345\257\271\350\261\241\345\237\272\347\241\200.md"
+++ "b/docs/Java/basic/\351\235\242\345\220\221\345\257\271\350\261\241\345\237\272\347\241\200.md"
@@ -16,10 +16,6 @@
     * [二、封装](#二、封装)
       * [1、封装的概念](#1、封装的概念)
       * [2、封装的优点](#2、封装的优点)
-      * [3、封装的实现步骤](#3、封装的实现步骤)
-        * [A、访问修饰符](#a、访问修饰符)
-        * [B、this关键字](#b、this关键字)
-        * [C、Java 中的内部类](#c、java-中的内部类)
     * [三、多态](#三、多态)
       * [1、多态的概念](#1、多态的概念)
       * [2、多态的好处](#2、多态的好处)
@@ -28,9 +24,7 @@
         * [B、方法多态](#b、方法多态)
         * [C、引用类型转换](#c、引用类型转换)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -67,27 +61,23 @@ Java 是面向对象的编程语言，对象就是面向对象程序设计的核
 ## 面向对象和面向过程的区别
 
 - 面向过程：
-    一种较早的编程思想，顾名思义就是该思想是站着过程的角度思考问题，强调的就是功能行为，功能的执行过程，即先后顺序，而每一个功能我们都使用函数（类似于方法）把这些步骤一步一步实现。使用的时候依次调用函数就可以了。
+一种较早的编程思想，顾名思义就是该思想是站着过程的角度思考问题，强调的就是功能行为，功能的执行过程，即先后顺序，而每一个功能我们都使用函数（类似于方法）把这些步骤一步一步实现。使用的时候依次调用函数就可以了。
 
 - 面向过程的设计：
-    最小的程序单元是函数，每个函数负责完成某一个功能，用于接受输入数据，函数对输入数据进行处理，然后输出结果数据，整个软件系统由一个个的函数组成，其中作为程序入口的函数称之为主函数，主函数依次调用其他函数，普通函数之间可以相互调用，从而实现整个系统功能。 
-      面向过程最大的问题在于随着系统的膨胀，面向过程将无法应付，最终导致系统的崩溃。为了解决这一种软件危机，我们提出面向对象思想。
+  最小的程序单元是函数，每个函数负责完成某一个功能，用于接受输入数据，函数对输入数据进行处理，然后输出结果数据，整个软件系统由一个个的函数组成，其中作为程序入口的函数称之为主函数，主函数依次调用其他函数，普通函数之间可以相互调用，从而实现整个系统功能。 
+  面向过程最大的问题在于随着系统的膨胀，面向过程将无法应付，最终导致系统的崩溃。为了解决这一种软件危机，我们提出面向对象思想。
 
 - 面向过程的缺陷：
-    是采用指定而下的设计模式，在设计阶段就需要考虑每一个模块应该分解成哪些子模块，每一个子模块又细分为更小的子模块，如此类推，直到将模块细化为一个个函数。
-
-- 存在的问题
+  是采用自顶而下的设计模式，在设计阶段就需要考虑每一个模块应该分解成哪些子模块，每一个子模块又细分为更小的子模块，如此类推，直到将模块细化为一个个函数。
 
-  ​		设计不够直观，与人类的思维习惯不一致
+- 存在的问题 
+  设计不够直观，与人类的思维习惯不一致
   系统软件适应新差，可拓展性差，维护性低
 
-- 面向对象：
-
-  ​		一种基于面向过程的新编程思想，顾名思义就是该思想是站在对象的角度思考问题，我们把多个功能合理放到不同对象里，强调的是具备某些功能的对象。 
-
-    具备某种功能的实体，称为对象。面向对象最小的程序单元是：类。面向对象更加符合常规的思维方式，稳定性好，可重用性强，易于开发大型软件产品，有良好的可维护性。 
-
-  在软件工程上，面向对象可以使工程更加模块化，实现更低的耦合和更高的内聚。
+- 面向对象： 
+  一种基于面向过程的新编程思想，顾名思义就是该思想是站在对象的角度思考问题，我们把多个功能合理放到不同对象里，强调的是具备某些功能的对象。
+  具备某种功能的实体，称为对象。面向对象最小的程序单元是：类。面向对象更加符合常规的思维方式，稳定性好，可重用性强，易于开发大型软件产品，有良好的可维护性。
+  在软件工程上，面向对象可以使工程更加模块化，实现更低的耦合和更高的内聚。
 
 
 ## 面向对象的三大核心特性简介
@@ -179,10 +169,7 @@ Java 是面向对象的编程语言，对象就是面向对象程序设计的核
 
 使用这种层次形的分类方式，是为了将多个类的通用属性和方法提取出来，放在它们的父类中，然后只需要在子类中各自定义自己独有的属性和方法，并以继承的形式在父类中获取它们的通用属性和方法即可。
 
-　继承是类与类的一种关系，是一种“is a”的关系。比如“狗”继承“动物”，这里动物类是狗类的父类或者基类，狗类是动物类的子类或者派生类。如下图所示：
-
-![img](https://images2015.cnblogs.com/blog/1189312/201707/1189312-20170701123011243-2128400556.png)
-
+　继承是类与类的一种关系，是一种“is a”的关系。比如“狗”继承“动物”，这里动物类是狗类的父类或者基类，狗类是动物类的子类或者派生类。
 注：java中的继承是**单继承**，即**一个类只有一个父类。**
 
 **补充：Java中的继承只能单继承，但是可以通过内部类继承其他类来实现多继承。**
@@ -218,47 +205,37 @@ System.out.println("mom cook");
 
 　子类拥有父类的所有属性和方法（除了private修饰的属性不能拥有）从而实现了实现代码的复用；　
 
-#### 3、语法规则
-
-![img](https://images2015.cnblogs.com/blog/1189312/201707/1189312-20170701123421961-647167245.png)
-
-------
-
  ##### A、方法的重写
 
-　子类如果对继承的父类的方法不满意（不适合），可以自己编写继承的方法，这种方式就称为**方法的重写。当调用方法时会优先调用子类的方法。**
+子类如果对继承的父类的方法不满意（不适合），可以自己编写继承的方法，这种方式就称为**方法的重写。当调用方法时会优先调用子类的方法。**
 
-　**重写要注意：**
+**重写要注意：**
 
-　    a、返回值类型
+a、返回值类型
 
-　　b、方法名
+b、方法名
 
-　　c、参数类型及个数
+c、参数类型及个数
 
-　都要与父类继承的方法相同，才叫方法的重写。
+都要与父类继承的方法相同，才叫方法的重写。
 
-　**重载和重写的区别：**
+**重载和重写的区别：**
 
-　　方法重载：在同一个类中处理不同数据的多个相同方法名的多态手段。
+方法重载：在同一个类中处理不同数据的多个相同方法名的多态手段。
 
-　　方法重写：相对继承而言，子类中对父类已经存在的方法进行区别化的修改。
+方法重写：相对继承而言，子类中对父类已经存在的方法进行区别化的修改。
 
 ------
 
 ##### B、继承的初始化顺序
 
-　　1、初始化父类再初始化子类
+1、初始化父类再初始化子类
 
-　　2、先执行初始化对象中属性，再执行构造方法中的初始化。
+2、先执行初始化对象中属性，再执行构造方法中的初始化。
 
-　基于上面两点，我们就知道实例化一个子类，java程序的执行顺序是：
+基于上面两点，我们就知道实例化一个子类，java程序的执行顺序是：
 
-　**父类对象属性初始化---->父类对象构造方法---->子类对象属性初始化--->子类对象构造方法**　　　
-
-　下面有个形象的图：
-
-![img](https://images2015.cnblogs.com/blog/1189312/201707/1189312-20170701144019071-1063399032.png)
+**父类对象属性初始化---->父类对象构造方法---->子类对象属性初始化--->子类对象构造方法**　　　
 
 ------
 
@@ -345,55 +322,22 @@ Java 封装，说白了就是将一大坨公共通用的实现逻辑玩意，装
 
 4. 一对一，一个功能就只为这个功能服务；避免头发绳子一块用，导致最后一团糟
 
-#### 3、封装的实现步骤
-
-![img](https://images2015.cnblogs.com/blog/1189312/201706/1189312-20170630170717493-357592353.png)
-
-　　　　需要注意：对封装的属性不一定要通过get/set方法，其他方法也可以对封装的属性进行操作。当然最好使用get/set方法，比较标准。
-
-------
-
- 
-
-##### A、访问修饰符
-
-![img](https://images2015.cnblogs.com/blog/1189312/201706/1189312-20170630174919274-1857293801.png)
-
-　　　　从表格可以看出**从上到下封装性越来越差**。
-
-
-
-##### B、this关键字
-
-　1.this关键字**代表当前对象**
-
-　　this.属性 操作当前对象的属性
-
-　　this.方法 调用当前对象的方法。
-
-　2.封装对象的属性的时候，经常会使用this关键字。
-
-　3.当getter和setter函数参数名和成员函数名重合的时候，**可以使用this****区别。如：**
-
-![img](https://images2015.cnblogs.com/blog/1189312/201706/1189312-20170630180217524-833886832.png)
-
-
 
 ##### C、Java 中的内部类
 
-　内部类（ Inner Class ）就是定义在另外一个类**里面**的类。与之对应，包含内部类的类被称为外部类。
+内部类（ Inner Class ）就是定义在另外一个类**里面**的类。与之对应，包含内部类的类被称为外部类。
 
-　那么问题来了：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！
+那么问题来了：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！
 
-　答：内部类的主要作用如下：
+答：内部类的主要作用如下：
 
-　　1. 内部类提供了**更好的封装**，可以把内部类**隐藏**在外部类之内，**不允许**同一个包中的其他类访问该类。
+1. 内部类提供了**更好的封装**，可以把内部类**隐藏**在外部类之内，**不允许**同一个包中的其他类访问该类。
 
-　　2. 内部类的方法可以**直接访问外部类的所有数据**，包括**私有的数据**。
+2. 内部类的方法可以**直接访问外部类的所有数据**，包括**私有的数据**。
 
-　　3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便。
+3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便。
 
-　　内部类可分为以下几种： 
+内部类可分为以下几种： 
 
 - 成员内部类
 
@@ -401,8 +345,6 @@ Java 封装，说白了就是将一大坨公共通用的实现逻辑玩意，装
 - 方法内部类
 - 匿名内部类　　
 
-
-
 ### 三、多态
 
 #### 1、多态的概念
@@ -452,9 +394,10 @@ java里的多态主要表现在两个方面：
 
 　　这两句话是什么意思呢，让我们用代码来体验一下，首先我们创建一个父类Animal和一个子类Dog，在主函数里如下所示：
 
-![img](https://images2015.cnblogs.com/blog/1189312/201707/1189312-20170701155536086-1897896282.png)
+![img](https://cdn.mianshigee.com/upload/note/thumbnails/202202211611552259.png)
 
-　　注意：我们不能使用一个子类的引用来指向父类的对象，如：![img](https://images2015.cnblogs.com/blog/1189312/201707/1189312-20170701155839586-923083573.png)。
+　　注意：我们不能使用一个子类的引用来指向父类的对象，如：
+![img](https://cdn.mianshigee.com/upload/note/thumbnails/202202211611556958.png)。
 
 　　这里我们必须深刻理解引用多态的意义，才能更好记忆这种多态的特性。为什么子类的引用不能用来指向父类的对象呢？我在这里通俗给大家讲解一下：就以上面的例子来说，我们能说“狗是一种动物”，但是不能说“动物是一种狗”，狗和动物是父类和子类的继承关系，它们的从属是不能颠倒的。当父类的引用指向子类的对象时，该对象将只是看成一种特殊的父类（里面有重写的方法和属性），反之，一个子类的引用来指向父类的对象是不可行的！！
 
@@ -482,23 +425,23 @@ java里的多态主要表现在两个方面：
 
 　 就以上述的父类Animal和一个子类Dog来说明，当父类的引用可以指向子类的对象时，就是**向上类型转换**。如：
 
-![img](https://images2015.cnblogs.com/blog/1189312/201707/1189312-20170701162630508-961507659.png)
+   ![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvMTE4OTMxMi8yMDE3MDcvMTE4OTMxMi0yMDE3MDcwMTE2MjYzMDUwOC05NjE1MDc2NTkucG5n?x-oss-process=image/format,png)
 
 　 **2. 向下类型转换(强制类型转换)，是大类型转换到小类型(有风险,可能出现数据溢出)。**
 
 　　将上述代码再加上一行，我们再次将父类转换为子类引用，那么会出现错误，编译器不允许我们直接这么做**，**虽然我们知道这个父类引用指向的就是子类对象，但是编译器认为这种转换是存在风险的**。**如：
 
-![img](https://images2015.cnblogs.com/blog/1189312/201707/1189312-20170701162926477-3857975.png)
+   ![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvMTE4OTMxMi8yMDE3MDcvMTE4OTMxMi0yMDE3MDcwMTE2MjkyNjQ3Ny0zODU3OTc1LnBuZw?x-oss-process=image/format,png)
 
-　　那么我们该怎么解决这个问题呢，我们可以在animal前加上（Dog）来强制类型转换。如：![img](https://images2015.cnblogs.com/blog/1189312/201707/1189312-20170701163408383-2003626729.png)
+　　那么我们该怎么解决这个问题呢，我们可以在animal前加上（Dog）来强制类型转换。如：![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvMTE4OTMxMi8yMDE3MDcvMTE4OTMxMi0yMDE3MDcwMTE2NDIyOTg5OS0xMDU1MTkwNzc0LnBuZw?x-oss-process=image/format,png)
 
-　　但是如果父类引用没有指向**该子类的对象**，则不能向下类型转换，虽然编译器不会报错，但是运行的时候程序会出错，如：![img](https://images2015.cnblogs.com/blog/1189312/201707/1189312-20170701164229899-1055190774.png)
+　　但是如果父类引用没有指向**该子类的对象**，则不能向下类型转换，虽然编译器不会报错，但是运行的时候程序会出错，如：![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvMTE4OTMxMi8yMDE3MDcvMTE4OTMxMi0yMDE3MDcwMTE2NTEzMzI4OS03MTc0MzkzNjAucG5n?x-oss-process=image/format,png)
 
 　　其实这就是上面所说的子类的引用指向父类的对象，而强制转换类型也不能转换！！
 
 　　还有一种情况是父类的引用指向**其他子类的对象**，则不能通过强制转为**该子类的对象**。如：
 
-　　　　![img](https://images2015.cnblogs.com/blog/1189312/201707/1189312-20170701165133289-717439360.png)
+　　![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvMTE4OTMxMi8yMDE3MDcvMTE4OTMxMi0yMDE3MDcwMTE2NTEzMzI4OS03MTc0MzkzNjAucG5n?x-oss-process=image/format,png)
 
 　　这是因为我们在编译的时候进行了强制类型转换，编译时的类型是我们强制转换的类型，所以编译器不会报错，而当我们运行的时候，程序给animal开辟的是Dog类型的内存空间，这与Cat类型内存空间不匹配，所以无法正常转换。这两种情况出错的本质是一样的，所以我们在使用强制类型转换的时候要特别注意这两种错误！！下面有个更安全的方式来实现向下类型转换。。。。
 
@@ -508,7 +451,7 @@ java里的多态主要表现在两个方面：
 
 　　我们来使用instanceof运算符来规避上面的错误，代码修改如下：
 
-　　![img](https://images2015.cnblogs.com/blog/1189312/201707/1189312-20170701165626571-501228254.png)
+　　![img](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvMTE4OTMxMi8yMDE3MDcvMTE4OTMxMi0yMDE3MDcwMTE2NTYyNjU3MS01MDEyMjgyNTQucG5n?x-oss-process=image/format,png)
 
 　　利用if语句和instanceof运算符来判断两个对象的类型是否一致。
 
@@ -686,23 +629,7 @@ public void eat(char ... c) {
 
 <https://www.runoob.com/>
 
-https://blog.csdn.net/android_hl/article/details/53228348
-
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
+<https://blog.csdn.net/android_hl/article/details/53228348/>
 
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
 
diff --git "a/docs/java/collection/Java\351\233\206\345\220\210\347\261\273\346\200\273\347\273\223.md" "b/docs/Java/collection/Java\351\233\206\345\220\210\347\261\273\346\200\273\347\273\223.md"
similarity index 74%
rename from "docs/java/collection/Java\351\233\206\345\220\210\347\261\273\346\200\273\347\273\223.md"
rename to "docs/Java/collection/Java\351\233\206\345\220\210\347\261\273\346\200\273\347\273\223.md"
index 2c05f7b..97f2d10 100644
--- "a/docs/java/collection/Java\351\233\206\345\220\210\347\261\273\346\200\273\347\273\223.md"
+++ "b/docs/Java/collection/Java\351\233\206\345\220\210\347\261\273\346\200\273\347\273\223.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [Colletion，iterator，comparable](#colletion，iterator，comparable)
   * [List](#list)
   * [Map](#map)
@@ -9,27 +8,10 @@
   * [collections和Arrays工具类](#collections和arrays工具类)
   * [comparable和comparator](#comparable和comparator)
   * [treemap和treeset](#treemap和treeset)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-
----
-title: Java集合框架学习总结
-date: 2018-07-08 22:03:44
-tags:
-	- Java集合
-categories:
-	- 后端
-	- 技术总结
----
-
 
 
 这篇总结是基于之前博客内容的一个整理和回顾。
 
-
-
 这里先简单地总结一下，更多详细内容请参考我的专栏：深入浅出Java核心技术
 
 https://blog.csdn.net/column/details/21930.html
@@ -40,8 +22,6 @@ https://blog.csdn.net/column/details/21930.html
 以下总结不保证全对，如有错误，还望能够指出。谢谢
 <!-- more -->
 
-
-
 ## Colletion，iterator，comparable
 
 
@@ -55,12 +35,8 @@ List接口下的实现类有ArrayList，linkedlist，vector等等，一般就是
 ArrayList的扩容方式是1.5倍扩容，这样扩容避免2倍扩容可能浪费空间，是一种折中的方案。
 另外他不是线程安全，vector则是线程安全的，它是两倍扩容的。
 
-
 linkedlist没啥好说的，多用于实现链表。
 
-
-
-
 ## Map
 
 
@@ -91,7 +67,7 @@ hashmap的增删改查方式比较简单，都是遍历，替换。有一点要
 ## CHM
 
 
-concurrenthashmap也稍微提一下把，chm1.7使用分段锁来控制并发，每个segment对应一个segmentmask，通过key的hash值相与这个segmentmask得到segment位置，然后在找到具体的entry数组下标。所以chm需要维护多个segment，每个segment对应一个数组。分段锁使用的是reetreetlock可重入锁实现。查询时不加锁。
+concurrenthashmap也稍微提一下把，chm1.7使用分段锁来控制并发，每个segment对应一个segmentmask，通过key的hash值相与这个segmentmask得到segment位置，然后在找到具体的entry数组下标。所以chm需要维护多个segment，每个segment对应一个数组。分段锁使用的是ReentrantLock可重入锁实现。查询时不加锁。
 
 
 1.8则放弃使用分段锁，改用cas+synchronized方式实现并发控制，查询时不加锁，插入时如果没有冲突直接cas到成功为止，有冲突则使用synchronized插入。
@@ -123,20 +99,4 @@ set就是hashmap将value固定为一个object，只存key元素包装成一个en
 
 主要是基于红黑树实现的两个数据结构，可以保证key序列是有序的，获取sortedset就可以顺序打印key值了。其中涉及到红黑树的插入和删除，调整等操作，比较复杂，这里就不细说了。
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232HashMap\345\222\214HashTable.md" "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232HashMap\345\222\214HashTable.md"
new file mode 100644
index 0000000..3670c97
--- /dev/null
+++ "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232HashMap\345\222\214HashTable.md"
@@ -0,0 +1,599 @@
+# 目录
+  * [HashMap](#hashmap)
+    * [定义](#定义)
+    * [构造函数](#构造函数)
+    * [数据结构](#数据结构)
+    * [存储实现：put(key,vlaue)](#存储实现：putkeyvlaue)
+    * [JDK1.8的hashmap：put方法](#jdk18的hashmap：put方法)
+    * [扩容](#扩容)
+    * [读取实现：get(key)](#读取实现：getkey)
+  * [HashTable](#hashtable)
+    * [定义](#定义-1)
+    * [构造方法](#构造方法)
+    * [主要方法](#主要方法)
+  * [HashTable与HashMap的异同点](#hashtable与hashmap的异同点)
+  * [面试题：HashMap和HashTable的区别](#面试题：hashmap和hashtable的区别)
+  * [参考文章](#参考文章)
+
+    
+本文参考http://cmsblogs.com/?p=176
+
+
+《Java集合详解系列》是我在完成夯实Java基础篇的系列博客后准备开始整理的新系列文章。
+为了更好地诠释知识点，形成体系文章，本系列文章整理了很多优质的博客内容，如有侵权请联系我，一定删除。
+
+这些文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star、fork哈
+
+本系列文章将整理于我的个人博客：
+
+> www.how2playlife.com
+
+## HashMap
+
+HashMap也是我们使用非常多的Collection，它是基于哈希表的 Map 接口的实现，以key-value的形式存在。在HashMap中，key-value总是会当做一个整体来处理，系统会根据hash算法来来计算key-value的存储位置，我们总是可以通过key快速地存、取value。下面就来分析HashMap的存取。
+
+### 定义
+
+HashMap实现了Map接口，继承AbstractMap。其中Map接口定义了键映射到值的规则，而AbstractMap类提供 Map 接口的骨干实现，以最大限度地减少实现此接口所需的工作，其实AbstractMap类已经实现了Map，这里标注Map LZ觉得应该是更加清晰吧！
+````
+public class HashMap<K,V>
+    extends AbstractMap<K,V>
+    implements Map<K,V>, Cloneable, Serializable
+````
+### 构造函数
+
+      HashMap提供了三个构造函数：
+    
+      HashMap()：构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
+    
+      HashMap(int initialCapacity)：构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。
+    
+      HashMap(int initialCapacity, float loadFactor)：构造一个带指定初始容量和加载因子的空 HashMap。
+
+  在这里提到了两个参数：初始容量，加载因子。
+
+>   这两个参数是影响HashMap性能的重要参数，其中容量表示哈希表中桶的数量，初始容量是创建哈希表时的容量，加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。
+>
+>   对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。系统默认负载因子为0.75，一般情况下我们是无需修改的。
+
+  HashMap是一种支持快速存取的数据结构，要了解它的性能必须要了解它的数据结构。
+
+### 数据结构
+
+>   我们知道在Java中最常用的两种结构是数组和模拟指针(引用)，几乎所有的数据结构都可以利用这两种来组合实现，HashMap也是如此。实际上HashMap是一个“链表散列”，如下是它的数据结构：
+
+HashMap数据结构图
+
+下图的table数组的每个格子都是一个桶。负载因子就是map中的元素占用的容量百分比。比如负载因子是0.75，初始容量（桶数量）为16时，那么允许装填的元素最大个数就是16*0.75 = 12，这个最大个数也被成为阈值，就是map中定义的threshold。超过这个阈值时，map就会自动扩容。
+
+
+### 存储实现：put(key,vlaue)
+首先我们先看源码
+````    
+public V put(K key, V value) {
+    //当key为null，调用putForNullKey方法，保存null与table第一个位置中，这是HashMap允许为null的原因
+    if (key == null)
+        return putForNullKey(value);
+    //计算key的hash值，此处对原来元素的hashcode进行了再次hash
+    int hash = hash(key.hashCode());                  ------(1)
+    //计算key hash 值在 table 数组中的位置
+    int i = indexFor(hash, table.length);             ------(2)
+    //从i出开始迭代 e,找到 key 保存的位置
+    for (Entry<K, V> e = table[i]; e != null; e = e.next) {
+        Object k;
+        //判断该条链上是否有hash值相同的(key相同)
+        //若存在相同，则直接覆盖value，返回旧value
+        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
+            V oldValue = e.value;    //旧值 = 新值
+            e.value = value;
+            e.recordAccess(this);
+            return oldValue;     //返回旧值
+        }
+    }
+    //修改次数增加1
+    modCount++;
+    //将key、value添加至i位置处
+    addEntry(hash, key, value, i);
+    return null;
+}
+````
+  通过源码我们可以清晰看到HashMap保存数据的过程为：首先判断key是否为null，若为null，则直接调用putForNullKey方法。
+
+  若不为空则先计算key的hash值，然后根据hash值搜索在table数组中的索引位置，如果table数组在该位置处有元素，则通过比较是否存在相同的key，若存在则覆盖原来key的value，==否则将该元素保存在链头（最先保存的元素放在链尾）==。
+
+  若table在该处没有元素，则直接保存。这个过程看似比较简单，其实深有内幕。有如下几点：
+
+>   1、 先看迭代处。此处迭代原因就是为了防止存在相同的key值，若发现两个hash值（key）相同时，HashMap的处理方式是用新value替换旧value，这里并没有处理key，这就解释了HashMap中没有两个相同的key。
+>
+>   2、 在看（1）、（2）处。这里是HashMap的精华所在。首先是hash方法，该方法为一个纯粹的数学计算，就是计算h的hash值。
+````
+static int hash(int h) {
+        h ^= (h >>> 20) ^ (h >>> 12);
+        return h ^ (h >>> 7) ^ (h >>> 4);
+    }
+````
+  我们知道对于HashMap的table而言，数据分布需要均匀（最好每项都只有一个元素，这样就可以直接找到），不能太紧也不能太松，太紧会导致查询速度慢，太松则浪费空间。计算hash值后，怎么才能保证table元素分布均与呢？我们会想到取模，但是由于取模的消耗较大，HashMap是这样处理的：调用indexFor方法。
+````
+static int indexFor(int h, int length) {
+        return h & (length-1);
+    }
+````
+  HashMap的底层数组长度总是2的n次方，在构造函数中存在：capacity <<= 1;这样做总是能够保证HashMap的底层数组长度为2的n次方。当length为2的n次方时，h&(length - 1)就相当于对length取模，而且速度比直接取模快得多，这是HashMap在速度上的一个优化。至于为什么是2的n次方下面解释。
+
+ ==对length取模来得到hash是常用的hash索引方法，这里采用位运算的话效率更高。==
+
+  我们回到indexFor方法，该方法仅有一条语句：h&(length - 1)，这句话除了上面的取模运算外还有一个非常重要的责任：均匀分布table数据和充分利用空间。
+
+  这里我们假设length为16(2^n)和15，h为5、6、7。
+
+  当n=15时，6和7的结果一样，这样表示他们在table存储的位置是相同的，也就是产生了碰撞，6、7就会在一个位置形成链表，这样就会导致查询速度降低。诚然这里只分析三个数字不是很多，那么我们就看0-15。
+
+>   而当length = 16时，length – 1 = 15 即1111，那么进行低位&运算时，值总是与原来hash值相同，而进行高位运算时，其值等于其低位值。所以说当length = 2^n时，不同的hash值发生碰撞的概率比较小，这样就会使得数据在table数组中分布较均匀，查询速度也较快。
+>
+>   这里我们再来复习put的流程：当我们想一个HashMap中添加一对key-value时，系统首先会计算key的hash值，然后根据hash值确认在table中存储的位置。若该位置没有元素，则直接插入。否则迭代该处元素链表并依此比较其key的hash值。
+>
+>   如果两个hash值相等且key值相等(e.hash == hash && ((k = e.key) == key || key.equals(k))),则用新的Entry的value覆盖原来节点的value。如果两个hash值相等但key值不等 ，则将该节点插入该链表的链头。具体的实现过程见addEntry方法，如下：
+````
+void addEntry(int hash, K key, V value, int bucketIndex) {
+        //获取bucketIndex处的Entry
+        Entry<K, V> e = table[bucketIndex];
+        //将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry 
+        table[bucketIndex] = new Entry<K, V>(hash, key, value, e);
+        //若HashMap中元素的个数超过极限了，则容量扩大两倍
+        if (size++ >= threshold)
+            resize(2 * table.length);
+    }
+````
+这个方法中有两点需要注意：
+
+    后面添加的entry反而会接到前面。
+
+  一、是链的产生。
+
+  这是一个非常优雅的设计。系统总是将新的Entry对象添加到bucketIndex处。如果bucketIndex处已经有了对象，那么新添加的Entry对象将指向原有的Entry对象，形成一条Entry链，但是若bucketIndex处没有Entry对象，也就是e==null,那么新添加的Entry对象指向null，也就不会产生Entry链了。
+
+  二、扩容问题。
+
+  随着HashMap中元素的数量越来越多，发生碰撞的概率就越来越大，所产生的链表长度就会越来越长，这样势必会影响HashMap的速度，为了保证HashMap的效率，系统必须要在某个临界点进行扩容处理。
+
+  该临界点在当HashMap中元素的数量等于table数组长度*加载因子。但是扩容是一个非常耗时的过程，因为它需要重新计算这些数据在新table数组中的位置并进行复制处理。所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。
+
+### JDK1.8的hashmap：put方法
+````
+final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
+               boolean evict) {
+    Node<K,V>[] tab; Node<K,V> p; int n, i;
+    if ((tab = table) == null || (n = tab.length) == 0)
+        n = (tab = resize()).length;
+    if ((p = tab[i = (n - 1) & hash]) == null)
+        tab[i] = newNode(hash, key, value, null);
+    else {
+        Node<K,V> e; K k;
+        if (p.hash == hash &&
+            ((k = p.key) == key || (key != null && key.equals(k))))
+            e = p;
+            //如果p是红黑树节点，则用另外的处理方法
+        else if (p instanceof TreeNode)
+            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
+        else {
+            for (int binCount = 0; ; ++binCount) {
+                if ((e = p.next) == null) {
+                    p.next = newNode(hash, key, value, null);
+                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
+                    //当链表节点数超过8个，则直接进行红黑树化。
+                        treeifyBin(tab, hash);
+                    break;
+                }
+                if (e.hash == hash &&
+                    ((k = e.key) == key || (key != null && key.equals(k))))
+                    break;
+                p = e;
+            }
+        }
+        if (e != null) { // existing mapping for key
+            V oldValue = e.value;
+            if (!onlyIfAbsent || oldValue == null)
+                e.value = value;
+            afterNodeAccess(e);
+            return oldValue;
+        }
+    }
+    ++modCount;
+    if (++size > threshold)
+        resize();
+    afterNodeInsertion(evict);
+    return null;
+}
+````
+JDK1.8在链表长度超过8时会转换为红黑树。
+转换方法如下：
+````
+final void treeifyBin(Node<K,V>[] tab, int hash) {
+    int n, index; Node<K,V> e;
+    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
+    //如果节点数变小小于红黑树的节点数阈值时，调整空间
+        resize();
+    else if ((e = tab[index = (n - 1) & hash]) != null) {
+        TreeNode<K,V> hd = null, tl = null;
+        do {
+        //该方法直接返回一个红黑树结点。
+            TreeNode<K,V> p = replacementTreeNode(e, null);
+            if (tl == null)
+                hd = p;
+            else {
+            //从链表头开始依次插入红黑树
+                p.prev = tl;
+                tl.next = p;
+            }
+            tl = p;
+        } while ((e = e.next) != null);
+        if ((tab[index] = hd) != null)
+            hd.treeify(tab);
+    }
+}
+    
+// For treeifyBin
+TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
+    return new TreeNode<>(p.hash, p.key, p.value, next);
+}
+````
+### 扩容
+````
+final Node<K,V>[] resize() {
+    Node<K,V>[] oldTab = table;
+    int oldCap = (oldTab == null) ? 0 : oldTab.length;
+    int oldThr = threshold;
+    int newCap, newThr = 0;
+    if (oldCap > 0) {
+        //如果原容量大于最大空间，则让阈值为最大值。因为不能再扩容了，最大容量就是整数最大值。
+        if (oldCap >= MAXIMUM_CAPACITY) {
+            threshold = Integer.MAX_VALUE;
+            return oldTab;
+        }
+        //两倍扩容，阈值也跟着变为两倍
+        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
+                 oldCap >= DEFAULT_INITIAL_CAPACITY)
+            newThr = oldThr << 1; // double threshold
+    }
+    else if (oldThr > 0) // initial capacity was placed in threshold
+        newCap = oldThr;
+    else {               // zero initial threshold signifies using defaults
+        newCap = DEFAULT_INITIAL_CAPACITY;
+        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
+    }
+    if (newThr == 0) {
+        float ft = (float)newCap * loadFactor;
+        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
+                  (int)ft : Integer.MAX_VALUE);
+    }
+    threshold = newThr;
+    
+    @SuppressWarnings({"rawtypes","unchecked"})
+    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
+    
+    table = newTab;
+    
+    if (oldTab != null) {
+        for (int j = 0; j < oldCap; ++j) {
+            Node<K,V> e;
+            if ((e = oldTab[j]) != null) {
+                oldTab[j] = null;
+                if (e.next == null)
+                    //当后面没有节点时，直接插入即可 //每个元素重新计算索引位置，此处的hash值并没有变，只是改变索引值
+                    newTab[e.hash & (newCap - 1)] = e;
+                else if (e instanceof TreeNode)
+                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
+                else { // preserve order
+                //否则，就从头到尾依次将节点进行索引然后插入新数组，这样插入后的链表顺序会和原来的顺序相反。
+                    Node<K,V> loHead = null, loTail = null;
+                    Node<K,V> hiHead = null, hiTail = null;
+                    Node<K,V> next;
+                    do {
+                        next = e.next;
+                        if ((e.hash & oldCap) == 0) {
+                            if (loTail == null)
+                                loHead = e;
+                            else
+                                loTail.next = e;
+                            loTail = e;
+                        }
+                        else {
+                            if (hiTail == null)
+                                hiHead = e;
+                            else
+                                hiTail.next = e;
+                            hiTail = e;
+                        }
+                    } while ((e = next) != null);
+                    if (loTail != null) {
+                        loTail.next = null;
+                        newTab[j] = loHead;
+                    }
+                    if (hiTail != null) {
+                        hiTail.next = null;
+                        newTab[j + oldCap] = hiHead;
+                    }
+                }
+            }
+        }
+    }
+    return newTab;
+}
+````
+### 读取实现：get(key)
+````
+相对于HashMap的存而言，取就显得比较简单了。通过key的hash值找到在table数组中的索引处的Entry，然后返回该key对应的value即可。
+
+public V get(Object key) {
+    // 若为null，调用getForNullKey方法返回相对应的value
+    if (key == null)
+        return getForNullKey();
+    // 根据该 key 的 hashCode 值计算它的 hash 码  
+    int hash = hash(key.hashCode());
+    // 取出 table 数组中指定索引处的值
+    for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
+        Object k;
+        //若搜索的key与查找的key相同，则返回相对应的value
+        if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
+            return e.value;
+    }
+    return null;
+}
+````
+> 在这里能够根据key快速的取到value除了和HashMap的数据结构密不可分外，还和Entry有莫大的关系，在前面就提到过，HashMap在存储过程中并没有将key，value分开来存储，而是当做一个整体key-value来处理的，这个整体就是Entry对象。
+>
+> 同时value也只相当于key的附属而已。在存储的过程中，系统根据key的hashcode来决定Entry在table数组中的存储位置，在取的过程中同样根据key的hashcode取出相对应的Entry对象。
+>
+> 在java中与有两个类都提供了一个多种用途的hashTable机制，他们都可以将可以key和value结合起来构成键值对通过put(key,value)方法保存起来，然后通过get(key)方法获取相对应的value值。
+
+## HashTable
+
+一个是前面提到的HashMap，还有一个就是马上要讲解的HashTable。对于HashTable而言，它在很大程度上和HashMap的实现差不多，如果我们对HashMap比较了解的话，对HashTable的认知会提高很大的帮助。他们两者之间只存在几点的不同，这个后面会阐述。
+
+### 定义
+
+HashTable在Java中的定义如下：
+
+public class Hashtable<K,V>
+extends Dictionary<K,V>
+implements Map<K,V>, Cloneable, java.io.Serializable
+从中可以看出HashTable继承Dictionary类，实现Map接口。其中Dictionary类是任何可将键映射到相应值的类（如 Hashtable）的抽象父类。每个键和每个值都是一个对象。在任何一个 Dictionary 对象中，每个键至多与一个值相关联。Map是"key-value键值对"接口。
+
+HashTable采用"拉链法"实现哈希表，它定义了几个重要的参数：table、count、threshold、loadFactor、modCount。
+
+table：为一个Entry[]数组类型，Entry代表了“拉链”的节点，每一个Entry代表了一个键值对，哈希表的"key-value键值对"都是存储在Entry数组中的。
+
+count：HashTable的大小，注意这个大小并不是HashTable的容器大小，而是他所包含Entry键值对的数量。
+
+threshold：Hashtable的阈值，用于判断是否需要调整Hashtable的容量。threshold的值="容量*加载因子"。
+
+loadFactor：加载因子。
+
+modCount：用来实现“fail-fast”机制的（也就是快速失败）。所谓快速失败就是在并发集合中，其进行迭代操作时，若有其他线程对其进行结构性的修改，这时迭代器会立马感知到，并且立即抛出ConcurrentModificationException异常，而不是等到迭代完成之后才告诉你（你已经出错了）。
+
+### 构造方法
+````
+//在HashTabel中存在5个构造函数。通过这5个构造函数我们构建出一个我想要的HashTable。
+public Hashtable() {
+        this(11, 0.75f);
+    }
+      默认构造函数，容量为11，加载因子为0.75。
+
+public Hashtable(int initialCapacity) {
+        this(initialCapacity, 0.75f);
+}
+
+//用指定初始容量和默认的加载因子 (0.75) 构造一个新的空哈希表。
+public Hashtable(int initialCapacity, float loadFactor) {
+    //验证初始容量
+    if (initialCapacity < 0)
+        throw new IllegalArgumentException("Illegal Capacity: "+
+                                           initialCapacity);
+    //验证加载因子
+    if (loadFactor <= 0 || Float.isNaN(loadFactor))
+        throw new IllegalArgumentException("Illegal Load: "+loadFactor);
+
+    if (initialCapacity==0)
+        initialCapacity = 1;
+
+    this.loadFactor = loadFactor;
+
+    //初始化table，获得大小为initialCapacity的table数组
+    table = new Entry[initialCapacity];
+    //计算阀值
+    threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
+    //初始化HashSeed值
+    initHashSeedAsNeeded(initialCapacity);
+}
+
+````
+
+>  用指定初始容量和指定加载因子构造一个新的空哈希表。其中initHashSeedAsNeeded方法用于初始化hashSeed参数，其中hashSeed用于计算key的hash值，它与key的hashCode进行按位异或运算。这个hashSeed是一个与实例相关的随机值，主要用于解决hash冲突。
+
+````
+    private int hash(Object k) {
+            return hashSeed ^ k.hashCode();
+        }
+````
+
+  构造一个与给定的 Map 具有相同映射关系的新哈希表。
+
+````
+    public Hashtable(Map<? extends K, ? extends V> t) {
+            //设置table容器大小，其值==t.size * 2 + 1
+            this(Math.max(2*t.size(), 11), 0.75f);
+            putAll(t);
+        }
+````
+
+### 主要方法
+
+HashTable的API对外提供了许多方法，这些方法能够很好帮助我们操作HashTable，但是这里我只介绍两个最根本的方法：put、get。
+````
+//首先我们先看put方法：将指定 key 映射到此哈希表中的指定 value。注意这里键key和值value都不可为空。
+public synchronized V put(K key, V value) {
+    // 确保value不为null
+    if (value == null) {
+        throw new NullPointerException();
+    }
+
+    /*
+     * 确保key在table[]是不重复的
+     * 处理过程：
+     * 1、计算key的hash值，确认在table[]中的索引位置
+     * 2、迭代index索引位置，如果该位置处的链表中存在一个一样的key，则替换其value，返回旧值
+     */
+    Entry tab[] = table;
+    int hash = hash(key);    //计算key的hash值
+    int index = (hash & 0x7FFFFFFF) % tab.length;     //确认该key的索引位置
+    //迭代，寻找该key，替换
+    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
+        if ((e.hash == hash) && e.key.equals(key)) {
+            V old = e.value;
+            e.value = value;
+            return old;
+        }
+    }
+
+    modCount++;
+    if (count >= threshold) {  //如果容器中的元素数量已经达到阀值，则进行扩容操作
+        rehash();
+        tab = table;
+        hash = hash(key);
+        index = (hash & 0x7FFFFFFF) % tab.length;
+    }
+
+    // 在索引位置处插入一个新的节点
+    Entry<K,V> e = tab[index];
+    tab[index] = new Entry<>(hash, key, value, e);
+    //容器中元素+1
+    count++;
+    return null;
+}
+````
+
+> put方法的整个处理流程是：计算key的hash值，根据hash值获得key在table数组中的索引位置，然后迭代该key处的Entry链表（我们暂且理解为链表），若该链表中存在一个这个的key对象，那么就直接替换其value值即可，否则在将改key-value节点插入该index索引位置处
+
+ 在HashTabled的put方法中有两个地方需要注意：
+
+````
+    //1、HashTable的扩容操作，在put方法中，如果需要向table[]中添加Entry元素，会首先进行容量校验，如果容量已经达到了阀值，HashTable就会进行扩容处理rehash()，如下:
+    protected void rehash() {
+            int oldCapacity = table.length;
+            //元素
+            Entry<K,V>[] oldMap = table;
+    
+            //新容量=旧容量 * 2 + 1
+            int newCapacity = (oldCapacity << 1) + 1;
+            if (newCapacity - MAX_ARRAY_SIZE > 0) {
+                if (oldCapacity == MAX_ARRAY_SIZE)
+                    return;
+                newCapacity = MAX_ARRAY_SIZE;
+            }
+    
+            //新建一个size = newCapacity 的HashTable
+            Entry<K,V>[] newMap = new Entry[];
+    
+            modCount++;
+            //重新计算阀值
+            threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
+            //重新计算hashSeed
+            boolean rehash = initHashSeedAsNeeded(newCapacity);
+    
+            table = newMap;
+            //将原来的元素拷贝到新的HashTable中
+            for (int i = oldCapacity ; i-- > 0 ;) {
+                for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
+                    Entry<K,V> e = old;
+                    old = old.next;
+    
+                    if (rehash) {
+                        e.hash = hash(e.key);
+                    }
+                    int index = (e.hash & 0x7FFFFFFF) % newCapacity;
+                    e.next = newMap[index];
+                    newMap[index] = e;
+                }
+            }
+        }
+````
+ 在这个rehash()方法中我们可以看到容量扩大两倍+1，同时需要将原来HashTable中的元素一一复制到新的HashTable中，这个过程是比较消耗时间的，同时还需要重新计算hashSeed的，毕竟容量已经变了。
+
+ 这里对阀值啰嗦一下：比如初始值11、加载因子默认0.75，那么这个时候阀值threshold=8，当容器中的元素达到8时，HashTable进行一次扩容操作，容量 = 8 * 2 + 1 =17，而阀值threshold=17*0.75 = 13，当容器元素再一次达到阀值时，HashTable还会进行扩容操作，依次类推。
+
+下面是计算key的hash值，这里hashSeed发挥了作用。
+````
+private int hash(Object k) {
+        return hashSeed ^ k.hashCode();
+    }
+````
+ 相对于put方法，get方法就会比较简单，处理过程就是计算key的hash值，判断在table数组中的索引位置，然后迭代链表，匹配直到找到相对应key的value,若没有找到返回null。
+````    
+public synchronized V get(Object key) {
+        Entry tab[] = table;
+        int hash = hash(key);
+        int index = (hash & 0x7FFFFFFF) % tab.length;
+        for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
+            if ((e.hash == hash) && e.key.equals(key)) {
+                return e.value;
+            }
+        }
+        return null;
+    }
+````
+## HashTable与HashMap的异同点
+
+  HashTable和HashMap存在很多的相同点，但是他们还是有几个比较重要的不同点。
+
+
+>
+> 第一：我们从他们的定义就可以看出他们的不同，HashTable基于Dictionary类，而HashMap是基于AbstractMap。Dictionary是什么？它是任何可将键映射到相应值的类的抽象父类，而AbstractMap是基于Map接口的骨干实现，它以最大限度地减少实现此接口所需的工作。
+>
+> 
+>
+> 第二：HashMap可以允许存在一个为null的key和任意个为null的value，但是HashTable中的key和value都不允许为null。如下：
+>
+> 
+>
+> 当HashMap遇到为null的key时，它会调用putForNullKey方法来进行处理。对于value没有进行任何处理，只要是对象都可以。
+
+    if (key == null)
+                 return putForNullKey(value);
+           而当HashTable遇到null时，他会直接抛出NullPointerException异常信息。
+
+    if (value == null) {
+        throw new NullPointerException();
+    }
+
+    第三：Hashtable的方法是同步的，而HashMap的方法不是。所以有人一般都建议如果是涉及到多线程同步时采用HashTable，没有涉及就采用HashMap，但是在Collections类中存在一个静态方法：synchronizedMap()，该方法创建了一个线程安全的Map对象，并把它作为一个封装的对象来返回，所以通过Collections类的synchronizedMap方法是可以我们你同步访问潜在的HashMap。这样君该如何选择呢？？？
+
+
+## 面试题：HashMap和HashTable的区别
+
+HashMap线程不安全，HashTable是线程安全的。HashMap内部实现没有任何线程同步相关的代码，所以相对而言性能要好一点。如果在多线程中使用HashMap需要自己管理线程同步。HashTable大部分对外接口都使用synchronized包裹，所以是线程安全的，但是性能会相对差一些。
+
+二者的基类不一样。HashMap派生于AbstractMap，HashTable派生于Dictionary。它们都实现Map, Cloneable, Serializable这些接口。AbstractMap中提供的基础方法更多，并且实现了多个通用的方法，而在Dictionary中只有少量的接口，并且都是abstract类型。
+
+key和value的取值范围不同。HashMap的key和value都可以为null，但是HashTablekey和value都不能为null。对于HashMap如果get返回null，并不能表明HashMap不存在这个key，如果需要判断HashMap中是否包含某个key，就需要使用containsKey这个方法来判断。
+
+算法不一样。HashMap的initialCapacity为16，而HashTable的initialCapacity为11。HashMap中初始容量必须是2的幂,如果初始化传入的initialCapacity不是2的幂，将会自动调整为大于出入的initialCapacity最小的2的幂。HashMap使用自己的计算hash的方法(会依赖key的hashCode方法)，HashTable则使用key的hashCode方法得到。
+
+## 参考文章
+http://cmsblogs.com/?p=176
+
+http://mini.eastday.com/mobile/180310183019559.html#
+
+https://blog.csdn.net/lihua5419/article/details/87691965
+
+https://www.cnblogs.com/aeolian/p/8468632.html
+
+
+
+
+
+​                     
diff --git "a/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232HashSet\357\274\214TreeSet\344\270\216LinkedHashSet.md" "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232HashSet\357\274\214TreeSet\344\270\216LinkedHashSet.md"
new file mode 100644
index 0000000..b6b8ed3
--- /dev/null
+++ "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232HashSet\357\274\214TreeSet\344\270\216LinkedHashSet.md"
@@ -0,0 +1,660 @@
+# 目录
+  * [HashSet](#hashset)
+    * [定义](#定义)
+    * [方法](#方法)
+  * [TreeSet](#treeset)
+    * [TreeSet定义](#treeset定义)
+    * [TreeSet主要方法](#treeset主要方法)
+  * [最后](#最后)
+  * [LinkedHashSet](#linkedhashset)
+    * [LinkedHashSet内部是如何工作的](#linkedhashset内部是如何工作的)
+    * [LinkedHashSet是如何维护插入顺序的](#linkedhashset是如何维护插入顺序的)
+  * [参考文章](#参考文章)
+
+
+本文参考 http://cmsblogs.com/?p=599
+
+《Java集合详解系列》是我在完成夯实Java基础篇的系列博客后准备开始整理的新系列文章。
+为了更好地诠释知识点，形成体系文章，本系列文章整理了很多优质的博客内容，如有侵权请联系我，一定删除。
+
+这些文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star、fork哈
+
+本系列文章将整理于我的个人博客：
+
+> www.how2playlife.com
+
+今天我们来探索一下HashSet，TreeSet与LinkedHashSet的基本原理与源码实现，由于这三个set都是基于之前文章的三个map进行实现的，所以推荐大家先看一下前面有关map的文章，结合使用味道更佳。
+
+## HashSet
+
+### 定义
+````
+public class HashSet<E>
+    extends AbstractSet<E>
+    implements Set<E>, Cloneable, java.io.Serializable
+````
+HashSet继承AbstractSet类，实现Set、Cloneable、Serializable接口。其中AbstractSet提供 Set 接口的骨干实现，从而最大限度地减少了实现此接口所需的工作。
+Set接口是一种不包括重复元素的Collection，它维持它自己的内部排序，所以随机访问没有任何意义。
+
+本文基于1.8jdk进行源码分析。
+
+ 基本属性
+
+基于HashMap实现，底层使用HashMap保存所有元素
+````
+private transient HashMap<E,Object> map;
+
+//定义一个Object对象作为HashMap的value
+private static final Object PRESENT = new Object();
+````
+构造函数
+
+````
+/**
+ * 默认构造函数
+ * 初始化一个空的HashMap，并使用默认初始容量为16和加载因子0.75。
+ */
+public HashSet() {
+    map = new HashMap<>();
+}
+
+/**
+ * 构造一个包含指定 collection 中的元素的新 set。
+ */
+public HashSet(Collection<? extends E> c) {
+    map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
+    addAll(c);
+}
+
+/**
+ * 构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子
+ */
+public HashSet(int initialCapacity, float loadFactor) {
+    map = new HashMap<>(initialCapacity, loadFactor);
+}
+
+/**
+ * 构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。
+ */
+public HashSet(int initialCapacity) {
+   map = new HashMap<>(initialCapacity);
+}
+
+/**
+ * 在API中我没有看到这个构造函数，今天看源码才发现（原来访问权限为包权限，不对外公开的）
+ * 以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。
+ * dummy 为标识 该构造函数主要作用是对LinkedHashSet起到一个支持作用
+ */
+HashSet(int initialCapacity, float loadFactor, boolean dummy) {
+   map = new LinkedHashMap<>(initialCapacity, loadFactor);
+}
+````
+从构造函数中可以看出HashSet所有的构造都是构造出一个新的HashMap，其中最后一个构造函数，为包访问权限是不对外公开，仅仅只在使用LinkedHashSet时才会发生作用。
+
+### 方法
+
+既然HashSet是基于HashMap，那么对于HashSet而言，其方法的实现过程是非常简单的。
+````
+public Iterator<E> iterator() {
+        return map.keySet().iterator();
+}
+````
+
+> iterator()方法返回对此 set 中元素进行迭代的迭代器。返回元素的顺序并不是特定的。
+>
+> 底层调用HashMap的keySet返回所有的key，这点反应了HashSet中的所有元素都是保存在HashMap的key中，value则是使用的PRESENT对象，该对象为static final。
+````
+    public int size() {
+             return map.size();
+         }
+        size()返回此 set 中的元素的数量（set 的容量）。底层调用HashMap的size方法，返回HashMap容器的大小。
+
+    public boolean isEmpty() {
+            return map.isEmpty();
+        }
+        isEmpty()，判断HashSet()集合是否为空，为空返回 true，否则返回false。
+    
+    public boolean contains(Object o) {
+            return map.containsKey(o);
+    }
+    
+    public boolean containsKey(Object key) {
+        return getNode(hash(key), key) != null;
+    }
+    
+    //最终调用该方法进行节点查找
+    final Node<K,V> getNode(int hash, Object key) {
+        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
+        //先检查桶的头结点是否存在
+        if ((tab = table) != null && (n = tab.length) > 0 &&
+            (first = tab[(n - 1) & hash]) != null) {
+            if (first.hash == hash && // always check first node
+                ((k = first.key) == key || (key != null && key.equals(k))))
+                return first;
+                //不是头结点，则遍历链表，如果是树节点则使用树节点的方法遍历，直到找到，或者为null
+            if ((e = first.next) != null) {
+                if (first instanceof TreeNode)
+                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
+                do {
+                    if (e.hash == hash &&
+                        ((k = e.key) == key || (key != null && key.equals(k))))
+                        return e;
+                } while ((e = e.next) != null);
+            }
+        }
+        return null;
+    }
+````
+
+contains()，判断某个元素是否存在于HashSet()中，存在返回true，否则返回false。更加确切的讲应该是要满足这种关系才能返回true：(o==null ? e==null : o.equals(e))。底层调用containsKey判断HashMap的key值是否为空。
+
+````
+public boolean add(E e) {
+        return map.put(e, PRESENT)==null;
+}
+
+public V put(K key, V value) {
+    return putVal(hash(key), key, value, false, true);
+}
+
+map的put方法：
+final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
+               boolean evict) {
+    Node<K,V>[] tab; Node<K,V> p; int n, i;
+    
+    //确认初始化
+    if ((tab = table) == null || (n = tab.length) == 0)
+        n = (tab = resize()).length;
+        
+    //如果桶为空，直接插入新元素，也就是entry
+    if ((p = tab[i = (n - 1) & hash]) == null)
+        tab[i] = newNode(hash, key, value, null);
+    else {
+        Node<K,V> e; K k;
+        //如果冲突，分为三种情况
+        //key相等时让旧entry等于新entry即可
+        if (p.hash == hash &&
+            ((k = p.key) == key || (key != null && key.equals(k))))
+            e = p;
+        //红黑树情况
+        else if (p instanceof TreeNode)
+            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
+        else {
+            //如果key不相等，则连成链表
+            for (int binCount = 0; ; ++binCount) {
+                if ((e = p.next) == null) {
+                    p.next = newNode(hash, key, value, null);
+                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
+                        treeifyBin(tab, hash);
+                    break;
+                }
+                if (e.hash == hash &&
+                    ((k = e.key) == key || (key != null && key.equals(k))))
+                    break;
+                p = e;
+            }
+        }
+        if (e != null) { // existing mapping for key
+            V oldValue = e.value;
+            if (!onlyIfAbsent || oldValue == null)
+                e.value = value;
+            afterNodeAccess(e);
+            return oldValue;
+        }
+    }
+    ++modCount;
+    if (++size > threshold)
+        resize();
+    afterNodeInsertion(evict);
+    return null;
+}
+````
+
+> 这里注意一点，hashset只是不允许重复的元素加入，而不是不允许元素连成链表，因为只要key的equals方法判断为true时它们是相等的，此时会发生value的替换，因为所有entry的value一样，所以和没有插入时一样的。
+>
+> 而当两个hashcode相同但key不相等的entry插入时，仍然会连成一个链表，长度超过8时依然会和hashmap一样扩展成红黑树，看完源码之后笔者才明白自己之前理解错了。所以看源码还是蛮有好处的。hashset基本上就是使用hashmap的方法再次实现了一遍而已，只不过value全都是同一个object，让你以为相同元素没有插入，事实上只是value替换成和原来相同的值而已。
+
+当add方法发生冲突时，如果key相同，则替换value，如果key不同，则连成链表。       
+
+add()如果此 set 中尚未包含指定元素，则添加指定元素。如果此Set没有包含满足(e==null ? e2==null : e.equals(e2)) 的e2时，则将e2添加到Set中，否则不添加且返回false。
+
+由于底层使用HashMap的put方法将key = e，value=PRESENT构建成key-value键值对，当此e存在于HashMap的key中，则value将会覆盖原有value，但是key保持不变，所以如果将一个已经存在的e元素添加中HashSet中，新添加的元素是不会保存到HashMap中，所以这就满足了HashSet中元素不会重复的特性。
+````
+public boolean remove(Object o) {
+    return map.remove(o)==PRESENT;
+}
+````
+remove如果指定元素存在于此 set 中，则将其移除。底层使用HashMap的remove方法删除指定的Entry。
+````
+public void clear() {
+    map.clear();
+}
+````
+clear从此 set 中移除所有元素。底层调用HashMap的clear方法清除所有的Entry。
+````
+public Object clone() {
+    try {
+        HashSet<E> newSet = (HashSet<E>) super.clone();
+        newSet.map = (HashMap<E, Object>) map.clone();
+        return newSet;
+    } catch (CloneNotSupportedException e) {
+        throw new InternalError();
+    }
+}
+````
+clone返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。
+
+后记：
+
+> 由于HashSet底层使用了HashMap实现，使其的实现过程变得非常简单，如果你对HashMap比较了解，那么HashSet简直是小菜一碟。有两个方法对HashMap和HashSet而言是非常重要的，下篇将详细讲解hashcode和equals。
+
+
+## TreeSet
+
+与HashSet是基于HashMap实现一样，TreeSet同样是基于TreeMap实现的。在《Java提高篇（二七）-----TreeMap》中LZ详细讲解了TreeMap实现机制，如果客官详情看了这篇博文或者多TreeMap有比较详细的了解，那么TreeSet的实现对您是喝口水那么简单。
+
+### TreeSet定义
+
+我们知道TreeMap是一个有序的二叉树，那么同理TreeSet同样也是一个有序的，它的作用是提供有序的Set集合。通过源码我们知道TreeSet基础AbstractSet，实现NavigableSet、Cloneable、Serializable接口。
+
+其中AbstractSet提供 Set 接口的骨干实现，从而最大限度地减少了实现此接口所需的工作。
+
+NavigableSet是扩展的 SortedSet，具有了为给定搜索目标报告最接近匹配项的导航方法，这就意味着它支持一系列的导航方法。比如查找与指定目标最匹配项。Cloneable支持克隆，Serializable支持序列化。
+````
+public class TreeSet<E> extends AbstractSet<E>
+    implements NavigableSet<E>, Cloneable, java.io.Serializable
+````
+同时在TreeSet中定义了如下几个变量。
+````
+private transient NavigableMap<E,Object> m;
+    
+//PRESENT会被当做Map的value与key构建成键值对
+ private static final Object PRESENT = new Object();
+````
+其构造方法：
+
+````
+//默认构造方法，根据其元素的自然顺序进行排序
+
+public TreeSet() {
+    this(new TreeMap<E,Object>());
+}
+
+//构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
+public TreeSet(Comparator<? super E> comparator) {
+        this(new TreeMap<>(comparator));
+}
+
+//构造一个新的空 TreeSet，它根据指定比较器进行排序。
+public TreeSet(Collection<? extends E> c) {
+    this();
+    addAll(c);
+}
+
+//构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。
+public TreeSet(SortedSet<E> s) {
+    this(s.comparator());
+    addAll(s);
+}
+
+TreeSet(NavigableMap<E,Object> m) {
+    this.m = m;
+}
+````
+### TreeSet主要方法
+
+1、add：将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。
+````    
+public boolean add(E e) {
+        return m.put(e, PRESENT)==null;
+    }
+ 
+public V put(K key, V value) {
+    Entry<K,V> t = root;
+    if (t == null) {
+    //空树时，判断节点是否为空
+        compare(key, key); // type (and possibly null) check
+
+        root = new Entry<>(key, value, null);
+        size = 1;
+        modCount++;
+        return null;
+    }
+    int cmp;
+    Entry<K,V> parent;
+    // split comparator and comparable paths
+    Comparator<? super K> cpr = comparator;
+    //非空树，根据传入比较器进行节点的插入位置查找
+    if (cpr != null) {
+        do {
+            parent = t;
+            //节点比根节点小，则找左子树，否则找右子树
+            cmp = cpr.compare(key, t.key);
+            if (cmp < 0)
+                t = t.left;
+            else if (cmp > 0)
+                t = t.right;
+                //如果key的比较返回值相等，直接更新值（一般compareto相等时equals方法也相等）
+            else
+                return t.setValue(value);
+        } while (t != null);
+    }
+    else {
+    //如果没有传入比较器，则按照自然排序
+        if (key == null)
+            throw new NullPointerException();
+        @SuppressWarnings("unchecked")
+            Comparable<? super K> k = (Comparable<? super K>) key;
+        do {
+            parent = t;
+            cmp = k.compareTo(t.key);
+            if (cmp < 0)
+                t = t.left;
+            else if (cmp > 0)
+                t = t.right;
+            else
+                return t.setValue(value);
+        } while (t != null);
+    }
+    //查找的节点为空，直接插入，默认为红节点
+    Entry<K,V> e = new Entry<>(key, value, parent);
+    if (cmp < 0)
+        parent.left = e;
+    else
+        parent.right = e;
+        //插入后进行红黑树调整
+    fixAfterInsertion(e);
+    size++;
+    modCount++;
+    return null;
+}    
+````
+2、get：获取元素
+````
+public V get(Object key) {
+    Entry<K,V> p = getEntry(key);
+    return (p==null ? null : p.value);
+}
+````
+该方法与put的流程类似，只不过是把插入换成了查找
+    
+3、ceiling：返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
+````
+public E ceiling(E e) {
+    return m.ceilingKey(e);
+}
+````
+4、clear：移除此 set 中的所有元素。
+````
+public void clear() {
+    m.clear();
+}
+````
+5、clone：返回 TreeSet 实例的浅表副本。属于浅拷贝。
+````
+public Object clone() {
+    TreeSet<E> clone = null;
+    try {
+        clone = (TreeSet<E>) super.clone();
+    } catch (CloneNotSupportedException e) {
+        throw new InternalError();
+    }
+
+    clone.m = new TreeMap<>(m);
+    return clone;
+}
+````
+6、comparator：返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。
+````
+public Comparator<? super E> comparator() {
+        return m.comparator();
+    }
+````
+7、contains：如果此 set 包含指定的元素，则返回 true。
+````
+public boolean contains(Object o) {
+        return m.containsKey(o);
+    }
+````
+8、descendingIterator：返回在此 set 元素上按降序进行迭代的迭代器。
+````
+public Iterator<E> descendingIterator() {
+    return m.descendingKeySet().iterator();
+}
+````
+9、descendingSet：返回此 set 中所包含元素的逆序视图。
+````
+public NavigableSet<E> descendingSet() {
+    return new TreeSet<>(m.descendingMap());
+}
+````
+10、first：返回此 set 中当前第一个（最低）元素。
+````
+public E first() {
+    return m.firstKey();
+}
+````
+11、floor：返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
+````    
+public E floor(E e) {
+    return m.floorKey(e);
+}
+````
+12、headSet：返回此 set 的部分视图，其元素严格小于 toElement。
+````
+public SortedSet<E> headSet(E toElement) {
+    return headSet(toElement, false);
+}
+````
+13、higher：返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
+````
+public E higher(E e) {
+    return m.higherKey(e);
+}
+````
+14、isEmpty：如果此 set 不包含任何元素，则返回 true。
+````
+public boolean isEmpty() {
+    return m.isEmpty();
+}
+````
+15、iterator：返回在此 set 中的元素上按升序进行迭代的迭代器。
+````
+public Iterator<E> iterator() {
+    return m.navigableKeySet().iterator();
+}
+````
+16、last：返回此 set 中当前最后一个（最高）元素。
+````
+public E last() {
+    return m.lastKey();
+}
+````
+17、lower：返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
+````    
+public E lower(E e) {
+    return m.lowerKey(e);
+}
+````
+18、pollFirst：获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
+````
+public E pollFirst() {
+    Map.Entry<E,?> e = m.pollFirstEntry();
+    return (e == null) ? null : e.getKey();
+}
+````
+19、pollLast：获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
+````
+public E pollLast() {
+    Map.Entry<E,?> e = m.pollLastEntry();
+    return (e == null) ? null : e.getKey();
+}
+````
+20、remove：将指定的元素从 set 中移除（如果该元素存在于此 set 中）。
+````
+public boolean remove(Object o) {
+    return m.remove(o)==PRESENT;
+}
+````
+该方法与put类似，只不过把插入换成了删除，并且要进行删除后调整
+
+21、size：返回 set 中的元素数（set 的容量）。
+````
+public int size() {
+    return m.size();
+}
+````
+22、subSet：返回此 set 的部分视图
+````
+/**
+ * 返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。
+ */
+ public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
+     E toElement,   boolean toInclusive) {
+     return new TreeSet<>(m.subMap(fromElement, fromInclusive,
+          toElement,   toInclusive));
+ }
+ 
+ /**
+  * 返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。
+  */
+ public SortedSet<E> subSet(E fromElement, E toElement) {
+     return subSet(fromElement, true, toElement, false);
+ }
+````
+23、tailSet：返回此 set 的部分视图
+````
+/**
+ * 返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。
+ */
+public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
+    return new TreeSet<>(m.tailMap(fromElement, inclusive));
+}
+
+/**
+ * 返回此 set 的部分视图，其元素大于等于 fromElement。
+ */
+public SortedSet<E> tailSet(E fromElement) {
+    return tailSet(fromElement, true);
+}
+````
+
+## 最后
+
+由于TreeSet是基于TreeMap实现的，所以如果我们对treeMap有了一定的了解，对TreeSet那是小菜一碟，我们从TreeSet中的源码可以看出，其实现过程非常简单，几乎所有的方法实现全部都是基于TreeMap的。
+
+## LinkedHashSet
+
+### LinkedHashSet内部是如何工作的
+
+LinkedHashSet是HashSet的一个“扩展版本”，HashSet并不管什么顺序，不同的是LinkedHashSet会维护“插入顺序”。HashSet内部使用HashMap对象来存储它的元素，而LinkedHashSet内部使用LinkedHashMap对象来存储和处理它的元素。这篇文章，我们将会看到LinkedHashSet内部是如何运作的及如何维护插入顺序的。
+
+我们首先着眼LinkedHashSet的构造函数。在LinkedHashSet类中一共有4个构造函数。这些构造函数都只是简单地调用父类构造函数（如HashSet类的构造函数）。
+下面看看LinkedHashSet的构造函数是如何定义的。
+````
+//Constructor - 1
+ 
+public LinkedHashSet(int initialCapacity, float loadFactor)
+{
+      super(initialCapacity, loadFactor, true);              //Calling super class constructor
+}
+ 
+//Constructor - 2
+ 
+public LinkedHashSet(int initialCapacity)
+{
+        super(initialCapacity, .75f, true);             //Calling super class constructor
+}
+ 
+//Constructor - 3
+ 
+public LinkedHashSet()
+{
+        super(16, .75f, true);                //Calling super class constructor
+}
+ 
+//Constructor - 4
+ 
+public LinkedHashSet(Collection<? extends E> c)
+{
+        super(Math.max(2*c.size(), 11), .75f, true);          //Calling super class constructor
+        addAll(c);
+}
+````    
+在上面的代码片段中，你可能注意到4个构造函数调用的是同一个父类的构造函数。这个构造函数（父类的，译者注）是一个包内私有构造函数（见下面的代码，HashSet的构造函数没有使用public公开，译者注），它只能被LinkedHashSet使用。
+
+这个构造函数需要初始容量，负载因子和一个boolean类型的哑值（没有什么用处的参数，作为标记，译者注）等参数。这个哑参数只是用来区别这个构造函数与HashSet的其他拥有初始容量和负载因子参数的构造函数，下面是这个构造函数的定义，
+````
+HashSet(int initialCapacity, float loadFactor, boolean dummy)
+{
+    map = new LinkedHashMap<>(initialCapacity, loadFactor);
+}
+````
+显然，这个构造函数内部初始化了一个LinkedHashMap对象，这个对象恰好被LinkedHashSet用来存储它的元素。
+
+LinkedHashSet并没有自己的方法，所有的方法都继承自它的父类HashSet，因此，对LinkedHashSet的所有操作方式就好像对HashSet操作一样。
+
+唯一的不同是内部使用不同的对象去存储元素。在HashSet中，插入的元素是被当做HashMap的键来保存的，而在LinkedHashSet中被看作是LinkedHashMap的键。
+
+这些键对应的值都是常量PRESENT（PRESENT是HashSet的静态成员变量，译者注）。
+
+### LinkedHashSet是如何维护插入顺序的
+> LinkedHashSet使用LinkedHashMap对象来存储它的元素，插入到LinkedHashSet中的元素实际上是被当作LinkedHashMap的键保存起来的。
+>
+> LinkedHashMap的每一个键值对都是通过内部的静态类Entry<K, V>实例化的。这个 Entry<K, V>类继承了HashMap.Entry类。
+>
+> 这个静态类增加了两个成员变量，before和after来维护LinkedHasMap元素的插入顺序。这两个成员变量分别指向前一个和后一个元素，这让LinkedHashMap也有类似双向链表的表现。
+````
+private static class Entry<K,V> extends HashMap.Entry<K,V>
+{
+    // These fields comprise the doubly linked list used for iteration.
+    Entry<K,V> before, after;
+
+    Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
+        super(hash, key, value, next);
+    }
+}
+````
+从上面代码看到的LinkedHashMap内部类的前面两个成员变量——before和after负责维护LinkedHashSet的插入顺序。LinkedHashMap定义的成员变量header保存的是
+这个双向链表的头节点。header的定义就像下面这样，
+
+接下来看一个例子就知道LinkedHashSet内部是如何工作的了。
+````
+public class LinkedHashSetExample
+{
+    public static void main(String[] args)
+    {
+        //Creating LinkedHashSet
+ 
+        LinkedHashSet<String> set = new LinkedHashSet<String>();
+ 
+        //Adding elements to LinkedHashSet
+ 
+        set.add("BLUE");
+ 
+        set.add("RED");
+ 
+        set.add("GREEN");    
+ 
+        set.add("BLACK");
+    }
+}
+````
+
+如果你知道LinkedHashMap内部是如何工作的，就非常容易明白LinkedHashSet内部是如何工作的。看一遍LinkedHashSet和LinkedHashMap的源码，
+你就能够准确地理解在Java中LinkedHashSet内部是如何工作的。
+
+
+## 参考文章
+http://cmsblogs.com/?p=599
+
+https://www.cnblogs.com/one-apple-pie/p/11036309.html
+
+https://blog.csdn.net/learningcoding/article/details/79983248
+
+
diff --git "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2433\357\274\232Iterator\357\274\214fail-fast\346\234\272\345\210\266\344\270\216\346\257\224\350\276\203\345\231\250.md" "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232Iterator\357\274\214fail-fast\346\234\272\345\210\266\344\270\216\346\257\224\350\276\203\345\231\250.md"
similarity index 74%
rename from "docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2433\357\274\232Iterator\357\274\214fail-fast\346\234\272\345\210\266\344\270\216\346\257\224\350\276\203\345\231\250.md"
rename to "docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232Iterator\357\274\214fail-fast\346\234\272\345\210\266\344\270\216\346\257\224\350\276\203\345\231\250.md"
index 2f9dbf3..95169c6 100644
--- "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2433\357\274\232Iterator\357\274\214fail-fast\346\234\272\345\210\266\344\270\216\346\257\224\350\276\203\345\231\250.md"
+++ "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232Iterator\357\274\214fail-fast\346\234\272\345\210\266\344\270\216\346\257\224\350\276\203\345\231\250.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [Iterator](#iterator)
     * [java.util.Iterator](#javautiliterator)
     * [各个集合的Iterator的实现](#各个集合的iterator的实现)
@@ -7,15 +6,13 @@
       * [fail-fast示例](#fail-fast示例)
       * [fail-fast产生原因](#fail-fast产生原因)
       * [fail-fast解决办法](#fail-fast解决办法)
-* [Comparable 和 Comparator](#comparable-和-comparator)
-  * [Comparable](#comparable)
-    * [Comparator](#comparator)
-    * [Java8中使用lambda实现比较器](#java8中使用lambda实现比较器)
-  * [总结](#总结)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+  * [Comparable 和 Comparator](#comparable-和-comparator)
+    * [Comparable](#comparable)
+      * [Comparator](#comparator)
+      * [Java8中使用lambda实现比较器](#java8中使用lambda实现比较器)
+    * [总结](#总结)
+    * [参考文章](#参考文章)
+
 
 本文参考 cmsblogs.com/p=1185
 
@@ -35,37 +32,36 @@
 
 今天我们来探索一下LIterator，fail-fast机制与比较器的源码。
 
-
 ## Iterator
 
-
 迭代对于我们搞Java的来说绝对不陌生。我们常常使用JDK提供的迭代接口进行Java集合的迭代。
-
-    Iterator iterator = list.iterator();
-            while(iterator.hasNext()){
-                String string = iterator.next();
-                do something
-            }
+````
+Iterator iterator = list.iterator();
+while(iterator.hasNext()){
+    String string = iterator.next();
+    do something
+}
+````
 迭代其实我们可以简单地理解为遍历，是一个标准化遍历各类容器里面的所有对象的方法类，它是一个很典型的设计模式。Iterator模式是用于遍历集合类的标准访问方法。
 
 它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。 在没有迭代器时我们都是这么进行处理的。如下：
 
 对于数组我们是使用下标来进行处理的
-
-    int[] arrays = new int[10];
-       for(int i = 0 ; i  arrays.length ; i++){
-           int a = arrays[i];
-           do something
-       }
-
+````
+int[] arrays = new int[10];
+   for(int i = 0 ; i  arrays.length ; i++){
+       int a = arrays[i];
+       do something
+   }
+````
 对于ArrayList是这么处理的
-
-    ListString list = new ArrayListString();
-       for(int i = 0 ; i  list.size() ;  i++){
-          String string = list.get(i);
-          do something
-       }
-
+````
+ListString list = new ArrayListString();
+for(int i = 0 ; i  list.size() ;  i++){
+  String string = list.get(i);
+  do something
+}
+````
 对于这两种方式，我们总是都事先知道集合的内部结构，访问代码和集合本身是紧密耦合的，无法将访问逻辑从集合类和客户端代码中分离出来。同时每一种集合对应一种遍历方法，客户端代码无法复用。
 
 在实际应用中如何需要将上面将两个集合进行整合是相当麻烦的。所以为了解决以上问题，Iterator模式腾空出世，它总是用同一种逻辑来遍历集合。
@@ -83,12 +79,13 @@
     2、方法名称得到了改进。
 
 其接口定义如下：
-
-    public interface Iterator {
-    　　boolean hasNext();
-    　　Object next();
-    　　void remove();
-    }
+````
+public interface Iterator {
+　　boolean hasNext();
+　　Object next();
+　　void remove();
+}
+````
 其中：
 
     Object next()：返回迭代器刚越过的元素的引用，返回值是Object，需要强制转换成自己需要的类型
@@ -98,12 +95,12 @@
     void remove()：删除迭代器刚越过的元素
 
 对于我们而言，我们只一般只需使用next()、hasNext()两个方法即可完成迭代。如下：
-
-    for(Iterator it = c.iterator(); it.hasNext(); ) {
-    　　Object o = it.next();
-    　　 do something
-    }
-
+````
+for(Iterator it = c.iterator(); it.hasNext(); ) {
+　　Object o = it.next();
+　　 do something
+}
+````
 ==前面阐述了Iterator有一个很大的优点,就是我们不必知道集合的内部结果,集合的内部结构、状态由Iterator来维持，通过统一的方法hasNext()、next()来判断、获取下一个元素，至于具体的内部实现我们就不用关心了。==
 
 但是作为一个合格的程序员我们非常有必要来弄清楚Iterator的实现。下面就ArrayList的源码进行分析分析。
@@ -115,44 +112,44 @@
 ArrayList的Iterator实现
 
 在ArrayList内部首先是定义一个内部类Itr，该内部类实现Iterator接口，如下：
-
-    private class Itr implements IteratorE {
-        do something
-    }
-    而ArrayList的iterator()方法实现：
-    
-    public IteratorE iterator() {
-            return new Itr();
-        }
-
+````
+private class Itr implements IteratorE {
+    do something
+}
+而ArrayList的iterator()方法实现：
+
+public IteratorE iterator() {
+        return new Itr();
+}
+````
 所以通过使用ArrayList.iterator()方法返回的是Itr()内部类，所以现在我们需要关心的就是Itr()内部类的实现：
 
 在Itr内部定义了三个int型的变量：cursor、lastRet、expectedModCount。其中cursor表示下一个元素的索引位置，lastRet表示上一个元素的索引位置
 
-            int cursor;             
-            int lastRet = -1;     
-            int expectedModCount = modCount;
+    int cursor;             
+    int lastRet = -1;     
+    int expectedModCount = modCount;
 
 从cursor、lastRet定义可以看出，lastRet一直比cursor少一所以hasNext()实现方法异常简单，只需要判断cursor和lastRet是否相等即可。
-
-    public boolean hasNext() {
-        return cursor != size;
-    }
-
+````
+public boolean hasNext() {
+    return cursor != size;
+}
+````
 对于next()实现其实也是比较简单的，只要返回cursor索引位置处的元素即可，然后修改cursor、lastRet即可。
-
-    public E next() {
-        checkForComodification();
-        int i = cursor;    记录索引位置
-        if (i = size)    如果获取元素大于集合元素个数，则抛出异常
-            throw new NoSuchElementException();
-        Object[] elementData = ArrayList.this.elementData;
-        if (i = elementData.length)
-            throw new ConcurrentModificationException();
-        cursor = i + 1;      cursor + 1
-        return (E) elementData[lastRet = i];  lastRet + 1 且返回cursor处元素
-    }
-
+````
+public E next() {
+    checkForComodification();
+    int i = cursor;    记录索引位置
+    if (i = size)    如果获取元素大于集合元素个数，则抛出异常
+        throw new NoSuchElementException();
+    Object[] elementData = ArrayList.this.elementData;
+    if (i = elementData.length)
+        throw new ConcurrentModificationException();
+    cursor = i + 1;      cursor + 1
+    return (E) elementData[lastRet = i];  lastRet + 1 且返回cursor处元素
+}
+````
  checkForComodification()主要用来判断集合的修改次数是否合法，即用来判断遍历过程中集合是否被修改过。
 
  。modCount用于记录ArrayList集合的修改次数，初始化为0，，每当集合被修改一次（结构上面的修改，内部update不算），如add、remove等方法，modCount + 1，所以如果modCount不变，则表示集合内容没有被修改。
@@ -160,28 +157,29 @@ ArrayList的Iterator实现
  该机制主要是用于实现ArrayList集合的快速失败机制，在Java的集合中，较大一部分集合是存在快速失败机制的，这里就不多说，后面会讲到。
 
  所以要保证在遍历过程中不出错误，我们就应该保证在遍历过程中不会对集合产生结构上的修改（当然remove方法除外），出现了异常错误，我们就应该认真检查程序是否出错而不是catch后不做处理。
-
-    final void checkForComodification() {
-                if (modCount != expectedModCount)
-                    throw new ConcurrentModificationException();
-            }
-    对于remove()方法的是实现，它是调用ArrayList本身的remove()方法删除lastRet位置元素，然后修改modCount即可。
-    
-    public void remove() {
-        if (lastRet  0)
-            throw new IllegalStateException();
-        checkForComodification();
-    
-        try {
-            ArrayList.this.remove(lastRet);
-            cursor = lastRet;
-            lastRet = -1;
-            expectedModCount = modCount;
-        } catch (IndexOutOfBoundsException ex) {
-            throw new ConcurrentModificationException();
+````
+final void checkForComodification() {
+            if (modCount != expectedModCount)
+                throw new ConcurrentModificationException();
         }
+        
+//对于remove()方法的是实现，它是调用ArrayList本身的remove()方法删除lastRet位置元素，然后修改modCount即可。
+
+public void remove() {
+    if (lastRet  0)
+        throw new IllegalStateException();
+    checkForComodification();
+
+    try {
+        ArrayList.this.remove(lastRet);
+        cursor = lastRet;
+        lastRet = -1;
+        expectedModCount = modCount;
+    } catch (IndexOutOfBoundsException ex) {
+        throw new ConcurrentModificationException();
     }
-
+}
+````
 这里就对ArrayList的Iterator实现讲解到这里，对于Hashset、TreeSet等集合的Iterator实现，各位如果感兴趣可以继续研究，个人认为在研究这些集合的源码之前，有必要对该集合的数据结构有清晰的认识，这样会达到事半功倍的效果！！！！
 
 ### fail-fast机制
@@ -205,41 +203,28 @@ HashMap中：
  记住是有可能，而不是一定。例如：假设存在两个线程（线程1、线程2），线程1通过Iterator在遍历集合A中的元素，在某个时候线程2修改了集合A的结构（是结构上面的修改，而不是简单的修改集合元素的内容），那么这个时候程序就会抛出 ConcurrentModificationException异常，从而产生fail-fast机制。
 
 #### fail-fast示例
-
-    public class FailFastTest {
-        private static ListInteger list = new ArrayList();
-
-
-​        
-          @desc线程one迭代list
-          @Projecttest
-          @fileFailFastTest.java
-          @Authrochenssy
-          @data2014年7月26日
-         
-        private static class threadOne extends Thread{
-            public void run() {
-                IteratorInteger iterator = list.iterator();
-                while(iterator.hasNext()){
-                    int i = iterator.next();
-                    System.out.println(ThreadOne 遍历 + i);
-                    try {
-                        Thread.sleep(10);
-                    } catch (InterruptedException e) {
-                        e.printStackTrace();
-                    }
+````
+public class FailFastTest {
+    private static ListInteger list = new ArrayList();    
+ 
+    private static class threadOne extends Thread{
+        public void run() {
+            IteratorInteger iterator = list.iterator();
+            while(iterator.hasNext()){
+                int i = iterator.next();
+                System.out.println(ThreadOne 遍历 + i);
+                try {
+                    Thread.sleep(10);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
                 }
             }
         }
+    }    
+````        
+desc当i == 3时，修改list
 
-
-​        
-          @desc当i == 3时，修改list
-          @Projecttest
-          @fileFailFastTest.java
-          @Authrochenssy
-          @data2014年7月26日
-         
+````
         private static class threadTwo extends Thread{
             public void run(){
                 int i = 0 ; 
@@ -261,6 +246,7 @@ HashMap中：
             new threadTwo().start();
         }
     }
+````    
 运行结果：
 
     ThreadOne 遍历0
@@ -281,91 +267,91 @@ HashMap中：
 
  要了解fail-fast机制，我们首先要对ConcurrentModificationException 异常有所了解。当方法检测到对象的并发修改，但不允许这种修改时就抛出该异常。同时需要注意的是，该异常不会始终指出对象已经由不同线程并发修改，如果单线程违反了规则，同样也有可能会抛出改异常。
 
-
 诚然，迭代器的快速失败行为无法得到保证，它不能保证一定会出现该错误，但是快速失败操作会尽最大努力抛出ConcurrentModificationException异常，所以因此，为提高此类操作的正确性而编写一个依赖于此异常的程序是错误的做法，正确做法是：ConcurrentModificationException 应该仅用于检测 bug。下面我将以ArrayList为例进一步分析fail-fast产生的原因。
 
  从前面我们知道fail-fast是在操作迭代器时产生的。现在我们来看看ArrayList中迭代器的源代码：
+````
+private class Itr implements IteratorE {
+    int cursor;
+    int lastRet = -1;
+    int expectedModCount = ArrayList.this.modCount;
 
-    private class Itr implements IteratorE {
-            int cursor;
-            int lastRet = -1;
-            int expectedModCount = ArrayList.this.modCount;
-    
-            public boolean hasNext() {
-                return (this.cursor != ArrayList.this.size);
-            }
-    
-            public E next() {
-                checkForComodification();
-                 省略此处代码 
-            }
-    
-            public void remove() {
-                if (this.lastRet  0)
-                    throw new IllegalStateException();
-                checkForComodification();
-                 省略此处代码 
-            }
-    
-            final void checkForComodification() {
-                if (ArrayList.this.modCount == this.expectedModCount)
-                    return;
-                throw new ConcurrentModificationException();
-            }
-        }
+    public boolean hasNext() {
+        return (this.cursor != ArrayList.this.size);
+    }
+
+    public E next() {
+        checkForComodification();
+         省略此处代码 
+    }
+
+    public void remove() {
+        if (this.lastRet  0)
+            throw new IllegalStateException();
+        checkForComodification();
+         省略此处代码 
+    }
 
+    final void checkForComodification() {
+        if (ArrayList.this.modCount == this.expectedModCount)
+            return;
+        throw new ConcurrentModificationException();
+    }
+}
+````
 从上面的源代码我们可以看出，迭代器在调用next()、remove()方法时都是调用checkForComodification()方法，该方法主要就是检测modCount == expectedModCount  若不等则抛出ConcurrentModificationException 异常，从而产生fail-fast机制。所以要弄清楚为什么会产生fail-fast机制我们就必须要用弄明白为什么modCount != expectedModCount ，他们的值在什么时候发生改变的。
 
 expectedModCount 是在Itr中定义的：int expectedModCount = ArrayList.this.modCount;所以他的值是不可能会修改的，所以会变的就是modCount。modCount是在 AbstractList 中定义的，为全局变量：
 
 protected transient int modCount = 0;
 那么他什么时候因为什么原因而发生改变呢？请看ArrayList的源码：
+````
+public boolean add(E paramE) {
+    ensureCapacityInternal(this.size + 1);
+     省略此处代码 
+}
+
+private void ensureCapacityInternal(int paramInt) {
+    if (this.elementData == EMPTY_ELEMENTDATA)
+        paramInt = Math.max(10, paramInt);
+    ensureExplicitCapacity(paramInt);
+}
+
+private void ensureExplicitCapacity(int paramInt) {
+    this.modCount += 1;    修改modCount
+     省略此处代码 
+}
+
+public boolean remove(Object paramObject) {
+    int i;
+    if (paramObject == null)
+        for (i = 0; i  this.size; ++i) {
+            if (this.elementData[i] != null)
+                continue;
+            fastRemove(i);
+            return true;
+        }
+    else
+        for (i = 0; i  this.size; ++i) {
+            if (!(paramObject.equals(this.elementData[i])))
+                continue;
+            fastRemove(i);
+            return true;
+        }
+    return false;
+}
 
-    public boolean add(E paramE) {
-        ensureCapacityInternal(this.size + 1);
-         省略此处代码 
-    }
-    
-    private void ensureCapacityInternal(int paramInt) {
-        if (this.elementData == EMPTY_ELEMENTDATA)
-            paramInt = Math.max(10, paramInt);
-        ensureExplicitCapacity(paramInt);
-    }
-    
-    private void ensureExplicitCapacity(int paramInt) {
-        this.modCount += 1;    修改modCount
-         省略此处代码 
-    }
-
-   public boolean remove(Object paramObject) {
-        int i;
-        if (paramObject == null)
-            for (i = 0; i  this.size; ++i) {
-                if (this.elementData[i] != null)
-                    continue;
-                fastRemove(i);
-                return true;
-            }
-        else
-            for (i = 0; i  this.size; ++i) {
-                if (!(paramObject.equals(this.elementData[i])))
-                    continue;
-                fastRemove(i);
-                return true;
-            }
-        return false;
-    }
+private void fastRemove(int paramInt) {
+    this.modCount += 1;   修改modCount
+     省略此处代码 
+}
 
-    private void fastRemove(int paramInt) {
-        this.modCount += 1;   修改modCount
-         省略此处代码 
-    }
-    
-    public void clear() {
-        this.modCount += 1;    修改modCount
-         省略此处代码 
-    }
- 从上面的源代码我们可以看出，ArrayList中无论add、remove、clear方法只要是涉及了改变ArrayList元素的个数的方法都会导致modCount的改变。
+public void clear() {
+    this.modCount += 1;    修改modCount
+     省略此处代码 
+}
+````
+从上面的源代码我们可以看出，ArrayList中无论add、remove、clear方法只要是涉及了改变ArrayList元素的个数的方法都会导致modCount的改变。
 
 所以我们这里可以初步判断由于expectedModCount 得值与modCount的改变不同步，导致两者之间不等从而产生fail-fast机制。知道产生fail-fast产生的根本原因了，我们可以有如下场景：
 
@@ -393,41 +379,37 @@ CopyOnWriteArrayList为何物？ArrayList 的一个线程安全的变体，其
 第一、CopyOnWriterArrayList的无论是从数据结构、定义都和ArrayList一样。它和ArrayList一样，同样是实现List接口，底层使用数组实现。在方法上也包含add、remove、clear、iterator等方法。
 
 第二、CopyOnWriterArrayList根本就不会产生ConcurrentModificationException异常，也就是它使用迭代器完全不会产生fail-fast机制。请看：
-
-    private static class COWIteratorE implements ListIteratorE {
-             省略此处代码 
-            public E next() {
-                if (!(hasNext()))
-                    throw new NoSuchElementException();
-                return this.snapshot[(this.cursor++)];
-            }
-    
-             省略此处代码 
-        }
+````
+private static class COWIteratorE implements ListIteratorE {
+    public E next() {
+        if (!(hasNext()))
+            throw new NoSuchElementException();
+        return this.snapshot[(this.cursor++)];
+    }
+}
+````
 CopyOnWriterArrayList的方法根本就没有像ArrayList中使用checkForComodification方法来判断expectedModCount 与 modCount 是否相等。它为什么会这么做，凭什么可以这么做呢？我们以add方法为例：
-
-    public boolean add(E paramE) {
-            ReentrantLock localReentrantLock = this.lock;
-            localReentrantLock.lock();
-            try {
-                Object[] arrayOfObject1 = getArray();
-                int i = arrayOfObject1.length;
-                Object[] arrayOfObject2 = Arrays.copyOf(arrayOfObject1, i + 1);
-                arrayOfObject2[i] = paramE;
-                setArray(arrayOfObject2);
-                int j = 1;
-                return j;
-            } finally {
-                localReentrantLock.unlock();
-            }
-        }
-
-
-      
-        final void setArray(Object[] paramArrayOfObject) {
-            this.array = paramArrayOfObject;
+````
+public boolean add(E paramE) {
+        ReentrantLock localReentrantLock = this.lock;
+        localReentrantLock.lock();
+        try {
+            Object[] arrayOfObject1 = getArray();
+            int i = arrayOfObject1.length;
+            Object[] arrayOfObject2 = Arrays.copyOf(arrayOfObject1, i + 1);
+            arrayOfObject2[i] = paramE;
+            setArray(arrayOfObject2);
+            int j = 1;
+            return j;
+        } finally {
+            localReentrantLock.unlock();
         }
+    }
 
+    final void setArray(Object[] paramArrayOfObject) {
+        this.array = paramArrayOfObject;
+    }
+````
 CopyOnWriterArrayList的add方法与ArrayList的add方法有一个最大的不同点就在于，下面三句代码：
 
     Object[] arrayOfObject2 = Arrays.copyOf(arrayOfObject1, i + 1);
@@ -444,11 +426,11 @@ Java 中为我们提供了两种比较机制：Comparable 和 Comparator，他
 ## Comparable
 
 Comparable 在 java.lang包下，是一个接口，内部只有一个方法 compareTo()：
-
+````
     public interface ComparableT {
         public int compareTo(T o);
     }
-
+````
 Comparable 可以让实现它的类的对象进行比较，具体的比较规则是按照 compareTo 方法中的规则进行。这种顺序称为 自然顺序。
 
 compareTo 方法的返回值有三种情况：
@@ -475,11 +457,7 @@ compareTo 方法的返回值有三种情况：
 
 
   description 测试用的实体类 书, 实现了 Comparable 接口，自然排序
-  
-      author shixinzhang
-      br
-      data 1052016
-    
+````    
     public class BookBean implements Serializable, Comparable {
         private String name;
         private int count;
@@ -505,12 +483,6 @@ compareTo 方法的返回值有三种情况：
     public void setCount(int count) {
         this.count = count;
     }
-
-
-​    
-      重写 equals
-      @param o
-      @return
      
     @Override
     public boolean equals(Object o) {
@@ -523,14 +495,12 @@ compareTo 方法的返回值有三种情况：
         return getName().equals(bean.getName());
     
     }
+````
+    重写 hashCode 的计算方法
+    根据所有属性进行 迭代计算，避免重复
+    计算 hashCode 时 计算因子 31 见得很多，是一个质数，不能再被除
 
-
-​    
-      重写 hashCode 的计算方法
-      根据所有属性进行 迭代计算，避免重复
-      计算 hashCode 时 计算因子 31 见得很多，是一个质数，不能再被除
-      @return
-     
+````     
     @Override
     public int hashCode() {
         调用 String 的 hashCode(), 唯一表示一个字符串内容
@@ -547,13 +517,11 @@ compareTo 方法的返回值有三种情况：
                 , count= + count +
                 '}';
     }
+````
 
+    当向 TreeSet 中添加 BookBean 时，会调用这个方法进行排序
 
-​    
-      当向 TreeSet 中添加 BookBean 时，会调用这个方法进行排序
-      @param another
-      @return
-     
+````
     @Override
     public int compareTo(Object another) {
         if (another instanceof BookBean){
@@ -574,7 +542,7 @@ compareTo 方法的返回值有三种情况：
          一样就返回 0
         return 0;
     }
-
+````
 上述代码还重写了 equlas(), hashCode() 方法，自定义的类将来可能会进行比较时，建议重写这些方法。
 
  这里我想表达的是在有些场景下 equals 和 compareTo 结果要保持一致，这时候不重写 equals，使用 Object.equals 方法得到的结果会有问题，比如说 HashMap.put() 方法，会先调用 key 的 equals 方法进行比较，然后才调用 compareTo。
@@ -592,40 +560,39 @@ Comparator 是javase中的接口，位于java.util包下，该接口抽象度极
 输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
 
 代码实现：
-    
-    import java.util.ArrayList;
-    import java.util.Collections;
-    import java.util.Comparator;
-     
-    public class Solution {
-        public String PrintMinNumber(int [] s) {
-            if(s==null) return null;
-            String s1="";
-            ArrayList<Integer> list=new ArrayList<Integer>();
-            for(int i=0;i<s.length;i++){
-                 list.add(s[i]);
-            }
-            Collections.sort(list,new Comparator<Integer>(){
-                public int compare(Integer str1,Integer str2){
-                    String s1=str1+""+str2;
-                    String s2=str2+""+str1;
-                    return s1.compareTo(s2);
-                }
-            });
-             for(int j:list){
-                    s1+=j;
-                 }
-            return s1;
+````    
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+ 
+public class Solution {
+    public String PrintMinNumber(int [] s) {
+        if(s==null) return null;
+        String s1="";
+        ArrayList<Integer> list=new ArrayList<Integer>();
+        for(int i=0;i<s.length;i++){
+             list.add(s[i]);
         }
+        Collections.sort(list,new Comparator<Integer>(){
+            public int compare(Integer str1,Integer str2){
+                String s1=str1+""+str2;
+                String s2=str2+""+str1;
+                return s1.compareTo(s2);
+            }
+        });
+         for(int j:list){
+                s1+=j;
+             }
+        return s1;
     }
-    
+}
+````    
 
- 
 
 一般需要做比较的逻辑都可以使用的上Comparator，最常用的场景就是排序和分组，排序常使用Arrays和Collections的sort方法，而分组则可以使用提供的divider方法。
 
-排序和分组的区别在于: 
-排序时，两个对象比较的结果有三种：大于，等于，小于。 
+排序和分组的区别在于:
+排序时，两个对象比较的结果有三种：大于，等于，小于。
 分组时，两个对象比较的结果只有两种：等于(两个对象属于同一组)，不等于(两个对象属于不同组)
 
 
@@ -637,14 +604,14 @@ Comparator 是javase中的接口，位于java.util包下，该接口抽象度极
 
 第一感觉就是这个箭头感觉有点怪，不过多用几次习惯就好，它主要是为了把参数列表与Lambda主体分隔开，箭头左边的是参数列表，右边的是Lambda主体。注意：Lambda表达式可以包含多行语句。
 在用Lambda 之前，我们先看看之前写比较器的写法
-
+````
     Comparator<Developer> byName = new Comparator<Developer>() {
         @Override
         public int compare(Developer o1, Developer o2) {
             return o1.getName().compareTo(o2.getName());
         }
     };
-
+````
 感觉也不是很复杂，没几行代码，再来看看Lambda 表达式的写法：
 
     Comparator<Developer> byName =
@@ -653,7 +620,7 @@ Comparator 是javase中的接口，位于java.util包下，该接口抽象度极
 比之前要简单许多有木有。
 下面再来看看排序功能示例：
 先用Collections.sort如下：
-
+````
     public class TestSorting {
         public static void main(String[] args) {
             List<Developer> listDevs = getDevelopers();
@@ -682,6 +649,7 @@ Comparator 是javase中的接口，位于java.util包下，该接口抽象度极
             return result;
         }
     }
+````
 
     输出结果：
     
@@ -698,7 +666,7 @@ Comparator 是javase中的接口，位于java.util包下，该接口抽象度极
     Developer [name=iris, salary=170000, age=55]
 
 看起来整个流程完全没毛病，下面再来看看Lambda的方式:
-
+````
     public class TestSorting {
         public static void main(String[] args) {
             List<Developer> listDevs = getDevelopers();
@@ -721,7 +689,7 @@ Comparator 是javase中的接口，位于java.util包下，该接口抽象度极
             return result;
         }
     }
-
+````
 输出结果：
 
     Before Sort
@@ -767,24 +735,8 @@ https://cmsblogs.com/p=1185
 
 https://blog.csdn.net/android_hl/article/details/53228348
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
 
 
 
-​                     
+                     
diff --git "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2438\357\274\232Java\351\233\206\345\220\210\347\261\273\347\273\206\350\212\202\347\262\276\350\256\262.md" "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232Java\351\233\206\345\220\210\347\261\273\347\273\206\350\212\202\347\262\276\350\256\262.md"
similarity index 94%
rename from "docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2438\357\274\232Java\351\233\206\345\220\210\347\261\273\347\273\206\350\212\202\347\262\276\350\256\262.md"
rename to "docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232Java\351\233\206\345\220\210\347\261\273\347\273\206\350\212\202\347\262\276\350\256\262.md"
index 658e558..00daca6 100644
--- "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2438\357\274\232Java\351\233\206\345\220\210\347\261\273\347\273\206\350\212\202\347\262\276\350\256\262.md"
+++ "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232Java\351\233\206\345\220\210\347\261\273\347\273\206\350\212\202\347\262\276\350\256\262.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [初始容量](#初始容量)
   * [asList的缺陷](#aslist的缺陷)
     * [避免使用基本数据类型数组转换为列表](#避免使用基本数据类型数组转换为列表)
@@ -10,9 +9,7 @@
     * [推荐使用subList处理局部列表](#推荐使用sublist处理局部列表)
   * [保持compareTo和equals同步](#保持compareto和equals同步)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 本文参考多篇优质技术博客，参考文章请在文末查看
 
@@ -482,23 +479,7 @@ http://blog.itpub.net/69906029/viewspace-2641300/
 https://www.cnblogs.com/itxiaok/p/10356553.html
 
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
 
 
 
diff --git "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2432\357\274\232Queue\345\222\214LinkedList.md" "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232Queue\345\222\214LinkedList.md"
similarity index 66%
rename from "docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2432\357\274\232Queue\345\222\214LinkedList.md"
rename to "docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232Queue\345\222\214LinkedList.md"
index 7849acb..e33315a 100644
--- "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2432\357\274\232Queue\345\222\214LinkedList.md"
+++ "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232Queue\345\222\214LinkedList.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [LinkedList](#linkedlist)
     * [概述](#概述)
     * [源码分析](#源码分析)
@@ -21,9 +20,8 @@
       * [remove，删除队列元素](#remove，删除队列元素)
   * [总结和同步的问题](#总结和同步的问题)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
+
 本文参考 http://cmsblogs.com/?p=155 
 和 
 https://www.jianshu.com/p/0e84b8d3606c
@@ -42,8 +40,6 @@ https://www.jianshu.com/p/0e84b8d3606c
 
 > www.how2playlife.com
 
-
-
 ## LinkedList
 ### 概述
 > 
@@ -66,117 +62,124 @@ https://www.jianshu.com/p/0e84b8d3606c
 #### 定义
 
   首先我们先看LinkedList的定义：
-
-    public class LinkedList<E>
-        extends AbstractSequentialList<E>
-        implements List<E>, Deque<E>, Cloneable, java.io.Serializable
-          从这段代码中我们可以清晰地看出LinkedList继承AbstractSequentialList，实现List、Deque、Cloneable、Serializable。其中AbstractSequentialList提供了 List 接口的骨干实现，从而最大限度地减少了实现受“连续访问”数据存储（如链接列表）支持的此接口所需的工作,从而以减少实现List接口的复杂度。Deque一个线性 collection，支持在两端插入和移除元素，定义了双端队列的操作。
+````
+public class LinkedList<E>
+extends AbstractSequentialList<E>
+implements List<E>, Deque<E>, Cloneable, java.io.Serializable
+````
+从这段代码中我们可以清晰地看出LinkedList继承AbstractSequentialList，实现List、Deque、Cloneable、Serializable。其中AbstractSequentialList提供了 List 接口的骨干实现，从而最大限度地减少了实现受“连续访问”数据存储（如链接列表）支持的此接口所需的工作,从而以减少实现List接口的复杂度。Deque一个线性 collection，支持在两端插入和移除元素，定义了双端队列的操作。
 
 #### 属性
 
 在LinkedList中提供了两个基本属性size、header。
-
+````
 private transient Entry<E> header = new Entry<E>(null, null, null);
 private transient int size = 0;
-其中size表示的LinkedList的大小，header表示链表的表头，Entry为节点对象。
+//其中size表示的LinkedList的大小，header表示链表的表头，Entry为节点对象。
 
-    private static class Entry<E> {
-        E element;        //元素节点
-        Entry<E> next;    //下一个元素
-        Entry<E> previous;  //上一个元素
-    
-        Entry(E element, Entry<E> next, Entry<E> previous) {
-            this.element = element;
-            this.next = next;
-            this.previous = previous;
-        }
+private static class Entry<E> {
+    E element;        //元素节点
+    Entry<E> next;    //下一个元素
+    Entry<E> previous;  //上一个元素
+
+    Entry(E element, Entry<E> next, Entry<E> previous) {
+        this.element = element;
+        this.next = next;
+        this.previous = previous;
     }
-      上面为Entry对象的源代码，Entry为LinkedList的内部类，它定义了存储的元素。该元素的前一个元素、后一个元素，这是典型的双向链表定义方式。
+}
+````
+上面为Entry对象的源代码，Entry为LinkedList的内部类，它定义了存储的元素。该元素的前一个元素、后一个元素，这是典型的双向链表定义方式。
 
 #### 构造方法
 
 LinkedList提供了两个构造方法：LinkedList()和LinkedList(Collection<? extends E> c)。
-
-    /**
-         *  构造一个空列表。
-         */
-        public LinkedList() {
-            header.next = header.previous = header;
-        }
-        
-        /**
-         *  构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。
-         */
-        public LinkedList(Collection<? extends E> c) {
-            this();
-            addAll(c);
-        }
+````
+/**
+ *  构造一个空列表。
+ */
+public LinkedList() {
+    header.next = header.previous = header;
+}
+
+/**
+ *  构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。
+ */
+public LinkedList(Collection<? extends E> c) {
+    this();
+    addAll(c);
+}
+````
   LinkedList()构造一个空列表。里面没有任何元素，仅仅只是将header节点的前一个元素、后一个元素都指向自身。
 
   LinkedList(Collection<? extends E> c)： 构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。该构造函数首先会调用LinkedList()，构造一个空列表，然后调用了addAll()方法将Collection中的所有元素添加到列表中。以下是addAll()的源代码：
 
-    /**
-         *  添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
-         */
-        public boolean addAll(Collection<? extends E> c) {
-            return addAll(size, c);
-        }
-        
-    /**
-     * 将指定 collection 中的所有元素从指定位置开始插入此列表。其中index表示在其中插入指定collection中第一个元素的索引
+````
+/**
+     *  添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
      */
-    public boolean addAll(int index, Collection<? extends E> c) {
-        //若插入的位置小于0或者大于链表长度，则抛出IndexOutOfBoundsException异常
-        if (index < 0 || index > size)
-            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
-        Object[] a = c.toArray();
-        int numNew = a.length;    //插入元素的个数
-        //若插入的元素为空，则返回false
-        if (numNew == 0)
-            return false;
-        //modCount:在AbstractList中定义的，表示从结构上修改列表的次数
-        modCount++;
-        //获取插入位置的节点，若插入的位置在size处，则是头节点，否则获取index位置处的节点
-        Entry<E> successor = (index == size ? header : entry(index));
-        //插入位置的前一个节点，在插入过程中需要修改该节点的next引用：指向插入的节点元素
-        Entry<E> predecessor = successor.previous;
-        //执行插入动作
-        for (int i = 0; i < numNew; i++) {
-            //构造一个节点e，这里已经执行了插入节点动作同时修改了相邻节点的指向引用
-            //
-            Entry<E> e = new Entry<E>((E) a[i], successor, predecessor);
-            //将插入位置前一个节点的下一个元素引用指向当前元素
-            predecessor.next = e;
-            //修改插入位置的前一个节点，这样做的目的是将插入位置右移一位，保证后续的元素是插在该元素的后面，确保这些元素的顺序
-            predecessor = e;
-        }
-        successor.previous = predecessor;
-        //修改容量大小
-        size += numNew;
-        return true;
+    public boolean addAll(Collection<? extends E> c) {
+        return addAll(size, c);
     }
-      在addAll()方法中，涉及到了两个方法，一个是entry(int index)，该方法为LinkedList的私有方法，主要是用来查找index位置的节点元素。
-
-    /**
-         * 返回指定位置(若存在)的节点元素
-         */
-        private Entry<E> entry(int index) {
-            if (index < 0 || index >= size)
-                throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
-                        + size);
-            //头部节点
-            Entry<E> e = header;
-            //判断遍历的方向
-            if (index < (size >> 1)) {
-                for (int i = 0; i <= index; i++)
-                    e = e.next;
-            } else {
-                for (int i = size; i > index; i--)
-                    e = e.previous;
-            }
-            return e;
-        }
-        
+    
+/**
+ * 将指定 collection 中的所有元素从指定位置开始插入此列表。其中index表示在其中插入指定collection中第一个元素的索引
+ */
+public boolean addAll(int index, Collection<? extends E> c) {
+    //若插入的位置小于0或者大于链表长度，则抛出IndexOutOfBoundsException异常
+    if (index < 0 || index > size)
+        throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
+    Object[] a = c.toArray();
+    int numNew = a.length;    //插入元素的个数
+    //若插入的元素为空，则返回false
+    if (numNew == 0)
+        return false;
+    //modCount:在AbstractList中定义的，表示从结构上修改列表的次数
+    modCount++;
+    //获取插入位置的节点，若插入的位置在size处，则是头节点，否则获取index位置处的节点
+    Entry<E> successor = (index == size ? header : entry(index));
+    //插入位置的前一个节点，在插入过程中需要修改该节点的next引用：指向插入的节点元素
+    Entry<E> predecessor = successor.previous;
+    //执行插入动作
+    for (int i = 0; i < numNew; i++) {
+        //构造一个节点e，这里已经执行了插入节点动作同时修改了相邻节点的指向引用
+        //
+        Entry<E> e = new Entry<E>((E) a[i], successor, predecessor);
+        //将插入位置前一个节点的下一个元素引用指向当前元素
+        predecessor.next = e;
+        //修改插入位置的前一个节点，这样做的目的是将插入位置右移一位，保证后续的元素是插在该元素的后面，确保这些元素的顺序
+        predecessor = e;
+    }
+    successor.previous = predecessor;
+    //修改容量大小
+    size += numNew;
+    return true;
+}
+````
+
+在addAll()方法中，涉及到了两个方法，一个是entry(int index)，该方法为LinkedList的私有方法，主要是用来查找index位置的节点元素。
+
+````
+/**
+ * 返回指定位置(若存在)的节点元素
+ */
+private Entry<E> entry(int index) {
+    if (index < 0 || index >= size)
+        throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+                + size);
+    //头部节点
+    Entry<E> e = header;
+    //判断遍历的方向
+    if (index < (size >> 1)) {
+        for (int i = 0; i <= index; i++)
+            e = e.next;
+    } else {
+        for (int i = size; i > index; i--)
+            e = e.previous;
+    }
+    return e;
+}
+````        
   从该方法有两个遍历方向中我们也可以看出LinkedList是双向链表，这也是在构造方法中为什么需要将header的前、后节点均指向自己。
 
   如果对数据结构有点了解，对上面所涉及的内容应该问题，我们只需要清楚一点：LinkedList是双向链表，其余都迎刃而解。
@@ -185,44 +188,48 @@ LinkedList提供了两个构造方法：LinkedList()和LinkedList(Collection<? e
 
 #### 增加方法
 
-      add(E e): 将指定元素添加到此列表的结尾。
+add(E e): 将指定元素添加到此列表的结尾。
 
-    public boolean add(E e) {
-        addBefore(e, header);
-            return true;
-        }
-          该方法调用addBefore方法，然后直接返回true，对于addBefore()而已，它为LinkedList的私有方法。
+````
+public boolean add(E e) {
+    addBefore(e, header);
+        return true;
+}
+
+//该方法调用addBefore方法，然后直接返回true，对于addBefore()而已，它为LinkedList的私有方法。
+private Entry<E> addBefore(E e, Entry<E> entry) {
+    //利用Entry构造函数构建一个新节点 newEntry，
+    Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
+    //修改newEntry的前后节点的引用，确保其链表的引用关系是正确的
+    newEntry.previous.next = newEntry;
+    newEntry.next.previous = newEntry;
+    //容量+1
+    size++;
+    //修改次数+1
+    modCount++;
+    return newEntry;
+}
+````
+
+    在addBefore方法中无非就是做了这件事：构建一个新节点newEntry，然后修改其前后的引用。
     
-    private Entry<E> addBefore(E e, Entry<E> entry) {
-            //利用Entry构造函数构建一个新节点 newEntry，
-            Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
-            //修改newEntry的前后节点的引用，确保其链表的引用关系是正确的
-            newEntry.previous.next = newEntry;
-            newEntry.next.previous = newEntry;
-            //容量+1
-            size++;
-            //修改次数+1
-            modCount++;
-            return newEntry;
-        }
-  在addBefore方法中无非就是做了这件事：构建一个新节点newEntry，然后修改其前后的引用。
-
-  LinkedList还提供了其他的增加方法：
-
-      add(int index, E element)：在此列表中指定的位置插入指定的元素。
-
-      addAll(Collection<? extends E> c)：添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
-
-      addAll(int index, Collection<? extends E> c)：将指定 collection 中的所有元素从指定位置开始插入此列表。
-
-      AddFirst(E e): 将指定元素插入此列表的开头。
-
-      addLast(E e): 将指定元素添加到此列表的结尾。
+    LinkedList还提供了其他的增加方法：
+    
+    add(int index, E element)：在此列表中指定的位置插入指定的元素。
+    
+    addAll(Collection<? extends E> c)：添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
+    
+    addAll(int index, Collection<? extends E> c)：将指定 collection 中的所有元素从指定位置开始插入此列表。
+    
+    AddFirst(E e): 将指定元素插入此列表的开头。
+    
+    addLast(E e): 将指定元素添加到此列表的结尾。
 
 #### 移除方法
 
-      remove(Object o)：从此列表中移除首次出现的指定元素（如果存在）。该方法的源代码如下：
+remove(Object o)：从此列表中移除首次出现的指定元素（如果存在）。该方法的源代码如下：
 
+````
     public boolean remove(Object o) {
             if (o==null) {
                 for (Entry<E> e = header.next; e != header; e = e.next) {
@@ -241,9 +248,10 @@ LinkedList提供了两个构造方法：LinkedList()和LinkedList(Collection<? e
             }
             return false;
         }
-        
+````        
   该方法首先会判断移除的元素是否为null，然后迭代这个链表找到该元素节点，最后调用remove(Entry<E> e)，remove(Entry<E> e)为私有方法，是LinkedList中所有移除方法的基础方法，如下：
 
+````
     private E remove(Entry<E> e) {
             if (e == header)
                 throw new NoSuchElementException();
@@ -263,7 +271,7 @@ LinkedList提供了两个构造方法：LinkedList()和LinkedList(Collection<? e
             modCount++;
             return result;
         }
-        
+````        
 其他的移除方法：
 
       clear()： 从此列表中移除所有元素。
@@ -300,7 +308,7 @@ LinkedList提供了两个构造方法：LinkedList()和LinkedList(Collection<? e
 
 Queue接口定义了队列数据结构，元素是有序的(按插入顺序)，先进先出。Queue接口相关的部分UML类图如下：
 
-![](https://upload-images.jianshu.io/upload_images/195193-bcff191213cf126a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/578)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404145942.png)
 
 ### DeQueue
 
@@ -309,7 +317,7 @@ Queue接口定义了队列数据结构，元素是有序的(按插入顺序)，
 ### ArrayDeque （底层使用循环数组实现双向队列）
 
 #### 创建
-
+````
     public ArrayDeque() {
        // 默认容量为16
        elements = new Object[16];
@@ -337,10 +345,10 @@ Queue接口定义了队列数据结构，元素是有序的(按插入顺序)，
             }
             elements = new Object[initialCapacity];
         }
-
+````
 
 #### add操作
-
+````
     add(E e) 调用 addLast(E e) 方法：
     public void addLast(E e) {
        if (e == null)
@@ -366,9 +374,9 @@ Queue接口定义了队列数据结构，元素是有序的(按插入顺序)，
           doubleCapacity();
     }
 
-
+````
 #### remove操作
-
+````
     remove()方法最终都会调对应的poll()方法：
         public E poll() {
             return pollFirst();
@@ -394,11 +402,9 @@ Queue接口定义了队列数据结构，元素是有序的(按插入顺序)，
             tail = t;
             return result;
         }
+````
 
-
-
-![](https://upload-images.jianshu.io/upload_images/195193-e36436dd0c750c3c.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404150054.png)
 
 ### PriorityQueue（底层用数组实现堆的结构）
 > 
@@ -408,7 +414,7 @@ Queue接口定义了队列数据结构，元素是有序的(按插入顺序)，
 > 
 
 #### add 添加方法
-
+````
     public boolean add(E e) {
         return offer(e); // add方法内部调用offer方法
     }
@@ -444,10 +450,12 @@ Queue接口定义了队列数据结构，元素是有序的(按插入顺序)，
         }
         queue[k] = x; // 新添加的元素添加到堆中
     }
+````
 
-![](https://upload-images.jianshu.io/upload_images/195193-be988ac1a1a415d1.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/670)
-#### poll，出队方法
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404150149.png)
 
+#### poll，出队方法
+````
     public E poll() {
         if (size == 0)
             return null;
@@ -482,9 +490,10 @@ Queue接口定义了队列数据结构，元素是有序的(按插入顺序)，
         }
         queue[k] = x; // 最后一个叶子节点添加到合适的位置
     }
-![](https://upload-images.jianshu.io/upload_images/195193-c88e7314648144da.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/680)
-#### remove，删除队列元素
+````
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404150228.png)#### remove，删除队列元素
+````
     public boolean remove(Object o) {
         int i = indexOf(o); // 找到数据对应的索引
         if (i == -1) // 不存在的话返回false
@@ -511,16 +520,15 @@ Queue接口定义了队列数据结构，元素是有序的(按插入顺序)，
         }
         return null;
     }
-
+````
 
 先执行 siftDown() 下滤过程：
 
-![](https://upload-images.jianshu.io/upload_images/195193-a64dbb5508a9c668.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/642)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404150304.png)
 
 再执行 siftUp() 上滤过程：
 
-![](https://upload-images.jianshu.io/upload_images/195193-e9ad437213e69b07.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/633)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404150353.png)
 ## 总结和同步的问题
 
 1、jdk内置的优先队列PriorityQueue内部使用一个堆维护数据，每当有数据add进来或者poll出去的时候会对堆做从下往上的调整和从上往下的调整。
@@ -541,20 +549,4 @@ https://www.iteye.com/blog/shmilyaw-hotmail-com-1825171
 
 https://blog.csdn.net/weixin_36378917/article/details/81812210
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2436\357\274\232TreeMap\345\222\214\347\272\242\351\273\221\346\240\221.md" "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232TreeMap\345\222\214\347\272\242\351\273\221\346\240\221.md"
similarity index 78%
rename from "docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2436\357\274\232TreeMap\345\222\214\347\272\242\351\273\221\346\240\221.md"
rename to "docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232TreeMap\345\222\214\347\272\242\351\273\221\346\240\221.md"
index 1d7bdc2..b9ed55a 100644
--- "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2436\357\274\232TreeMap\345\222\214\347\272\242\351\273\221\346\240\221.md"
+++ "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232TreeMap\345\222\214\347\272\242\351\273\221\346\240\221.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [什么是红黑树](#什么是红黑树)
     * [定义](#定义)
     * [实践](#实践)
@@ -11,9 +10,7 @@
         * [删除节点](#删除节点)
     * [3.总结](#3总结)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 本文参考多篇优质技术博客，参考文章请在文末查看
 
@@ -35,27 +32,25 @@
 
 首先，什么是红黑树呢？ 红黑树是一种“平衡的”二叉查找树，它是一种经典高效的算法，能够保证在最坏的情况下动态集合操作的时间为O（lgn）。红黑树每个节点包含5个域，分别为color,key,left,right和p。 color是在每个节点上增加的一个存储位表示节点的颜色，可以是RED或者BLACK。key为结点中的value值，left,right为该结点的左右孩子指针，没有的话为NIL，p是一个指针，是指向该节的父节点。如下图（来自维基百科）表示就是一颗红黑树，NIL为指向外结点的指针。（外结点视为没有key的结点）
 
+ 红黑树有什么性质呢？一般称为红黑性质，有以下五点：
 
+ 1）每个结点或者是红的或者是黑的；
 
-       红黑树有什么性质呢？一般称为红黑性质，有以下五点：
-
-     1）每个结点或者是红的或者是黑的；
+ 2）根结点是黑的；
 
-     2）根结点是黑的；
+ 3）每个叶结点（NIL）是黑的；
 
-     3）每个叶结点（NIL）是黑的；
+ 4）如果一个结点是红的，则它的两个孩子都是黑的；
 
-     4）如果一个结点是红的，则它的两个孩子都是黑的；
+ 5）对每个结点，从该结点到其他其子孙结点的所有路径上包含相同数目的黑结点。
 
-     5）对每个结点，从该结点到其他其子孙结点的所有路径上包含相同数目的黑结点。
+为了后面的分析，我们还得知道以下知识点。
 
-       为了后面的分析，我们还得知道以下知识点。
+（1）黑高度：从某个结点x出发（不包括该结点）到达一个叶结点的任意一条路径上，黑色结点的个数称为该结点x的黑高度。
 
-    （1）黑高度：从某个结点x出发（不包括该结点）到达一个叶结点的任意一条路径上，黑色结点的个数称为该结点x的黑高度。
+（2）一颗有n个内结点的红黑树的高度至多为2lg(n+1)。 （内结点视为红黑树中带关键字的结点）
 
-    （2）一颗有n个内结点的红黑树的高度至多为2lg(n+1)。   （内结点视为红黑树中带关键字的结点）
-
-    （3）包含n个内部节点的红黑树的高度是 O(log(n))。
+ （3）包含n个内部节点的红黑树的高度是 O(log(n))。
 
 ### 定义
 
@@ -89,88 +84,35 @@
 
 如图所示，这种情况不会破坏红黑树的特性，即不需要任何处理
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4761309-5c5b2c2111526b40.png?imageMogr2/auto-orient/strip|imageView2/2/w/317/format/webp)
-
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404155235.png)
 
 2.**红父**
 
 当其父亲为红色时又会存在以下的情况
 
-*   **红叔**
+**红叔**
 
 红叔的情况，其实相对来说比较简单的，如下图所示，只需要通过修改父、叔的颜色为黑色，祖的颜色为红色，而且回去递归的检查祖节点即可
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4761309-d03b6cc68cd297e5.png?imageMogr2/auto-orient/strip|imageView2/2/w/582/format/webp)
-
-
-
-
-
-
-*   **黑叔**
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404155342.png)
+**黑叔**
 
 黑叔的情况有如下几种，这几种情况下是不能够通过修改颜色达到平衡的效果，因此会通过旋转的操作，红黑树种有两种旋转操作，左旋和右旋(现在存在的疑问，什么时候使用到左旋，什么时候使用到右旋)
 
 *   Case 1:[先右旋，在改变颜色(根节点必须为黑色，其两个子节点为红色，叔节点不用改变)],如下图所示，注意省略黑哨兵节点
 
-    
-
-    
-
-![](https://upload-images.jianshu.io/upload_images/4761309-be4bb2dee4bffd10.png?imageMogr2/auto-orient/strip|imageView2/2/w/870/format/webp)
-
-    
-
-    
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404155411.png)
 
 *   Case 2:[先左旋变成Case1中的情况，再右旋，最后改变颜色(根节点必须为黑色，其两个子节点为红色，叔节点不用改变)],如下图所示，注意省略黑哨兵节点
 
-    
-
-    
-
-![](https://upload-images.jianshu.io/upload_images/4761309-7eed01cd63266976.png?imageMogr2/auto-orient/strip|imageView2/2/w/751/format/webp)
-
-
-    
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404155517.png)
 *   Case 3:[先左旋，最后改变颜色(根节点必须为黑色，其两个子节点为红色，叔节点不用改变)],如下图所示，注意省略黑哨兵节点
 
-    
-
-    
-
-![](https://upload-images.jianshu.io/upload_images/4761309-2885dd45740eb113.png?imageMogr2/auto-orient/strip|imageView2/2/w/831/format/webp)
-
-    
-
-
-    
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404155545.png)
 
 *   Case 4:[先右旋变成Case 3的情况，再左旋，最后改变颜色(根节点必须为黑色，其两个子节点为红色，叔节点不用改变)],如下图所示，注意省略黑哨兵节点
 
-    
-
-    
-
-![](https://upload-images.jianshu.io/upload_images/4761309-db86cb65433a632e.png?imageMogr2/auto-orient/strip|imageView2/2/w/754/format/webp)
-
-    
-
-
-    
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404155622.png)
 
 以上就是红黑树新增节点所有可能的操作，下面会介绍红黑树中的删除操作
 
@@ -188,16 +130,7 @@
 
 1.对于红黑树而言，单支节点的情况只有如下图所示的一种情况，即为当前节点为黑色，其孩子节点为红色,(1.假设当前节点为红色，其两个孩子节点必须为黑色，2.若有孙子节点，则必为黑色，导致黑子数量不等，而红黑树不平衡)
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4761309-f8b873df1b880922.png?imageMogr2/auto-orient/strip|imageView2/2/w/318/format/webp)
-
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404155656.png)
 
 2.由于红黑树是特殊的二叉查找树，它的删除和二叉查找树类型，真正的删除点即为删除点A的中序遍历的后继(前继也可以)，通过红黑树的特性可知这个后继必然最多只能有一个孩子，其这个孩子节点必然是右孩子节点，从而为单支情况(即这个后继节点只能有一个红色孩子或没有孩子)
 
@@ -205,129 +138,60 @@
 
 *   Case 1:被删除的节点为红色，则这节点必定为叶子节点(首先这里的被删除的节点指的是真正删除的节点，通过上文得知的真正删除的节点要么是节点本身，要么是其后继节点，若是节点本身则必须为叶子节点，不为叶子节点的话其会有左右孩子，则真正删除的是其右孩子树上的最小值，若是后继节点，也必须为叶子节点，若不是则其也会有左右孩子，从而和2中相违背)，这种情况下删除红色叶节点就可以了，不用进行其他的操作了。
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4761309-ff82fc5e72f98af8.png?imageMogr2/auto-orient/strip|imageView2/2/w/431/format/webp)
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404155743.png)
 
 *   Case 2:被删除的节点是黑色，其子节点是红色，将其子节点顶替上来并改变其颜色为黑色，如下图所示
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4761309-66968f353c49fe50.png?imageMogr2/auto-orient/strip|imageView2/2/w/434/format/webp)
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404155811.png)
 
 *   Case 3:被删除的节点是黑色，其子节点也是黑色，将其子节点顶替上来，变成了双黑的问题，此时有以下情况
 
-    *   Case 1:新节点的兄弟节点为**红色**，此时若新节点在左边则做左旋操作，否则做右旋操作，之后再将其父节点颜色改变为红色，兄弟节点
-
-        
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4761309-55eb7590905dbe38.png?imageMogr2/auto-orient/strip|imageView2/2/w/490/format/webp)
-
-
-
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4761309-75984ffc3773a040.png?imageMogr2/auto-orient/strip|imageView2/2/w/562/format/webp)
-
-    
+*   Case 1:新节点的兄弟节点为**红色**，此时若新节点在左边则做左旋操作，否则做右旋操作，之后再将其父节点颜色改变为红色，兄弟节点
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404155834.png)
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404155859.png)
 
 从图中可以看出，操作之后红黑树并未达到平衡状态，而是变成的**黑兄**的情况
 
 *   Case 2:新节点的兄弟节点为**黑色**,此时可能有如下情况
 
-    *   红父二黑侄：将父节点变成黑色，兄弟节点变成红色，新节点变成黑色即可,如下图所示
-
-        
-
-        
-
-![](https://upload-images.jianshu.io/upload_images/4761309-19ad02906c67ff6b.png?imageMogr2/auto-orient/strip|imageView2/2/w/589/format/webp)
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4761309-ed648a6bf4224a10.png?imageMogr2/auto-orient/strip|imageView2/2/w/564/format/webp)
-
+*   红父二黑侄：将父节点变成黑色，兄弟节点变成红色，新节点变成黑色即可,如下图所示
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404155933.png)
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404155959.png)
 *   黑父二黑侄：将父节点变成新节点的颜色，新节点变成黑色，兄弟节点染成红色，还需要继续以父节点为判定点继续判断,如下图所示
 
-    
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4761309-85819fe812e784f1.png?imageMogr2/auto-orient/strip|imageView2/2/w/603/format/webp)
-
-
-![](https://upload-images.jianshu.io/upload_images/4761309-cc00764b1900a74e.png?imageMogr2/auto-orient/strip|imageView2/2/w/549/format/webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404160015.png)
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404160051.png)
 
 *   红侄：
 
 情况一:新节点在右子树，红侄在兄弟节点左子树，此时的操作为右旋，并将兄弟节点变为父亲的颜色，父亲节点变为黑色，侄节点变为黑色，如下图所示
 
-
-
-
-
 ![](https://upload-images.jianshu.io/upload_images/4761309-62ecd431cc7a3e64.png?imageMogr2/auto-orient/strip|imageView2/2/w/895/format/webp)
 
-
-
-
 情况二:新节点在右子树，红侄在兄弟节点右子树，此时的操作为先左旋，后右旋并将侄节点变为父亲的颜色，父节点变为黑色，如下图所示
 
-
-
-
-
 ![](https://upload-images.jianshu.io/upload_images/4761309-b5e0ada3d870dcf6.png?imageMogr2/auto-orient/strip|imageView2/2/w/879/format/webp)
 
-
-
 情况三：新节点在左子树，红侄在兄弟节点左子树,此时的操作为先右旋在左旋并将侄节点变为父亲的颜色，父亲节点变为黑色，如下图所示
 
-
-
-
-
 ![](https://upload-images.jianshu.io/upload_images/4761309-bd3e2c1efdc7a147.png?imageMogr2/auto-orient/strip|imageView2/2/w/885/format/webp)
 
-
-
-
 情况四：新节点在右子树，红侄在兄弟节点右子树,此时的操作为左旋，并将兄弟节点变为父节点的颜色，父亲节点变为黑色，侄节点变为黑色，如下图所示
 
-
-
-
-
 ![](https://upload-images.jianshu.io/upload_images/4761309-9f34c34f7d02da29.png?imageMogr2/auto-orient/strip|imageView2/2/w/879/format/webp)
 
-
-
 #### 红黑树实现
 
 如下是使用JAVA代码实现红黑树的过程，主要包括了插入、删除、左旋、右旋、遍历等操作
 
 ##### 插入
 
-```
+````
 /* 插入一个节点
  * @param node
  */
@@ -427,7 +291,7 @@ private void insertFixUp(RBTreeNode<T> node){
     setColorBlack(this.rootNode);
 }
 
-```
+````
 
 插入节点的操作主要分为以下几步：
 
@@ -439,7 +303,7 @@ private void insertFixUp(RBTreeNode<T> node){
 
 如下为删除节点的代码
 
-```
+````
 private void remove(RBTreeNode<T> node){
     RBTreeNode<T> child,parent;
     boolean color;
@@ -522,9 +386,6 @@ private void remove(RBTreeNode<T> node){
     node = null;
 }
 
-```
-
-```
 /**
  * 删除修复
  * @param node
@@ -603,7 +464,7 @@ private void removeFixUp(RBTreeNode<T> node, RBTreeNode<T> parent){
         setColorBlack(node);
 }
 
-```
+````
 
 删除节点主要分为几种情况去做对应的处理：
 
@@ -617,12 +478,8 @@ private void removeFixUp(RBTreeNode<T> node, RBTreeNode<T> parent){
 
 以上主要介绍了红黑树的一些特性，包括一些操作详细的解析了里面的过程，写的时间比较长，感觉确实比较难理清楚。后面会持续的理解更深入，若有存在问题的地方，请指正。
 
-
-
 ## 参考文章
 
-
-
 [红黑树(五)之 Java的实现](https://link.jianshu.com/?t=http://www.cnblogs.com/skywang12345/p/3624343.html/)
 
 [通过分析 JDK 源代码研究 TreeMap 红黑树算法实现](https://link.jianshu.com/?t=https://www.ibm.com/developerworks/cn/java/j-lo-tree/index.html?ca=drs-)
@@ -633,24 +490,4 @@ private void removeFixUp(RBTreeNode<T> node, RBTreeNode<T> parent){
 
 [红黑树深入剖析及Java实现](https://link.jianshu.com/?t=https://zhuanlan.zhihu.com/p/24367771)
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
 
-​                     
diff --git "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2431\357\274\232\344\270\200\346\226\207\350\257\273\346\207\202ArrayList,Vector\344\270\216Stack\344\275\277\347\224\250\346\226\271\346\263\225\345\222\214\345\256\236\347\216\260\345\216\237\347\220\206.md" "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232\344\270\200\346\226\207\350\257\273\346\207\202ArrayList,Vector\344\270\216Stack\344\275\277\347\224\250\346\226\271\346\263\225\345\222\214\345\256\236\347\216\260\345\216\237\347\220\206.md"
similarity index 89%
rename from "docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2431\357\274\232\344\270\200\346\226\207\350\257\273\346\207\202ArrayList,Vector\344\270\216Stack\344\275\277\347\224\250\346\226\271\346\263\225\345\222\214\345\256\236\347\216\260\345\216\237\347\220\206.md"
rename to "docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232\344\270\200\346\226\207\350\257\273\346\207\202ArrayList,Vector\344\270\216Stack\344\275\277\347\224\250\346\226\271\346\263\225\345\222\214\345\256\236\347\216\260\345\216\237\347\220\206.md"
index df28c42..ed04968 100644
--- "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2431\357\274\232\344\270\200\346\226\207\350\257\273\346\207\202ArrayList,Vector\344\270\216Stack\344\275\277\347\224\250\346\226\271\346\263\225\345\222\214\345\256\236\347\216\260\345\216\237\347\220\206.md"
+++ "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232\344\270\200\346\226\207\350\257\273\346\207\202ArrayList,Vector\344\270\216Stack\344\275\277\347\224\250\346\226\271\346\263\225\345\222\214\345\256\236\347\216\260\345\216\237\347\220\206.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [ArrayList](#arraylist)
     * [ArrayList概述](#arraylist概述)
     * [ArrayList的继承关系](#arraylist的继承关系)
@@ -14,12 +13,9 @@
     * [初始容量和扩容](#初始容量和扩容)
     * [线程安全](#线程安全-1)
   * [Stack](#stack)
-* [Stack](#stack-1)
-  * [三个集合类之间的区别](#三个集合类之间的区别)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+    * [三个集合类之间的区别](#三个集合类之间的区别)
+    * [参考文章](#参考文章)
+
 
 本文参考多篇优质技术博客，参考文章请在文末查看
 
@@ -79,7 +75,7 @@ non-private to simplify nested class access
 
 //总结一下就是只复制数组中有值的位置，其他未赋值的位置不进行序列化，可以节省空间。
 
-
+````
     //        private void writeObject(java.io.ObjectOutputStream s)
     //        throws java.io.IOException{
     //            // Write out element count, and any hidden stuff
@@ -99,7 +95,7 @@ non-private to simplify nested class access
     //            }
     //        }
 
-
+````
 ### 增删改查
 
     //增删改查
@@ -109,13 +105,13 @@ non-private to simplify nested class access
 这个方法无非就是使用System.arraycopy()方法将C集合(先准换为数组)里面的数据复制到elementData数组中。这里就稍微介绍下System.arraycopy()，因为下面还将大量用到该方法
 
 。该方法的原型为：
-
+````
     public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)。
-
+````
 它的根本目的就是进行数组元素的复制。即从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
 
 将源数组src从srcPos位置开始复制到dest数组中，复制长度为length，数据从dest的destPos位置开始粘贴。
-
+````
     //        public void add(int index, E element) {
     //            rangeCheckForAdd(index);
     //
@@ -126,9 +122,9 @@ non-private to simplify nested class access
     //            size++;
     //        }
     //
-
+````
 删除元素时，同样判断索引是否和法，删除的方式是把被删除元素右边的元素左移，方法同样是使用System.arraycopy进行拷贝。
-
+````
     //        public E remove(int index) {
     //            rangeCheck(index);
     //
@@ -143,9 +139,9 @@ non-private to simplify nested class access
     //
     //            return oldValue;
     //        }
-
+````
 ArrayList提供一个清空数组的办法，方法是将所有元素置为null，这样就可以让GC自动回收掉没有被引用的元素了。
-
+````
     //
     //        /**
     //         * Removes all of the elements from this list.  The list will
@@ -160,9 +156,9 @@ ArrayList提供一个清空数组的办法，方法是将所有元素置为null
     //
     //            size = 0;
     //        }
-
+````
 修改元素时，只需要检查下标即可进行修改操作。
-
+````
     //        public E set(int index, E element) {
     //            rangeCheck(index);
     //
@@ -177,18 +173,18 @@ ArrayList提供一个清空数组的办法，方法是将所有元素置为null
     //            return elementData(index);
     //        }
     //
-
+````
 上述方法都使用了rangeCheck方法，其实就是简单地检查下标而已。
-
+````
     //        private void rangeCheck(int index) {
     //            if (index >= size)
     //                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
     //        }
-
+````
 ### modCount
-
+````
     //        protected transient int modCount = 0;
-
+````
 由以上代码可以看出，在一个迭代器初始的时候会赋予它调用这个迭代器的对象的mCount，如何在迭代器遍历的过程中，一旦发现这个对象的mcount和迭代器中存储的mcount不一样那就抛异常 
 
 > 好的，下面是这个的完整解释 
@@ -205,10 +201,10 @@ ArrayList提供一个清空数组的办法，方法是将所有元素置为null
 
 初始容量是10，下面是扩容方法。
 首先先取
-
-    //        private static final int DEFAULT_CAPACITY = 10;
+````
+    //private static final int DEFAULT_CAPACITY = 10;
     
-    扩容发生在add元素时，传入当前元素容量加一
+    // 扩容发生在add元素时，传入当前元素容量加一
        public boolean add(E e) {
         ensureCapacityInternal(size + 1);  // Increments modCount!!
         elementData[size++] = e;
@@ -238,13 +234,13 @@ ArrayList提供一个清空数组的办法，方法是将所有元素置为null
         if (minCapacity - elementData.length > 0)
             grow(minCapacity);
     }
-
+````
 真正执行扩容的方法grow
                
 扩容方式是让新容量等于旧容量的1.5被。
 
 当新容量大于最大数组容量时，执行大数扩容
-
+````
     //        private void grow(int minCapacity) {
     //            // overflow-conscious code
     //            int oldCapacity = elementData.length;
@@ -256,9 +252,9 @@ ArrayList提供一个清空数组的办法，方法是将所有元素置为null
     //            // minCapacity is usually close to size, so this is a win:
     //            elementData = Arrays.copyOf(elementData, newCapacity);
     //        }
-
+````
 当新容量大于最大数组长度，有两种情况，一种是溢出，抛异常，一种是没溢出，返回整数的最大值。
-
+````
     private static int hugeCapacity(int minCapacity) {
         if (minCapacity < 0) // overflow
             throw new OutOfMemoryError();
@@ -266,12 +262,12 @@ ArrayList提供一个清空数组的办法，方法是将所有元素置为null
             Integer.MAX_VALUE :
             MAX_ARRAY_SIZE;
     }
-
+````
 
 在这里有一个疑问，为什么每次扩容处理会是1.5倍，而不是2.5、3、4倍呢？通过google查找，发现1.5倍的扩容是最好的倍数。因为一次性扩容太大(例如2.5倍)可能会浪费更多的内存(1.5倍最多浪费33%，而2.5被最多会浪费60%，3.5倍则会浪费71%……)。但是一次性扩容太小，需要多次对数组重新分配内存，对性能消耗比较严重。所以1.5倍刚刚好，既能满足性能需求，也不会造成很大的内存消耗。
 
   处理这个ensureCapacity()这个扩容数组外，ArrayList还给我们提供了将底层数组的容量调整为当前列表保存的实际元素的大小的功能。它可以通过trimToSize()方法来实现。该方法可以最小化ArrayList实例的存储量。
-
+````
     public void trimToSize() {
         modCount++;
         int oldCapacity = elementData.length;
@@ -279,15 +275,16 @@ ArrayList提供一个清空数组的办法，方法是将所有元素置为null
             elementData = Arrays.copyOf(elementData, size);
         }
     }
+````
 ### 线程安全
 
 ArrayList是线程不安全的。在其迭代器iteator中，如果有多线程操作导致modcount改变，会执行fastfail。抛出异常。
-
+````
         final void checkForComodification() {
             if (modCount != expectedModCount)
                 throw new ConcurrentModificationException();
         }
-
+````
 ## Vector
 
 ### Vector简介
@@ -301,7 +298,7 @@ Vector实现RandmoAccess接口，即提供了随机访问功能，提供提供
 Vector 实现了Cloneable接口，支持clone()方法，可以被克隆。
 
 vector底层数组不加transient，序列化时会全部复制
-
+````
      protected Object[] elementData;
 
 
@@ -318,9 +315,9 @@ vector底层数组不加transient，序列化时会全部复制
     //            fields.put("elementData", data);
     //            s.writeFields();
     //        }
-
+````
 Vector除了iterator外还提供Enumeration枚举方法，不过现在比较过时。
-
+````
     //        public Enumeration<E> elements() {
     //            return new Enumeration<E>() {
     //                int count = 0;
@@ -340,13 +337,13 @@ Vector除了iterator外还提供Enumeration枚举方法，不过现在比较过
     //            };
     //        }
     //
-
+````
 
 ### 增删改查
 
 vector的增删改查既提供了自己的实现，也继承了abstractList抽象类的部分方法。
 下面的方法是vector自己实现的。
-
+````
     //
     //    public synchronized E elementAt(int index) {
     //        if (index >= elementCount) {
@@ -404,11 +401,11 @@ vector的增删改查既提供了自己的实现，也继承了abstractList抽
     //        ensureCapacityHelper(elementCount + 1);
     //        elementData[elementCount++] = obj;
     //    }
-
+````
 ### 初始容量和扩容  
 扩容方式与ArrayList基本一样，但是扩容时不是1.5倍扩容，而是有一个扩容增量。
 
-
+````
     //    protected int elementCount;
     
     //    protected int capacityIncrement;
@@ -418,11 +415,11 @@ vector的增删改查既提供了自己的实现，也继承了abstractList抽
     //    public Vector() {
     //        this(10);
     //    }
-
+````
 capacityIncrement：向量的大小大于其容量时，容量自动增加的量。如果在创建Vector时，指定了capacityIncrement的大小；则，每次当Vector中动态数组容量增加时>，增加的大小都是capacityIncrement。如果容量的增量小于等于零，则每次需要增大容量时，向量的容量将增大一倍。
 
 
-
+````
     //        public synchronized void ensureCapacity(int minCapacity) {
     //            if (minCapacity > 0) {
     //                modCount++;
@@ -447,15 +444,15 @@ capacityIncrement：向量的大小大于其容量时，容量自动增加的量
     //            elementData = Arrays.copyOf(elementData, newCapacity);
     //        }
 
-
+````
 下面是扩容过程示意图
 
 
-![](https://img-blog.csdn.net/20180818200637720?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjM3ODkxNw==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404145205.png)
 
-![](https://img-blog.csdn.net/20180818200704724?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjM3ODkxNw==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404145237.png)
 
-![](https://img-blog.csdn.net/20180818200735561?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjM3ODkxNw==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404145305.png)
 
 ### 线程安全
 
@@ -466,11 +463,11 @@ vector大部分方法都使用了synchronized修饰符，所以他是线层安
 
 # Stack
 
-    如果我们去查jdk的文档，我们会发现stack是在java.util这个包里。它对应的一个大致的类关系图如下：
+  如果我们去查jdk的文档，我们会发现stack是在java.util这个包里。它对应的一个大致的类关系图如下：
 
 ![](http://dl.iteye.com/upload/attachment/0081/2496/006da63f-388e-3669-b57f-1cdd1909d5f8.jpg)
 
-    通过继承Vector类，Stack类可以很容易的实现他本身的功能。因为大部分的功能在Vector里面已经提供支持了。
+  通过继承Vector类，Stack类可以很容易的实现他本身的功能。因为大部分的功能在Vector里面已经提供支持了。
 在Java中Stack类表示后进先出（LIFO）的对象堆栈。栈是一种非常常见的数据结构，它采用典型的先进后出的操作方式完成的。
 
 
@@ -497,10 +494,12 @@ Stack通过五个操作对Vector进行扩展，允许将向量视为堆栈。这
 > 返回对象在堆栈中的位置，以 1 为基数。
 
 Stack继承Vector，他对Vector进行了简单的扩展：
-
+````
 public class Stack<E> extends Vector<E>
-  Stack的实现非常简单，仅有一个构造方法，五个实现方法（从Vector继承而来的方法不算与其中），同时其实现的源码非常简单
+````
 
+  Stack的实现非常简单，仅有一个构造方法，五个实现方法（从Vector继承而来的方法不算与其中），同时其实现的源码非常简单
+````
     /**
      * 构造函数
      */
@@ -563,7 +562,7 @@ public class Stack<E> extends Vector<E>
         }
         return -1;
     }
-
+````
 Stack的源码很多都是基于Vector，所以这里不再累述
 
 ## 三个集合类之间的区别
@@ -589,24 +588,24 @@ ArrayList的优缺点
 ArrayList和Vector的区别
 
 > ArrayList是线程非安全的，这很明显，因为ArrayList中所有的方法都不是同步的，在并发下一定会出现线程安全问题。那么我们想要使用ArrayList并且让它线程安全怎么办？一个方法是用Collections.synchronizedList方法把你的ArrayList变成一个线程安全的List，比如：
->
->     List<String> synchronizedList = Collections.synchronizedList(list);
->     synchronizedList.add("aaa");
->     synchronizedList.add("bbb");
->     for (int i = 0; i < synchronizedList.size(); i++)
->     {
->         System.out.println(synchronizedList.get(i));
->     }
-
+````
+     List<String> synchronizedList = Collections.synchronizedList(list);
+     synchronizedList.add("aaa");
+     synchronizedList.add("bbb");
+     for (int i = 0; i < synchronizedList.size(); i++)
+     {
+         System.out.println(synchronizedList.get(i));
+     }
+````
 另一个方法就是Vector，它是ArrayList的线程安全版本，其实现90%和ArrayList都完全一样，区别在于：
 
 > 1、Vector是线程安全的，ArrayList是线程非安全的
 >
 > 2、Vector可以指定增长因子，如果该增长因子指定了，那么扩容的时候会每次新的数组大小会在原数组的大小基础上加上增长因子；如果不指定增长因子，那么就给原数组大小*2，源代码是这样的：
-
+````
     int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                      capacityIncrement : oldCapacity);
-
+````
 
 ## 参考文章
 
@@ -620,24 +619,4 @@ https://blog.csdn.net/u011419651/article/details/83831156
 
 https://www.jianshu.com/p/c4027084ac43
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
 
-​                     
diff --git "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2435\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243LinkedHashMap\345\222\214LRU\347\274\223\345\255\230.md" "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243LinkedHashMap\345\222\214LRU\347\274\223\345\255\230.md"
similarity index 58%
rename from "docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2435\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243LinkedHashMap\345\222\214LRU\347\274\223\345\255\230.md"
rename to "docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243LinkedHashMap\345\222\214LRU\347\274\223\345\255\230.md"
index bf76482..9f52389 100644
--- "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2435\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243LinkedHashMap\345\222\214LRU\347\274\223\345\255\230.md"
+++ "b/docs/Java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\243\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243LinkedHashMap\345\222\214LRU\347\274\223\345\255\230.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [LinkedHashMap 概述](#linkedhashmap-概述)
   * [LinkedHashMap 在 JDK 中的定义](#linkedhashmap-在-jdk-中的定义)
     * [类结构定义](#类结构定义)
@@ -24,9 +23,7 @@
   * [LinkedHashMap 有序性原理分析](#linkedhashmap-有序性原理分析)
   * [JDK1.8的改动](#jdk18的改动)
   * [总结](#总结)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 本文参考多篇优质技术博客，参考文章请在文末查看
 
@@ -69,21 +66,21 @@
 
 > 　　特别地，该迭代顺序可以是插入顺序，也可以是访问顺序。因此，根据链表中元素的顺序可以将LinkedHashMap分为：保持插入顺序的LinkedHashMap和保持访问顺序的LinkedHashMap，其中LinkedHashMap的默认实现是按插入顺序排序的。
 
-　　　　　![image](https://img-blog.csdn.net/20170317181610752?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvanVzdGxvdmV5b3Vf/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)　　　　　　
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404153000.png)
 
 > 　 本质上，HashMap和双向链表合二为一即是LinkedHashMap。所谓LinkedHashMap，其落脚点在HashMap，因此更准确地说，它是一个将所有Entry节点链入一个双向链表双向链表的HashMap。
 
 > 　 在LinkedHashMapMap中，所有put进来的Entry都保存在如下面第一个图所示的哈希表中，但由于它又额外定义了一个以head为头结点的双向链表(如下面第二个图所示)，因此对于每次put进来Entry，除了将其保存到哈希表中对应的位置上之外，还会将其插入到双向链表的尾部。
 
-![image](https://img-blog.csdn.net/20170317181650025?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvanVzdGxvdmV5b3Vf/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
-    
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404153032.png)
+
 　　更直观地，下图很好地还原了LinkedHashMap的原貌：HashMap和双向链表的密切配合和分工合作造就了LinkedHashMap。特别需要注意的是，next用于维护HashMap各个桶中的Entry链，before、after用于维护LinkedHashMap的双向链表，虽然它们的作用对象都是Entry，但是各自分离，是两码事儿。
 
-![这里写图片描述](https://img-blog.csdn.net/20170512160734275?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvanVzdGxvdmV5b3Vf/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404153119.png)
 　　 
 　　其中，HashMap与LinkedHashMap的Entry结构示意图如下图所示：
 
-![这里写图片描述](https://img-blog.csdn.net/20170512155609530?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvanVzdGxvdmV5b3Vf/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404153144.png)
 
 　　特别地，由于LinkedHashMap是HashMap的子类，所以LinkedHashMap自然会拥有HashMap的所有特性。比如，==LinkedHashMap也最多只允许一条Entry的键为Null(多条会覆盖)，但允许多条Entry的值为Null。==
 　　
@@ -93,63 +90,62 @@
 
 ### 类结构定义
 
-　　LinkedHashMap继承于HashMap，其在JDK中的定义为：
-
-    public class LinkedHashMap<K,V> extends HashMap<K,V>
-        implements Map<K,V> {
-    
-        ...
-    }
+LinkedHashMap继承于HashMap，其在JDK中的定义为：
+````
+public class LinkedHashMap<K,V> extends HashMap<K,V>
+    implements Map<K,V> {
 
+    ...
+}
+````
 ### 成员变量定义
 
 　　与HashMap相比，LinkedHashMap增加了两个属性用于保证迭代顺序，分别是 双向链表头结点header 和 标志位accessOrder (值为true时，表示按照访问顺序迭代；值为false时，表示按照插入顺序迭代)。
+````
+/**
+ * The head of the doubly linked list.
+ */
+private transient Entry<K,V> header;  // 双向链表的表头元素
 
-    /**
-     * The head of the doubly linked list.
-     */
-    private transient Entry<K,V> header;  // 双向链表的表头元素
-    
-    /**
-     * The iteration ordering method for this linked hash map: <tt>true</tt>
-     * for access-order, <tt>false</tt> for insertion-order.
-     *
-     * @serial
-     */
-    private final boolean accessOrder;  //true表示按照访问顺序迭代，false时表示按照插入顺序 
-
+/**
+ * The iteration ordering method for this linked hash map: <tt>true</tt>
+ * for access-order, <tt>false</tt> for insertion-order.
+ *
+ * @serial
+ */
+private final boolean accessOrder;  //true表示按照访问顺序迭代，false时表示按照插入顺序 
+````
 ### 成员方法定义
 
-　　从下图我们可以看出，LinkedHashMap中并增加没有额外方法。也就是说，LinkedHashMap与HashMap在操作上大致相同，只是在实现细节上略有不同罢了。
-
-[外链图片转存失败(img-C2vYmjQ7-1567839753833)(http://static.zybuluo.com/Rico123/nvojgv4s0o0ciieibz1tbakc/LinkedHashMap_Outline.png)]
+从下图我们可以看出，LinkedHashMap中并增加没有额外方法。也就是说，LinkedHashMap与HashMap在操作上大致相同，只是在实现细节上略有不同罢了。
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404153251.png)
 ### 基本元素 Entry
 
 　　LinkedHashMap采用的hash算法和HashMap相同，但是它重新定义了Entry。LinkedHashMap中的Entry增加了两个指针 before 和 after，它们分别用于维护双向链接列表。特别需要注意的是，next用于维护HashMap各个桶中Entry的连接顺序，before、after用于维护Entry插入的先后顺序的，源代码如下：
+````
+private static class Entry<K,V> extends HashMap.Entry<K,V> {
 
-    private static class Entry<K,V> extends HashMap.Entry<K,V> {
-    
-        // These fields comprise the doubly linked list used for iteration.
-        Entry<K,V> before, after;
-    
-        Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
-            super(hash, key, value, next);
-        }
-        ...
-    }
+    // These fields comprise the doubly linked list used for iteration.
+    Entry<K,V> before, after;
 
-　　形象地，HashMap与LinkedHashMap的Entry结构示意图如下图所示：
+    Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
+        super(hash, key, value, next);
+    }
+    ...
+}
+````
+形象地，HashMap与LinkedHashMap的Entry结构示意图如下图所示：
 
-![这里写图片描述](https://img-blog.csdn.net/20170512155609530?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvanVzdGxvdmV5b3Vf/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404153428.png)
 
 ## LinkedHashMap 的构造函数
-　　LinkedHashMap 一共提供了五个构造函数，它们都是在HashMap的构造函数的基础上实现的，除了默认空参数构造方法，下面这个构造函数包含了大部分其他构造方法使用的参数，就不一一列举了。
+LinkedHashMap 一共提供了五个构造函数，它们都是在HashMap的构造函数的基础上实现的，除了默认空参数构造方法，下面这个构造函数包含了大部分其他构造方法使用的参数，就不一一列举了。
 
 ### LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)
 
-　　该构造函数意在构造一个指定初始容量和指定负载因子的具有指定迭代顺序的LinkedHashMap，其源码如下：
-
+该构造函数意在构造一个指定初始容量和指定负载因子的具有指定迭代顺序的LinkedHashMap，其源码如下：
+````
 /**
      * Constructs an empty <tt>LinkedHashMap</tt> instance with the
      * specified initial capacity, load factor and ordering mode.
@@ -167,13 +163,13 @@
         super(initialCapacity, loadFactor);   // 调用HashMap对应的构造函数
         this.accessOrder = accessOrder;    // 迭代顺序的默认值
     }
-
+````
 初始容量 和负载因子是影响HashMap性能的两个重要参数。同样地，它们也是影响LinkedHashMap性能的两个重要参数。此外，LinkedHashMap 增加了双向链表头结点 header和标志位 accessOrder两个属性用于保证迭代顺序。
 　　
 ### LinkedHashMap(Map<? extends K, ? extends V> m)
 
 　　该构造函数意在构造一个与指定 Map 具有相同映射的 LinkedHashMap，其 初始容量不小于 16 (具体依赖于指定Map的大小)，负载因子是 0.75，是 Java Collection Framework 规范推荐提供的，其源码如下：
-
+````
     /**
      * Constructs an insertion-ordered <tt>LinkedHashMap</tt> instance with
      * the same mappings as the specified map.  The <tt>LinkedHashMap</tt>
@@ -187,11 +183,12 @@
         super(m);       // 调用HashMap对应的构造函数
         accessOrder = false;    // 迭代顺序的默认值
     }
-
+````
 ### init 方法
 
-　　从上面的五种构造函数我们可以看出，无论采用何种方式创建LinkedHashMap，其都会调用HashMap相应的构造函数。事实上，不管调用HashMap的哪个构造函数，HashMap的构造函数都会在最后调用一个init()方法进行初始化，只不过这个方法在HashMap中是一个空实现，而在LinkedHashMap中重写了它用于初始化它所维护的双向链表。例如，HashMap的参数为空的构造函数以及init方法的源码如下：
+从上面的五种构造函数我们可以看出，无论采用何种方式创建LinkedHashMap，其都会调用HashMap相应的构造函数。事实上，不管调用HashMap的哪个构造函数，HashMap的构造函数都会在最后调用一个init()方法进行初始化，只不过这个方法在HashMap中是一个空实现，而在LinkedHashMap中重写了它用于初始化它所维护的双向链表。例如，HashMap的参数为空的构造函数以及init方法的源码如下：
 
+````
     /**
      * Constructs an empty <tt>HashMap</tt> with the default initial capacity
      * (16) and the default load factor (0.75).
@@ -212,9 +209,11 @@
      */
     void init() {
     }
+````
 
-　　在LinkedHashMap中，它重写了init方法以便初始化双向列表，源码如下：
+在LinkedHashMap中，它重写了init方法以便初始化双向列表，源码如下：
 
+````
  /**
      * Called by superclass constructors and pseudoconstructors (clone,
      * readObject) before any entries are inserted into the map.  Initializes
@@ -224,8 +223,9 @@
         header = new Entry<K,V>(-1, null, null, null);
         header.before = header.after = header;
     }
+````
 
-　　因此，我们在创建LinkedHashMap的同时就会不知不觉地对双向链表进行初始化。
+因此，我们在创建LinkedHashMap的同时就会不知不觉地对双向链表进行初始化。
 
 ## LinkedHashMap 的数据结构
 
@@ -235,7 +235,7 @@
 
 > 在LinkedHashMapMap中，所有put进来的Entry都保存在HashMap中，但由于它又额外定义了一个以head为头结点的空的双向链表，因此对于每次put进来Entry还会将其插入到双向链表的尾部。
 
-　　　　　　　　　　　　![这里写图片描述](https://img-blog.csdn.net/20170512160734275?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvanVzdGxvdmV5b3Vf/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404153615.png)
 
 ## LinkedHashMap 的快速存取
 
@@ -247,116 +247,117 @@
 
 ### LinkedHashMap 的存储实现 : put(key, vlaue)
 
-　　上面谈到，LinkedHashMap没有对 put(key,vlaue) 方法进行任何直接的修改，完全继承了HashMap的 put(Key,Value) 方法，其源码如下：
+上面谈到，LinkedHashMap没有对 put(key,vlaue) 方法进行任何直接的修改，完全继承了HashMap的 put(Key,Value) 方法，其源码如下：
 
+````
+public V put(K key, V value) {
 
-    public V put(K key, V value) {
-    
-        //当key为null时，调用putForNullKey方法，并将该键值对保存到table的第一个位置 
-        if (key == null)
-            return putForNullKey(value); 
-    
-        //根据key的hashCode计算hash值
-        int hash = hash(key.hashCode());           
-    
-        //计算该键值对在数组中的存储位置（哪个桶）
-        int i = indexFor(hash, table.length);              
-    
-        //在table的第i个桶上进行迭代，寻找 key 保存的位置
-        for (Entry<K,V> e = table[i]; e != null; e = e.next) {      
-            Object k;
-            //判断该条链上是否存在hash值相同且key值相等的映射，若存在，则直接覆盖 value，并返回旧value
-            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
-                V oldValue = e.value;
-                e.value = value;
-                e.recordAccess(this); // LinkedHashMap重写了Entry中的recordAccess方法--- (1)    
-                return oldValue;    // 返回旧值
-            }
-        }
-    
-        modCount++; //修改次数增加1，快速失败机制
-    
-        //原Map中无该映射，将该添加至该链的链头
-        addEntry(hash, key, value, i);  // LinkedHashMap重写了HashMap中的createEntry方法 ---- (2)    
-        return null;
-    }
+    //当key为null时，调用putForNullKey方法，并将该键值对保存到table的第一个位置 
+    if (key == null)
+        return putForNullKey(value); 
 
-　　上述源码反映了LinkedHashMap与HashMap保存数据的过程。特别地，在LinkedHashMap中，它对addEntry方法和Entry的recordAccess方法进行了重写。下面我们对比地看一下LinkedHashMap 和HashMap的addEntry方法的具体实现：
+    //根据key的hashCode计算hash值
+    int hash = hash(key.hashCode());           
 
-    /**
-     * This override alters behavior of superclass put method. It causes newly
-     * allocated entry to get inserted at the end of the linked list and
-     * removes the eldest entry if appropriate.
-     *
-     * LinkedHashMap中的addEntry方法
-     */
-    void addEntry(int hash, K key, V value, int bucketIndex) {   
-    
-        //创建新的Entry，并插入到LinkedHashMap中  
-        createEntry(hash, key, value, bucketIndex);  // 重写了HashMap中的createEntry方法
-    
-        //双向链表的第一个有效节点（header后的那个节点）为最近最少使用的节点，这是用来支持LRU算法的
-        Entry<K,V> eldest = header.after;  
-        //如果有必要，则删除掉该近期最少使用的节点，  
-        //这要看对removeEldestEntry的覆写,由于默认为false，因此默认是不做任何处理的。  
-        if (removeEldestEntry(eldest)) {  
-            removeEntryForKey(eldest.key);  
-        } else {  
-            //扩容到原来的2倍  
-            if (size >= threshold)  
-                resize(2 * table.length);  
-        }  
-    } 
-    
-    -------------------------------我是分割线------------------------------------
-    
-     /**
-     * Adds a new entry with the specified key, value and hash code to
-     * the specified bucket.  It is the responsibility of this
-     * method to resize the table if appropriate.
-     *
-     * Subclass overrides this to alter the behavior of put method.
-     * 
-     * HashMap中的addEntry方法
-     */
-    void addEntry(int hash, K key, V value, int bucketIndex) {
-        //获取bucketIndex处的Entry
-        Entry<K,V> e = table[bucketIndex];
-    
-        //将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry 
-        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
-    
-        //若HashMap中元素的个数超过极限了，则容量扩大两倍
-        if (size++ >= threshold)
-            resize(2 * table.length);
+    //计算该键值对在数组中的存储位置（哪个桶）
+    int i = indexFor(hash, table.length);              
+
+    //在table的第i个桶上进行迭代，寻找 key 保存的位置
+    for (Entry<K,V> e = table[i]; e != null; e = e.next) {      
+        Object k;
+        //判断该条链上是否存在hash值相同且key值相等的映射，若存在，则直接覆盖 value，并返回旧value
+        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
+            V oldValue = e.value;
+            e.value = value;
+            e.recordAccess(this); // LinkedHashMap重写了Entry中的recordAccess方法--- (1)    
+            return oldValue;    // 返回旧值
+        }
     }
 
-　　由于LinkedHashMap本身维护了插入的先后顺序，因此其可以用来做缓存，14~19行的操作就是用来支持LRU算法的，这里暂时不用去关心它。此外，在LinkedHashMap的addEntry方法中，它重写了HashMap中的createEntry方法，我们接着看一下createEntry方法：
+    modCount++; //修改次数增加1，快速失败机制
 
-    void createEntry(int hash, K key, V value, int bucketIndex) { 
-        // 向哈希表中插入Entry，这点与HashMap中相同 
-        //创建新的Entry并将其链入到数组对应桶的链表的头结点处， 
-        HashMap.Entry<K,V> old = table[bucketIndex];  
-        Entry<K,V> e = new Entry<K,V>(hash, key, value, old);  
-        table[bucketIndex] = e;     
-    
-        //在每次向哈希表插入Entry的同时，都会将其插入到双向链表的尾部，  
-        //这样就按照Entry插入LinkedHashMap的先后顺序来迭代元素(LinkedHashMap根据双向链表重写了迭代器)
-        //同时，新put进来的Entry是最近访问的Entry，把其放在链表末尾 ，也符合LRU算法的实现  
-        e.addBefore(header);  
-        size++;  
+    //原Map中无该映射，将该添加至该链的链头
+    addEntry(hash, key, value, i);  // LinkedHashMap重写了HashMap中的createEntry方法 ---- (2)    
+    return null;
+}
+````
+　　上述源码反映了LinkedHashMap与HashMap保存数据的过程。特别地，在LinkedHashMap中，它对addEntry方法和Entry的recordAccess方法进行了重写。下面我们对比地看一下LinkedHashMap 和HashMap的addEntry方法的具体实现：
+````
+/**
+ * This override alters behavior of superclass put method. It causes newly
+ * allocated entry to get inserted at the end of the linked list and
+ * removes the eldest entry if appropriate.
+ *
+ * LinkedHashMap中的addEntry方法
+ */
+void addEntry(int hash, K key, V value, int bucketIndex) {   
+
+    //创建新的Entry，并插入到LinkedHashMap中  
+    createEntry(hash, key, value, bucketIndex);  // 重写了HashMap中的createEntry方法
+
+    //双向链表的第一个有效节点（header后的那个节点）为最近最少使用的节点，这是用来支持LRU算法的
+    Entry<K,V> eldest = header.after;  
+    //如果有必要，则删除掉该近期最少使用的节点，  
+    //这要看对removeEldestEntry的覆写,由于默认为false，因此默认是不做任何处理的。  
+    if (removeEldestEntry(eldest)) {  
+        removeEntryForKey(eldest.key);  
+    } else {  
+        //扩容到原来的2倍  
+        if (size >= threshold)  
+            resize(2 * table.length);  
     }  
-
+} 
+````    
+    -------------------------------我是分割线------------------------------------
+````    
+ /**
+ * Adds a new entry with the specified key, value and hash code to
+ * the specified bucket.  It is the responsibility of this
+ * method to resize the table if appropriate.
+ *
+ * Subclass overrides this to alter the behavior of put method.
+ * 
+ * HashMap中的addEntry方法
+ */
+void addEntry(int hash, K key, V value, int bucketIndex) {
+    //获取bucketIndex处的Entry
+    Entry<K,V> e = table[bucketIndex];
+
+    //将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry 
+    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
+
+    //若HashMap中元素的个数超过极限了，则容量扩大两倍
+    if (size++ >= threshold)
+        resize(2 * table.length);
+}
+````
+　　由于LinkedHashMap本身维护了插入的先后顺序，因此其可以用来做缓存，14~19行的操作就是用来支持LRU算法的，这里暂时不用去关心它。此外，在LinkedHashMap的addEntry方法中，它重写了HashMap中的createEntry方法，我们接着看一下createEntry方法：
+````
+void createEntry(int hash, K key, V value, int bucketIndex) { 
+    // 向哈希表中插入Entry，这点与HashMap中相同 
+    //创建新的Entry并将其链入到数组对应桶的链表的头结点处， 
+    HashMap.Entry<K,V> old = table[bucketIndex];  
+    Entry<K,V> e = new Entry<K,V>(hash, key, value, old);  
+    table[bucketIndex] = e;     
+
+    //在每次向哈希表插入Entry的同时，都会将其插入到双向链表的尾部，  
+    //这样就按照Entry插入LinkedHashMap的先后顺序来迭代元素(LinkedHashMap根据双向链表重写了迭代器)
+    //同时，新put进来的Entry是最近访问的Entry，把其放在链表末尾 ，也符合LRU算法的实现  
+    e.addBefore(header);  
+    size++;  
+}  
+````
 　　由以上源码我们可以知道，在LinkedHashMap中向哈希表中插入新Entry的同时，还会通过Entry的addBefore方法将其链入到双向链表中。其中，addBefore方法本质上是一个双向链表的插入操作，其源码如下：
-
-    //在双向链表中，将当前的Entry插入到existingEntry(header)的前面  
-    private void addBefore(Entry<K,V> existingEntry) {  
-        after  = existingEntry;  
-        before = existingEntry.before;  
-        before.after = this;  
-        after.before = this;  
-    }  
-
+````
+
+//在双向链表中，将当前的Entry插入到existingEntry(header)的前面  
+private void addBefore(Entry<K,V> existingEntry) {  
+    after  = existingEntry;  
+    before = existingEntry.before;  
+    before.after = this;  
+    after.before = this;  
+}  
+````
 　　到此为止，我们分析了在LinkedHashMap中put一条键值对的完整过程。总的来说，相比HashMap而言，LinkedHashMap在向哈希表添加一个键值对的同时，也会将其链入到它所维护的双向链表中，以便设定迭代顺序。
 
 ### LinkedHashMap 的扩容操作 : resize()
@@ -368,7 +369,7 @@
 但是，不得不说，扩容是一个非常耗时的过程，因为它需要重新计算这些元素在新table数组中的位置并进行复制处理。所以，如果我们能够提前预知HashMap中元素的个数，那么在构造HashMap时预设元素的个数能够有效的提高HashMap的性能。 
 
 同样的问题也存在于LinkedHashMap中，因为LinkedHashMap本来就是一个HashMap，只是它还将所有Entry节点链入到了一个双向链表中。LinkedHashMap完全继承了HashMap的resize()方法，只是对它所调用的transfer方法进行了重写。我们先看resize()方法源码：
-
+````
     void resize(int newCapacity) {
         Entry[] oldTable = table;
         int oldCapacity = oldTable.length;
@@ -388,9 +389,9 @@
         table = newTable;
         threshold = (int)(newCapacity * loadFactor);  // 重新设定 threshold
     }
-
+````
 　　从上面代码中我们可以看出，Map扩容操作的核心在于重哈希。所谓重哈希是指重新计算原HashMap中的元素在新table数组中的位置并进行复制处理的过程。鉴于性能和LinkedHashMap自身特点的考量，LinkedHashMap对重哈希过程(transfer方法)进行了重写，源码如下：
-
+````
     /**
      * Transfers all entries to new table array.  This method is called
      * by superclass resize.  It is overridden for performance, as it is
@@ -406,49 +407,49 @@
             newTable[index] = e;   
         }
     }
-
+````
 　　如上述源码所示，LinkedHashMap借助于自身维护的双向链表轻松地实现了重哈希操作。 
 
 ### LinkedHashMap 的读取实现 ：get(Object key)
 
 　　相对于LinkedHashMap的存储而言，读取就显得比较简单了。LinkedHashMap中重写了HashMap中的get方法，源码如下：
 
+````
+public V get(Object key) {
+    // 根据key获取对应的Entry，若没有这样的Entry，则返回null
+    Entry<K,V> e = (Entry<K,V>)getEntry(key); 
+    if (e == null)      // 若不存在这样的Entry，直接返回
+        return null;
+    e.recordAccess(this);
+    return e.value;
+}
 
-    public V get(Object key) {
-        // 根据key获取对应的Entry，若没有这样的Entry，则返回null
-        Entry<K,V> e = (Entry<K,V>)getEntry(key); 
-        if (e == null)      // 若不存在这样的Entry，直接返回
-            return null;
-        e.recordAccess(this);
-        return e.value;
+/**
+ * Returns the entry associated with the specified key in the
+ * HashMap.  Returns null if the HashMap contains no mapping
+ * for the key.
+ * 
+ * HashMap 中的方法
+ *     
+ */
+final Entry<K,V> getEntry(Object key) {
+    if (size == 0) {
+        return null;
     }
-    
-    /**
-         * Returns the entry associated with the specified key in the
-         * HashMap.  Returns null if the HashMap contains no mapping
-         * for the key.
-         * 
-         * HashMap 中的方法
-         *     
-         */
-        final Entry<K,V> getEntry(Object key) {
-            if (size == 0) {
-                return null;
-            }
-    
-            int hash = (key == null) ? 0 : hash(key);
-            for (Entry<K,V> e = table[indexFor(hash, table.length)];
-                 e != null;
-                 e = e.next) {
-                Object k;
-                if (e.hash == hash &&
-                    ((k = e.key) == key || (key != null && key.equals(k))))
-                    return e;
-            }
-            return null;
-        }
 
-　　在LinkedHashMap的get方法中，通过HashMap中的getEntry方法获取Entry对象。注意这里的recordAccess方法，如果链表中元素的排序规则是按照插入的先后顺序排序的话，该方法什么也不做；如果链表中元素的排序规则是按照访问的先后顺序排序的话，则将e移到链表的末尾处，笔者会在后文专门阐述这个问题。
+    int hash = (key == null) ? 0 : hash(key);
+    for (Entry<K,V> e = table[indexFor(hash, table.length)];
+         e != null;
+         e = e.next) {
+        Object k;
+        if (e.hash == hash &&
+            ((k = e.key) == key || (key != null && key.equals(k))))
+            return e;
+    }
+    return null;
+}
+````
+在LinkedHashMap的get方法中，通过HashMap中的getEntry方法获取Entry对象。注意这里的recordAccess方法，如果链表中元素的排序规则是按照插入的先后顺序排序的话，该方法什么也不做；如果链表中元素的排序规则是按照访问的先后顺序排序的话，则将e移到链表的末尾处，笔者会在后文专门阐述这个问题。
 
 另外，同样地，调用LinkedHashMap的get(Object key)方法后，若返回值是 NULL，则也存在如下两种可能：
 
@@ -465,7 +466,7 @@ HashMap 中不存在该 key。
 
 ## LinkedHashMap 与 LRU(Least recently used，最近最少使用)算法
 
-　　到此为止，我们已经分析完了LinkedHashMap的存取实现，这与HashMap大体相同。LinkedHashMap区别于HashMap最大的一个不同点是，前者是有序的，而后者是无序的。为此，LinkedHashMap增加了两个属性用于保证顺序，分别是双向链表头结点header和标志位accessOrder。
+到此为止，我们已经分析完了LinkedHashMap的存取实现，这与HashMap大体相同。LinkedHashMap区别于HashMap最大的一个不同点是，前者是有序的，而后者是无序的。为此，LinkedHashMap增加了两个属性用于保证顺序，分别是双向链表头结点header和标志位accessOrder。
 
 我们知道，header是LinkedHashMap所维护的双向链表的头结点，而accessOrder用于决定具体的迭代顺序。实际上，accessOrder标志位的作用可不像我们描述的这样简单，我们接下来仔细分析一波~ 
 
@@ -478,101 +479,102 @@ HashMap 中不存在该 key。
 因此，当标志位accessOrder的值为false时，虽然也会调用recordAccess方法，但不做任何操作。
 
 ### put操作与标志位accessOrder
-
-    / 将key/value添加到LinkedHashMap中      
-    public V put(K key, V value) {      
-        // 若key为null，则将该键值对添加到table[0]中。      
-        if (key == null)      
-            return putForNullKey(value);      
-        // 若key不为null，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。      
-        int hash = hash(key.hashCode());      
-        int i = indexFor(hash, table.length);      
-        for (Entry<K,V> e = table[i]; e != null; e = e.next) {      
-            Object k;      
-            // 若key对已经存在，则用新的value取代旧的value     
-            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {      
-                V oldValue = e.value;      
-                e.value = value;      
-                e.recordAccess(this);      
-                return oldValue;      
-            }      
+````
+/ 将key/value添加到LinkedHashMap中      
+public V put(K key, V value) {      
+    // 若key为null，则将该键值对添加到table[0]中。      
+    if (key == null)      
+        return putForNullKey(value);      
+    // 若key不为null，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。      
+    int hash = hash(key.hashCode());      
+    int i = indexFor(hash, table.length);      
+    for (Entry<K,V> e = table[i]; e != null; e = e.next) {      
+        Object k;      
+        // 若key对已经存在，则用新的value取代旧的value     
+        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {      
+            V oldValue = e.value;      
+            e.value = value;      
+            e.recordAccess(this);      
+            return oldValue;      
         }      
-    
-        // 若key不存在，则将key/value键值对添加到table中      
-        modCount++;    
-        //将key/value键值对添加到table[i]处    
-        addEntry(hash, key, value, i);      
-        return null;      
     }      
 
+    // 若key不存在，则将key/value键值对添加到table中      
+    modCount++;    
+    //将key/value键值对添加到table[i]处    
+    addEntry(hash, key, value, i);      
+    return null;      
+}      
+````
 　　从上述源码我们可以看到，当要put进来的Entry的key在哈希表中已经在存在时，会调用Entry的recordAccess方法；当该key不存在时，则会调用addEntry方法将新的Entry插入到对应桶的单链表的头部。我们先来看recordAccess方法：
-
-    /**
-    * This method is invoked by the superclass whenever the value
-    * of a pre-existing entry is read by Map.get or modified by Map.set.
-    * If the enclosing Map is access-ordered, it moves the entry
-    * to the end of the list; otherwise, it does nothing.
-    */
-    void recordAccess(HashMap<K,V> m) {  
-        LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;  
-        //如果链表中元素按照访问顺序排序，则将当前访问的Entry移到双向循环链表的尾部，  
-        //如果是按照插入的先后顺序排序，则不做任何事情。  
-        if (lm.accessOrder) {  
-            lm.modCount++;  
-            //移除当前访问的Entry  
-            remove();  
-            //将当前访问的Entry插入到链表的尾部  
-            addBefore(lm.header);  
-          }  
-      } 
-
+````
+/**
+* This method is invoked by the superclass whenever the value
+* of a pre-existing entry is read by Map.get or modified by Map.set.
+* If the enclosing Map is access-ordered, it moves the entry
+* to the end of the list; otherwise, it does nothing.
+*/
+void recordAccess(HashMap<K,V> m) {  
+    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;  
+    //如果链表中元素按照访问顺序排序，则将当前访问的Entry移到双向循环链表的尾部，  
+    //如果是按照插入的先后顺序排序，则不做任何事情。  
+    if (lm.accessOrder) {  
+        lm.modCount++;  
+        //移除当前访问的Entry  
+        remove();  
+        //将当前访问的Entry插入到链表的尾部  
+        addBefore(lm.header);  
+      }  
+  } 
+````
 　　LinkedHashMap重写了HashMap中的recordAccess方法（HashMap中该方法为空），当调用父类的put方法时，在发现key已经存在时，会调用该方法；当调用自己的get方法时，也会调用到该方法。
 
 该方法提供了LRU算法的实现，它将最近使用的Entry放到双向循环链表的尾部。也就是说，当accessOrder为true时，get方法和put方法都会调用recordAccess方法使得最近使用的Entry移到双向链表的末尾；当accessOrder为默认值false时，从源码中可以看出recordAccess方法什么也不会做。我们反过头来，再看一下addEntry方法：
 
-   /**
-     * This override alters behavior of superclass put method. It causes newly
-     * allocated entry to get inserted at the end of the linked list and
-     * removes the eldest entry if appropriate.
-     *
-     * LinkedHashMap中的addEntry方法
-     */
-    void addEntry(int hash, K key, V value, int bucketIndex) {   
-
-        //创建新的Entry，并插入到LinkedHashMap中  
-        createEntry(hash, key, value, bucketIndex);  // 重写了HashMap中的createEntry方法
-    
-        //双向链表的第一个有效节点（header后的那个节点）为最近最少使用的节点，这是用来支持LRU算法的
-        Entry<K,V> eldest = header.after;  
-        //如果有必要，则删除掉该近期最少使用的节点，  
-        //这要看对removeEldestEntry的覆写,由于默认为false，因此默认是不做任何处理的。  
-        if (removeEldestEntry(eldest)) {  
-            removeEntryForKey(eldest.key);  
-        } else {  
-            //扩容到原来的2倍  
-            if (size >= threshold)  
-                resize(2 * table.length);  
-        }  
-    } 
-    
-    void createEntry(int hash, K key, V value, int bucketIndex) { 
-        // 向哈希表中插入Entry，这点与HashMap中相同 
-        //创建新的Entry并将其链入到数组对应桶的链表的头结点处， 
-        HashMap.Entry<K,V> old = table[bucketIndex];  
-        Entry<K,V> e = new Entry<K,V>(hash, key, value, old);  
-        table[bucketIndex] = e;     
-    
-        //在每次向哈希表插入Entry的同时，都会将其插入到双向链表的尾部，  
-        //这样就按照Entry插入LinkedHashMap的先后顺序来迭代元素(LinkedHashMap根据双向链表重写了迭代器)
-        //同时，新put进来的Entry是最近访问的Entry，把其放在链表末尾 ，也符合LRU算法的实现  
-        e.addBefore(header);  
-        size++;  
-    }
-
+````
+/**
+ * This override alters behavior of superclass put method. It causes newly
+ * allocated entry to get inserted at the end of the linked list and
+ * removes the eldest entry if appropriate.
+ *
+ * LinkedHashMap中的addEntry方法
+ */
+void addEntry(int hash, K key, V value, int bucketIndex) {   
+
+    //创建新的Entry，并插入到LinkedHashMap中  
+    createEntry(hash, key, value, bucketIndex);  // 重写了HashMap中的createEntry方法
+
+    //双向链表的第一个有效节点（header后的那个节点）为最近最少使用的节点，这是用来支持LRU算法的
+    Entry<K,V> eldest = header.after;  
+    //如果有必要，则删除掉该近期最少使用的节点，  
+    //这要看对removeEldestEntry的覆写,由于默认为false，因此默认是不做任何处理的。  
+    if (removeEldestEntry(eldest)) {  
+        removeEntryForKey(eldest.key);  
+    } else {  
+        //扩容到原来的2倍  
+        if (size >= threshold)  
+            resize(2 * table.length);  
+    }  
+} 
+
+void createEntry(int hash, K key, V value, int bucketIndex) { 
+    // 向哈希表中插入Entry，这点与HashMap中相同 
+    //创建新的Entry并将其链入到数组对应桶的链表的头结点处， 
+    HashMap.Entry<K,V> old = table[bucketIndex];  
+    Entry<K,V> e = new Entry<K,V>(hash, key, value, old);  
+    table[bucketIndex] = e;     
+
+    //在每次向哈希表插入Entry的同时，都会将其插入到双向链表的尾部，  
+    //这样就按照Entry插入LinkedHashMap的先后顺序来迭代元素(LinkedHashMap根据双向链表重写了迭代器)
+    //同时，新put进来的Entry是最近访问的Entry，把其放在链表末尾 ，也符合LRU算法的实现  
+    e.addBefore(header);  
+    size++;  
+}
+````
 　　同样是将新的Entry链入到table中对应桶中的单链表中，但可以在createEntry方法中看出，同时也会把新put进来的Entry插入到了双向链表的尾部。
 　　
 从插入顺序的层面来说，新的Entry插入到双向链表的尾部可以实现按照插入的先后顺序来迭代Entry，而从访问顺序的层面来说，新put进来的Entry又是最近访问的Entry，也应该将其放在双向链表的尾部。在上面的addEntry方法中还调用了removeEldestEntry方法，该方法源码如下：
-
+````
     /**
      * Returns <tt>true</tt> if this map should remove its eldest entry.
      * This method is invoked by <tt>put</tt> and <tt>putAll</tt> after
@@ -584,13 +586,13 @@ HashMap 中不存在该 key。
      * <p>Sample use: this override will allow the map to grow up to 100
      * entries and then delete the eldest entry each time a new entry is
      * added, maintaining a steady state of 100 entries.
-     * <pre>
+     * 
      *     private static final int MAX_ENTRIES = 100;
      *
      *     protected boolean removeEldestEntry(Map.Entry eldest) {
      *        return size() > MAX_ENTRIES;
      *     }
-     * </pre>
+     * 
      *
      * <p>This method typically does not modify the map in any way,
      * instead allowing the map to modify itself as directed by its
@@ -614,15 +616,16 @@ HashMap 中不存在该 key。
      * @return   <tt>true</tt> if the eldest entry should be removed
      *           from the map; <tt>false</tt> if it should be retained.
      */
+     
     protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
         return false;
     }
 }
-
+````
 　　该方法是用来被重写的，一般地，如果用LinkedHashmap实现LRU算法，就要重写该方法。比如可以将该方法覆写为如果设定的内存已满，则返回true，这样当再次向LinkedHashMap中putEntry时，在调用的addEntry方法中便会将近期最少使用的节点删除掉（header后的那个节点）。在第七节，笔者便重写了该方法并实现了一个名副其实的LRU结构。
 
 ### get操作与标志位accessOrder
-
+````
     public V get(Object key) {
         // 根据key获取对应的Entry，若没有这样的Entry，则返回null
         Entry<K,V> e = (Entry<K,V>)getEntry(key); 
@@ -631,7 +634,7 @@ HashMap 中不存在该 key。
         e.recordAccess(this);
         return e.value;
     }
-
+````
 　　在LinkedHashMap中进行读取操作时，一样也会调用recordAccess方法。上面笔者已经表述的很清楚了，此不赘述。
 
 ### LinkedListMap与LRU小结
@@ -643,108 +646,109 @@ put方法在覆盖已有key的情况下，也是通过调用recordAccess方法
 ## 使用LinkedHashMap实现LRU算法
 　　如下所示，笔者使用LinkedHashMap实现一个符合LRU算法的数据结构，该结构最多可以缓存6个元素，但元素多余六个时，会自动删除最近最久没有被使用的元素，如下所示：
 
+````
+public class LRU<K,V> extends LinkedHashMap<K, V> implements Map<K, V>{
 
-    public class LRU<K,V> extends LinkedHashMap<K, V> implements Map<K, V>{
-    
-        private static final long serialVersionUID = 1L;
-    
-        public LRU(int initialCapacity,
-                 float loadFactor,
-                            boolean accessOrder) {
-            super(initialCapacity, loadFactor, accessOrder);
-        }
-    
-        /** 
-         * @description 重写LinkedHashMap中的removeEldestEntry方法，当LRU中元素多余6个时，
-         *              删除最不经常使用的元素
-         * @author rico       
-         * @created 2017年5月12日 上午11:32:51      
-         * @param eldest
-         * @return     
-         * @see java.util.LinkedHashMap#removeEldestEntry(java.util.Map.Entry)     
-         */  
-        @Override
-        protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
-            // TODO Auto-generated method stub
-            if(size() > 6){
-                return true;
-            }
-            return false;
-        }
-    
-        public static void main(String[] args) {
-    
-            LRU<Character, Integer> lru = new LRU<Character, Integer>(
-                    16, 0.75f, true);
-    
-            String s = "abcdefghijkl";
-            for (int i = 0; i < s.length(); i++) {
-                lru.put(s.charAt(i), i);
-            }
-            System.out.println("LRU中key为h的Entry的值为： " + lru.get('h'));
-            System.out.println("LRU的大小 ：" + lru.size());
-            System.out.println("LRU ：" + lru);
+    private static final long serialVersionUID = 1L;
+
+    public LRU(int initialCapacity,
+             float loadFactor,
+                        boolean accessOrder) {
+        super(initialCapacity, loadFactor, accessOrder);
+    }
+
+    /** 
+     * @description 重写LinkedHashMap中的removeEldestEntry方法，当LRU中元素多余6个时，
+     *              删除最不经常使用的元素
+     * @author rico       
+     * @created 2017年5月12日 上午11:32:51      
+     * @param eldest
+     * @return     
+     * @see java.util.LinkedHashMap#removeEldestEntry(java.util.Map.Entry)     
+     */  
+    @Override
+    protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
+        // TODO Auto-generated method stub
+        if(size() > 6){
+            return true;
         }
+        return false;
     }
 
+    public static void main(String[] args) {
+
+        LRU<Character, Integer> lru = new LRU<Character, Integer>(
+                16, 0.75f, true);
+
+        String s = "abcdefghijkl";
+        for (int i = 0; i < s.length(); i++) {
+            lru.put(s.charAt(i), i);
+        }
+        System.out.println("LRU中key为h的Entry的值为： " + lru.get('h'));
+        System.out.println("LRU的大小 ：" + lru.size());
+        System.out.println("LRU ：" + lru);
+    }
+}
+````
 　　下图是程序的运行结果： 
 ![](http://static.zybuluo.com/Rico123/gjz8mjvhkkhwjlzr5o8b27yv/LRU.png)
 ## LinkedHashMap 有序性原理分析
 
 如前文所述，LinkedHashMap 增加了双向链表头结点header 和 标志位accessOrder两个属性用于保证迭代顺序。但是要想真正实现其有序性，还差临门一脚，那就是重写HashMap 的迭代器，其源码实现如下：
+````
+private abstract class LinkedHashIterator<T> implements Iterator<T> {
+    Entry<K,V> nextEntry    = header.after;
+    Entry<K,V> lastReturned = null;
 
-    private abstract class LinkedHashIterator<T> implements Iterator<T> {
-        Entry<K,V> nextEntry    = header.after;
-        Entry<K,V> lastReturned = null;
-    
-        /**
-         * The modCount value that the iterator believes that the backing
-         * List should have.  If this expectation is violated, the iterator
-         * has detected concurrent modification.
-         */
-        int expectedModCount = modCount;
-    
-        public boolean hasNext() {         // 根据双向列表判断 
-                return nextEntry != header;
-        }
-    
-        public void remove() {
-            if (lastReturned == null)
-            throw new IllegalStateException();
-            if (modCount != expectedModCount)
-            throw new ConcurrentModificationException();
-    
-                LinkedHashMap.this.remove(lastReturned.key);
-                lastReturned = null;
-                expectedModCount = modCount;
-        }
-    
-        Entry<K,V> nextEntry() {        // 迭代输出双向链表各节点
-            if (modCount != expectedModCount)
-            throw new ConcurrentModificationException();
-                if (nextEntry == header)
-                    throw new NoSuchElementException();
-    
-                Entry<K,V> e = lastReturned = nextEntry;
-                nextEntry = e.after;
-                return e;
-        }
-    }
-    
-    // Key 迭代器，KeySet
-    private class KeyIterator extends LinkedHashIterator<K> {   
-        public K next() { return nextEntry().getKey(); }
+    /**
+     * The modCount value that the iterator believes that the backing
+     * List should have.  If this expectation is violated, the iterator
+     * has detected concurrent modification.
+     */
+    int expectedModCount = modCount;
+
+    public boolean hasNext() {         // 根据双向列表判断 
+            return nextEntry != header;
     }
-    
-       // Value 迭代器，Values(Collection)
-    private class ValueIterator extends LinkedHashIterator<V> {
-        public V next() { return nextEntry().value; }
+
+    public void remove() {
+        if (lastReturned == null)
+        throw new IllegalStateException();
+        if (modCount != expectedModCount)
+        throw new ConcurrentModificationException();
+
+            LinkedHashMap.this.remove(lastReturned.key);
+            lastReturned = null;
+            expectedModCount = modCount;
     }
-    
-    // Entry 迭代器，EntrySet
-    private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {
-        public Map.Entry<K,V> next() { return nextEntry(); }
+
+    Entry<K,V> nextEntry() {        // 迭代输出双向链表各节点
+        if (modCount != expectedModCount)
+        throw new ConcurrentModificationException();
+            if (nextEntry == header)
+                throw new NoSuchElementException();
+
+            Entry<K,V> e = lastReturned = nextEntry;
+            nextEntry = e.after;
+            return e;
     }
+}
+
+// Key 迭代器，KeySet
+private class KeyIterator extends LinkedHashIterator<K> {   
+    public K next() { return nextEntry().getKey(); }
+}
+
+   // Value 迭代器，Values(Collection)
+private class ValueIterator extends LinkedHashIterator<V> {
+    public V next() { return nextEntry().value; }
+}
+
+// Entry 迭代器，EntrySet
+private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {
+    public Map.Entry<K,V> next() { return nextEntry(); }
+}
+````
 
 　 从上述代码中我们可以知道，LinkedHashMap重写了HashMap 的迭代器，它使用其维护的双向链表进行迭代输出。
 　 
@@ -758,66 +762,65 @@ linkedhashmap同样使用了大部分hashmap的增删改查方法。
 
 hashmap不提供实现：
 
-     void afterNodeAccess(Node<K,V> p) { }
-        void afterNodeInsertion(boolean evict) { }
-        void afterNodeRemoval(Node<K,V> p) { }
+    void afterNodeAccess(Node<K,V> p) { }
+    void afterNodeInsertion(boolean evict) { }
+    void afterNodeRemoval(Node<K,V> p) { }
 
 linkedhashmap的实现：
     
 处理元素被访问后的情况
-
-    void afterNodeAccess(Node<K,V> e) { // move node to last
-            LinkedHashMap.Entry<K,V> last;
-            if (accessOrder && (last = tail) != e) {
-                LinkedHashMap.Entry<K,V> p =
-                    (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
-                p.after = null;
-                if (b == null)
-                    head = a;
-                else
-                    b.after = a;
-                if (a != null)
-                    a.before = b;
-                else
-                    last = b;
-                if (last == null)
-                    head = p;
-                else {
-                    p.before = last;
-                    last.after = p;
-                }
-                tail = p;
-                ++modCount;
-            }
-        }
-
-处理元素插入后的情况
-
-
-        void afterNodeInsertion(boolean evict) { // possibly remove eldest
-        LinkedHashMap.Entry<K,V> first;
-        if (evict && (first = head) != null && removeEldestEntry(first)) {
-            K key = first.key;
-            removeNode(hash(key), key, null, false, true);
-        }
-
-处理元素被删除后的情况
-
-         void afterNodeRemoval(Node<K,V> e) { // unlink
+````
+void afterNodeAccess(Node<K,V> e) { // move node to last
+    LinkedHashMap.Entry<K,V> last;
+    if (accessOrder && (last = tail) != e) {
         LinkedHashMap.Entry<K,V> p =
             (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
-        p.before = p.after = null;
+        p.after = null;
         if (b == null)
             head = a;
         else
             b.after = a;
-        if (a == null)
-            tail = b;
-        else
+        if (a != null)
             a.before = b;
+        else
+            last = b;
+        if (last == null)
+            head = p;
+        else {
+            p.before = last;
+            last.after = p;
+        }
+        tail = p;
+        ++modCount;
     }
-    }
+}
+````
+处理元素插入后的情况
 
+````
+    void afterNodeInsertion(boolean evict) { // possibly remove eldest
+    LinkedHashMap.Entry<K,V> first;
+    if (evict && (first = head) != null && removeEldestEntry(first)) {
+        K key = first.key;
+        removeNode(hash(key), key, null, false, true);
+    }
+````
+处理元素被删除后的情况
+````
+void afterNodeRemoval(Node<K,V> e) { // unlink
+    LinkedHashMap.Entry<K,V> p =
+        (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
+    p.before = p.after = null;
+    if (b == null)
+        head = a;
+    else
+        b.after = a;
+    if (a == null)
+        tail = b;
+    else
+        a.before = b;
+}
+````
 另外1.8的hashmap在链表长度超过8时自动转为红黑树，会按顺序插入链表中的元素，可以自定义比较器来定义节点的插入顺序。
 
 1.8的linkedhashmap同样会使用这一特性，当变为红黑树以后，节点的先后顺序同样是插入红黑树的顺序，其双向链表的性质没有改表，只是原来hashmap的链表变成了红黑树而已，在此不要混淆。
@@ -846,22 +849,7 @@ https://blog.csdn.net/wang_8101/article/details/83067860
 https://www.cnblogs.com/create-and-orange/p/11237072.html
 
 https://www.cnblogs.com/ganchuanpu/p/8908093.html
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
 
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
 
 
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2278\357\274\232AQS\344\270\255\347\232\204\345\205\254\345\271\263\351\224\201\344\270\216\351\235\236\345\205\254\345\271\263\351\224\201\357\274\214Condtion.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232AQS\344\270\255\347\232\204\345\205\254\345\271\263\351\224\201\344\270\216\351\235\236\345\205\254\345\271\263\351\224\201\357\274\214Condtion.md"
similarity index 92%
rename from "docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2278\357\274\232AQS\344\270\255\347\232\204\345\205\254\345\271\263\351\224\201\344\270\216\351\235\236\345\205\254\345\271\263\351\224\201\357\274\214Condtion.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232AQS\344\270\255\347\232\204\345\205\254\345\271\263\351\224\201\344\270\216\351\235\236\345\205\254\345\271\263\351\224\201\357\274\214Condtion.md"
index ec8782e..eb10601 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2278\357\274\232AQS\344\270\255\347\232\204\345\205\254\345\271\263\351\224\201\344\270\216\351\235\236\345\205\254\345\271\263\351\224\201\357\274\214Condtion.md"
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232AQS\344\270\255\347\232\204\345\205\254\345\271\263\351\224\201\344\270\216\351\235\236\345\205\254\345\271\263\351\224\201\357\274\214Condtion.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [公平锁和非公平锁](#公平锁和非公平锁)
   * [Condition](#condition)
     * [1\. 将节点加入到条件队列](#1-将节点加入到条件队列)
@@ -9,8 +8,8 @@
     * [5\. 唤醒后检查中断状态](#5-唤醒后检查中断状态)
     * [6\. 获取独占锁](#6-获取独占锁)
     * [7\. 处理中断状态](#7-处理中断状态)
-    * [* 带超时机制的 await](#-带超时机制的-await)
-    * [* 不抛出 InterruptedException 的 await](#-不抛出-interruptedexception-的-await)
+    * [带超时机制的 await](#-带超时机制的-await)
+    * [不抛出 InterruptedException 的 await](#-不抛出-interruptedexception-的-await)
   * [AbstractQueuedSynchronizer 独占锁的取消排队](#abstractqueuedsynchronizer-独占锁的取消排队)
   * [再说 java 线程中断和 InterruptedException 异常](#再说-java-线程中断和-interruptedexception-异常)
     * [线程中断](#线程中断)
@@ -46,7 +45,7 @@
 2.  深入分析 AbstractQueuedSynchronizer 中的 ConditionObject
 3.  深入理解 Java 线程中断和 InterruptedException 异常
 
-基本上本文把以上几点都说清楚了，我假设读者看过[上一篇文章中对 AbstractQueuedSynchronizer 的介绍 ](http://hongjiev.github.io/2017/06/16/AbstractQueuedSynchronizer/)，当然如果你已经熟悉 AQS 中的独占锁了，那也可以直接看这篇。各小节之间基本上没什么关系，大家可以只关注自己感兴趣的部分。
+基本上本文把以上几点都说清楚了，我假设读者看过[上一篇文章中对 AbstractQueuedSynchronizer 的介绍](http://hongjiev.github.io/2017/06/16/AbstractQueuedSynchronizer/)，当然如果你已经熟悉 AQS 中的独占锁了，那也可以直接看这篇。各小节之间基本上没什么关系，大家可以只关注自己感兴趣的部分。
 
 其实这篇文章的信息量很大，初学者估计**至少要 1 小时**才能看完，希望本文对得起大家的时间。
 
@@ -157,7 +156,7 @@ final boolean nonfairTryAcquire(int acquires) {
 
 ## Condition
 
-Tips: 这里重申一下，要看懂这个，必须要先看懂上一篇关于 [AbstractQueuedSynchronizer](http://hongjiev.github.io/2017/06/16/AbstractQueuedSynchronizer/) 的介绍，或者你已经有相关的知识了，否则这节肯定是看不懂的。
+Tips: 这里重申一下，要看懂这个，必须要先看懂上一篇关于[AbstractQueuedSynchronizer](http://hongjiev.github.io/2017/06/16/AbstractQueuedSynchronizer/)的介绍，或者你已经有相关的知识了，否则这节肯定是看不懂的。
 
 我们先来看看 Condition 的使用场景，Condition 经常可以用在**生产者-消费者**的场景中，请看 Doug Lea 给出的这个例子：
 
@@ -225,7 +224,7 @@ final ConditionObject newCondition() {
 }
 ```
 
-我们首先来看下我们关注的 Condition 的实现类 `AbstractQueuedSynchronizer` 类中的 `ConditionObject`。
+我们首先来看下我们关注的 Condition 的实现类`AbstractQueuedSynchronizer`类中的`ConditionObject`。
 
 ```
 public class ConditionObject implements Condition, java.io.Serializable {
@@ -260,8 +259,8 @@ public class ConditionObject implements Condition, java.io.Serializable {
 
 1.  条件队列和阻塞队列的节点，都是 Node 的实例，因为条件队列的节点是需要转移到阻塞队列中去的；
 2.  我们知道一个 ReentrantLock 实例可以通过多次调用 newCondition() 来产生多个 Condition 实例，这里对应 condition1 和 condition2。注意，ConditionObject 只有两个属性 firstWaiter 和 lastWaiter；
-3.  每个 condition 有一个关联的**条件队列**，如线程 1 调用 `condition1.await()` 方法即可将当前线程 1 包装成 Node 后加入到条件队列中，然后阻塞在这里，不继续往下执行，条件队列是一个单向链表；
-4.  调用`condition1.signal()` 触发一次唤醒，此时唤醒的是队头，会将condition1 对应的**条件队列**的 firstWaiter（队头） 移到**阻塞队列的队尾**，等待获取锁，获取锁后 await 方法才能返回，继续往下执行。
+3.  每个 condition 有一个关联的**条件队列**，如线程 1 调用`condition1.await()`方法即可将当前线程 1 包装成 Node 后加入到条件队列中，然后阻塞在这里，不继续往下执行，条件队列是一个单向链表；
+4.  调用`condition1.signal()`触发一次唤醒，此时唤醒的是队头，会将condition1 对应的**条件队列**的 firstWaiter（队头） 移到**阻塞队列的队尾**，等待获取锁，获取锁后 await 方法才能返回，继续往下执行。
 
 上面的 2->3->4 描述了一个最简单的流程，没有考虑中断、signalAll、还有带有超时参数的 await 方法等，不过把这里弄懂是这节的主要目的。
 
@@ -369,7 +368,7 @@ private void unlinkCancelledWaiters() {
 
 ### 2\. 完全释放独占锁
 
-回到 wait 方法，节点入队了以后，会调用 `int savedState = fullyRelease(node);` 方法释放锁，注意，这里是完全释放独占锁（fully release），因为 ReentrantLock 是可以重入的。
+回到 wait 方法，节点入队了以后，会调用`int savedState = fullyRelease(node);`方法释放锁，注意，这里是完全释放独占锁（fully release），因为 ReentrantLock 是可以重入的。
 
 > 考虑一下这里的 savedState。如果在 condition1.await() 之前，假设线程先执行了 2 次 lock() 操作，那么 state 为 2，我们理解为该线程持有 2 把锁，这里 await() 方法必须将 state 设置为 0，然后再进入挂起状态，这样其他线程才能持有锁。当它被唤醒的时候，它需要重新持有 2 把锁，才能继续下去。
 
@@ -397,7 +396,7 @@ final int fullyRelease(Node node) {
 }
 ```
 
-> 考虑一下，如果一个线程在不持有 lock 的基础上，就去调用 condition1.await() 方法，它能进入条件队列，但是在上面的这个方法中，由于它不持有锁，release(savedState) 这个方法肯定要返回 false，进入到异常分支，然后进入 finally 块设置 `node.waitStatus = Node.CANCELLED`，这个已经入队的节点之后会被后继的节点”请出去“。
+> 考虑一下，如果一个线程在不持有 lock 的基础上，就去调用 condition1.await() 方法，它能进入条件队列，但是在上面的这个方法中，由于它不持有锁，release(savedState) 这个方法肯定要返回 false，进入到异常分支，然后进入 finally 块设置`node.waitStatus = Node.CANCELLED`，这个已经入队的节点之后会被后继的节点”请出去“。
 
 ### 3\. 等待进入阻塞队列
 
@@ -455,11 +454,11 @@ private boolean findNodeFromTail(Node node) {
 }
 ```
 
-回到前面的循环，isOnSyncQueue(node) 返回 false 的话，那么进到 `LockSupport.park(this);` 这里线程挂起。
+回到前面的循环，isOnSyncQueue(node) 返回 false 的话，那么进到`LockSupport.park(this);`这里线程挂起。
 
 ### 4\. signal 唤醒线程，转移到阻塞队列
 
-为了大家理解，这里我们先看唤醒操作，因为刚刚到 `LockSupport.park(this);` 把线程挂起了，等待唤醒。
+为了大家理解，这里我们先看唤醒操作，因为刚刚到`LockSupport.park(this);`把线程挂起了，等待唤醒。
 
 唤醒操作通常由另一个线程来操作，就像生产者-消费者模式中，如果线程因为等待消费而挂起，那么当生产者生产了一个东西后，会调用 signal 唤醒正在等待的线程来消费。
 
@@ -514,7 +513,7 @@ final boolean transferForSignal(Node node) {
 }
 ```
 
-正常情况下，`ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL)` 这句中，ws <= 0，而且 `compareAndSetWaitStatus(p, ws, Node.SIGNAL)` 会返回 true，所以一般也不会进去 if 语句块中唤醒 node 对应的线程。然后这个方法返回 true，也就意味着 signal 方法结束了，节点进入了阻塞队列。
+正常情况下，`ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL)`这句中，ws <= 0，而且`compareAndSetWaitStatus(p, ws, Node.SIGNAL)`会返回 true，所以一般也不会进去 if 语句块中唤醒 node 对应的线程。然后这个方法返回 true，也就意味着 signal 方法结束了，节点进入了阻塞队列。
 
 假设发生了阻塞队列中的前驱节点取消等待，或者 CAS 失败，只要唤醒线程，让其进到下一步即可。
 
@@ -561,7 +560,7 @@ private int checkInterruptWhileWaiting(Node node) {
 }
 ```
 
-> Thread.interrupted()：如果当前线程已经处于中断状态，那么该方法返回 true，同时将中断状态重置为 false，所以，才有后续的 `重新中断（REINTERRUPT）` 的使用。
+> Thread.interrupted()：如果当前线程已经处于中断状态，那么该方法返回 true，同时将中断状态重置为 false，所以，才有后续的`重新中断（REINTERRUPT）`的使用。
 
 看看怎么判断是 signal 之前还是之后发生的中断：
 
@@ -618,9 +617,9 @@ if (interruptMode != 0)
     reportInterruptAfterWait(interruptMode);
 ```
 
-本着一丝不苟的精神，这边说说 `node.nextWaiter != null` 怎么满足。我前面也说了 signal 的时候会将节点转移到阻塞队列，有一步是 node.nextWaiter = null，将断开节点和条件队列的联系。
+本着一丝不苟的精神，这边说说`node.nextWaiter != null`怎么满足。我前面也说了 signal 的时候会将节点转移到阻塞队列，有一步是 node.nextWaiter = null，将断开节点和条件队列的联系。
 
-可是，`在判断发生中断的情况下，是 signal 之前还是之后发生的？` 这部分的时候，我也介绍了，如果 signal 之前就中断了，也需要将节点进行转移到阻塞队列，这部分转移的时候，是没有设置 node.nextWaiter = null 的。
+可是，`在判断发生中断的情况下，是 signal 之前还是之后发生的？`这部分的时候，我也介绍了，如果 signal 之前就中断了，也需要将节点进行转移到阻塞队列，这部分转移的时候，是没有设置 node.nextWaiter = null 的。
 
 之前我们说过，如果有节点取消，也会调用 unlinkCancelledWaiters 这个方法，就是这里了。
 
@@ -769,9 +768,9 @@ private final boolean parkAndCheckInterrupt() {
 
 这两段代码联系起来看，是不是就清楚了。
 
-如果我们要取消一个线程的排队，我们需要在另外一个线程中对其进行中断。比如某线程调用 lock() 老久不返回，我想中断它。一旦对其进行中断，此线程会从 `LockSupport.park(this);` 中唤醒，然后 `Thread.interrupted();` 返回 true。
+如果我们要取消一个线程的排队，我们需要在另外一个线程中对其进行中断。比如某线程调用 lock() 老久不返回，我想中断它。一旦对其进行中断，此线程会从`LockSupport.park(this);`中唤醒，然后`Thread.interrupted();`返回 true。
 
-我们发现一个问题，即使是中断唤醒了这个线程，也就只是设置了 `interrupted = true` 然后继续下一次循环。而且，由于 `Thread.interrupted();` 会清除中断状态，第二次进 parkAndCheckInterrupt 的时候，返回会是 false。
+我们发现一个问题，即使是中断唤醒了这个线程，也就只是设置了`interrupted = true`然后继续下一次循环。而且，由于`Thread.interrupted();`会清除中断状态，第二次进 parkAndCheckInterrupt 的时候，返回会是 false。
 
 所以，我们要看到，在这个方法中，interrupted 只是用来记录是否发生了中断，然后用于方法返回值，其他没有做任何相关事情。
 
@@ -802,7 +801,7 @@ public void lockInterruptibly() throws InterruptedException {
 }
 ```
 
-方法上多了个 `throws InterruptedException` ，经过前面那么多知识的铺垫，这里我就不再啰里啰嗦了。
+方法上多了个`throws InterruptedException`，经过前面那么多知识的铺垫，这里我就不再啰里啰嗦了。
 
 ```
 public final void acquireInterruptibly(int arg)
@@ -951,11 +950,11 @@ while (!Thread.interrupted()) {
 
 ### InterruptedException 概述
 
-它是一个特殊的异常，不是说 JVM 对其有特殊的处理，而是它的使用场景比较特殊。通常，我们可以看到，像 Object 中的 wait() 方法，ReentrantLock 中的 lockInterruptibly() 方法，Thread 中的 sleep() 方法等等，这些方法都带有 `throws InterruptedException`，我们通常称这些方法为阻塞方法（blocking method）。
+它是一个特殊的异常，不是说 JVM 对其有特殊的处理，而是它的使用场景比较特殊。通常，我们可以看到，像 Object 中的 wait() 方法，ReentrantLock 中的 lockInterruptibly() 方法，Thread 中的 sleep() 方法等等，这些方法都带有`throws InterruptedException`，我们通常称这些方法为阻塞方法（blocking method）。
 
 阻塞方法一个很明显的特征是，它们需要花费比较长的时间（不是绝对的，只是说明时间不可控），还有它们的方法结束返回往往依赖于外部条件，如 wait 方法依赖于其他线程的 notify，lock 方法依赖于其他线程的 unlock等等。
 
-当我们看到方法上带有 `throws InterruptedException` 时，我们就要知道，这个方法应该是阻塞方法，我们如果希望它能早点返回的话，我们往往可以通过中断来实现。
+当我们看到方法上带有`throws InterruptedException`时，我们就要知道，这个方法应该是阻塞方法，我们如果希望它能早点返回的话，我们往往可以通过中断来实现。
 
 除了几个特殊类（如 Object，Thread等）外，感知中断并提前返回是通过轮询中断状态来实现的。我们自己需要写可中断的方法的时候，就是通过在合适的时机（通常在循环的开始处）去判断线程的中断状态，然后做相应的操作（通常是方法直接返回或者抛出异常）。当然，我们也要看到，如果我们一次循环花的时间比较长的话，那么就需要比较长的时间才能**感知**到线程中断了。
 
@@ -1000,7 +999,7 @@ public final void acquire(int arg) {
 }
 ```
 
-而对于 lockInterruptibly() 方法，因为其方法上面有 `throws InterruptedException` ，这个信号告诉我们，如果我们要取消线程抢锁，直接中断这个线程即可，它会立即返回，抛出 InterruptedException 异常。
+而对于 lockInterruptibly() 方法，因为其方法上面有`throws InterruptedException`，这个信号告诉我们，如果我们要取消线程抢锁，直接中断这个线程即可，它会立即返回，抛出 InterruptedException 异常。
 
 在并发包中，有非常多的这种处理中断的例子，提供两个方法，分别为响应中断和不响应中断，对于不响应中断的方法，记录中断而不是丢失这个信息。如 Condition 中的两个方法就是这样的：
 
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2279\357\274\232AQS\345\205\261\344\272\253\346\250\241\345\274\217\344\270\216\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\347\232\204\345\256\236\347\216\260.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232AQS\345\205\261\344\272\253\346\250\241\345\274\217\344\270\216\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\347\232\204\345\256\236\347\216\260.md"
similarity index 99%
rename from "docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2279\357\274\232AQS\345\205\261\344\272\253\346\250\241\345\274\217\344\270\216\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\347\232\204\345\256\236\347\216\260.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232AQS\345\205\261\344\272\253\346\250\241\345\274\217\344\270\216\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\347\232\204\345\256\236\347\216\260.md"
index c966c90..5fb8968 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2279\357\274\232AQS\345\205\261\344\272\253\346\250\241\345\274\217\344\270\216\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\347\232\204\345\256\236\347\216\260.md"
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232AQS\345\205\261\344\272\253\346\250\241\345\274\217\344\270\216\345\271\266\345\217\221\345\267\245\345\205\267\347\261\273\347\232\204\345\256\236\347\216\260.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [前言](#前言)
   * [CountDownLatch](#countdownlatch)
     * [使用例子](#使用例子)
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\347\274\226\347\250\213\346\214\207\345\215\22715\357\274\232Fork join\345\271\266\345\217\221\346\241\206\346\236\266\344\270\216\345\267\245\344\275\234\347\252\203\345\217\226\347\256\227\346\263\225\345\211\226\346\236\220.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232ForkJoin\345\271\266\345\217\221\346\241\206\346\236\266\344\270\216\345\267\245\344\275\234\347\252\203\345\217\226\347\256\227\346\263\225\345\211\226\346\236\220.md"
similarity index 88%
rename from "docs/java/currency/Java\345\271\266\345\217\221\347\274\226\347\250\213\346\214\207\345\215\22715\357\274\232Fork join\345\271\266\345\217\221\346\241\206\346\236\266\344\270\216\345\267\245\344\275\234\347\252\203\345\217\226\347\256\227\346\263\225\345\211\226\346\236\220.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232ForkJoin\345\271\266\345\217\221\346\241\206\346\236\266\344\270\216\345\267\245\344\275\234\347\252\203\345\217\226\347\256\227\346\263\225\345\211\226\346\236\220.md"
index 52d5ad3..74fa6a0 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\347\274\226\347\250\213\346\214\207\345\215\22715\357\274\232Fork join\345\271\266\345\217\221\346\241\206\346\236\266\344\270\216\345\267\245\344\275\234\347\252\203\345\217\226\347\256\227\346\263\225\345\211\226\346\236\220.md"	
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232ForkJoin\345\271\266\345\217\221\346\241\206\346\236\266\344\270\216\345\267\245\344\275\234\347\252\203\345\217\226\347\256\227\346\263\225\345\211\226\346\236\220.md"
@@ -1,10 +1,8 @@
-# Table of Contents
-
+# 目录
   * [Fork/Join框架介绍](#forkjoin框架介绍)
   * [简介](#简介)
   * [工作窃取算法介绍](#工作窃取算法介绍)
 
-
 本文转自：https://www.imooc.com/article/24822
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -29,7 +27,7 @@ Fork/Join框架是Java7提供的一个用于并行执行任务的框架， 是
 
 ## 简介
 
-通常，使用Java来开发一个简单的并发应用程序时，会创建一些**Runnable**对象，然后创建对应的**Thread** 对象来控制程序中这些线程的创建、执行以及线程的状态。自从Java 5开始引入了**Executor**和**ExecutorService**接口以及实现这两个接口的类（比如**ThreadPoolExecutor**）之后，使得Java在并发支持上得到了进一步的提升。
+通常，使用Java来开发一个简单的并发应用程序时，会创建一些**Runnable**对象，然后创建对应的**Thread**对象来控制程序中这些线程的创建、执行以及线程的状态。自从Java 5开始引入了**Executor**和**ExecutorService**接口以及实现这两个接口的类（比如**ThreadPoolExecutor**）之后，使得Java在并发支持上得到了进一步的提升。
 
 **执行器框架（Executor Framework）**将任务的创建和执行进行了分离，通过这个框架，只需要实现**Runnable**接口的对象和使用**Executor**对象，然后将**Runnable**对象发送给执行器。执行器再负责运行这些任务所需要的线程，包括线程的创建，线程的管理以及线程的结束。
 
@@ -37,9 +35,9 @@ Fork/Join框架是Java7提供的一个用于并行执行任务的框架， 是
 
 **Fork/Join框架**是用来解决能够通过**分治技术（Divide and Conquer Technique）**将问题拆分成小任务的问题。在一个任务中，先检查将要解决的问题的大小，如果大于一个设定的大小，那就将问题拆分成可以通过框架来执行的小任务。如果问题的大小比设定的大小要小，就可以直接在任务里解决这个问题，然后，根据需要返回任务的结果。下面的图形总结了这个原理。
 
-[![Java Concurrency Cook Book 5.1](http://ifeve.com/wp-content/uploads/2014/02/Java-Concurrency-Cook-Book-5.1-300x141.png)](http://ifeve.com/wp-content/uploads/2014/02/Java-Concurrency-Cook-Book-5.1.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404203219.png)
 
-没有固定的公式来决定问题的**参考大小（Reference Size）**，从而决定一个任务是需要进行拆分或不需要拆分，拆分与否仍是依赖于任务本身的特性。可以使用在任务中将要处理的元素的数目和任务执行所需要的时间来决定参考大小。测试不同的参考大小来决定解决问题最好的一个方案，将**ForkJoinPool**类看作一个特殊的 **Executor** 执行器类型。这个框架基于以下两种操作。
+没有固定的公式来决定问题的**参考大小（Reference Size）**，从而决定一个任务是需要进行拆分或不需要拆分，拆分与否仍是依赖于任务本身的特性。可以使用在任务中将要处理的元素的数目和任务执行所需要的时间来决定参考大小。测试不同的参考大小来决定解决问题最好的一个方案，将**ForkJoinPool**类看作一个特殊的**Executor**执行器类型。这个框架基于以下两种操作。
 
 *   **分解（Fork）**操作：当需要将一个任务拆分成更小的多个任务时，在框架中执行这些任务；
 *   **合并（Join）**操作：当一个主任务等待其创建的多个子任务的完成执行。
@@ -48,7 +46,7 @@ Fork/Join框架是Java7提供的一个用于并行执行任务的框架， 是
 
 为了达到这个目标，通过**Fork/Join框架**执行的任务有以下限制。
 
-*   任务只能使用**fork()**和**join()** 操作当作同步机制。如果使用其他的同步机制，工作者线程就不能执行其他任务，当然这些任务是在同步操作里时。比如，如果在**Fork/Join 框架**中将一个任务休眠，正在执行这个任务的工作者线程在休眠期内不能执行另一个任务。
+*   任务只能使用**fork()**和**join()**操作当作同步机制。如果使用其他的同步机制，工作者线程就不能执行其他任务，当然这些任务是在同步操作里时。比如，如果在**Fork/Join 框架**中将一个任务休眠，正在执行这个任务的工作者线程在休眠期内不能执行另一个任务。
 *   任务不能执行I/O操作，比如文件数据的读取与写入。
 *   任务不能抛出非运行时异常（Checked Exception），必须在代码中处理掉这些异常。
 
@@ -66,7 +64,7 @@ Fork/Join框架是Java7提供的一个用于并行执行任务的框架， 是
 
 工作窃取（work-stealing）算法优点是充分利用线程进行并行计算，并减少了线程间的竞争，其缺点是在某些情况下还是存在竞争，比如双端队列里只有一个任务时。并且消耗了更多的系统资源，比如创建多个线程和多个双端队列。
 
-![图片描述](https://img.mukewang.com/5abf3c33000156c304140358.png "并发之Fork/Join框架使用及注意点_")
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404203237.png)
 
 **Fork/Join框架基础类**
 
@@ -157,14 +155,14 @@ public class ForkJoinTaskExample extends RecursiveTask<Integer> {
 2.  这里继承的是RecursiveTask，还可以继承RecursiveAction。前者适用于有返回值的场景，而后者适合于没有返回值的场景
 3.  这一点是最容易忽略的地方，其实这里执行子任务调用fork方法并不是最佳的选择，最佳的选择是invokeAll方法。
 
-    ```
-    leftTask.fork();  
-    rightTask.fork();
+```
+leftTask.fork();  
+rightTask.fork();
 
-    替换为
+替换为
 
-    invokeAll(leftTask, rightTask);
-    ```
+invokeAll(leftTask, rightTask);
+```
 
 具体说一下原理：对于Fork/Join模式，假如Pool里面线程数量是固定的，那么调用子任务的fork方法相当于A先分工给B，然后A当监工不干活，B去完成A交代的任务。所以上面的模式相当于浪费了一个线程。那么如果使用invokeAll相当于A分工给B后，A和B都去完成工作。这样可以更好的利用线程池，缩短执行的时间。
 
diff --git "a/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232JMM\344\270\255\347\232\204final\345\205\263\351\224\256\345\255\227\350\247\243\346\236\220.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232JMM\344\270\255\347\232\204final\345\205\263\351\224\256\345\255\227\350\247\243\346\236\220.md"
new file mode 100644
index 0000000..c9a13f8
--- /dev/null
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232JMM\344\270\255\347\232\204final\345\205\263\351\224\256\345\255\227\350\247\243\346\236\220.md"
@@ -0,0 +1,227 @@
+# 目录
+
+  * [一、properly constructed / this对象逸出](#一、properly-constructed--this对象逸出)
+  * [二、对象的安全发布](#二、对象的安全发布)
+  * [三、 final 关键字的内存语义](#三、-final-关键字的内存语义)
+  * [四、HotSpot VM中对final内存语义的实现](#四、hotspot-vm中对final内存语义的实现)
+* [参考文献](#参考文献)
+
+
+**本文转载自互联网，侵删**
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+文章首发于我的个人博客：
+> www.how2playlife.com
+
+本文是微信公众号【Java技术江湖】的《Java并发指南》其中一篇，本文大部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+
+该系列博文会告诉你如何全面深入地学习Java并发技术，从Java多线程基础，再到并发编程的基础知识，从Java并发包的入门和实战，再到JUC的源码剖析，一步步地学习Java并发编程，并上手进行实战，以便让你更完整地了解整个Java并发编程知识体系，形成自己的知识框架。
+
+为了更好地总结和检验你的学习成果，本系列文章也会提供一些对应的面试题以及参考答案。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+<!-- more -->
+
+## 一、properly constructed / this对象逸出
+在开始讲之前final之前，先了解一个概念，叫做 “properly constructed”。其含义是：在构造器创建对象的过程中，正在被创建的对象的引用没有发生 “逸出(escape)” 。
+````
+public Test {
+private final int x;
+private int y;
+private static Test instance;
+
+	public Test(int x, int y) {
+		this.x = x;
+		this.y = y;
+		instance = this;
+	}
+}
+````
+在上面的例子中，在构造器中把正在创建的对象赋值给了一个静态变量instance，这种行为就叫“逸出”。
+
+## 二、对象的安全发布
+所谓对象的安全发布，意思就是构建一个被完整初始化的对象，防止一个未完全初始化的对象被访问。
+
+看下面的例子：
+````
+public class Test {
+static MyObj obj;
+
+	static class MyObj {
+		int a, b, c, d;
+		MyObj() {
+			a = 1;
+			b = 1;
+			c = 1;
+			d = 1;
+		}
+	}
+	
+	// Thread 1
+	public static void init() {
+		obj = new MyObj();
+	}
+	
+	// Thread 2
+	public static void f() {
+		if (obj == null) return;
+		if (obj != null) {
+			System.out.println(obj.a + obj.b + obj.c + obj.d);
+		}
+	}
+
+}
+````
+
+上述代码中，Thread 2 打印出的数将会是几呢？事实上，可能是0, 1, 2, 3, 4 中的任意一个值。
+
+如果打印出的数不是4，那么就说明线程2读到了未完全初始化的MyObj对象。
+
+为什么会出现这种情况呢？是因为 obj = new MyObj() 这个操作底层实际上分为以下3个步骤：
+
+在堆上给MyObj对象分配空间，对象的字段置为默认值
+执行构造器中的初始化语句进行初始化
+将堆上的MyObj对象的引用赋值给obj
+其中，步骤2和3是可能发生重排序的 (StoreStore重排序)，因此就Thread 2就可能看到 obj != null，但是a,b,c,d还没全部赋值完成的情况，也就是 Thread 1 不安全的发布了 MyObj 对象。
+
+扩展一下，在实现单例模式时，会什么要double checked且加上volatile，正是这个原因，防止不安全的发布。
+
+笔者在 x86 平台的 HotSpot 虚拟机中使用 jcstress 工具对不安全发布现象进行了测试，发现类似于上述的代码在 x86 平台的 HotSpot 虚拟机中并不会出现为完全初始化的情况，出现这种情况就说明，x86 平台的 HotSpot 虚拟机实现中，编译器没有对上述步骤2和3进行重排序，而x86的内存模型又保证了x86不会发生StoreStore重排序，因此上述步骤2和3不会发生重排序，进而始终可以读到完全初始化过的对象。但是，在其他硬件平台或其他JVM中就未必如此了。 我们的Java代码不应该基于特定硬件平台或虚拟机实现之上，而是应该遵循JLS和JMM的规范！
+
+## 三、 final 关键字的内存语义
+
+1. 可见性
+   摘自[1]：
+
+The values for an object’s final fields are set in its constructor. Assuming the object is constructed “correctly”, once an object is constructed, the values assigned to the final fields in the constructor will be visible to all other threads without synchronization. In addition, the visible values for any other object or array referenced by those final fields will be at least as up-to-date as the final fields.
+
+在JMM中规定，如果我们在构造器中对final字段进行初始化，并且构造器中没有发生this对象的逸出，那么无需任何同步措施，即可确保其他线程可以看到构造器中初始化给final字段的值。此外，如果这个final字段是一个引用类型，那么可以确保该引用类型对象引用到的对象或数组的内容都是至少和final字段一样新的值。
+
+这里的“至少和final字段一样新的值”，意思也就是 up to date as of the end of the object’s constructor ([1])，也就是说，对于引用类型的final变量，其他线程至少能够读到构造器结束时，这个final类型引用变量的成员的状态。
+
+实际上，final 关键字对可见性的影响在Java语言规范的 17.5.1. Semantics of final Fields 一节也作出了正式规范。针对final关键字，引入了两个偏序关系——Dereference Chain和Memory Chain，借助这两个偏序关系，可以在不同线程之间的 w ww 和 r 2 r2r2 操作之间建立 happens before 关系，如下图所示：
+
+
+而 happens before 关系又隐含着可见性，所以 w ww 写的内容对于 r 2 r2r2 是可见的。结合上图 w ww 到 r 2 r2r2 的关系链，我们也不难理解为什么之前说 “对于引用类型的final变量，其他线程至少能够读到构造器结束时，这个final类型引用变量的成员的状态” 了，借助上述关系同样可以建立修改final字段成员 和 读取final字段成员之间的happens before 关系。
+
+2. 有序性
+
+注意：重排序是针对单个线程（单个CPU）而言的。
+
+以下摘自文档 [2]：
+
+Loads and Stores of final fields act as “normal” accesses with respect to locks and volatiles, but impose two additional reordering rules:
+
+对final字段的load和store操作和对普通字段的load和store操作几乎一样，只不过针对final字段存在下面两条额外的重排序规则：
+
+规则1
+
+【① A store of a final field】 (inside a constructor) and, 【② if the field is a reference, any store that this final can reference】, cannot be reordered with 【③ a subsequent store (outside that constructor) of the reference to the object holding that field into a variable accessible to other threads】. For example, you cannot reorder
+x.finalField = v; ... ; sharedRef = x;
+
+This comes into play for example when inlining constructors, where “...” spans the logical end of the constructor. You cannot move stores of finals within constructors down below a store outside of the constructor that might make the object visible to other threads. (As seen below, this may also require issuing a barrier). Similarly, you cannot reorder either of the first two with the third assignment in:
+v.afield = 1; x.finalField = v; ... ; sharedRef = x;
+
+直接看上面的话有点难懂，下面举一个例子：
+````
+class Apple {
+private String color;
+
+	public Apple(String color) { this.color = color; }
+}
+
+public class Test {
+static Test instance;
+final int a;
+final Apple apple;
+
+	public Test() { 
+		a = 10;
+		apple = new Apple("red"); 
+	}
+	
+	public static void init() {
+		instance = new Test();
+	}
+}
+````
+
+其实， x.finalField = v; ... ; sharedRef = x; 中的 x 在构造器中可以理解为 this，在 init() 方法中可以理解为new Test() 返回的对象。
+
+上述英文文档中：
+
+操作①是在构造器中对final字段 (基本类型和引用类型) 的赋值操作，对应a = 10，它不能和操作③进行重排序
+操作②也是指构造器中的操作，在①的基础上，如果final字段是一个引用类型，那么所有这个final字段引用到的store操作，都不能和操作③重排序。例如上面代码中的 apple 就是一个 final 类型应用变量，那么通过apple可以引用到color，则对apple.color的赋值操作不能和③进行重排序。
+操作③是在构造器外，将包含final字段的对象赋值给一个其他线程可以访问到的变量。在上述代码中，也就对应init()方法中的instance = new Test()，因为new Test()对象包含final字段a，且字段instance可以被其他线程访问到。
+实现这一条重排序规则可以通过在构造器结束位置插入StoreStore屏障来实现。
+
+规则2
+The initial load (i.e., the very first encounter by a thread) of a final field cannot be reordered with the initial load of the reference to the object containing the final field. This comes into play in:
+x = sharedRef; ... ; i = x.finalField;
+A compiler would never reorder these since they are dependent, but there can be consequences of this rule on some processors.
+
+再看个例子：
+````
+public class Test {
+static Test instance;
+final int a;
+
+	public Test() { a = 10; }
+	
+	public static void init() {
+		instance = new Test();
+	}
+	
+	public static void read() {
+		if (obj != null) {
+			System.out.println(obj.a);
+		}
+	}
+}
+````
+这条规则的意思是，通过对象访问其final字段(obj.a)这一操作 和 该操作之前第一次访问该对象的操作 (if (obj != null)中读取obj的操作) 是不能重排序的。
+
+Java编译器不会对不会对上述两个操作进行重排序，因为对编译器来说这两个操作(load(x)和load(x.field))之间存在依赖。但是对于处理器来说，它俩都是load操作，所以在允许LoadLoad重排序的处理器上，这两个操作是可能被重排序的，此时就需要加上LoadLoad屏障。
+
+总结
+final字段的重排序规则总结如下：
+
+构造器内final字段的写 和 构造器外将包含该final字段的对象赋值给一个其他线程能访问到的变量 这两个操作不能重排序
+加入final字段是一个引用类型，那么构造器内对该final引用类型字段的成员的写 和 构造器外将包含该final字段的对象赋值给一个其他线程能访问到的变量 这两个操作之间不能重排序
+构造器外，对于包含final字段的对象的读 和 对final字段的成员的读 不能重排序
+
+## 四、HotSpot VM中对final内存语义的实现
+[3] 在HotSpot源码的 parse1.cpp 中：
+````
+//------------------------------do_exits---------------------------------------
+void Parse::do_exits() {
+// ...
+if (method()->is_initializer() &&
+(wrote_final() ||
+PPC64_ONLY(wrote_volatile() ||)
+(AlwaysSafeConstructors && wrote_fields()))) {
+_exits.insert_mem_bar(Op_MemBarRelease, alloc_with_final());
+// ...
+do_exists() 函数在构造器退出时会执行，显然它会使用 wrote_final() 判断构造器内是不是存在final类型的写，如果是的话，则插入一个内存屏障 Op_MemBarRelease，这个屏障实际上对应 LoadStore 和 StoreStore。插入 LoadStore 屏障是为了照顾这样一种特殊情况：final 字段的值依赖于另外的字段。例如x.finalField = x.normalField + 1; ...; sharedRef = x;，这里插入LoadStore 就是为了防止对 x.normalField 的读操作和sharedRef = x 发生重排序。
+````
+
+ 总结
+final关键字的内存语义相较于volatile等关键字还是很难理解的，以上的内容如有表述不恰当之处还请指正。
+
+总结
+final关键字的内存语义相较于volatile等关键字还是很难理解的，以上的内容如有表述不恰当之处还请指正。
+
+# 参考文献
+Java Concurrency in Practice
+
+JSR 133 (Java Memory Model) FAQ
+
+Java Concurrency in Practice
+
+The JSR-133 Cookbook for Compiler Writers
+Intel® 64 and IA-32 ArchitecturesvSoftware Developer’s Manual Volume 3A: System Programming Guide, Part 1
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22714\357\274\232JUC\344\270\255\345\270\270\347\224\250\347\232\204Unsafe\345\222\214Locksupport.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232JUC\344\270\255\345\270\270\347\224\250\347\232\204Unsafe\345\222\214Locksupport.md"
similarity index 68%
rename from "docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22714\357\274\232JUC\344\270\255\345\270\270\347\224\250\347\232\204Unsafe\345\222\214Locksupport.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232JUC\344\270\255\345\270\270\347\224\250\347\232\204Unsafe\345\222\214Locksupport.md"
index f1c33dc..6c1e5d6 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22714\357\274\232JUC\344\270\255\345\270\270\347\224\250\347\232\204Unsafe\345\222\214Locksupport.md"
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232JUC\344\270\255\345\270\270\347\224\250\347\232\204Unsafe\345\222\214Locksupport.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [前言](#前言)
   * [Unsafe类是啥？](#unsafe类是啥？)
   * [为什么叫Unsafe？](#为什么叫unsafe？)
@@ -28,21 +27,15 @@
 
 最近在看Java并发包的源码，发现了神奇的Unsafe类，仔细研究了一下，在这里跟大家分享一下。
 
-![](http://p1.pstatp.com/large/c5e00061c7c63b28923)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404202919.png)
 
 Unsafe类是在sun.misc包下，不属于Java标准。但是很多Java的基础类库，包括一些被广泛使用的高性能开发库都是基于Unsafe类开发的，比如Netty、Cassandra、Hadoop、Kafka等。Unsafe类在提升Java运行效率，增强Java语言底层操作能力方面起了很大的作用。
 
-![](http://p3.pstatp.com/large/ca4000030d1f375caf1)
-
-![](http://p3.pstatp.com/large/ca4000030319e3adb8f)
-
 Unsafe类使Java拥有了像C语言的指针一样操作内存空间的能力，同时也带来了指针的问题。过度的使用Unsafe类会使得出错的几率变大，因此Java官方并不建议使用的，官方文档也几乎没有。Oracle正在计划从Java 9中去掉Unsafe类，如果真是如此影响就太大了。
 
-![](http://p3.pstatp.com/large/c5e00061cf0b59ac2ac)
-
 通常我们最好也不要使用Unsafe类，除非有明确的目的，并且也要对它有深入的了解才行。要想使用Unsafe类需要用一些比较tricky的办法。Unsafe类使用了单例模式，需要通过一个静态方法getUnsafe()来获取。但Unsafe类做了限制，如果是普通的调用的话，它会抛出一个SecurityException异常；只有由主类加载器加载的类才能调用这个方法。其源码如下：
 
-
+````
     1 public static Unsafe getUnsafe() {
     2     Class var0 = Reflection.getCallerClass();
     3     if(!VM.isSystemDomainLoader(var0.getClassLoader())) {
@@ -51,13 +44,13 @@ Unsafe类使Java拥有了像C语言的指针一样操作内存空间的能力，
     6         return theUnsafe;
     7     }
     8 }
-
+````
 网上也有一些办法来用主类加载器加载用户代码，比如设置bootclasspath参数。但更简单方法是利用Java反射，方法如下：
-
+````
     1 Field f = Unsafe.class.getDeclaredField("theUnsafe");
     2 f.setAccessible(true);
     3 Unsafe unsafe = (Unsafe) f.get(null);
-
+````
 获取到Unsafe实例之后，我们就可以为所欲为了。Unsafe类提供了以下这些功能：
 
 一、内存管理。包括分配内存、释放内存等。
@@ -114,23 +107,23 @@ Java官方不推荐使用Unsafe类，因为官方认为，这个类别人很难
 
 
 1、简单介绍
-   LockSupport是JDK中比较底层的类，用来创建锁和其他同步工具类的基本线程阻塞原语。可以做到与join() 、wait()/notifyAll() 功能一样，使线程自由的阻塞、释放。
-   Java锁和同步器框架的核心AQS(AbstractQueuedSynchronizer 抽象队列同步器)，就是通过调用LockSupport.park()和LockSupport.unpark()实现线程的阻塞和唤醒的。
+ LockSupport是JDK中比较底层的类，用来创建锁和其他同步工具类的基本线程阻塞原语。可以做到与join() 、wait()/notifyAll() 功能一样，使线程自由的阻塞、释放。
+ Java锁和同步器框架的核心AQS(AbstractQueuedSynchronizer 抽象队列同步器)，就是通过调用LockSupport.park()和LockSupport.unpark()实现线程的阻塞和唤醒的。
 
 补充：AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，
 如常用的ReentrantLock/Semaphore/CountDownLatch...。
 
 2、简单原理
-  LockSupport方法底层都是调用Unsafe的方法实现。全名sun.misc.Unsafe，该类可以直接操控内存，被JDK广泛用于自己的包中，如java.nio和java.util.concurrent。但是不建议在生产环境中使用这个类。因为这个API十分不安全、不轻便、而且不稳定。
+LockSupport方法底层都是调用Unsafe的方法实现。全名sun.misc.Unsafe，该类可以直接操控内存，被JDK广泛用于自己的包中，如java.nio和java.util.concurrent。但是不建议在生产环境中使用这个类。因为这个API十分不安全、不轻便、而且不稳定。
 
-   LockSupport提供park()和unpark()方法实现阻塞线程和解除线程阻塞，LockSupport和每个使用它的线程都与一个许可(permit)关联。permit是相当于1，0的开关，默认是0，调用一次unpark就加1变成1，调用一次park会消费permit, 也就会将1变成0，同时park立即返回。
+ LockSupport提供park()和unpark()方法实现阻塞线程和解除线程阻塞，LockSupport和每个使用它的线程都与一个许可(permit)关联。permit是相当于1，0的开关，默认是0，调用一次unpark就加1变成1，调用一次park会消费permit, 也就会将1变成0，同时park立即返回。
 
-   再次调用park会变成block（因为permit为0了，会阻塞在这里，直到permit变为1）, 这时调用unpark会把permit置为1。每个线程都有一个相关的permit, permit最多只有一个，重复调用unpark也不会积累。意思就是说unpark 之后，如果permit 已经变为1，之后，再执行unpark ,permit 依旧是1。下边有例子会说到。
+ 再次调用park会变成block（因为permit为0了，会阻塞在这里，直到permit变为1）, 这时调用unpark会把permit置为1。每个线程都有一个相关的permit, permit最多只有一个，重复调用unpark也不会积累。意思就是说unpark 之后，如果permit 已经变为1，之后，再执行unpark ,permit 依旧是1。下边有例子会说到。
 
 3、简单例子
-  以下边的做饭例子，正常来说，做饭 之前，要有锅、有菜才能开始做饭 。具体如下：
+以下边的做饭例子，正常来说，做饭 之前，要有锅、有菜才能开始做饭 。具体如下：
 （1）先假设已经有了锅 ，那只需要买菜就可以做饭。如下，即注释掉了买锅的步骤：
-
+````
       public class LockSupportTest {
           public static void main(String[] args) throws InterruptedException {
             //买锅
@@ -172,7 +165,7 @@ Java官方不推荐使用Unsafe类，因为官方认为，这个类别人很难
               LockSupport.unpark((Thread)threadObj);
           }
       }
-  
+````  
 
 执行后，可出现下面的结果：
 
@@ -180,18 +173,18 @@ Java官方不推荐使用Unsafe类，因为官方认为，这个类别人很难
 菜买回来了...
 开始做饭
 
-   如上所述，可以达到阻塞主线程等到买完菜之后才开始做饭。这即是park()、unpark() 的用法。简单解释一下上述的步骤：
+ 如上所述，可以达到阻塞主线程等到买完菜之后才开始做饭。这即是park()、unpark() 的用法。简单解释一下上述的步骤：
 
 main 方法启动后，主线程 和 买菜线程 同时开始执行。
 因为两者同时进行，当主线程 走到park() 时，发现permit 还为0 ，即会等待在这里。
 当买菜线程执行进去后，走到unpark() 会将permit 变为1 。
 主线程 park() 处发现permit 已经变成1 ，就可以继续往下执行了，同时消费掉permit ，重新变成0 。
-   以上permit 只是park/unpark 执行的一种逻辑开关，执行的步骤大致如此。
+ 以上permit 只是park/unpark 执行的一种逻辑开关，执行的步骤大致如此。
 
 4、注意点及思考
 （1）必须将park()与uppark() 配对使用才更高效。
-  如果上边也把买锅的线程放开，main 方法改为如下：
-
+如果上边也把买锅的线程放开，main 方法改为如下：
+````
        //买锅
       Thread t1 = new Thread(new BuyGuo(Thread.currentThread()));
        t1.start();
@@ -203,9 +196,9 @@ main 方法启动后，主线程 和 买菜线程 同时开始执行。
         LockSupport.park();
         System.out.println("菜买回来了...");
         System.out.println("开始做饭");
-
-  即调用了两次park() 和unpark() ，发现有时候可以，有时候会使线程卡在那里，然后我又换了下顺序，如下：
-
+````
+即调用了两次park() 和unpark() ，发现有时候可以，有时候会使线程卡在那里，然后我又换了下顺序，如下：
+````
        //买锅
       Thread t1 = new Thread(new BuyGuo(Thread.currentThread()));
        t1.start();
@@ -217,13 +210,13 @@ main 方法启动后，主线程 和 买菜线程 同时开始执行。
         LockSupport.park();
         System.out.println("菜买回来了...");
         System.out.println("开始做饭");
+````
+原理没有详细去研究,不过想了想，上边两种其实并无区别，只是执行顺序有了影响，park() 和unpark() 既然是成对配合使用，通过标识permit 来控制，如果像前边那个例子那样，出现阻塞的情况原因，我分析可能是这么个原因：
 
-  原理没有详细去研究,不过想了想，上边两种其实并无区别，只是执行顺序有了影响，park() 和unpark() 既然是成对配合使用，通过标识permit 来控制，如果像前边那个例子那样，出现阻塞的情况原因，我分析可能是这么个原因：
-
-  当买锅的时候，通过unpark()将permit 置为1，但是还没等到外边的main方法执行第一个park() ,买菜的线程又调了一次unpark(),但是这时候permit 还是从1变成了1，等回到主线程调用park()的时候，因为还有两个park()需要执行，也就是需要两个消费permit ,因为permit 只有1个，所以，可能会剩下一个park()卡在那里了。
+当买锅的时候，通过unpark()将permit 置为1，但是还没等到外边的main方法执行第一个park() ,买菜的线程又调了一次unpark(),但是这时候permit 还是从1变成了1，等回到主线程调用park()的时候，因为还有两个park()需要执行，也就是需要两个消费permit ,因为permit 只有1个，所以，可能会剩下一个park()卡在那里了。
 
 （2）使用park(Object blocker) 方法更能明确问题
-  其实park() 有个重载方法park(Object blocker) ,这俩方法效果差不多，但是有blocker的可以传递给开发人员更多的现场信息，可以查看到当前线程的阻塞对象，方便定位问题。所以java6新增加带blocker入参的系列park方法，替代原有的park方法。
+其实park() 有个重载方法park(Object blocker) ,这俩方法效果差不多，但是有blocker的可以传递给开发人员更多的现场信息，可以查看到当前线程的阻塞对象，方便定位问题。所以java6新增加带blocker入参的系列park方法，替代原有的park方法。
 
 5、与wait()/notifyAll() 的比较
 LockSupport 的 park/unpark 方法，虽然与平时Object 中wait/notify 同样达到阻塞线程的效果。但是它们之间还是有区别的。
@@ -235,27 +228,27 @@ wait/notify 需要获取对象的监视器，即synchronized修饰，而park/unp
 
 ## JAVA高并发—LockSupport的学习及简单使用
 1、简单介绍
-   LockSupport是JDK中比较底层的类，用来创建锁和其他同步工具类的基本线程阻塞原语。可以做到与join() 、wait()/notifyAll() 功能一样，使线程自由的阻塞、释放。
-   
+ LockSupport是JDK中比较底层的类，用来创建锁和其他同步工具类的基本线程阻塞原语。可以做到与join() 、wait()/notifyAll() 功能一样，使线程自由的阻塞、释放。
+ 
 
-   Java锁和同步器框架的核心AQS(AbstractQueuedSynchronizer 抽象队列同步器)，就是通过调用LockSupport.park()和LockSupport.unpark()实现线程的阻塞和唤醒的。
+ Java锁和同步器框架的核心AQS(AbstractQueuedSynchronizer 抽象队列同步器)，就是通过调用LockSupport.park()和LockSupport.unpark()实现线程的阻塞和唤醒的。
 
 补充：AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，
 如常用的ReentrantLock/Semaphore/CountDownLatch...。
 
 2、简单原理
-  LockSupport方法底层都是调用Unsafe的方法实现。全名sun.misc.Unsafe，该类可以直接操控内存，被JDK广泛用于自己的包中，如java.nio和java.util.concurrent。但是不建议在生产环境中使用这个类。因为这个API十分不安全、不轻便、而且不稳定。
+LockSupport方法底层都是调用Unsafe的方法实现。全名sun.misc.Unsafe，该类可以直接操控内存，被JDK广泛用于自己的包中，如java.nio和java.util.concurrent。但是不建议在生产环境中使用这个类。因为这个API十分不安全、不轻便、而且不稳定。
 
-   LockSupport提供park()和unpark()方法实现阻塞线程和解除线程阻塞，LockSupport和每个使用它的线程都与一个许可(permit)关联。
+ LockSupport提供park()和unpark()方法实现阻塞线程和解除线程阻塞，LockSupport和每个使用它的线程都与一个许可(permit)关联。
 
 permit是相当于1，0的开关，默认是0，调用一次unpark就加1变成1，调用一次park会消费permit, 也就会将1变成0，同时park立即返回。再次调用park会变成block（因为permit为0了，会阻塞在这里，直到permit变为1）, 这时调用unpark会把permit置为1。
 
-   每个线程都有一个相关的permit, permit最多只有一个，重复调用unpark也不会积累。意思就是说unpark 之后，如果permit 已经变为1，之后，再执行unpark ,permit 依旧是1。下边有例子会说到。
+ 每个线程都有一个相关的permit, permit最多只有一个，重复调用unpark也不会积累。意思就是说unpark 之后，如果permit 已经变为1，之后，再执行unpark ,permit 依旧是1。下边有例子会说到。
 
 3、简单例子
-  以下边的做饭例子，正常来说，做饭 之前，要有锅、有菜才能开始做饭 。具体如下：
+以下边的做饭例子，正常来说，做饭 之前，要有锅、有菜才能开始做饭 。具体如下：
 （1）先假设已经有了锅 ，那只需要买菜就可以做饭。如下，即注释掉了买锅的步骤：
-    
+````    
     public class LockSupportTest {
         public static void main(String[] args) throws InterruptedException {
           //买锅
@@ -297,57 +290,57 @@ permit是相当于1，0的开关，默认是0，调用一次unpark就加1变成1
             LockSupport.unpark((Thread)threadObj);
         }
     }
-    
-  执行后，可出现下面的结果：
+````    
+执行后，可出现下面的结果：
 
 买菜去...
 菜买回来了...
 开始做饭
 
-   如上所述，可以达到阻塞主线程等到买完菜之后才开始做饭。这即是park()、unpark() 的用法。简单解释一下上述的步骤：
+ 如上所述，可以达到阻塞主线程等到买完菜之后才开始做饭。这即是park()、unpark() 的用法。简单解释一下上述的步骤：
 
 main 方法启动后，主线程 和 买菜线程 同时开始执行。
 因为两者同时进行，当主线程 走到park() 时，发现permit 还为0 ，即会等待在这里。
 当买菜线程执行进去后，走到unpark() 会将permit 变为1 。
 主线程 park() 处发现permit 已经变成1 ，就可以继续往下执行了，同时消费掉permit ，重新变成0 。
-   以上permit 只是park/unpark 执行的一种逻辑开关，执行的步骤大致如此。
+ 以上permit 只是park/unpark 执行的一种逻辑开关，执行的步骤大致如此。
 
 4、注意点及思考
 （1）必须将park()与uppark() 配对使用才更高效。
-  如果上边也把买锅的线程放开，main 方法改为如下：
-
-       //买锅
-      Thread t1 = new Thread(new BuyGuo(Thread.currentThread()));
-       t1.start();
-      //买菜
-        Thread t2 = new Thread(new BuyCai(Thread.currentThread()));
-        t2.start();
-        LockSupport.park();
-        System.out.println("锅买回来了...");
-        LockSupport.park();
-        System.out.println("菜买回来了...");
-        System.out.println("开始做饭");
-
-  即调用了两次park() 和unpark() ，发现有时候可以，有时候会使线程卡在那里，然后我又换了下顺序，如下：
-
-       //买锅
-      Thread t1 = new Thread(new BuyGuo(Thread.currentThread()));
-       t1.start();
-          LockSupport.park();
-        System.out.println("锅买回来了...");
-      //买菜
-        Thread t2 = new Thread(new BuyCai(Thread.currentThread()));
-        t2.start();
-        LockSupport.park();
-        System.out.println("菜买回来了...");
-        System.out.println("开始做饭");
-
-  原理没有详细去研究,不过想了想，上边两种其实并无区别，只是执行顺序有了影响，park() 和unpark() 既然是成对配合使用，通过标识permit 来控制，如果像前边那个例子那样，出现阻塞的情况原因，我分析可能是这么个原因：
-
-  当买锅的时候，通过unpark()将permit 置为1，但是还没等到外边的main方法执行第一个park() ,买菜的线程又调了一次unpark(),但是这时候permit 还是从1变成了1，等回到主线程调用park()的时候，因为还有两个park()需要执行，也就是需要两个消费permit ,因为permit 只有1个，所以，可能会剩下一个park()卡在那里了。
+如果上边也把买锅的线程放开，main 方法改为如下：
+````
+   //买锅
+  Thread t1 = new Thread(new BuyGuo(Thread.currentThread()));
+   t1.start();
+  //买菜
+    Thread t2 = new Thread(new BuyCai(Thread.currentThread()));
+    t2.start();
+    LockSupport.park();
+    System.out.println("锅买回来了...");
+    LockSupport.park();
+    System.out.println("菜买回来了...");
+    System.out.println("开始做饭");
+````
+即调用了两次park() 和unpark() ，发现有时候可以，有时候会使线程卡在那里，然后我又换了下顺序，如下：
+````
+   //买锅
+  Thread t1 = new Thread(new BuyGuo(Thread.currentThread()));
+   t1.start();
+      LockSupport.park();
+    System.out.println("锅买回来了...");
+  //买菜
+    Thread t2 = new Thread(new BuyCai(Thread.currentThread()));
+    t2.start();
+    LockSupport.park();
+    System.out.println("菜买回来了...");
+    System.out.println("开始做饭");
+````
+原理没有详细去研究,不过想了想，上边两种其实并无区别，只是执行顺序有了影响，park() 和unpark() 既然是成对配合使用，通过标识permit 来控制，如果像前边那个例子那样，出现阻塞的情况原因，我分析可能是这么个原因：
+
+当买锅的时候，通过unpark()将permit 置为1，但是还没等到外边的main方法执行第一个park() ,买菜的线程又调了一次unpark(),但是这时候permit 还是从1变成了1，等回到主线程调用park()的时候，因为还有两个park()需要执行，也就是需要两个消费permit ,因为permit 只有1个，所以，可能会剩下一个park()卡在那里了。
 
 （2）使用park(Object blocker) 方法更能明确问题
-  其实park() 有个重载方法park(Object blocker) ,这俩方法效果差不多，但是有blocker的可以传递给开发人员更多的现场信息，可以查看到当前线程的阻塞对象，方便定位问题。所以java6新增加带blocker入参的系列park方法，替代原有的park方法。
+其实park() 有个重载方法park(Object blocker) ,这俩方法效果差不多，但是有blocker的可以传递给开发人员更多的现场信息，可以查看到当前线程的阻塞对象，方便定位问题。所以java6新增加带blocker入参的系列park方法，替代原有的park方法。
 
 5、与wait()/notifyAll() 的比较
 LockSupport 的 park/unpark 方法，虽然与平时Object 中wait/notify 同样达到阻塞线程的效果。但是它们之间还是有区别的。
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2277\357\274\232JUC\347\232\204\346\240\270\345\277\203\347\261\273AQS\350\257\246\350\247\243.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232JUC\347\232\204\346\240\270\345\277\203\347\261\273AQS\350\257\246\350\247\243.md"
similarity index 97%
rename from "docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2277\357\274\232JUC\347\232\204\346\240\270\345\277\203\347\261\273AQS\350\257\246\350\247\243.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232JUC\347\232\204\346\240\270\345\277\203\347\261\273AQS\350\257\246\350\247\243.md"
index 5a7da8e..e7388a7 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2277\357\274\232JUC\347\232\204\346\240\270\345\277\203\347\261\273AQS\350\257\246\350\247\243.md"
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232JUC\347\232\204\346\240\270\345\277\203\347\261\273AQS\350\257\246\350\247\243.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [简介](#简介)
   * [AQS 结构](#aqs-结构)
   * [线程抢锁](#线程抢锁)
@@ -7,7 +6,6 @@
   * [总结](#总结)
   * [示例图解析](#示例图解析)
 
-
 本文转自：https://www.javadoop.com/post/AbstractQueuedSynchronizer#toc4
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -26,6 +24,7 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 <!--more -->
+
 ## 简介
 
 在分析 Java 并发包 java.util.concurrent 源码的时候，少不了需要了解 AbstractQueuedSynchronizer（以下简写AQS）这个抽象类，因为它是 Java 并发包的基础工具类，是实现 ReentrantLock、CountDownLatch、Semaphore、FutureTask 等类的基础。
@@ -68,7 +67,7 @@ private transient Thread exclusiveOwnerThread; //继承自AbstractOwnableSynchro
 
 AbstractQueuedSynchronizer 的等待队列示意如下所示，注意了，之后分析过程中所说的 queue，也就是阻塞队列**不包含 head，不包含 head，不包含 head**。
 
-![aqs-0](https://www.javadoop.com/blogimages/AbstractQueuedSynchronizer/aqs-0.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404200412.png)
 
 等待队列中每个线程被包装成一个 Node 实例，数据结构是链表，一起看看源码吧：
 
@@ -424,11 +423,11 @@ static final class FairSync extends Sync {
 }
 ```
 
-说到这里，也就明白了，多看几遍 `final boolean acquireQueued(final Node node, int arg)` 这个方法吧。自己推演下各个分支怎么走，哪种情况下会发生什么，走到哪里。
+说到这里，也就明白了，多看几遍`final boolean acquireQueued(final Node node, int arg)`这个方法吧。自己推演下各个分支怎么走，哪种情况下会发生什么，走到哪里。
 
 ## 解锁操作
 
-最后，就是还需要介绍下唤醒的动作了。我们知道，正常情况下，如果线程没获取到锁，线程会被 `LockSupport.park(this);` 挂起停止，等待被唤醒。
+最后，就是还需要介绍下唤醒的动作了。我们知道，正常情况下，如果线程没获取到锁，线程会被`LockSupport.park(this);`挂起停止，等待被唤醒。
 
 ```
 // 唤醒的代码还是比较简单的，你如果上面加锁的都看懂了，下面都不需要看就知道怎么回事了
@@ -554,11 +553,11 @@ private Node enq(final Node node) {
 
 首先，是线程 2 初始化 head 节点，此时 head==tail, waitStatus==0
 
-![aqs-1](https://www.javadoop.com/blogimages/AbstractQueuedSynchronizer/aqs-1.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404200724.png)
 
 然后线程 2 入队：
 
-![aqs-2](https://www.javadoop.com/blogimages/AbstractQueuedSynchronizer/aqs-2.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404200745.png)
 
 同时我们也要看此时节点的 waitStatus，我们知道 head 节点是线程 2 初始化的，此时的 waitStatus 没有设置， java 默认会设置为 0，但是到 shouldParkAfterFailedAcquire 这个方法的时候，线程 2 会把前驱节点，也就是 head 的waitStatus设置为 -1。
 
@@ -566,6 +565,5 @@ private Node enq(final Node node) {
 
 如果线程 3 此时再进来，直接插到线程 2 的后面就可以了，此时线程 3 的 waitStatus 是 0，到 shouldParkAfterFailedAcquire 方法的时候把前驱节点线程 2 的 waitStatus 设置为 -1。
 
-![aqs-3](https://www.javadoop.com/blogimages/AbstractQueuedSynchronizer/aqs-3.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404200816.png)
 这里可以简单说下 waitStatus 中 SIGNAL(-1) 状态的意思，Doug Lea 注释的是：代表后继节点需要被唤醒。也就是说这个 waitStatus 其实代表的不是自己的状态，而是后继节点的状态，我们知道，每个 node 在入队的时候，都会把前驱节点的状态改为 SIGNAL，然后阻塞，等待被前驱唤醒。这里涉及的是两个问题：有线程取消了排队、唤醒操作。其实本质是一样的，读者也可以顺着 “waitStatus代表后继节点的状态” 这种思路去看一遍源码。
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22713\357\274\232Java \344\270\255\347\232\204 HashMap \345\222\214 ConcurrentHashMap \345\205\250\350\247\243\346\236\220.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232Java\344\270\255\347\232\204HashMap\345\222\214ConcurrentHashMap\345\205\250\350\247\243\346\236\220.md"
similarity index 99%
rename from "docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22713\357\274\232Java \344\270\255\347\232\204 HashMap \345\222\214 ConcurrentHashMap \345\205\250\350\247\243\346\236\220.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232Java\344\270\255\347\232\204HashMap\345\222\214ConcurrentHashMap\345\205\250\350\247\243\346\236\220.md"
index efa273f..dff6cc3 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22713\357\274\232Java \344\270\255\347\232\204 HashMap \345\222\214 ConcurrentHashMap \345\205\250\350\247\243\346\236\220.md"	
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232Java\344\270\255\347\232\204HashMap\345\222\214ConcurrentHashMap\345\205\250\350\247\243\346\236\220.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [前言](#前言)
   * [Java7 HashMap](#java7-hashmap)
     * [put 过程分析](#put-过程分析)
@@ -346,7 +345,7 @@ public V put(K key, V value) {
 
 第一层皮很简单，根据 hash 值很快就能找到相应的 Segment，之后就是 Segment 内部的 put 操作了。
 
-Segment 内部是由 **数组+链表** 组成的。
+Segment 内部是由**数组+链表**组成的。
 
 ```
 final V put(K key, int hash, V value, boolean onlyIfAbsent) {
@@ -641,11 +640,11 @@ public V get(Object key) {
 
 ## Java8 HashMap
 
-Java8 对 HashMap 进行了一些修改，最大的不同就是利用了红黑树，所以其由 **数组+链表+红黑树** 组成。
+Java8 对 HashMap 进行了一些修改，最大的不同就是利用了红黑树，所以其由**数组+链表+红黑树**组成。
 
-根据 Java7 HashMap 的介绍，我们知道，查找的时候，根据 hash 值我们能够快速定位到数组的具体下标，但是之后的话，需要顺着链表一个个比较下去才能找到我们需要的，时间复杂度取决于链表的长度，为 **O(n)**。
+根据 Java7 HashMap 的介绍，我们知道，查找的时候，根据 hash 值我们能够快速定位到数组的具体下标，但是之后的话，需要顺着链表一个个比较下去才能找到我们需要的，时间复杂度取决于链表的长度，为**O(n)**。
 
-为了降低这部分的开销，在 Java8 中，当链表中的元素达到了 8 个时，会将链表转换为红黑树，在这些位置进行查找的时候可以降低时间复杂度为 **O(logN)**。
+为了降低这部分的开销，在 Java8 中，当链表中的元素达到了 8 个时，会将链表转换为红黑树，在这些位置进行查找的时候可以降低时间复杂度为**O(logN)**。
 
 来一张图简单示意一下吧：
 
@@ -655,7 +654,7 @@ Java8 对 HashMap 进行了一些修改，最大的不同就是利用了红黑
 
 下面，我们还是用代码来介绍吧，个人感觉，Java8 的源码可读性要差一些，不过精简一些。
 
-Java7 中使用 Entry 来代表每个 HashMap 中的数据节点，Java8 中使用 **Node**，基本没有区别，都是 key，value，hash 和 next 这四个属性，不过，Node 只能用于链表的情况，红黑树的情况需要使用 **TreeNode**。
+Java7 中使用 Entry 来代表每个 HashMap 中的数据节点，Java8 中使用**Node**，基本没有区别，都是 key，value，hash 和 next 这四个属性，不过，Node 只能用于链表的情况，红黑树的情况需要使用**TreeNode**。
 
 我们根据数组元素中，第一个节点数据类型是 Node 还是 TreeNode 来判断该位置下是链表还是红黑树的。
 
@@ -1146,7 +1145,7 @@ private final void tryPresize(int size) {
 
 这个方法的核心在于 sizeCtl 值的操作，首先将其设置为一个负数，然后执行 transfer(tab, null)，再下一个循环将 sizeCtl 加 1，并执行 transfer(tab, nt)，之后可能是继续 sizeCtl 加 1，并执行 transfer(tab, nt)。
 
-所以，可能的操作就是执行 **1 次 transfer(tab, null) + 多次 transfer(tab, nt)**，这里怎么结束循环的需要看完 transfer 源码才清楚。
+所以，可能的操作就是执行**1 次 transfer(tab, null) + 多次 transfer(tab, nt)**，这里怎么结束循环的需要看完 transfer 源码才清楚。
 
 #### 数据迁移：transfer
 
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2274\357\274\232Java\344\270\255\347\232\204\351\224\201 Lock\345\222\214synchronized.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232Java\344\270\255\347\232\204\351\224\201Lock\345\222\214synchronized.md"
similarity index 84%
rename from "docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2274\357\274\232Java\344\270\255\347\232\204\351\224\201 Lock\345\222\214synchronized.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232Java\344\270\255\347\232\204\351\224\201Lock\345\222\214synchronized.md"
index d3d1b76..979a35d 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2274\357\274\232Java\344\270\255\347\232\204\351\224\201 Lock\345\222\214synchronized.md"	
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232Java\344\270\255\347\232\204\351\224\201Lock\345\222\214synchronized.md"
@@ -1,10 +1,8 @@
-# Table of Contents
-
+# 目录
   * [Java中的锁机制及Lock类](#java中的锁机制及lock类)
     * [锁的释放-获取建立的happens before 关系](#锁的释放-获取建立的happens-before-关系)
     * [锁释放和获取的内存语义](#锁释放和获取的内存语义)
     * [锁内存语义的实现](#锁内存语义的实现)
-            * [LOCK_IF_MP(mp) __asm cmp mp, 0  \](#lock_if_mpmp-__asm-cmp-mp-0--)
   * [concurrent包的实现](#concurrent包的实现)
   * [synchronized实现原理](#synchronized实现原理)
     * [****1、实现原理****](#1、实现原理)
@@ -20,7 +18,6 @@
   * [**11、重量级锁**](#11、重量级锁)
   * [参考资料](#参考资料)
 
-
 **本文转载自并发编程网，侵删**
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -47,6 +44,7 @@
 锁是java并发编程中最重要的同步机制。锁除了让临界区互斥执行外，还可以让释放锁的线程向获取同一个锁的线程发送消息。
 
 下面是锁释放-获取的示例代码：
+````
     class MonitorExample {
         int a = 0;
      
@@ -59,6 +57,7 @@
             ……
         }                                    //6
     }
+````
 根据程序次序规则，1 happens before 2, 2 happens before 3; 4 happens before 5, 5 happens before 6。假设线程A执行writer()方法，随后线程B执行reader()方法。根据happens before规则，这个过程包含的happens before 关系可以分为两类：
 
 1.  根据监视器锁规则，3 happens before 4。
@@ -95,7 +94,7 @@
 本文将借助ReentrantLock的源代码，来分析锁内存语义的具体实现机制。
 
 请看下面的示例代码：
-
+````
     class ReentrantLockExample {
     int a = 0;
     ReentrantLock lock = new ReentrantLock();
@@ -119,7 +118,7 @@
         }
     }
     }
-    
+````    
 在ReentrantLock中，调用lock()方法获取锁；调用unlock()方法释放锁。
 
 ReentrantLock的实现依赖于java同步器框架AbstractQueuedSynchronizer（本文简称之为AQS）。AQS使用一个整型的volatile变量（命名为state）来维护同步状态，马上我们会看到，这个volatile变量是ReentrantLock内存语义实现的关键。 下面是ReentrantLock的类图（仅画出与本文相关的部分）：
@@ -137,27 +136,27 @@ ReentrantLock分为公平锁和非公平锁，我们首先分析公平锁。
 
 在第4步真正开始加锁，下面是该方法的源代码：
 
-
-    protected final boolean tryAcquire(int acquires) {
-        final Thread current = Thread.currentThread();
-        int c = getState();   //获取锁的开始，首先读volatile变量state
-        if (c == 0) {
-            if (isFirst(current) &&
-                compareAndSetState(0, acquires)) {
-                setExclusiveOwnerThread(current);
-                return true;
-            }
-        }
-        else if (current == getExclusiveOwnerThread()) {
-            int nextc = c + acquires;
-            if (nextc < 0)  
-                throw new Error("Maximum lock count exceeded");
-            setState(nextc);
+````
+protected final boolean tryAcquire(int acquires) {
+    final Thread current = Thread.currentThread();
+    int c = getState();   //获取锁的开始，首先读volatile变量state
+    if (c == 0) {
+        if (isFirst(current) &&
+            compareAndSetState(0, acquires)) {
+            setExclusiveOwnerThread(current);
             return true;
         }
-        return false;
     }
-
+    else if (current == getExclusiveOwnerThread()) {
+        int nextc = c + acquires;
+        if (nextc < 0)  
+            throw new Error("Maximum lock count exceeded");
+        setState(nextc);
+        return true;
+    }
+    return false;
+}
+````
 
 从上面源代码中我们可以看出，加锁方法首先读volatile变量state。
 
@@ -169,20 +168,20 @@ ReentrantLock分为公平锁和非公平锁，我们首先分析公平锁。
 
 在第3步真正开始释放锁，下面是该方法的源代码：
 
-
-    protected final boolean tryRelease(int releases) {
-        int c = getState() - releases;
-        if (Thread.currentThread() != getExclusiveOwnerThread())
-            throw new IllegalMonitorStateException();
-        boolean free = false;
-        if (c == 0) {
-            free = true;
-            setExclusiveOwnerThread(null);
-        }
-        setState(c);           //释放锁的最后，写volatile变量state
-        return free;
+````
+protected final boolean tryRelease(int releases) {
+    int c = getState() - releases;
+    if (Thread.currentThread() != getExclusiveOwnerThread())
+        throw new IllegalMonitorStateException();
+    boolean free = false;
+    if (c == 0) {
+        free = true;
+        setExclusiveOwnerThread(null);
     }
-
+    setState(c);           //释放锁的最后，写volatile变量state
+    return free;
+}
+````
 
 从上面的源代码我们可以看出，在释放锁的最后写volatile变量state。
 
@@ -199,9 +198,11 @@ ReentrantLock分为公平锁和非公平锁，我们首先分析公平锁。
 3.  AbstractQueuedSynchronizer : compareAndSetState(int expect, int update)
 
 在第3步真正开始加锁，下面是该方法的源代码：
-
-<pre name="code">protected final boolean compareAndSetState(int expect, int update) {return unsafe.compareAndSwapInt(this, stateOffset, expect, update);}</pre>
-
+````
+protected final boolean compareAndSetState(int expect, int update){
+    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
+}
+````
 该方法以原子操作的方式更新state变量，本文把java的compareAndSet()方法调用简称为CAS。JDK文档对该方法的说明如下：如果当前状态值等于预期值，则以原子方式将同步状态设置为给定的更新值。此操作具有 volatile 读和写的内存语义。
 
 这里我们分别从编译器和处理器的角度来分析,CAS如何同时具有volatile读和volatile写的内存语义。
@@ -211,13 +212,13 @@ ReentrantLock分为公平锁和非公平锁，我们首先分析公平锁。
 下面我们来分析在常见的intel x86处理器中，CAS是如何同时具有volatile读和volatile写的内存语义的。
 
 下面是sun.misc.Unsafe类的compareAndSwapInt()方法的源代码：
-
+````
     protected final boolean compareAndSetState(int expect, int update) {
         return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
     }
-
+````
 可以看到这是个本地方法调用。这个本地方法在openjdk中依次调用的c++代码为：unsafe.cpp，atomic.cpp和atomicwindowsx86.inline.hpp。这个本地方法的最终实现在openjdk的如下位置：openjdk-7-fcs-src-b147-27jun2011\openjdk\hotspot\src\oscpu\windowsx86\vm\ atomicwindowsx86.inline.hpp（对应于windows操作系统，X86处理器）。下面是对应于intel x86处理器的源代码的片段：
-
+````
     // Adding a lock prefix to an instruction on MP machine
     // VC++ doesn't like the lock prefix to be on a single line
     // so we can't insert a label after the lock prefix.
@@ -238,6 +239,7 @@ ReentrantLock分为公平锁和非公平锁，我们首先分析公平锁。
         cmpxchg dword ptr [edx], ecx
       }
     }
+````
 
 如上面源代码所示，程序会根据当前处理器的类型来决定是否为cmpxchg指令添加lock前缀。如果程序是在多处理器上运行，就为cmpxchg指令加上lock前缀（lock cmpxchg）。反之，如果程序是在单处理器上运行，就省略lock前缀（单处理器自身会维护单处理器内的顺序一致性，不需要lock前缀提供的内存屏障效果）。
 
@@ -292,15 +294,15 @@ AQS，非阻塞数据结构和原子变量类（java.util.concurrent.atomic包
 转自：https://blog.csdn.net/chenssy/article/details/54883355
 
 
-记得刚刚开始学习Java的时候，一遇到多线程情况就是synchronized。对于当时的我们来说，synchronized是如此的神奇且强大。我们赋予它一个名字“同步”，也成为我们解决多线程情况的良药，百试不爽。但是，随着学习的深入，我们知道synchronized是一个重量级锁，相对于Lock，它会显得那么笨重，以至于我们认为它不是那么的高效，并慢慢抛弃它。 
+记得刚刚开始学习Java的时候，一遇到多线程情况就是synchronized。对于当时的我们来说，synchronized是如此的神奇且强大。我们赋予它一个名字“同步”，也成为我们解决多线程情况的良药，百试不爽。但是，随着学习的深入，我们知道synchronized是一个重量级锁，相对于Lock，它会显得那么笨重，以至于我们认为它不是那么的高效，并慢慢抛弃它。
 
-　　诚然，随着Javs SE 1.6对synchronized进行各种优化后，synchronized不会显得那么重。
+诚然，随着Javs SE 1.6对synchronized进行各种优化后，synchronized不会显得那么重。
 
- 　　下面跟随LZ一起来探索**synchronized的实现机制、Java是如何对它进行了优化、锁优化机制、锁的存储结构和升级过程。**
+下面跟随LZ一起来探索**synchronized的实现机制、Java是如何对它进行了优化、锁优化机制、锁的存储结构和升级过程。**
 
 ### ****1、实现原理****
 
- 　　synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。
+synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。
 
 Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：
 
@@ -310,26 +312,24 @@ Java中每一个对象都可以作为锁，这是synchronized实现同步的基
 
 3.  **同步方法块，锁是括号里面的对象。**
 
-　　当一个线程访问同步代码块时，它首先是需要得到锁才能执行同步代码，**当退出或者抛出异常时必须要释放锁，那么它是如何来实现这个机制的呢？**
-
- 我们先看一段简单的代码：
+当一个线程访问同步代码块时，它首先是需要得到锁才能执行同步代码，**当退出或者抛出异常时必须要释放锁，那么它是如何来实现这个机制的呢？**
 
-
-
-<pre>public class SynchronizedTest{ public synchronized void test1(){
+我们先看一段简单的代码：
+````
+public class SynchronizedTest{ public synchronized void test1(){
 
 　　} public void test2(){
 　　　　synchronized(this){
 
        }
     }
-}</pre>
-
+}
 
+````
 
 **利用Javap工具查看生成的class文件信息来分析Synchronize的实现：**
 
-![](https://images2018.cnblogs.com/blog/1169376/201807/1169376-20180726111452385-496687429.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404192352.png)
 
 　　从上面可以看出，同步代码块是使用monitorenter和monitorexit指令实现的，同步方法（在这看不出来需要看JVM底层实现）依靠的是方法修饰符上的ACCSYNCHRONIZED实现。
 
@@ -345,7 +345,7 @@ Java中每一个对象都可以作为锁，这是synchronized实现同步的基
 
 下面我们来继续分析，但是在深入之前我们需要了解两个重要的概念：**Java对象头、Monitor。**
 
- **Java对象头、monitor：Java对象头和monitor是实现synchronized的基础！下面就这两个概念来做详细介绍。**
+**Java对象头、monitor：Java对象头和monitor是实现synchronized的基础！下面就这两个概念来做详细介绍。**
 
 ### **2、Java对象头**
 
@@ -355,15 +355,15 @@ Hotspot虚拟机的对象头主要包括两部分数据：**Mark Word（标记
 
 所以下面将重点阐述。
 
-*   **Mark Word**
+**Mark Word**
 
     Mark Word用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程 ID、偏向时间戳等等。Java对象头一般占有两个机器码（在32位虚拟机中，1个机器码等于4字节，也就是32bit），但是如果对象是数组类型，则需要三个机器码，因为JVM虚拟机可以通过Java对象的元数据信息确定Java对象的大小，但是无法从数组的元数据来确认数组的大小，所以用一块来记录数组长度。
 
-　　下图是Java对象头的存储结构（32位虚拟机）：
+下图是Java对象头的存储结构（32位虚拟机）：
 
-　　![](https://images2018.cnblogs.com/blog/1169376/201807/1169376-20180726111729662-408733474.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404192459.png)
 
-　　对象头信息是与对象自身定义的数据无关的额外存储成本，但是考虑到虚拟机的空间效率，Mark Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据，它会根据对象的状态复用自己的存储空间，也就是说，Mark Word会随着程序的运行发生变化，变化状态如下（32位虚拟机）：
+对象头信息是与对象自身定义的数据无关的额外存储成本，但是考虑到虚拟机的空间效率，Mark Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据，它会根据对象的状态复用自己的存储空间，也就是说，Mark Word会随着程序的运行发生变化，变化状态如下（32位虚拟机）：
 
 ![](https://images2018.cnblogs.com/blog/1169376/201807/1169376-20180726111757632-1279497345.png)
 
@@ -373,25 +373,25 @@ Hotspot虚拟机的对象头主要包括两部分数据：**Mark Word（标记
 
 什么是Monitor？
 
-　　我们可以把它理解为一个同步工具，也可以描述为一种同步机制，它通常被描述为一个对象。 
+我们可以把它理解为一个同步工具，也可以描述为一种同步机制，它通常被描述为一个对象。
 
-　　与一切皆对象一样，所有的Java对象是天生的Monitor，**每一个Java对象都有成为Monitor的潜质**，因为在Java的设计中 ，每一个Java对象自打娘胎里出来**就带了一把看不见的锁，它叫做内部锁或者Monitor锁**。 
+与一切皆对象一样，所有的Java对象是天生的Monitor，**每一个Java对象都有成为Monitor的潜质**，因为在Java的设计中 ，每一个Java对象自打娘胎里出来**就带了一把看不见的锁，它叫做内部锁或者Monitor锁**。
 
-　　Monitor 是线程私有的数据结构，每一个线程都有一个可用monitor record列表，同时还有一个全局的可用列表。每一个被锁住的对象都会和一个monitor关联（对象头的MarkWord中的LockWord指向monitor的起始地址），**同时monitor中有一个Owner字段存放拥有该锁的线程的唯一标识，表示该锁被这个线程占用**。　　
+Monitor 是线程私有的数据结构，每一个线程都有一个可用monitor record列表，同时还有一个全局的可用列表。每一个被锁住的对象都会和一个monitor关联（对象头的MarkWord中的LockWord指向monitor的起始地址），**同时monitor中有一个Owner字段存放拥有该锁的线程的唯一标识，表示该锁被这个线程占用**。　　
 
 其结构如下：
 
- ![](https://images2018.cnblogs.com/blog/1169376/201807/1169376-20180726111912718-1995783204.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404192639.png)
 
-*   **Owner：**初始时为NULL表示当前没有任何线程拥有该monitor record，当线程成功拥有该锁后保存线程唯一标识，当锁被释放时又设置为NULL。
+*   Owner：初始时为NULL表示当前没有任何线程拥有该monitor record，当线程成功拥有该锁后保存线程唯一标识，当锁被释放时又设置为NULL。
 
-*   **EntryQ：**关联一个系统互斥锁（semaphore），阻塞所有试图锁住monitor record失败的线程。
+*   EntryQ：关联一个系统互斥锁（semaphore），阻塞所有试图锁住monitor record失败的线程。
 
-*   **RcThis：**表示blocked或waiting在该monitor record上的所有线程的个数。
+*   RcThis：表示blocked或waiting在该monitor record上的所有线程的个数。
 
-*   **Nest：**用来实现重入锁的计数。HashCode:保存从对象头拷贝过来的HashCode值（可能还包含GC age）。
+*   Nest：用来实现重入锁的计数。HashCode:保存从对象头拷贝过来的HashCode值（可能还包含GC age）。
 
-*   **Candidate：用来避免不必要的阻塞或等待线程唤醒**，因为每一次只有一个线程能够成功拥有锁，如果每次前一个释放锁的线程唤醒所有正在阻塞或等待的线程，会引起不必要的上下文切换（从阻塞到就绪然后因为竞争锁失败又被阻塞）从而导致性能严重下降。
+*   Candidate：用来避免不必要的阻塞或等待线程唤醒**，因为每一次只有一个线程能够成功拥有锁，如果每次前一个释放锁的线程唤醒所有正在阻塞或等待的线程，会引起不必要的上下文切换（从阻塞到就绪然后因为竞争锁失败又被阻塞）从而导致性能严重下降。
 
     Candidate只有两种可能的值0表示没有需要唤醒的线程1表示要唤醒一个继任线程来竞争锁。
 
@@ -399,7 +399,7 @@ Hotspot虚拟机的对象头主要包括两部分数据：**Mark Word（标记
 
 ### **4、锁优化**
 
-　　JDK1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。 
+　　JDK1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。
 
 **　　锁主要存在四中状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态。**他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。
 
@@ -407,7 +407,7 @@ Hotspot虚拟机的对象头主要包括两部分数据：**Mark Word（标记
 
 　　线程的阻塞和唤醒需要CPU从用户态转为核心态，频繁的阻塞和唤醒对CPU来说是一件负担很重的工作，势必会给系统的并发性能带来很大的压力。同时我们发现在许多应用上面，**对象锁的锁状态只会持续很短一段时间**，**为了这一段很短的时间频繁地阻塞和唤醒线程**是非常不值得的。
 
-所以引入自旋锁。 
+所以引入自旋锁。
 
 何谓自旋锁？
 
@@ -429,11 +429,11 @@ Hotspot虚拟机的对象头主要包括两部分数据：**Mark Word（标记
 
 　　它怎么做呢？
 
-　　线程如果自旋成功了，那么下次自旋的次数会更加多，因为虚拟机认为既然上次成功了，那么此次自旋也很有可能会再次成功，那么它就会允许自旋等待持续的次数更多。反之，如果对于某个锁，很少有自旋能够成功的，那么在以后要或者这个锁的时候自旋的次数会减少甚至省略掉自旋过程，以免浪费处理器资源。**有了自适应自旋锁，随着程序运行和性能监控信息的不断完善，虚拟机对程序锁的状况预测会越来越准确，虚拟机会变得越来越聪明。** 
+　　线程如果自旋成功了，那么下次自旋的次数会更加多，因为虚拟机认为既然上次成功了，那么此次自旋也很有可能会再次成功，那么它就会允许自旋等待持续的次数更多。反之，如果对于某个锁，很少有自旋能够成功的，那么在以后要或者这个锁的时候自旋的次数会减少甚至省略掉自旋过程，以免浪费处理器资源。**有了自适应自旋锁，随着程序运行和性能监控信息的不断完善，虚拟机对程序锁的状况预测会越来越准确，虚拟机会变得越来越聪明。**
 
 ### **7、锁消除**
 
-　　为了保证数据的完整性，我们在进行操作时需要对这部分操作进行同步控制，但是在有些情况下，JVM检测到不可能存在共享数据竞争，这是JVM会对这些同步锁进行锁消除。锁消除的依据是逃逸分析的数据支持。 
+　　为了保证数据的完整性，我们在进行操作时需要对这部分操作进行同步控制，但是在有些情况下，JVM检测到不可能存在共享数据竞争，这是JVM会对这些同步锁进行锁消除。锁消除的依据是逃逸分析的数据支持。
 
 **　　如果不存在竞争，为什么还需要加锁呢？**
 
@@ -443,23 +443,23 @@ Hotspot虚拟机的对象头主要包括两部分数据：**Mark Word（标记
 
 **　　比如StringBuffer的append()方法，Vector的add()方法：**
 
-
-<pre>public void vectorTest(){
+````
+public void vectorTest(){
     Vector<String> vector = new Vector<String>(); for(int i = 0 ; i < 10 ; i++){
         vector.add(i + "");
      } 
 
     System.out.println(vector);
-}</pre>
-
+}
+````
 
 在运行这段代码时，JVM可以明显检测到变量vector没有逃逸出方法vectorTest()之外，所以JVM可以大胆地将vector内部的加锁操作消除。
 
 ### **8、锁粗化**
 
-　　我们知道在使用同步锁的时候，需要让同步块的作用范围尽可能小，仅在共享数据的实际作用域中才进行同步。这样做的目的是为了使需要同步的操作数量尽可能缩小，如果存在锁竞争，那么等待锁的线程也能尽快拿到锁。 
+　　我们知道在使用同步锁的时候，需要让同步块的作用范围尽可能小，仅在共享数据的实际作用域中才进行同步。这样做的目的是为了使需要同步的操作数量尽可能缩小，如果存在锁竞争，那么等待锁的线程也能尽快拿到锁。
 
-　　在大多数的情况下，上述观点是正确的，LZ也一直坚持着这个观点。但是如果一系列的连续加锁解锁操作，可能会导致不必要的性能损耗，所以引入锁粗化的概念。 
+　　在大多数的情况下，上述观点是正确的，LZ也一直坚持着这个观点。但是如果一系列的连续加锁解锁操作，可能会导致不必要的性能损耗，所以引入锁粗化的概念。
 
 　　**那什么是锁粗化？**
 
@@ -477,7 +477,7 @@ Hotspot虚拟机的对象头主要包括两部分数据：**Mark Word（标记
 
 2.  JVM利用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指正，如果成功表示竞争到锁，则将锁标志位变成00（表示此对象处于轻量级锁状态），执行同步操作；如果失败则执行步骤（3）；
 
-3.  判断当前对象的Mark Word是否指向当前线程的栈帧，如果是则表示当前线程已经持有当前对象的锁，则直接执行同步代码块；否则只能说明该锁对象已经被其他线程抢占了，这时轻量级锁需要膨胀为重量级锁，锁标志位变成10，后面等待的线程将会进入阻塞状态； 
+3.  判断当前对象的Mark Word是否指向当前线程的栈帧，如果是则表示当前线程已经持有当前对象的锁，则直接执行同步代码块；否则只能说明该锁对象已经被其他线程抢占了，这时轻量级锁需要膨胀为重量级锁，锁标志位变成10，后面等待的线程将会进入阻塞状态；
 
 **释放锁轻量级锁的释放也是通过CAS操作来进行的，主要步骤如下：**
 
@@ -499,7 +499,7 @@ https://blog.csdn.net/qq_35357656/article/details/78657373
 
 下图是轻量级锁的获取和释放过程：
 
-![](https://images2018.cnblogs.com/blog/1169376/201807/1169376-20180726104054182-532040033.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404192732.png)
 
 ### **10、偏向锁**
 
@@ -515,7 +515,7 @@ https://blog.csdn.net/qq_35357656/article/details/78657373
 
 4.  通过CAS竞争锁失败，证明当前存在多线程竞争情况，当到达全局安全点，获得偏向锁的线程被挂起，偏向锁升级为轻量级锁，然后被阻塞在安全点的线程继续往下执行同步代码块；
 
-5.  执行同步代码块。 
+5.  执行同步代码块。
 
 释放锁偏向锁的释放采用了一种只有竞争才会释放锁的机制，线程是不会主动去释放偏向锁，需要等待其他线程来竞争。偏向锁的撤销需要等待全局安全点（这个时间点是上没有正在执行的代码）。
 
@@ -525,9 +525,9 @@ https://blog.csdn.net/qq_35357656/article/details/78657373
 
 2.  **撤销偏向苏，恢复到无锁状态（01）或者轻量级锁的状态。**
 
- 下图是偏向锁的获取和释放流程：
+下图是偏向锁的获取和释放流程：
 
-![](https://images2018.cnblogs.com/blog/1169376/201807/1169376-20180726110935396-89753255.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404192911.png)
 
 ## **11、重量级锁**
 
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2276\357\274\232Java\345\206\205\345\255\230\346\250\241\345\236\213JMM\346\200\273\347\273\223.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232Java\345\206\205\345\255\230\346\250\241\345\236\213JMM\346\200\273\347\273\223.md"
similarity index 93%
rename from "docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2276\357\274\232Java\345\206\205\345\255\230\346\250\241\345\236\213JMM\346\200\273\347\273\223.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232Java\345\206\205\345\255\230\346\250\241\345\236\213JMM\346\200\273\347\273\223.md"
index c708dfc..cf8281c 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2276\357\274\232Java\345\206\205\345\255\230\346\250\241\345\236\213JMM\346\200\273\347\273\223.md"
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232Java\345\206\205\345\255\230\346\250\241\345\236\213JMM\346\200\273\347\273\223.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [简介](#简介)
     * [一、Java内存区域（JVM内存区域）](#一、java内存区域（jvm内存区域）)
     * [二、Java内存模型](#二、java内存模型)
@@ -18,7 +17,6 @@
   * [五、JMM是如何处理并发过程中的三大特性](#五、jmm是如何处理并发过程中的三大特性)
   * [参考链接：](#参考链接：)
 
-
 本文转自 https://www.cnblogs.com/kukri/p/9109639.html
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -52,7 +50,7 @@
 
 ### 一、Java内存区域（JVM内存区域）
 
-![](https://images2018.cnblogs.com/blog/1332556/201805/1332556-20180530105521301-2013126296.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404195526.png)
 
 Java虚拟机在运行程序时会把其自动管理的内存划分为以上几个区域，每个区域都有的用途以及创建销毁的时机，其中蓝色部分代表的是所有线程共享的数据区域，而绿色部分代表的是每个线程的私有数据区域。
 
@@ -72,7 +70,7 @@ Java虚拟机在运行程序时会把其自动管理的内存划分为以上几
 
     属于线程私有的数据区域，与线程同时创建，总数与线程关联，代表Java方法执行的内存模型。栈中只保存基础数据类型和自定义对象的引用(不是对象)，对象都存放在堆区中。每个方法执行时都会创建一个栈桢来存储方法的的变量表、操作数栈、动态链接方法、返回值、返回地址等信息。每个方法从调用直结束就对于一个栈桢在虚拟机栈中的入栈和出栈过程，如下（图有误，应该为栈桢）：
 
-    ![](https://img-blog.csdn.net/20170608151435751?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvamF2YXplamlhbg==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404195609.png)
 
 *   本地方法栈(Native Method Stacks)：
 
@@ -82,14 +80,13 @@ Java虚拟机在运行程序时会把其自动管理的内存划分为以上几
 
 Java内存模型(即Java Memory Model，简称JMM)本身是一种抽象的概念，并不真实存在。Java线程之间的通信由JMM控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系。
 
-　　
-　　
+　
 由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存(有些地方称为栈空间)，用于存储线程私有的数据，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作(读取赋值等)必须在工作内存中进行。
 
 　　
 首先要将变量从主内存拷贝的自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，工作内存中存储着主内存中的变量副本拷贝，前面说过，工作内存是每个线程的私有数据区域，因此不同的线程间无法访问对方的工作内存，线程间的通信(传值)必须通过主内存来完成，其简要访问过程如下图
 
-![](https://images2018.cnblogs.com/blog/1332556/201805/1332556-20180530110846270-1135031810.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404195704.png)
 
 图3
 
@@ -108,9 +105,6 @@ Java内存模型(即Java Memory Model，简称JMM)本身是一种抽象的概念
     注意由于工作内存是每个线程的私有数据，线程间无法相互访问工作内存，因此存储在工作内存的数据不存在线程安全问题。注意，工作内存是JMM的一个抽象概念，并不真实存在。
 
 弄清楚主内存和工作内存后，接了解一下主内存与工作内存的数据存储类型以及操作方式，根据虚拟机规范，对于一个实例对象中的成员方法而言，如果方法中包含本地变量是基本数据类型（boolean,byte,short,char,int,long,float,double），将直接存储在工作内存的帧栈结构中，但倘若本地变量是引用类型，那么该变量的引用会存储在功能内存的帧栈中，而对象实例将存储在主内存(共享数据区域，堆)中。
-
-　
-　　
 　　
 但对于实例对象的成员变量，不管它是基本数据类型或者包装类型(Integer、Double等)还是引用类型，都会被存储到堆区。至于static变量以及类本身相关信息将会存储在主内存中。需要注意的是，在主内存中的实例对象可以被多线程共享，倘若两个线程同时调用了同一个对象的同一个方法，那么两条线程会将要操作的数据拷贝一份到自己的工作内存中，执行完成操作后才刷新到主内存，简单示意图如下所示：
 
@@ -147,20 +141,20 @@ JMM也主要是通过控制主内存与每个线程的工作内存之间的交
 
 但以上两点相互矛盾，所以JSR-133专家组在设计JMM时的核心膜表就是找到一个好的平衡点：一方面，为程序员提高足够强的内存可见性保证；另一方面，对编译器和处理器的限制尽可能地放松。
 
-另外还要一个特别有意思的事情就是关于重排序问题，更简单的说，重排序可以分为两类：1)会改变程序执行结果的重排序。 2) 不会改变程序执行结果的重排序。 
+另外还要一个特别有意思的事情就是关于重排序问题，更简单的说，重排序可以分为两类：1)会改变程序执行结果的重排序。 2)不会改变程序执行结果的重排序。
 
 JMM对这两种不同性质的重排序，采取了不同的策略，如下：
 
-*   对于会改变程序执行结果的重排序，JMM要求编译器和处理器必须禁止这种重排序。 
-*   对于不会改变程序执行结果的重排序，JMM对编译器和处理器不做要求（JMM允许这种 重排序） 
+*   对于会改变程序执行结果的重排序，JMM要求编译器和处理器必须禁止这种重排序。
+*   对于不会改变程序执行结果的重排序，JMM对编译器和处理器不做要求（JMM允许这种 重排序）
 
-JMM的设计图为： 
+JMM的设计图为：
 
-![](https://images2018.cnblogs.com/blog/1332556/201806/1332556-20180611104204152-1569228705.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404195805.png)
 
 JMM设计示意图 从图可以看出：
 
-*   JMM向程序员提供的happens-before规则能满足程序员的需求。JMM的happens-before规则不但简单易懂，而且也向程序员提供了足够强的内存可见性保证（有些内存可见性保证其实并不一定真实存在，比如上面的A happens-before B）。 
+*   JMM向程序员提供的happens-before规则能满足程序员的需求。JMM的happens-before规则不但简单易懂，而且也向程序员提供了足够强的内存可见性保证（有些内存可见性保证其实并不一定真实存在，比如上面的A happens-before B）。
 *   JMM对编译器和处理器的束缚已经尽可能少。从上面的分析可以看出，JMM其实是在遵循一个基本原则：只要不改变程序的执行结果（指的是单线程程序和正确同步的多线程程序），编译器和处理器怎么优化都行。例如，如果编译器经过细致的分析后，认定一个锁只会被单个线程访问，那么这个锁可以被消除。再如，如果编译器经过细致的分析后，认定一个volatile变量只会被单个线程访问，那么编译器可以把这个volatile变量当作一个普通变量来对待。这些优化既不会改变程序的执行结果，又能提高程序的执行效率。
 
 ### 3.3 happens-before定义
@@ -185,14 +179,14 @@ happens-before的概念最初由Leslie Lamport在其一篇影响深远的论文
 
 *   程序顺序规则：一个线程中的每个操作，happens-before于该线程中的任意后续操作。
 *   监视器锁规则：对一个锁的解锁，happens-before于随后对这个锁的加锁。
-*   volatile变量规则：对一个volatile域的写，happens-before于任意后续对这个volatile域的读。 
+*   volatile变量规则：对一个volatile域的写，happens-before于任意后续对这个volatile域的读。
 *   传递性：如果A happens-before B，且B happens-before C，那么A happens-before C。
 *   start()规则：如果线程A执行操作ThreadB.start()（启动线程B），那么A线程的ThreadB.start()操作happens-before于线程B中的任意操作。
 *   join()规则：如果线程A执行操作ThreadB.join()并成功返回，那么线程B中的任意操作happens-before于线程A从ThreadB.join()操作成功返回。
 
 ### 3.5 happens-before与JMM的关系图
 
-![](https://images2018.cnblogs.com/blog/1332556/201806/1332556-20180611201524034-1587404964.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404195827.png)
 
 一个happens-before规则对应于一个或多个编译器和处理器重排序规则。对于Java程序员来说，happens-before规则简单易懂，它避免Java程序员为了理解JMM提供的内存可见性保证而去学习复杂的重排序规则以及这些规则的具体实现方法
 
@@ -222,20 +216,14 @@ happens-before的概念最初由Leslie Lamport在其一篇影响深远的论文
     　　2）在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。
 
     　　可能上面说的比较绕，举个简单的例子：
-
-
-
-
-<pre>//x、y为非volatile变量 //flag为volatile变量
+````
+//x、y为非volatile变量 //flag为volatile变量
  x = 2;        //语句1
 y = 0;        //语句2
 flag = true;  //语句3
 x = 4;         //语句4
-y = -1;       //语句5</pre>
-
-
-
-
+y = -1;       //语句5
+````
 由于flag变量为volatile变量，那么在进行指令重排序的过程的时候，不会将语句3放到语句1、语句2前面，也不会讲语句3放到语句4、语句5后面。但是要注意语句1和语句2的顺序、语句4和语句5的顺序是不作任何保证的。
 
 *   原子性。对任意单个volatile变量的读、写具有原子性，但类似于volatile++这种复合操作不具有原子性。
@@ -269,22 +257,21 @@ volatile写和读的内存语义总结总结：
 
 下面是保守策略下，volatile写插入内存屏障后生成的指令序列示意图：
 
-![](https://images2018.cnblogs.com/blog/1332556/201806/1332556-20180627155958330-1026129500.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404195915.png)
 
 上图中的StoreStore屏障可以保证在volatile写之前，其前面的所有普通写操作已经对任意处理器可见了。这是因为StoreStore屏障将保障上面所有的普通写在volatile写之前刷新到主内存。
 
 这里比较有意思的是volatile写后面的StoreLoad屏障。这个屏障的作用是避免volatile写与后面可能有的volatile读/写操作重排序。因为编译器常常无法准确判断在一个volatile写的后面，是否需要插入一个StoreLoad屏障（比如，一个volatile写之后方法立即return）。为了保证能正确实现volatile的内存语义，JMM在这里采取了保守策略：在每个volatile写的后面或在每个volatile读的前面插入一个StoreLoad屏障。从整体执行效率的角度考虑，JMM选择了在每个volatile写的后面插入一个StoreLoad屏障。因为volatile写-读内存语义的常见使用模式是：一个写线程写volatile变量，多个读线程读同一个volatile变量。当读线程的数量大大超过写线程时，选择在volatile写之后插入StoreLoad屏障将带来可观的执行效率的提升。从这里我们可以看到JMM在实现上的一个特点：首先确保正确性，然后再去追求执行效率。下面是在保守策略下，volatile读插入内存屏障后生成的指令序列示意图：
 
-![](https://images2018.cnblogs.com/blog/1332556/201806/1332556-20180627155942083-844958043.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404195934.png)
 上图中的LoadLoad屏障用来禁止处理器把上面的volatile读与下面的普通读重排序。LoadStore屏障用来禁止处理器把上面的volatile读与下面的普通写重排序。
 
 上述volatile写和volatile读的内存屏障插入策略非常保守。在实际执行时，只要不改变volatile写-读的内存语义，编译器可以根据具体情况省略不必要的屏障。下面我们通过具体的示例代码来说明：
 
 
 
-
-<pre>class VolatileBarrierExample { int a; volatile int v1 = 1; volatile int v2 = 2; void readAndWrite() { int i = v1;      //第一个volatile读
+````
+class VolatileBarrierExample { int a; volatile int v1 = 1; volatile int v2 = 2; void readAndWrite() { int i = v1;      //第一个volatile读
     int j = v2;      // 第二个volatile读
     a = i + j;      //普通写
     v1 = i + 1;     // 第一个volatile写
@@ -292,14 +279,11 @@ volatile写和读的内存语义总结总结：
  }
 
   … //其他方法
-}</pre>
-
-
-
-
+}
+````
 针对readAndWrite()方法，编译器在生成字节码时可以做如下的优化：
 
-![](https://images2018.cnblogs.com/blog/1332556/201806/1332556-20180627160549655-1808405069.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404195956.png)
 
 注意，最后的StoreLoad屏障不能省略。因为第二个volatile写之后，方法立即return。此时编译器可能无法准确断定后面是否会有volatile读或写，为了安全起见，编译器常常会在这里插入一个StoreLoad屏障。
 
@@ -312,9 +296,9 @@ volatile写和读的内存语义总结总结：
 当一个变量被定义为volatile之后，就可以保证此变量对所有线程的可见性，即当一个线程修改了此变量的值的时候，变量新的值对于其他线程来说是可以立即得知的。可以理解成：对volatile变量所有的写操作都能立刻被其他线程得知。但是这并不代表基于volatile变量的运算在并发下是安全的，因为volatile只能保证内存可见性，却没有保证对变量操作的原子性。比如下面的代码：
 
 
+````
 
-
-<pre>/ * 
+/ * 
  * 发起20个线程，每个线程对race变量进行10000次自增操作，如果代码能够正确并发，
  * 则最终race的结果应为200000，但实际的运行结果却小于200000。
  * 
@@ -342,9 +326,9 @@ public class Test { public static volatile int race = 0; public static void incr
 
     }
 
-}</pre>
-
+}
 
+````
 
 
 按道理来说结果是10000，但是运行下很可能是个小于10000的值。有人可能会说volatile不是保证了可见性啊，一个线程对race的修改，另外一个线程应该立刻看到啊！可是这里的操作race++是个复合操作啊，包括读取race的值，对其自增，然后再写回主存。
@@ -363,7 +347,7 @@ public class Test { public static volatile int race = 0; public static void incr
 
 要想保证原子性，只能借助于synchronized,Lock以及并发包下的atomic的原子操作类了，即对基本数据类型的 自增（加1操作），自减（减1操作）、以及加法操作（加一个数），减法操作（减一个数）进行了封装，保证这些操作是原子性操作。
 
-[Java 理论与实践: 正确使用 Volatile 变量](http://www.ibm.com/developerworks/cn/java/j-jtp06197.html) 总结了volatile关键的使用场景，
+[Java 理论与实践: 正确使用 Volatile 变量](http://www.ibm.com/developerworks/cn/java/j-jtp06197.html)总结了volatile关键的使用场景，
 
 只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：
 
@@ -374,9 +358,9 @@ public class Test { public static volatile int race = 0; public static void incr
 
 实际上，这些条件表明，可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。
 
-第一个条件的限制使 volatile 变量不能用作线程安全计数器。虽然增量操作（`x++`）看上去类似一个单独操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作，必须以原子方式执行，而 volatile 不能提供必须的原子特性。实现正确的操作需要使`x` 的值在操作期间保持不变，而 volatile 变量无法实现这点。（然而，如果将值调整为只从单个线程写入，那么可以忽略第一个条件。） 
+第一个条件的限制使 volatile 变量不能用作线程安全计数器。虽然增量操作（`x++`）看上去类似一个单独操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作，必须以原子方式执行，而 volatile 不能提供必须的原子特性。实现正确的操作需要使`x`的值在操作期间保持不变，而 volatile 变量无法实现这点。（然而，如果将值调整为只从单个线程写入，那么可以忽略第一个条件。）
 
- volatile一个使用场景是状态位；还有只有一个线程写，其余线程读的场景
+volatile一个使用场景是状态位；还有只有一个线程写，其余线程读的场景
 
 
 
@@ -388,7 +372,7 @@ public class Test { public static volatile int race = 0; public static void incr
 
 当线程获取锁时，JMM会把该线程对应的本地内存置位无效，从而使得被监视器保护的临界区代码必须从主内存中读取共享变量。
 
-不难发现：锁释放与volatile写有相同的内存语音；锁获取与volatile读有相同的内存语义。 
+不难发现：锁释放与volatile写有相同的内存语音；锁获取与volatile读有相同的内存语义。
 
 下面对锁释放和锁获取的内存语义做个总结。
 
@@ -410,8 +394,8 @@ public class Test { public static volatile int race = 0; public static void incr
 
 
 
-
-<pre>public class FinalTest { int i;//普通变量
+````
+public class FinalTest { int i;//普通变量
     final int j; static FinalExample obj; public FinalExample(){
         i = 1;
         j = 2;
@@ -421,9 +405,9 @@ public class Test { public static volatile int race = 0; public static void incr
         FinalExample object = obj;//读对象引用
         int a = object.i; int b = object.j;
     }
-}</pre>
-
+}
 
+````
 
 
 这里假设一个线程A执行writer()方法，随后另一个线程B执行reader()方法。下面我们通过这两个线程的交互来说明这两个规则。
@@ -434,7 +418,7 @@ public class Test { public static volatile int race = 0; public static void incr
 
 2）编译器会在final域的写之后，构造函数return之前，插入一个StoreStore屏障。这个屏障禁止处理器把final域的写重排序到构造函数之外。
 
-现在让我们分析writer方法，writer方法只包含一行代码obj = new FinalTest();这行代码包含两个步骤：
+现在让我们分析writer方法，writer方法只包含一行代码obj =newFinalTest();这行代码包含两个步骤：
 
 1）构造一个FinalTest类型的对象
 
@@ -442,7 +426,7 @@ public class Test { public static volatile int race = 0; public static void incr
 
 假设线程B的读对象引用与读对象的成员域之间没有重排序，下图是一种可能的执行时序
 
-![](https://images2018.cnblogs.com/blog/1332556/201807/1332556-20180702161158925-1636540001.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404200259.png)
 
 在上图中，写普通域的操作被编译器重排序到了构造函数之外，读线程B错误的读取到了普通变量i初始化之前的值。而写final域的操作被写final域重排序的规则限定在了构造函数之内，读线程B正确的读取到了final变量初始化之后的值。
 
@@ -462,7 +446,7 @@ public class Test { public static volatile int race = 0; public static void incr
 
 现在假设写线程A没有发生任何重排序，同时程序在不遵守间接依赖的处理器上执行，下图是一种可能的执行时序：
 
-![](https://images2018.cnblogs.com/blog/1332556/201807/1332556-20180702162017295-865800268.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404200319.png)
 
 在上图中，读对象的普通域操作被处理器重排序到读对象引用之前。在读普通域时，该域还没有被写线程写入，这是一个错误的读取操作，而读final域的重排序规则会把读对象final域的操作“限定”在读对象引用之后，此时该final域已经被A线程初始化过了，这是一个正确的读取操作。
 
@@ -471,9 +455,9 @@ public class Test { public static volatile int race = 0; public static void incr
 final域为引用类型，上面我们看到的final域是基础的数据类型，如果final域是引用类型呢？
 
 
+````
 
-
-<pre>public class FinalReferenceTest { final int[] arrs;//final引用
+public class FinalReferenceTest { final int[] arrs;//final引用
 
     static FinalReferenceTest obj; public FinalReferenceTest(){
         arrs = new int[1];//1
@@ -487,9 +471,9 @@ final域为引用类型，上面我们看到的final域是基础的数据类型
             int temp =obj.arrs[0];//6
  }
     }
-}</pre>
-
+}
 
+````
 
 
 JMM可以确保读线程C至少能看到写线程A在构造函数中对final引用对象的成员域的写入。即C至少能看到数组下标0的值为1。而写线程B对数组元素的写入，读线程C可能看得到，也可能看不到。JMM不保证线程B的写入对读线程C可见，因为写线程B和读线程C之间存在数据竞争，此时的执行结果不可预知。
@@ -500,8 +484,8 @@ JMM可以确保读线程C至少能看到写线程A在构造函数中对final引
 
 
 
-
-<pre>public class FinalReferenceEscapeExample {final int i;static FinalReferenceEscapeExample obj;public FinalReferenceEscapeExample () {
+````
+public class FinalReferenceEscapeExample {final int i;static FinalReferenceEscapeExample obj;public FinalReferenceEscapeExample () {
 　　　　i = 1; // 1写final域
 　　　　obj = this; // 2 this引用在此"逸出"
 　　}
@@ -510,9 +494,9 @@ JMM可以确保读线程C至少能看到写线程A在构造函数中对final引
 　　　　　　int temp = obj.i; // 4
 　　　　}
 　　}
-}</pre>
-
+}
 
+````
 
 
 假设一个线程A执行writer()方法，另一个线程B执行reader()方法。这里的操作2使得对象还未完成构造前就为线程B可见。即使这里的操作2是构造函数的最后一步，且在程序中操作2排在操作1后面，执行read()方法的线程仍然可能无法看到final域被初始化后的值，因为这里的操作1和操作2之间可能被重排序。
@@ -523,7 +507,7 @@ JSR-133为什么要增强final的语义：
 
 ## 五、JMM是如何处理并发过程中的三大特性
 
- JMM是围绕这在并发过程中如何处理原子性、可见性和有序性这3个特性来建立的。
+JMM是围绕这在并发过程中如何处理原子性、可见性和有序性这3个特性来建立的。
 
 *   原子性：
 
@@ -551,7 +535,7 @@ JSR-133为什么要增强final的语义：
 
 [https://www.cnblogs.com/_popc/p/6096517.html](https://www.cnblogs.com/_popc/p/6096517.html)
 
-[https://blog.csdn.net/liu_dong_liang/article/details/80391040 ](https://blog.csdn.net/liu_dong_liang/article/details/80391040)
+[https://blog.csdn.net/liu_dong_liang/article/details/80391040](https://blog.csdn.net/liu_dong_liang/article/details/80391040)
 
 [https://www.jb51.net/article/76006.htm](https://www.jb51.net/article/76006.htm)
 
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22710\357\274\232Java \350\257\273\345\206\231\351\224\201 ReentrantReadWriteLock \346\272\220\347\240\201\345\210\206\346\236\220.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232Java\350\257\273\345\206\231\351\224\201ReentrantReadWriteLock\346\272\220\347\240\201\345\210\206\346\236\220.md"
similarity index 95%
rename from "docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22710\357\274\232Java \350\257\273\345\206\231\351\224\201 ReentrantReadWriteLock \346\272\220\347\240\201\345\210\206\346\236\220.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232Java\350\257\273\345\206\231\351\224\201ReentrantReadWriteLock\346\272\220\347\240\201\345\210\206\346\236\220.md"
index 01860bf..a357d88 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22710\357\274\232Java \350\257\273\345\206\231\351\224\201 ReentrantReadWriteLock \346\272\220\347\240\201\345\210\206\346\236\220.md"	
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232Java\350\257\273\345\206\231\351\224\201ReentrantReadWriteLock\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [使用示例](#使用示例)
   * [ReentrantReadWriteLock 总览](#reentrantreadwritelock-总览)
   * [源码分析](#源码分析)
@@ -10,7 +9,6 @@
   * [锁降级](#锁降级)
   * [总结](#总结)
 
-
 本文转自：https://www.javadoop.com/
 
 **本文转载自互联网，侵删**
@@ -93,7 +91,7 @@ ReentrantReadWriteLock 分为读锁和写锁两个实例，读锁是共享锁，
 
 很清楚了，ReadLock 和 WriteLock 中的方法都是通过 Sync 这个类来实现的。Sync 是 AQS 的子类，然后再派生了公平模式和不公平模式。
 
-从它们调用的 Sync 方法，我们可以看到： **ReadLock 使用了共享模式，WriteLock 使用了独占模式**。
+从它们调用的 Sync 方法，我们可以看到：**ReadLock 使用了共享模式，WriteLock 使用了独占模式**。
 
 等等，**同一个 AQS 实例怎么可以同时使用共享模式和独占模式**？？？
 
@@ -101,7 +99,7 @@ ReentrantReadWriteLock 分为读锁和写锁两个实例，读锁是共享锁，
 
 ![13](https://www.javadoop.com/blogimages/reentrant-read-write-lock/13.png)
 
-AQS 的精髓在于内部的属性 **state**：
+AQS 的精髓在于内部的属性**state**：
 
 1.  对于独占模式来说，通常就是 0 代表可获取锁，1 代表锁被别人获取了，重入例外
 2.  而共享模式下，每个线程都可以对 state 进行加减操作
@@ -170,9 +168,9 @@ abstract static class Sync extends AbstractQueuedSynchronizer {
 
 1.  state 的高 16 位代表读锁的获取次数，包括重入次数，获取到读锁一次加 1，释放掉读锁一次减 1
 2.  state 的低 16 位代表写锁的获取次数，因为写锁是独占锁，同时只能被一个线程获得，所以它代表重入次数
-3.  每个线程都需要维护自己的 HoldCounter，记录该线程获取的读锁次数，这样才能知道到底是不是读锁重入，用 ThreadLocal 属性 **readHolds** 维护
-4.  **cachedHoldCounter** 有什么用？其实没什么用，但能提示性能。将最后一次获取读锁的线程的 HoldCounter 缓存到这里，这样比使用 ThreadLocal 性能要好一些，因为 ThreadLocal 内部是基于 map 来查询的。但是 cachedHoldCounter 这一个属性毕竟只能缓存一个线程，所以它要起提升性能作用的依据就是：通常读锁的获取紧随着就是该读锁的释放。我这里可能表达不太好，但是大家应该是懂的吧。
-5.  **firstReader** 和 **firstReaderHoldCount** 有什么用？其实也没什么用，但是它也能提示性能。将"第一个"获取读锁的线程记录在 firstReader 属性中，这里的**第一个**不是全局的概念，等这个 firstReader 当前代表的线程释放掉读锁以后，会有后来的线程占用这个属性的。**firstReader 和 firstReaderHoldCount 使得在读锁不产生竞争的情况下，记录读锁重入次数非常方便快速**
+3.  每个线程都需要维护自己的 HoldCounter，记录该线程获取的读锁次数，这样才能知道到底是不是读锁重入，用 ThreadLocal 属性**readHolds**维护
+4.  **cachedHoldCounter**有什么用？其实没什么用，但能提示性能。将最后一次获取读锁的线程的 HoldCounter 缓存到这里，这样比使用 ThreadLocal 性能要好一些，因为 ThreadLocal 内部是基于 map 来查询的。但是 cachedHoldCounter 这一个属性毕竟只能缓存一个线程，所以它要起提升性能作用的依据就是：通常读锁的获取紧随着就是该读锁的释放。我这里可能表达不太好，但是大家应该是懂的吧。
+5.  **firstReader**和**firstReaderHoldCount**有什么用？其实也没什么用，但是它也能提示性能。将"第一个"获取读锁的线程记录在 firstReader 属性中，这里的**第一个**不是全局的概念，等这个 firstReader 当前代表的线程释放掉读锁以后，会有后来的线程占用这个属性的。**firstReader 和 firstReaderHoldCount 使得在读锁不产生竞争的情况下，记录读锁重入次数非常方便快速**
 6.  如果一个线程使用了 firstReader，那么它就不需要占用 cachedHoldCounter
 7.  个人认为，读写锁源码中最让初学者头疼的就是这几个用于提升性能的属性了，使得大家看得云里雾里的。主要是因为 ThreadLocal 内部是通过一个 ThreadLocalMap 来操作的，会增加检索时间。而很多场景下，执行 unlock 的线程往往就是刚刚最后一次执行 lock 的线程，中间可能没有其他线程进行 lock。还有就是很多不怎么会发生读锁竞争的场景。
 
@@ -500,7 +498,7 @@ protected final boolean tryAcquire(int acquires) {
 }
 ```
 
-下面看一眼 **writerShouldBlock()** 的判定，然后你再回去看一篇写锁获取过程。
+下面看一眼**writerShouldBlock()**的判定，然后你再回去看一篇写锁获取过程。
 
 ```
 static final class NonfairSync extends Sync {
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2273\357\274\232\345\271\266\345\217\221\344\270\211\345\244\247\351\227\256\351\242\230\344\270\216volatile\345\205\263\351\224\256\345\255\227\357\274\214CAS\346\223\215\344\275\234.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\345\271\266\345\217\221\344\270\211\345\244\247\351\227\256\351\242\230\344\270\216volatile\345\205\263\351\224\256\345\255\227\357\274\214CAS\346\223\215\344\275\234.md"
similarity index 84%
rename from "docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2273\357\274\232\345\271\266\345\217\221\344\270\211\345\244\247\351\227\256\351\242\230\344\270\216volatile\345\205\263\351\224\256\345\255\227\357\274\214CAS\346\223\215\344\275\234.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\345\271\266\345\217\221\344\270\211\345\244\247\351\227\256\351\242\230\344\270\216volatile\345\205\263\351\224\256\345\255\227\357\274\214CAS\346\223\215\344\275\234.md"
index 4220389..60a9c3e 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2273\357\274\232\345\271\266\345\217\221\344\270\211\345\244\247\351\227\256\351\242\230\344\270\216volatile\345\205\263\351\224\256\345\255\227\357\274\214CAS\346\223\215\344\275\234.md"
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\345\271\266\345\217\221\344\270\211\345\244\247\351\227\256\351\242\230\344\270\216volatile\345\205\263\351\224\256\345\255\227\357\274\214CAS\346\223\215\344\275\234.md"
@@ -1,26 +1,24 @@
-# Table of Contents
-
+# 目录
   * [序言](#序言)
   * [原子性](#原子性)
   * [可见性](#可见性)
-  * [有序性 ](#有序性 )
+  * [有序性](#有序性)
   * [volatile关键字详解：在JMM中volatile的内存语义是锁](#volatile关键字详解：在jmm中volatile的内存语义是锁)
     * [volatile的特性](#volatile的特性)
   * [volatile写-读建立的happens before关系](#volatile写-读建立的happens-before关系)
     * [volatile写-读的内存语义](#volatile写-读的内存语义)
     * [volatile内存语义的实现](#volatile内存语义的实现)
     * [JSR-133为什么要增强volatile的内存语义](#jsr-133为什么要增强volatile的内存语义)
-                * [](#)
     * [引言](#引言)
     * [术语定义](#术语定义)
-    * [3    处理器如何实现原子操作](#3   -处理器如何实现原子操作)
-      * [3.1   处理器自动保证基本内存操作的原子性](#31  -处理器自动保证基本内存操作的原子性)
-      * [3.2   使用总线锁保证原子性](#32  -使用总线锁保证原子性)
+    * [3 处理器如何实现原子操作](#3-处理器如何实现原子操作)
+      * [3.1 处理器自动保证基本内存操作的原子性](#31-处理器自动保证基本内存操作的原子性)
+      * [3.2 使用总线锁保证原子性](#32-使用总线锁保证原子性)
       * [3.3 使用缓存锁保证原子性](#33-使用缓存锁保证原子性)
-    * [4    JAVA如何实现原子操作](#4   -java如何实现原子操作)
+    * [4 JAVA如何实现原子操作](#4-java如何实现原子操作)
   * [4.1 使用循环CAS实现原子操作](#41-使用循环cas实现原子操作)
       * [4.2 使用锁机制实现原子操作](#42-使用锁机制实现原子操作)
-  * [5      参考资料](#5     -参考资料)
+  * [5 参考资料](#5-参考资料)
 
 
 **本文转载自互联网，侵删**
@@ -41,27 +39,27 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 <!--more -->
+
 ## 序言
 
 先来看如下这个简单的Java类，该类中并没有使用任何的同步。
 
-
-    final class SetCheck {
-    	private int a = 0;
-    	private long b = 0;
-     
-    	void set() {
-    		a = 1;
-    		b = -1;
-    	}
-     
-    	boolean check() {
-    		return ((b == 0) || (b == -1 && a == 1));
-    	}
+````
+final class SetCheck {
+    private int a = 0;
+    private long b = 0;
+ 
+    void set() {
+        a = 1;
+        b = -1;
     }
-     
-
-
+ 
+    boolean check() {
+        return ((b == 0) || (b == -1 && a == 1));
+    }
+}
+    
+````     
 
 如果是在一个串行执行的语言中，执行SetCheck类中的check方法永远不会返回false，即使编译器，运行时和计算机硬件并没有按照你所期望的逻辑来处理这段程序，该方法依然不会返回false。在程序执行过程中，下面这些你所不能预料的行为都是可能发生的：
 
@@ -91,7 +89,7 @@ Java内存模型是Java语言规范的一部分，主要在JLS的第17章节介
 
 我们假设Java内存模型可以被看作在1.2.4中描述的那种标准的SMP机器的理想化模型。
 
-![](http://gee.cs.oswego.edu/dl/cpj/mm-1.gif)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404190605.png)
 
 （1.2.4）
 
@@ -143,65 +141,66 @@ Java内存模型没有具体讲述前面讨论的执行策略是由编译器，C
 
 这使得测试基于内存可见性的错误是不切实际的，因为这样的错误极难发生。或者这种错误仅仅在某个你没有使用过的平台上发生，或仅在未来的某个平台上发生。这些类似的解释对于多线程之间的内存可见性问题来说非常普遍。没有同步的并发程序会出现很多问题，包括内存一致性问题。
 
-## 有序性 
+## 有序性
 
-有序性规则表现在以下两种场景: 线程内和线程间
+有序性规则表现在以下两种场景:线程内和线程间
 
 *   从某个线程的角度看方法的执行，指令会按照一种叫“串行”（as-if-serial）的方式执行，此种方式已经应用于顺序编程语言。
 *   这个线程“观察”到其他线程并发地执行非同步的代码时，任何代码都有可能交叉执行。唯一起作用的约束是：对于同步方法，同步块以及volatile字段的操作仍维持相对有序。
 
 再次提醒，这些仅是最小特性的规则。具体到任何一个程序或平台上，可能存在更严格的有序性规则。所以你不能依赖它们，因为即使你的代码遵循了这些更严格的规则，仍可能在不同特性的JVM上运行失败，而且测试非常困难。
 
-需要注意的是，线程内部的观察视角被JLS _[1] _中其他的语义的讨论所采用。例如，算术表达式的计算在线程内看来是从左到右地执行操作（JLS 15.6章节），而这种执行效果是没有必要被其他线程观察到的。
+需要注意的是，线程内部的观察视角被JLS_[1]_中其他的语义的讨论所采用。例如，算术表达式的计算在线程内看来是从左到右地执行操作（JLS15.6章节），而这种执行效果是没有必要被其他线程观察到的。
 
-仅当某一时刻只有一个线程操作变量时，线程内的执行表现为串行。出现上述情景，可能是因为使用了同步，互斥体_[2] _或者纯属巧合。当多线程同时运行在非同步的代码里进行公用字段的读写时，会形成一种执行模式。在这种模式下，代码会任意交叉执行，原子性和可见性会失效，以及产生竞态条件。这时线程执行不再表现为串行。
+仅当某一时刻只有一个线程操作变量时，线程内的执行表现为串行。出现上述情景，可能是因为使用了同步，互斥体_[2]_或者纯属巧合。当多线程同时运行在非同步的代码里进行公用字段的读写时，会形成一种执行模式。在这种模式下，代码会任意交叉执行，原子性和可见性会失效，以及产生竞态条件。这时线程执行不再表现为串行。
 
-尽管JLS列出了一些特定的合法和非法的重排序，如果碰到所列范围之外的问题，会降低以下这条实践保证 ：运行结果反映了几乎所有的重排序产生的代码交叉执行的情况。所以，没必要去探究这些代码的有序性。
+尽管JLS列出了一些特定的合法和非法的重排序，如果碰到所列范围之外的问题，会降低以下这条实践保证：运行结果反映了几乎所有的重排序产生的代码交叉执行的情况。所以，没必要去探究这些代码的有序性。
 
 ## volatile关键字详解：在JMM中volatile的内存语义是锁
 
 ### volatile的特性
 
 当我们声明共享变量为volatile后，对这个变量的读/写将会很特别。理解volatile特性的一个好方法是：把对volatile变量的单个读/写，看成是使用同一个监视器锁对这些单个读/写操作做了同步。下面我们通过具体的示例来说明，请看下面的示例代码：
-
-    class VolatileFeaturesExample {
-    	volatile long vl = 0L; // 使用volatile声明64位的long型变量
-     
-    	public void set(long l) {
-    		vl = l; // 单个volatile变量的写
-    	}
-     
-    	public void getAndIncrement() {
-    		vl++; // 复合（多个）volatile变量的读/写
-    	}
-     
-    	public long get() {
-    		return vl; // 单个volatile变量的读
-    	}
+````
+class VolatileFeaturesExample {
+    volatile long vl = 0L; // 使用volatile声明64位的long型变量
+ 
+    public void set(long l) {
+        vl = l; // 单个volatile变量的写
     }
-
+ 
+    public void getAndIncrement() {
+        vl++; // 复合（多个）volatile变量的读/写
+    }
+ 
+    public long get() {
+        return vl; // 单个volatile变量的读
+    }
+}
+````
 
     
 
 假设有多个线程分别调用上面程序的三个方法，这个程序在语意上和下面程序等价：
-    class VolatileFeaturesExample {
-        long vl = 0L;               // 64位的long型普通变量
-     
-        public synchronized void set(long l) {     //对单个的普通 变量的写用同一个监视器同步
-            vl = l;
-        }
-     
-        public void getAndIncrement () { //普通方法调用
-            long temp = get();           //调用已同步的读方法
-            temp += 1L;                  //普通写操作
-            set(temp);                   //调用已同步的写方法
-        }
-        public synchronized long get() { 
-        //对单个的普通变量的读用同一个监视器同步
-            return vl;
-        }
+````
+class VolatileFeaturesExample {
+    long vl = 0L;               // 64位的long型普通变量
+ 
+    public synchronized void set(long l) {     //对单个的普通 变量的写用同一个监视器同步
+        vl = l;
     }
-
+ 
+    public void getAndIncrement () { //普通方法调用
+        long temp = get();           //调用已同步的读方法
+        temp += 1L;                  //普通写操作
+        set(temp);                   //调用已同步的写方法
+    }
+    public synchronized long get() { 
+    //对单个的普通变量的读用同一个监视器同步
+        return vl;
+    }
+}
+````
 
     
 
@@ -223,6 +222,7 @@ Java内存模型没有具体讲述前面讨论的执行策略是由编译器，C
 从内存语义的角度来说，volatile与监视器锁有相同的效果：volatile写和监视器的释放有相同的内存语义；volatile读与监视器的获取有相同的内存语义。
 
 请看下面使用volatile变量的示例代码：
+````
 class VolatileExample {
 	int a = 0;
 	volatile boolean flag = false;
@@ -238,9 +238,7 @@ class VolatileExample {
         }
     }
 }
-
-
-    
+````
 
 假设线程A执行writer()方法之后，线程B执行reader()方法。根据happens before规则，这个过程建立的happens before 关系可以分为两类：
 
@@ -248,23 +246,17 @@ class VolatileExample {
 2.  根据volatile规则，2 happens before 3。
 3.  根据happens before 的传递性规则，1 happens before 4。
 
-上述happens before 关系的图形化表现形式如下：
-
-![](https://res.infoq.com/articles/java-memory-model-4/zh/resources/1.png)
-
-在上图中，每一个箭头链接的两个节点，代表了一个happens before 关系。黑色箭头表示程序顺序规则；橙色箭头表示volatile规则；蓝色箭头表示组合这些规则后提供的happens before保证。
-
 这里A线程写一个volatile变量后，B线程读同一个volatile变量。A线程在写volatile变量之前所有可见的共享变量，在B线程读同一个volatile变量后，将立即变得对B线程可见。
 
 ### volatile写-读的内存语义
 
 volatile写的内存语义如下：
 
-*   当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量刷新到主内存。
+当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量刷新到主内存。
 
 以上面示例程序VolatileExample为例，假设线程A首先执行writer()方法，随后线程B执行reader()方法，初始时两个线程的本地内存中的flag和a都是初始状态。下图是线程A执行volatile写后，共享变量的状态示意图：
 
-![](https://res.infoq.com/articles/java-memory-model-4/zh/resources/2.png)
+![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9UTEgzQ2ljUFZpYnJlMXJ3emFJWjJkT3VVdDVjekVBdVQ3dmRtZ0NFNjBKeTlRODRsZ0VwdzNqaWFCREJmSjE2TkxZUEQ2a1dNeHBnOTNad0tUOVY2Ym1Ydy82NDA?x-oss-process=image/format,png)
 
 如上图所示，线程A在写flag变量后，本地内存A中被线程A更新过的两个共享变量的值被刷新到主内存中。此时，本地内存A和主内存中的共享变量的值是一致的。
 
@@ -274,7 +266,7 @@ volatile读的内存语义如下：
 
 下面是线程B读同一个volatile变量后，共享变量的状态示意图：
 
-![](https://res.infoq.com/articles/java-memory-model-4/zh/resources/3.png)
+![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9UTEgzQ2ljUFZpYnJlMXJ3emFJWjJkT3VVdDVjekVBdVQ3WWcwMEt1bGVicDAza0MyU2ZHWmI3Tm5vaDcxaG5JS3dpYW5qcnJsUzBUN3dNZWljWUJySmY4YVEvNjQw?x-oss-process=image/format,png)
 
 如上图所示，在读flag变量后，本地内存B已经被置为无效。此时，线程B必须从主内存中读取共享变量。线程B的读取操作将导致本地内存B与主内存中的共享变量的值也变成一致的了。
 
@@ -297,9 +289,9 @@ volatile读的内存语义如下：
 | 是否能重排序 | 第二个操作 |
 | --- | --- |
 | 第一个操作 | 普通读/写 | volatile读 | volatile写 |
-| 普通读/写 |   |   | NO |
+| 普通读/写 |  |  | NO |
 | volatile读 | NO | NO | NO |
-| volatile写 |   | NO | NO |
+| volatile写 |  | NO | NO |
 
 
 
@@ -322,7 +314,7 @@ volatile读的内存语义如下：
 
 下面是保守策略下，volatile写插入内存屏障后生成的指令序列示意图：
 
-![](https://res.infoq.com/articles/java-memory-model-4/zh/resources/4.png)
+![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9UTEgzQ2ljUFZpYnJlMXJ3emFJWjJkT3VVdDVjekVBdVQ3U2dxcTJ0SnF1N1pwQllpYVZmZnpTd3F5NGhDY1dSWVhNVzlzM0VWSmljRFZzODY5cWc1M1A3eEEvNjQw?x-oss-process=image/format,png)
 
 上图中的StoreStore屏障可以保证在volatile写之前，其前面的所有普通写操作已经对任意处理器可见了。这是因为StoreStore屏障将保障上面所有的普通写在volatile写之前刷新到主内存。
 
@@ -330,31 +322,31 @@ volatile读的内存语义如下：
 
 下面是在保守策略下，volatile读插入内存屏障后生成的指令序列示意图：
 
-![](https://res.infoq.com/articles/java-memory-model-4/zh/resources/5.png)
+![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9UTEgzQ2ljUFZpYnJlMXJ3emFJWjJkT3VVdDVjekVBdVQ3U2dxcTJ0SnF1N1pwQllpYVZmZnpTd3F5NGhDY1dSWVhNVzlzM0VWSmljRFZzODY5cWc1M1A3eEEvNjQw?x-oss-process=image/format,png)
 
 上图中的LoadLoad屏障用来禁止处理器把上面的volatile读与下面的普通读重排序。LoadStore屏障用来禁止处理器把上面的volatile读与下面的普通写重排序。
 
 上述volatile写和volatile读的内存屏障插入策略非常保守。在实际执行时，只要不改变volatile写-读的内存语义，编译器可以根据具体情况省略不必要的屏障。下面我们通过具体的示例代码来说明：
-    class VolatileBarrierExample {
-    	int a;
-    	volatile int v1 = 1;
-    	volatile int v2 = 2;
-     
-    	void readAndWrite() {
-    		int i = v1; // 第一个volatile读
-    		int j = v2; // 第二个volatile读
-    		a = i + j; // 普通写
-    		v1 = i + 1; // 第一个volatile写
-    		v2 = j * 2; // 第二个 volatile写
-    	}
+````
+class VolatileBarrierExample {
+    int a;
+    volatile int v1 = 1;
+    volatile int v2 = 2;
+ 
+    void readAndWrite() {
+        int i = v1; // 第一个volatile读
+        int j = v2; // 第二个volatile读
+        a = i + j; // 普通写
+        v1 = i + 1; // 第一个volatile写
+        v2 = j * 2; // 第二个 volatile写
     }
-
-
+}
+````
     
 
 针对readAndWrite()方法，编译器在生成字节码时可以做如下的优化：
 
-![](https://res.infoq.com/articles/java-memory-model-4/zh/resources/6.png)
+![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9UTEgzQ2ljUFZpYnJlMXJ3emFJWjJkT3VVdDVjekVBdVQ3RzlISFVoNTh0MHNCVUZwMEJyZVU4Njc0OGZHMFhKdmxRTXFpYXE3dUhRNklGd1Q5a1pZQktjZy82NDA?x-oss-process=image/format,png)
 
 注意，最后的StoreLoad屏障不能省略。因为第二个volatile写之后，方法立即return。此时编译器可能无法准确断定后面是否会有volatile读或写，为了安全起见，编译器常常会在这里插入一个StoreLoad屏障。
 
@@ -362,7 +354,7 @@ volatile读的内存语义如下：
 
 前面保守策略下的volatile读和写，在 x86处理器平台可以优化成：
 
-![](https://res.infoq.com/articles/java-memory-model-4/zh/resources/7.png)
+![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9UTEgzQ2ljUFZpYnJlMXJ3emFJWjJkT3VVdDVjekVBdVQ3aWNaU1h6dURzT2pnZ0hBTmljYnljbTNPYjkwbkVVOURCTm1JaHE1Y2NVdTZMUnZxS3V1cmlhQ29nLzY0MA?x-oss-process=image/format,png)
 
 前文提到过，x86处理器仅会对写-读操作做重排序。X86不会对读-读，读-写和写-写操作做重排序，因此在x86处理器中会省略掉这三种操作类型对应的内存屏障。在x86中，JMM仅需在volatile写后面插入一个StoreLoad屏障即可正确实现volatile写-读的内存语义。这意味着在x86处理器中，volatile写的开销比volatile读的开销会大很多（因为执行StoreLoad屏障开销会比较大）。
 
@@ -370,7 +362,7 @@ volatile读的内存语义如下：
 
 在JSR-133之前的旧Java内存模型中，虽然不允许volatile变量之间重排序，但旧的Java内存模型允许volatile变量与普通变量之间重排序。在旧的内存模型中，VolatileExample示例程序可能被重排序成下列时序来执行：
 
-![](https://res.infoq.com/articles/java-memory-model-4/zh/resources/8.png)
+![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9UTEgzQ2ljUFZpYnJlMXJ3emFJWjJkT3VVdDVjekVBdVQ3TG9aamN2em13WUk3aGVJcksyemp2YWs5RGI5cHZKaFJ3NVR0cHFGMzNWUjFHb0tzd1lwNUdnLzY0MA?x-oss-process=image/format,png)
 
 在旧的内存模型中，当1和2之间没有数据依赖关系时，1和2之间就可能被重排序（3和4类似）。其结果就是：读线程B执行4时，不一定能看到写线程A在执行1时对共享变量的修改。
 
@@ -388,8 +380,6 @@ volatile读的内存语义如下：
 
 ### 术语定义
 
-
-
 | 术语名称 | 英文 | 解释 |
 | --- | --- | --- |
 | 缓存行 | Cache line | 缓存的最小操作单位 |
@@ -398,20 +388,18 @@ volatile读的内存语义如下：
 | 内存顺序冲突 | Memory order violation | 内存顺序冲突一般是由假共享引起，假共享是指多个CPU同时修改同一个缓存行的不同部分而引起其中一个CPU的操作无效，当出现这个内存顺序冲突时，CPU必须清空流水线。 |
 
 
-
-### 3    处理器如何实现原子操作
+### 3 处理器如何实现原子操作
 
 32位IA-32处理器使用基于对缓存加锁或总线加锁的方式来实现多处理器之间的原子操作。
 
-#### 3.1   处理器自动保证基本内存操作的原子性
+#### 3.1 处理器自动保证基本内存操作的原子性
 
 首先处理器会自动保证基本的内存操作的原子性。处理器保证从系统内存当中读取或者写入一个字节是原子的，意思是当一个处理器读取一个字节时，其他处理器不能访问这个字节的内存地址。奔腾6和最新的处理器能自动保证单处理器对同一个缓存行里进行16/32/64位的操作是原子的，但是复杂的内存操作处理器不能自动保证其原子性，比如跨总线宽度，跨多个缓存行，跨页表的访问。但是处理器提供总线锁定和缓存锁定两个机制来保证复杂内存操作的原子性。
 
-#### 3.2   使用总线锁保证原子性
+#### 3.2 使用总线锁保证原子性
 
 第一个机制是通过总线锁保证原子性。如果多个处理器同时对共享变量进行读改写（i++就是经典的读改写操作）操作，那么共享变量就会被多个处理器同时进行操作，这样读改写操作就不是原子的，操作完之后共享变量的值会和期望的不一致，举个例子：如果i=1,我们进行两次i++操作，我们期望的结果是3，但是有可能结果是2。如下图
-[![1](http://ifeve.com/wp-content/uploads/2012/12/1.png)](http://ifeve.com/atomic_operation/attachment/1/)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404191936.png)
 （例1）
 
 原因是有可能多个处理器同时从各自的缓存中读取变量i，分别进行加一操作，然后分别写入系统内存当中。那么想要保证读改写共享变量的操作是原子的，就必须保证CPU1读改写共享变量的时候，CPU2不能操作缓存了该共享变量内存地址的缓存。
@@ -428,7 +416,7 @@ volatile读的内存语义如下：
 
 以上两个机制我们可以通过Inter处理器提供了很多LOCK前缀的指令来实现。比如位测试和修改指令BTS，BTR，BTC，交换指令XADD，CMPXCHG和其他一些操作数和逻辑指令，比如ADD（加），OR（或）等，被这些指令操作的内存区域就会加锁，导致其他处理器不能同时访问它。
 
-### 4    JAVA如何实现原子操作
+### 4 JAVA如何实现原子操作
 
 在java中可以通过锁和循环CAS的方式来实现原子操作。
 
@@ -436,103 +424,102 @@ volatile读的内存语义如下：
 
 JVM中的CAS操作正是利用了上一节中提到的处理器提供的CMPXCHG指令实现的。自旋CAS实现的基本思路就是循环进行CAS操作直到成功为止，以下代码实现了一个基于CAS线程安全的计数器方法safeCount和一个非线程安全的计数器count。
 
-
-    package Test;
-     
-    import java.util.ArrayList;
-    import java.util.List;
-    import java.util.concurrent.atomic.AtomicInteger;
-     
-    public class Counter {
-     
-    	private AtomicInteger atomicI = new AtomicInteger();
-     
-    	private int i = 0;
-     
-    	public static void main(String[] args) {
-     
-    		final Counter cas = new Counter();
-     
-    		List<Thread> ts = new ArrayList<Thread>();
-     
-    		long start = System.currentTimeMillis();
-     
-    		for (int j = 0; j < 100; j++) {
-     
-    			Thread t = new Thread(new Runnable() {
-    				@Override
-    				public void run() {
-    					for (int i = 0; i < 10000; i++) {
-    						cas.count();
-    						cas.safeCount();
-    					}
-     
-    				}
-     
-    			});
-    			ts.add(t);
-    		}
-     
-    		for (Thread t : ts) {
-    			t.start();
-    		}
-     
-    		// 等待所有线程执行完成
-     
-    		for (Thread t : ts) {
-    			try {
-     
-    				t.join();
-     
-    			} catch (InterruptedException e) {
-     
-    				e.printStackTrace();
-     
-    			}
-     
-    		}
-     
-    		System.out.println(cas.i);
-     
-    		System.out.println(cas.atomicI.get());
-     
-    		System.out.println(System.currentTimeMillis() - start);
-     
-    	}
-     
-    	/**
-    	 * 
-    	 * 使用CAS实现线程安全计数器
-    	 * 
-    	 */
-     
-    	private void safeCount() {
-    		for (;;) {
-    			int i = atomicI.get();
-    			boolean suc = atomicI.compareAndSet(i, ++i);
-    			if (suc) {
-    				break;
-    			}
-    		}
-    	}
-     
-    	/**
-    	 * 
-    	 * 非线程安全计数器
-    	 * 
-    	 */
-     
-    	private void count() {
-    		i++;
-    	}
+````
+package Test;
+ 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+ 
+public class Counter {
+ 
+    private AtomicInteger atomicI = new AtomicInteger();
+ 
+    private int i = 0;
+ 
+    public static void main(String[] args) {
+ 
+        final Counter cas = new Counter();
+ 
+        List<Thread> ts = new ArrayList<Thread>();
+ 
+        long start = System.currentTimeMillis();
+ 
+        for (int j = 0; j < 100; j++) {
+ 
+            Thread t = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    for (int i = 0; i < 10000; i++) {
+                        cas.count();
+                        cas.safeCount();
+                    }
+ 
+                }
+ 
+            });
+            ts.add(t);
+        }
+ 
+        for (Thread t : ts) {
+            t.start();
+        }
+ 
+        // 等待所有线程执行完成
+ 
+        for (Thread t : ts) {
+            try {
+ 
+                t.join();
+ 
+            } catch (InterruptedException e) {
+ 
+                e.printStackTrace();
+ 
+            }
+ 
+        }
+ 
+        System.out.println(cas.i);
+ 
+        System.out.println(cas.atomicI.get());
+ 
+        System.out.println(System.currentTimeMillis() - start);
+ 
     }
+ 
+    /**
+     * 
+     * 使用CAS实现线程安全计数器
+     * 
+     */
+ 
+    private void safeCount() {
+        for (;;) {
+            int i = atomicI.get();
+            boolean suc = atomicI.compareAndSet(i, ++i);
+            if (suc) {
+                break;
+            }
+        }
+    }
+ 
+    /**
+     * 
+     * 非线程安全计数器
+     * 
+     */
+ 
+    private void count() {
+        i++;
+    }
+}
+````
+
     结果
     992362
     1000000
     75
-    
-
-
 
 从Java1.5开始JDK的并发包里提供了一些类来支持原子操作，如[AtomicBoolean](http://www.cjsdn.net/doc/jdk60/java/util/concurrent/atomic/AtomicBoolean.html)（用原子方式更新的 boolean 值），[AtomicInteger](http://www.cjsdn.net/doc/jdk60/java/util/concurrent/atomic/AtomicInteger.html)（用原子方式更新的 int 值），[AtomicLong](http://www.cjsdn.net/doc/jdk60/java/util/concurrent/atomic/AtomicLong.html)（用原子方式更新的 long 值），这些原子包装类还提供了有用的工具方法，比如以原子的方式将当前值自增1和自减1。
 
@@ -542,19 +529,17 @@ JVM中的CAS操作正是利用了上一节中提到的处理器提供的CMPXCHG
 
 从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。
 
-    
-    public boolean compareAndSet(
-       V      expectedReference,//预期引用
-     
-       V      newReference,//更新后的引用
-     
-      int    expectedStamp, //预期标志
-     
-      int    newStamp //更新后的标志
-    )
-
-
-
+````    
+public boolean compareAndSet(
+   V      expectedReference,//预期引用
+ 
+   V      newReference,//更新后的引用
+ 
+  int    expectedStamp, //预期标志
+ 
+  int    newStamp //更新后的标志
+)
+````
 1.  循环时间长开销大。自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。如果JVM能支持处理器提供的pause指令那么效率会有一定的提升，pause指令有两个作用，第一它可以延迟流水线执行指令（de-pipeline）,使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突（memory order violation）而引起CPU流水线被清空（CPU pipeline flush），从而提高CPU的执行效率。
 
 
@@ -564,7 +549,7 @@ JVM中的CAS操作正是利用了上一节中提到的处理器提供的CMPXCHG
 
 锁机制保证了只有获得锁的线程能够操作锁定的内存区域。JVM内部实现了很多种锁机制，有偏向锁，轻量级锁和互斥锁，有意思的是除了偏向锁，JVM实现锁的方式都用到的循环CAS，当一个线程想进入同步块的时候使用循环CAS的方式来获取锁，当它退出同步块的时候使用循环CAS释放锁。详细说明可以参见文章[Java SE1.6中的Synchronized](http://www.infoq.com/cn/articles/java-se-16-synchronized)。
 
-## 5      参考资料
+## 5 参考资料
 
 1.  [Java SE1.6中的Synchronized](http://www.infoq.com/cn/articles/java-se-16-synchronized)
 2.  [Intel 64和IA-32架构软件开发人员手册](http://www.intel.com/products/processor/manuals/)
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2271\357\274\232\345\271\266\345\217\221\345\237\272\347\241\200\344\270\216Java\345\244\232\347\272\277\347\250\213.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\345\271\266\345\217\221\345\237\272\347\241\200\344\270\216Java\345\244\232\347\272\277\347\250\213.md"
similarity index 85%
rename from "docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2271\357\274\232\345\271\266\345\217\221\345\237\272\347\241\200\344\270\216Java\345\244\232\347\272\277\347\250\213.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\345\271\266\345\217\221\345\237\272\347\241\200\344\270\216Java\345\244\232\347\272\277\347\250\213.md"
index e5cfa46..1b25c68 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2271\357\274\232\345\271\266\345\217\221\345\237\272\347\241\200\344\270\216Java\345\244\232\347\272\277\347\250\213.md"
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\345\271\266\345\217\221\345\237\272\347\241\200\344\270\216Java\345\244\232\347\272\277\347\250\213.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [1多线程的优点](#1多线程的优点)
     * [1.1资源利用率更好案例](#11资源利用率更好案例)
     * [1.2程序响应更快](#12程序响应更快)
@@ -31,8 +30,8 @@
 
 ## 1多线程的优点
 
-1.  - 资源利用率更好 
-2.  - 程序设计在某些情况下更简单 
+1.  - 资源利用率更好
+2.  - 程序设计在某些情况下更简单
 3.  - 程序响应更快
 
 ### 1.1资源利用率更好案例
@@ -41,14 +40,14 @@
 从磁盘读取一个文件需要5秒，处理一个文件需要2秒。处理两个文件则需要14秒
 
 ```
-1    5秒读取文件A2    2秒处理文件A3    5秒读取文件B4    2秒处理文件B5    ---------------------6    总共需要14秒
+1 5秒读取文件A2 2秒处理文件A3 5秒读取文件B4 2秒处理文件B5 ---------------------6 总共需要14秒
 ```
 
 **方式2**
 从磁盘中读取文件的时候，大部分的CPU非常的空闲。它可以做一些别的事情。通过改变操作的顺序，就能够更好的使用CPU资源。看下面的顺序：
 
 ```
-1    5秒读取文件A2    5秒读取文件B + 2秒处理文件A3    2秒处理文件B4    ---------------------5    总共需要12秒
+1 5秒读取文件A2 5秒读取文件B + 2秒处理文件A3 2秒处理文件B4 ---------------------5 总共需要12秒
 ```
 
 **总结：多线程并发效率提高2秒**
@@ -57,12 +56,12 @@
 ### 1.2程序响应更快
 
 设想一个服务器应用，它在某一个端口监听进来的请求。当一个请求到来时，它把请求传递给工作者线程(worker thread)，然后立刻返回去监听。而工作者线程则能够处理这个请求并发送一个回复给客户端。
-
-     while(server is active){
-            listenThread for request
-           hand request to workerThread
-        }
-
+````
+while(server is active){
+    listenThread for request
+   hand request to workerThread
+}
+````
 
 这种方式，服务端线程迅速地返回去监听。因此，更多的客户端能够发送请求给服务端。这个服务也变得响应更快。
 
@@ -84,7 +83,7 @@ CPU会在一个上下文中执行一个线程，然后切换到另外一个上
 
 **每个线程需要消耗的资源：**
 
-CPU，内存（维持它本地的堆栈），操作系统资源（管理线程） 
+CPU，内存（维持它本地的堆栈），操作系统资源（管理线程）
 
 ## 3竞态条件与临界区
 
@@ -92,14 +91,15 @@ CPU，内存（维持它本地的堆栈），操作系统资源（管理线程
 
 **多线程同时执行下面的代码可能会出错：**
 
-
-    public class Counter {
-    	protected long count = 0;
-     
-    	public void add(long value) {
-    		this.count = this.count + value;
-    	}
+````
+public class Counter {
+    protected long count = 0;
+ 
+    public void add(long value) {
+        this.count = this.count + value;
     }
+}
+````
 想象下线程A和B同时执行同一个Counter对象的add()方法，我们无法知道操作系统何时会在两个线程之间切换。JVM并不是将这段代码视为单条指令来执行的，而是按照下面的顺序
 
 
@@ -132,11 +132,10 @@ CPU，内存（维持它本地的堆栈），操作系统资源（管理线程
 
 在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个jvm，每一个jvm实际上就是在操作系统中启动了一个进程。
 
-![](https://img-blog.csdnimg.cn/20181031104947230.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3U5MjA3ODYzMTI=,size_16,color_FFFFFF,t_70)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404183859.png)
 ## 5线程的状态和优先级
 
-**线程优先级**1 到 10 ，其中 1 是最低优先级，10 是最高优先级。 
+**线程优先级**1 到 10 ，其中 1 是最低优先级，10 是最高优先级。
 
 **状态**
 
@@ -149,8 +148,7 @@ CPU，内存（维持它本地的堆栈），操作系统资源（管理线程
 
 **状态转换**
 
-**![](https://img-blog.csdnimg.cn/20181031105627437.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3U5MjA3ODYzMTI=,size_16,color_FFFFFF,t_70)**
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404183924.png)
 **线程状态流程如下：**
 
 *   线程创建后，进入 new 状态
@@ -161,7 +159,7 @@ CPU，内存（维持它本地的堆栈），操作系统资源（管理线程
 
 **代码**
 
-
+````
     public class MyThreadInfo extends Thread {
      
     	@Override // 可以省略
@@ -180,7 +178,7 @@ CPU，内存（维持它本地的堆栈），操作系统资源（管理线程
     		System.out.println("线程优先级：" + thread.getPriority());
     	}
     }
-     
+````     
     结果：
     线程唯一标识符：9
     线程名称：Thread-0
diff --git "a/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243Java\345\206\205\345\255\230\346\250\241\345\236\213JMM.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243Java\345\206\205\345\255\230\346\250\241\345\236\213JMM.md"
new file mode 100644
index 0000000..a9aad6e
--- /dev/null
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243Java\345\206\205\345\255\230\346\250\241\345\236\213JMM.md"
@@ -0,0 +1,243 @@
+# 目录
+  * [一：JMM基础与happens-before](#一：jmm基础与happens-before)
+    * [并发编程模型的分类](#并发编程模型的分类)
+    * [重排序](#重排序)
+    * [处理器重排序与内存屏障指令](#处理器重排序与内存屏障指令)
+    * [happens-before](#happens-before)
+  * [二：重排序与JMM的as-if-serial](#二：重排序与jmm的as-if-serial)
+    * [数据依赖性](#数据依赖性)
+    * [as-if-serial语义](#as-if-serial语义)
+    * [程序顺序规则](#程序顺序规则)
+    * [重排序对多线程的影响](#重排序对多线程的影响)
+  * [三：顺序一致性内存模型与JMM](#三：顺序一致性内存模型与jmm)
+    * [数据竞争与顺序一致性保证](#数据竞争与顺序一致性保证)
+    * [顺序一致性内存模型](#顺序一致性内存模型)
+    * [同步程序的顺序一致性效果](#同步程序的顺序一致性效果)
+    * [未同步程序的执行特性](#未同步程序的执行特性)
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+文章同步发于我的个人博客：
+> www.how2playlife.com
+
+本文是微信公众号【Java技术江湖】的《Java并发指南》其中一篇，本文大部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+
+该系列博文会告诉你如何全面深入地学习Java并发技术，从Java多线程基础，再到并发编程的基础知识，从Java并发包的入门和实战，再到JUC的源码剖析，一步步地学习Java并发编程，并上手进行实战，以便让你更完整地了解整个Java并发编程知识体系，形成自己的知识框架。
+
+为了更好地总结和检验你的学习成果，本系列文章也会提供一些对应的面试题以及参考答案。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+<!--more -->
+
+最近在面试的的时候，什么是Java内存模型也是常问的的一道面试题。
+
+> 网上有很多关于Java内存模型的文章，在《深入理解Java虚拟机》和《Java并发编程的艺术》等书中也都有关于这个知识点的介绍。但是，很多人读完之后还是搞不清楚，甚至有的人说自己更懵了。本文，就来整体的介绍一下Java内存模型，目的很简单，让你读完本文以后，就知道到底Java内存模型是什么，为什么要有Java内存模型，Java内存模型解决了什么问题等。
+
+## 1\. 为什么要有内存模型？
+
+要想回答这个问题，我们需要先弄懂传统计算机硬件内存架构。好了，我要开始画图了。
+
+## 1.1\. 硬件内存架构
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404185859.png)
+
+**1）CPU**
+
+去过机房的同学都知道，一般在大型服务器上会配置多个CPU，每个CPU还会有多个核，这就意味着多个CPU或者多个核可以同时（并发）工作。如果使用Java 起了一个多线程的任务，很有可能每个 CPU 都会跑一个线程，那么你的任务在某一刻就是真正并发执行了。
+
+**（2）CPU Register**
+
+CPU Register也就是 CPU 寄存器。CPU 寄存器是 CPU 内部集成的，在寄存器上执行操作的效率要比在主存上高出几个数量级。
+
+**（3）CPU Cache Memory**
+
+CPU Cache Memory也就是 CPU 高速缓存，相对于寄存器来说，通常也可以成为 L2 二级缓存。相对于硬盘读取速度来说内存读取的效率非常高，但是与 CPU 还是相差数量级，所以在 CPU 和主存间引入了多级缓存，目的是为了做一下缓冲。
+
+**（4）Main Memory**
+
+Main Memory 就是主存，主存比 L1、L2 缓存要大很多。
+
+注意：部分高端机器还有 L3 三级缓存。
+
+## 1.2\. 缓存一致性问题
+
+由于主存与 CPU 处理器的运算能力之间有数量级的差距，所以在传统计算机内存架构中会引入高速缓存来作为主存和处理器之间的缓冲，CPU 将常用的数据放在高速缓存中，运算结束后 CPU 再讲运算结果同步到主存中。
+
+使用高速缓存解决了 CPU 和主存速率不匹配的问题，但同时又引入另外一个新问题：缓存一致性问题。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404190013.png)
+
+在多CPU的系统中(或者单CPU多核的系统)，每个CPU内核都有自己的高速缓存，它们共享同一主内存(Main Memory)。当多个CPU的运算任务都涉及同一块主内存区域时，CPU 会将数据读取到缓存中进行运算，这可能会导致各自的缓存数据不一致。
+
+因此需要每个 CPU 访问缓存时遵循一定的协议，在读写数据时根据协议进行操作，共同来维护缓存的一致性。这类协议有 MSI、MESI、MOSI、和 Dragon Protocol 等。
+
+## 1.3\. 处理器优化和指令重排序
+
+为了提升性能在 CPU 和主内存之间增加了高速缓存，但在多线程并发场景可能会遇到`缓存一致性问题`。那还有没有办法进一步提升 CPU 的执行效率呢？答案是：处理器优化。
+
+> 为了使处理器内部的运算单元能够最大化被充分利用，处理器会对输入代码进行乱序执行处理，这就是处理器优化。
+
+除了处理器会对代码进行优化处理，很多现代编程语言的编译器也会做类似的优化，比如像 Java 的即时编译器（JIT）会做指令重排序。
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404190116.png)
+
+> 处理器优化其实也是重排序的一种类型，这里总结一下，重排序可以分为三种类型：
+
+*   编译器优化的重排序。编译器在不改变单线程程序语义放入前提下，可以重新安排语句的执行顺序。
+*   指令级并行的重排序。现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
+*   内存系统的重排序。由于处理器使用缓存和读写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。
+
+## 2\. 并发编程的问题
+
+上面讲了一堆硬件相关的东西，有些同学可能会有点懵，绕了这么大圈，这些东西跟 Java 内存模型有啥关系吗？不要急咱们慢慢往下看。
+
+熟悉 Java 并发的同学肯定对这三个问题很熟悉：『可见性问题』、『原子性问题』、『有序性问题』。如果从更深层次看这三个问题，其实就是上面讲的『缓存一致性』、『处理器优化』、『指令重排序』造成的。
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404190045.png)
+
+
+缓存一致性问题其实就是可见性问题，处理器优化可能会造成原子性问题，指令重排序会造成有序性问题，你看是不是都联系上了。
+
+出了问题总是要解决的，那有什么办法呢？首先想到简单粗暴的办法，干掉缓存让 CPU 直接与主内存交互就解决了可见性问题，禁止处理器优化和指令重排序就解决了原子性和有序性问题，但这样一夜回到解放前了，显然不可取。
+
+所以技术前辈们想到了在物理机器上定义出一套内存模型， 规范内存的读写操作。内存模型解决并发问题主要采用两种方式：限制处理器优化和使用内存屏障。
+
+## 3\. Java 内存模型
+
+同一套内存模型规范，不同语言在实现上可能会有些差别。接下来着重讲一下 Java 内存模型实现原理。
+
+## 3.1\. Java 运行时内存区域与硬件内存的关系
+
+了解过 JVM 的同学都知道，JVM 运行时内存区域是分片的，分为栈、堆等，其实这些都是 JVM 定义的逻辑概念。在传统的硬件内存架构中是没有栈和堆这种概念。
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404190254.png)
+
+
+从图中可以看出栈和堆既存在于高速缓存中又存在于主内存中，所以两者并没有很直接的关系。
+
+## 3.2\. Java 线程与主内存的关系
+
+Java 内存模型是一种规范，定义了很多东西：
+
+*   所有的变量都存储在主内存（Main Memory）中。
+*   每个线程都有一个私有的本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的拷贝副本。
+*   线程对变量的所有操作都必须在本地内存中进行，而不能直接读写主内存。
+*   不同的线程之间无法直接访问对方本地内存中的变量。
+
+看文字太枯燥了，我又画了一张图：
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404190315.png)
+
+
+## 3.3\. 线程间通信
+
+如果两个线程都对一个共享变量进行操作，共享变量初始值为 1，每个线程都变量进行加 1，预期共享变量的值为 3。在 JMM 规范下会有一系列的操作。
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404190335.png)
+
+
+为了更好的控制主内存和本地内存的交互，Java 内存模型定义了八种操作来实现：
+
+*   lock：锁定。作用于主内存的变量，把一个变量标识为一条线程独占状态。
+*   unlock：解锁。作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
+*   read：读取。作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用
+*   load：载入。作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
+*   use：使用。作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
+*   assign：赋值。作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
+*   store：存储。作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
+*   write：写入。作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。
+
+> 注意：工作内存也就是本地内存的意思。
+
+## 4\. 有态度的总结
+
+由于CPU 和主内存间存在数量级的速率差，想到了引入了多级高速缓存的传统硬件内存架构来解决，多级高速缓存作为 CPU 和主内间的缓冲提升了整体性能。解决了速率差的问题，却又带来了缓存一致性问题。
+
+数据同时存在于高速缓存和主内存中，如果不加以规范势必造成灾难，因此在传统机器上又抽象出了内存模型。
+
+Java 语言在遵循内存模型的基础上推出了 JMM 规范，目的是解决由于多线程通过共享内存进行通信时，存在的本地内存数据不一致、编译器会对代码指令重排序、处理器会对代码乱序执行等带来的问题。
+
+为了更精准控制工作内存和主内存间的交互，JMM 还定义了八种操作：lock, unlock, read, load,use,assign, store, write。
+
+前面介绍过了计算机内存模型，这是解决多线程场景下并发问题的一个重要规范。那么具体的实现是如何的呢，不同的编程语言，在实现上可能有所不同。
+
+我们知道，Java程序是需要运行在Java虚拟机上面的，**Java内存模型（Java Memory Model ,JMM）就是一种符合内存模型规范的，屏蔽了各种硬件和操作系统的访问差异的，保证了Java程序在各种平台下对内存的访问都能保证效果一致的机制及规范。**
+
+提到Java内存模型，一般指的是JDK 5 开始使用的新的内存模型，主要由<u>[JSR-133: JavaTM Memory Model and Thread Specification](http://www.cs.umd.edu/~pugh/java/memoryModel/jsr133.pdf)</u>描述。感兴趣的可以参看下这份PDF文档（[http://www.cs.umd.edu/~pugh/java/memoryModel/jsr133.pdf](http://www.cs.umd.edu/~pugh/java/memoryModel/jsr133.pdf)）
+
+Java内存模型规定了所有的变量都存储在主内存中，每条线程还有自己的工作内存，线程的工作内存中保存了该线程中是用到的变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存。不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量的传递均需要自己的工作内存和主存之间进行数据同步进行。
+
+而JMM就作用于工作内存和主存之间数据同步过程。他规定了如何做数据同步以及什么时候做数据同步。
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404190350.png)
+
+
+这里面提到的主内存和工作内存，读者可以简单的类比成计算机内存模型中的主存和缓存的概念。特别需要注意的是，主内存和工作内存与JVM内存结构中的Java堆、栈、方法区等并不是同一个层次的内存划分，无法直接类比。《深入理解Java虚拟机》中认为，如果一定要勉强对应起来的话，从变量、主内存、工作内存的定义来看，主内存主要对应于Java堆中的对象实例数据部分。工作内存则对应于虚拟机栈中的部分区域。
+
+**所以，再来总结下，JMM是一种规范，目的是解决由于多线程通过共享内存进行通信时，存在的本地内存数据不一致、编译器会对代码指令重排序、处理器会对代码乱序执行等带来的问题。**
+
+## **Java内存模型的实现**
+
+了解Java多线程的朋友都知道，在Java中提供了一系列和并发处理相关的关键字，比如`volatile`、`synchronized`、`final`、`concurren`包等。其实这些就是Java内存模型封装了底层的实现后提供给程序员使用的一些关键字。
+
+在开发多线程的代码的时候，我们可以直接使用`synchronized`等关键字来控制并发，从来就不需要关心底层的编译器优化、缓存一致性等问题。所以，**Java内存模型，除了定义了一套规范，还提供了一系列原语，封装了底层实现后，供开发者直接使用。**
+
+本文并不准备把所有的关键字逐一介绍其用法，因为关于各个关键字的用法，网上有很多资料。读者可以自行学习。本文还有一个重点要介绍的就是，我们前面提到，并发编程要解决原子性、有序性和一致性的问题，我们就再来看下，在Java中，分别使用什么方式来保证。
+
+### **原子性**
+
+在Java中，为了保证原子性，提供了两个高级的字节码指令`monitorenter`和`monitorexit`。在<u>[synchronized的实现原理](http://www.hollischuang.com/archives/1883)</u>文章中，介绍过，这两个字节码，在Java中对应的关键字就是`synchronized`。
+
+因此，在Java中可以使用`synchronized`来保证方法和代码块内的操作是原子性的。
+
+### **可见性**
+
+Java内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值的这种依赖主内存作为传递媒介的方式来实现的。
+
+Java中的`volatile`关键字提供了一个功能，那就是被其修饰的变量在被修改后可以立即同步到主内存，被其修饰的变量在每次是用之前都从主内存刷新。因此，可以使用`volatile`来保证多线程操作时变量的可见性。
+
+除了`volatile`，Java中的`synchronized`和`final`两个关键字也可以实现可见性。只不过实现方式不同，这里不再展开了。
+
+### **有序性**
+
+在Java中，可以使用`synchronized`和`volatile`来保证多线程之间操作的有序性。实现方式有所区别：
+
+`volatile`关键字会禁止指令重排。`synchronized`关键字保证同一时刻只允许一条线程操作。
+
+好了，这里简单的介绍完了Java并发编程中解决原子性、可见性以及有序性可以使用的关键字。读者可能发现了，好像`synchronized`关键字是万能的，他可以同时满足以上三种特性，这其实也是很多人滥用`synchronized`的原因。
+
+但是`synchronized`是比较影响性能的，虽然编译器提供了很多锁优化技术，但是也不建议过度使用。
+
+## **总结**
+
+在读完本文之后，相信你应该了解了什么是Java内存模型、Java内存模型的作用以及Java中内存模型做了什么事情等。关于Java中这些和内存模型有关的关键字，希望读者还可以继续深入学习，并且自己写几个例子亲自体会一下。
+
+可以参考《深入理解Java虚拟机》和《Java并发编程的艺术》两本书。
+
+参考：
+
+> [https://www.cnblogs.com/aishangJava/p/14742033.html](https://www.cnblogs.com/aishangJava/p/14742033.html)
+> [https://www.jianshu.com/p/8420ade6ff76](https://www.jianshu.com/p/8420ade6ff76)
+> httpa://[http://www.hollischuang.com/archives/2550](http://www.hollischuang.com/archives/2550)
+
+
+
+
+
+
+
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22712\357\274\232\346\267\261\345\272\246\350\247\243\350\257\273 java \347\272\277\347\250\213\346\261\240\350\256\276\350\256\241\346\200\235\346\203\263\345\217\212\346\272\220\347\240\201\345\256\236\347\216\260.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\346\267\261\345\272\246\350\247\243\350\257\273Java\347\272\277\347\250\213\346\261\240\350\256\276\350\256\241\346\200\235\346\203\263\345\217\212\346\272\220\347\240\201\345\256\236\347\216\260.md"
similarity index 95%
rename from "docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22712\357\274\232\346\267\261\345\272\246\350\247\243\350\257\273 java \347\272\277\347\250\213\346\261\240\350\256\276\350\256\241\346\200\235\346\203\263\345\217\212\346\272\220\347\240\201\345\256\236\347\216\260.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\346\267\261\345\272\246\350\247\243\350\257\273Java\347\272\277\347\250\213\346\261\240\350\256\276\350\256\241\346\200\235\346\203\263\345\217\212\346\272\220\347\240\201\345\256\236\347\216\260.md"
index 76f6d4b..aa025c9 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22712\357\274\232\346\267\261\345\272\246\350\247\243\350\257\273 java \347\272\277\347\250\213\346\261\240\350\256\276\350\256\241\346\200\235\346\203\263\345\217\212\346\272\220\347\240\201\345\256\236\347\216\260.md"	
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\346\267\261\345\272\246\350\247\243\350\257\273Java\347\272\277\347\250\213\346\261\240\350\256\276\350\256\241\346\200\235\346\203\263\345\217\212\346\272\220\347\240\201\345\256\236\347\216\260.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [前言](#前言)
   * [总览](#总览)
   * [Executor 接口](#executor-接口)
@@ -8,6 +7,7 @@
   * [AbstractExecutorService](#abstractexecutorservice)
   * [ThreadPoolExecutor](#threadpoolexecutor)
   * [Executors](#executors)
+  * [Worker获取任务](#getTask)
   * [总结](#总结)
 
 
@@ -92,7 +92,7 @@ public interface Executor {
 }
 ```
 
-我们可以看到 Executor 接口非常简单，就一个 `void execute(Runnable command)` 方法，代表提交一个任务。为了让大家理解 java 线程池的整个设计方案，我会按照 Doug Lea 的设计思路来多说一些相关的东西。
+我们可以看到 Executor 接口非常简单，就一个`void execute(Runnable command)`方法，代表提交一个任务。为了让大家理解 java 线程池的整个设计方案，我会按照 Doug Lea 的设计思路来多说一些相关的东西。
 
 我们经常这样启动一个线程：
 
@@ -171,7 +171,7 @@ class SerialExecutor implements Executor {
 }
 ```
 
-当然了，Executor 这个接口只有提交任务的功能，太简单了，我们想要更丰富的功能，比如我们想知道执行结果、我们想知道当前线程池有多少个线程活着、已经完成了多少任务等等，这些都是这个接口的不足的地方。接下来我们要介绍的是继承自 `Executor` 接口的 `ExecutorService` 接口，这个接口提供了比较丰富的功能，也是我们最常使用到的接口。
+当然了，Executor 这个接口只有提交任务的功能，太简单了，我们想要更丰富的功能，比如我们想知道执行结果、我们想知道当前线程池有多少个线程活着、已经完成了多少任务等等，这些都是这个接口的不足的地方。接下来我们要介绍的是继承自`Executor`接口的`ExecutorService`接口，这个接口提供了比较丰富的功能，也是我们最常使用到的接口。
 
 ## ExecutorService
 
@@ -277,13 +277,13 @@ public interface Callable<V> {
 
 在这里，就不展开说 FutureTask 类了，因为本文篇幅本来就够大了，这里我们需要知道怎么用就行了。
 
-下面，我们来看看 `ExecutorService` 的抽象实现 `AbstractExecutorService` 。
+下面，我们来看看`ExecutorService`的抽象实现`AbstractExecutorService`。
 
 ## AbstractExecutorService
 
 AbstractExecutorService 抽象类派生自 ExecutorService 接口，然后在其基础上实现了几个实用的方法，这些方法提供给子类进行调用。
 
-这个抽象类实现了 invokeAny 方法和 invokeAll 方法，这里的两个 newTaskFor 方法也比较有用，用于将任务包装成 FutureTask。定义于最上层接口 Executor中的 `void execute(Runnable command)` 由于不需要获取结果，不会进行 FutureTask 的包装。
+这个抽象类实现了 invokeAny 方法和 invokeAll 方法，这里的两个 newTaskFor 方法也比较有用，用于将任务包装成 FutureTask。定义于最上层接口 Executor中的`void execute(Runnable command)`由于不需要获取结果，不会进行 FutureTask 的包装。
 
 > 需要获取结果（FutureTask），用 submit 方法，不需要获取结果，可以用 execute 方法。
 
@@ -600,7 +600,7 @@ public <T> Future<T> submit(Callable<T> task) {
 
 当然，上图没有考虑队列是否有界，提交任务时队列满了怎么办？什么情况下会创建新的线程？提交任务时线程池满了怎么办？空闲线程怎么关掉？这些问题下面我们会一一解决。
 
-我们经常会使用 `Executors` 这个工具类来快速构造一个线程池，对于初学者而言，这种工具类是很有用的，开发者不需要关注太多的细节，只要知道自己需要一个线程池，仅仅提供必需的参数就可以了，其他参数都采用作者提供的默认值。
+我们经常会使用`Executors`这个工具类来快速构造一个线程池，对于初学者而言，这种工具类是很有用的，开发者不需要关注太多的细节，只要知道自己需要一个线程池，仅仅提供必需的参数就可以了，其他参数都采用作者提供的默认值。
 
 ```
 public static ExecutorService newFixedThreadPool(int nThreads) {
@@ -659,7 +659,7 @@ public static ExecutorService newCachedThreadPool() {
 
 *   keepAliveTime
 
-    > 空闲线程的保活时间，如果某线程的空闲时间超过这个值都没有任务给它做，那么可以被关闭了。注意这个值并不会对所有线程起作用，如果线程池中的线程数少于等于核心线程数 corePoolSize，那么这些线程不会因为空闲太长时间而被关闭，当然，也可以通过调用 `allowCoreThreadTimeOut(true)`使核心线程数内的线程也可以被回收。
+    > 空闲线程的保活时间，如果某线程的空闲时间超过这个值都没有任务给它做，那么可以被关闭了。注意这个值并不会对所有线程起作用，如果线程池中的线程数少于等于核心线程数 corePoolSize，那么这些线程不会因为空闲太长时间而被关闭，当然，也可以通过调用`allowCoreThreadTimeOut(true)`使核心线程数内的线程也可以被回收。
 
 *   threadFactory
 
@@ -1275,6 +1275,51 @@ else if (!addWorker(command, false))
 
 > SynchronousQueue 是一个比较特殊的 BlockingQueue，其本身不储存任何元素，它有一个虚拟队列（或虚拟栈），不管读操作还是写操作，如果当前队列中存储的是与当前操作相同模式的线程，那么当前操作也进入队列中等待；如果是相反模式，则配对成功，从当前队列中取队头节点。具体的信息，可以看我的另一篇关于 BlockingQueue 的文章。
 
+## getTask
+  前文已经分析了`runWorker`方法，我们可以看到该方法中有一行这样的代码
+  ```java
+  //...
+   while (task != null || (task = getTask()) != null) {
+  //...
+   ```
+  这一行代码如果`task!=null`，即前一个条件为`true`时意味着传入的一个非`null`的`task`，同时代码会优化使得第二个条件不去执行；那么前一个条件为`false`时，就会尝试调用`getTask`方法。在这一个方法中，`worker`会尝试从工作队列中取出任务来进行执行。
+  ```java
+   private Runnable getTask() {
+        boolean timedOut = false;
+        //不断尝试获得任务
+        for (;;) {
+            int c = ctl.get();
+            int rs = runStateOf(c);
+            // 前文已有相似的状态，这里不再赘述
+            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
+                decrementWorkerCount();
+                return null;
+            }
+            int wc = workerCountOf(c);
+            //是否设置了允许核心线程超时（设置了之后核心线程在超时后会销毁），或者当前worker数量比核心池大
+            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
+          
+            if ((wc > maximumPoolSize || (timed && timedOut))&& (wc > 1 || workQueue.isEmpty())) {
+                if (compareAndDecrementWorkerCount(c))
+                    return null;
+                continue;
+            }
+            try {
+                //是否设置了允许核心线程超时（设置了之后核心线程在超时后会销毁），或者当前worker数量比核心池大
+                //如果是调用queue的poll(int,TimeUnit)方法，否则直接调用take方法
+                Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();
+                //能获取到非空的任务就返回
+                //对于不设置允许核心线程超时的情况，核心线程就一直在getTask的这个循环中
+                //一直等待有新的任务来执行
+                if (r != null)
+                    return r;
+                timedOut = true;
+            } catch (InterruptedException retry) {
+                timedOut = false;
+            }
+        }
+    }
+    ```
 ## 总结
 
 我一向不喜欢写总结，因为我把所有需要表达的都写在正文中了，写小篇幅的总结并不能真正将话说清楚，本文的总结部分为准备面试的读者而写，希望能帮到面试者或者没有足够的时间看完全文的读者。
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22711\357\274\232\350\247\243\350\257\273 Java \351\230\273\345\241\236\351\230\237\345\210\227 BlockingQueue.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\350\247\243\350\257\273Java\351\230\273\345\241\236\351\230\237\345\210\227BlockingQueue.md"
similarity index 96%
rename from "docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22711\357\274\232\350\247\243\350\257\273 Java \351\230\273\345\241\236\351\230\237\345\210\227 BlockingQueue.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\350\247\243\350\257\273Java\351\230\273\345\241\236\351\230\237\345\210\227BlockingQueue.md"
index f082991..55fcd94 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\22711\357\274\232\350\247\243\350\257\273 Java \351\230\273\345\241\236\351\230\237\345\210\227 BlockingQueue.md"	
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\346\214\207\345\215\227\357\274\232\350\247\243\350\257\273Java\351\230\273\345\241\236\351\230\237\345\210\227BlockingQueue.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [前言](#前言)
   * [BlockingQueue](#blockingqueue)
   * [BlockingQueue 实现之 ArrayBlockingQueue](#blockingqueue-实现之-arrayblockingqueue)
@@ -8,7 +7,6 @@
   * [BlockingQueue 实现之 PriorityBlockingQueue](#blockingqueue-实现之-priorityblockingqueue)
   * [总结](#总结)
 
-
 本文转自：https://www.javadoop.com/
 
 **本文转载自互联网，侵删**
@@ -67,7 +65,7 @@ BlockingQueue 不接受 null 值的插入，相应的方法在碰到 null 的插
 
 BlockingQueue 是设计用来实现生产者-消费者队列的，当然，你也可以将它当做普通的 Collection 来用，前面说了，它实现了 java.util.Collection 接口。例如，我们可以用 remove(x) 来删除任意一个元素，但是，这类操作通常并不高效，所以尽量只在少数的场合使用，比如一条消息已经入队，但是需要做取消操作的时候。
 
-BlockingQueue 的实现都是线程安全的，但是批量的集合操作如 `addAll`, `containsAll`, `retainAll` 和 `removeAll` 不一定是原子操作。如 addAll(c) 有可能在添加了一些元素后中途抛出异常，此时 BlockingQueue 中已经添加了部分元素，这个是允许的，取决于具体的实现。
+BlockingQueue 的实现都是线程安全的，但是批量的集合操作如`addAll`,`containsAll`,`retainAll`和`removeAll`不一定是原子操作。如 addAll(c) 有可能在添加了一些元素后中途抛出异常，此时 BlockingQueue 中已经添加了部分元素，这个是允许的，取决于具体的实现。
 
 BlockingQueue 不支持 close 或 shutdown 等**关闭**操作，因为开发者可能希望不会有新的元素添加进去，此特性取决于具体的实现，不做强制约束。
 
@@ -103,8 +101,7 @@ private final Condition notFull;
 
 我们用个示意图来描述其同步机制：
 
-![array-blocking-queue](https://www.javadoop.com/blogimages/java-concurrent-queue/array-blocking-queue.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404201844.png)
 ArrayBlockingQueue 实现并发同步的原理就是，读操作和写操作都需要获取到 AQS 独占锁才能进行操作。如果队列为空，这个时候读操作的线程进入到**读线程队列**排队，等待写线程写入新的元素，然后唤醒读线程队列的第一个等待线程。如果队列已满，这个时候写操作的线程进入到**写线程队列**排队，等待读线程将队列元素移除腾出空间，然后唤醒写线程队列的第一个等待线程。
 
 对于 ArrayBlockingQueue，我们可以在构造的时候指定以下三个参数：
@@ -171,8 +168,7 @@ private final Condition notFull = putLock.newCondition();
 
 首先，这里用一个示意图来看看 LinkedBlockingQueue 的并发读写控制，然后再开始分析源码：
 
-![linked-blocking-queue](https://www.javadoop.com/blogimages/java-concurrent-queue/linked-blocking-queue.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404201927.png)
 看懂这个示意图，源码也就简单了，读操作是排好队的，写操作也是排好队的，唯一的并发问题在于一个写操作和一个读操作同时进行，只要控制好这个就可以了。
 
 先上构造方法：
@@ -334,7 +330,7 @@ abstract static class Transferer {
 
 Transferer 有两个内部实现类，是因为构造 SynchronousQueue 的时候，我们可以指定公平策略。公平模式意味着，所有的读写线程都遵守先来后到，FIFO 嘛，对应 TransferQueue。而非公平模式则对应 TransferStack。
 
-![synchronous-queue](https://www.javadoop.com/blogimages/java-concurrent-queue/synchronous-queue.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404202000.png)
 
 我们先采用公平模式分析源码，然后再说说公平模式和非公平模式的区别。
 
@@ -569,12 +565,11 @@ private PriorityQueue q;
 
 PriorityBlockingQueue 使用了基于数组的**二叉堆**来存放元素，所有的 public 方法采用同一个 lock 进行并发控制。
 
-二叉堆：一颗完全二叉树，它非常适合用数组进行存储，对于数组中的元素 `a[i]`，其左子节点为 `a[2*i+1]`，其右子节点为 `a[2*i + 2]`，其父节点为 `a[(i-1)/2]`，其堆序性质为，每个节点的值都小于其左右子节点的值。二叉堆中最小的值就是根节点，但是删除根节点是比较麻烦的，因为需要调整树。
+二叉堆：一颗完全二叉树，它非常适合用数组进行存储，对于数组中的元素`a[i]`，其左子节点为`a[2*i+1]`，其右子节点为`a[2*i + 2]`，其父节点为`a[(i-1)/2]`，其堆序性质为，每个节点的值都小于其左右子节点的值。二叉堆中最小的值就是根节点，但是删除根节点是比较麻烦的，因为需要调整树。
 
 简单用个图解释一下二叉堆，我就不说太多专业的严谨的术语了，这种数据结构的优点是一目了然的，最小的元素一定是根元素，它是一棵满的树，除了最后一层，最后一层的节点从左到右紧密排列。
 
-![priority-blocking-queue-1](https://www.javadoop.com/blogimages/java-concurrent-queue/priority-blocking-queue-1.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404202057.png)
 下面开始 PriorityBlockingQueue 的源码分析，首先我们来看看构造方法:
 
 ```
@@ -737,9 +732,9 @@ private static <T> void siftUpComparable(int k, T x, Object[] array) {
 }
 ```
 
-我们用图来示意一下，我们接下来要将 **11** 插入到队列中，看看 siftUp 是怎么操作的。
+我们用图来示意一下，我们接下来要将**11**插入到队列中，看看 siftUp 是怎么操作的。
 
-![priority-blocking-queue-2](https://www.javadoop.com/blogimages/java-concurrent-queue/priority-blocking-queue-2.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404202125.png)
 
 我们再看看 take 方法：
 
@@ -822,14 +817,13 @@ private static <T> void siftDownComparable(int k, T x, Object[] array,
 }
 ```
 
-![priority-blocking-queue-3](https://www.javadoop.com/blogimages/java-concurrent-queue/priority-blocking-queue-3.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404202147.png)
 
 记住二叉堆是一棵完全二叉树，那么根节点 10 拿掉后，最后面的元素 17 必须找到合适的地方放置。首先，17 和 10 不能直接交换，那么先将根节点 10 的左右子节点中较小的节点往上滑，即 12 往上滑，然后原来 12 留下了一个空节点，然后再把这个空节点的较小的子节点往上滑，即 13 往上滑，最后，留出了位子，17 补上即可。
 
 我稍微调整下这个树，以便读者能更明白：
 
-![priority-blocking-queue-4](https://www.javadoop.com/blogimages/java-concurrent-queue/priority-blocking-queue-4.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404202208.png)
 好了， PriorityBlockingQueue 我们也说完了。
 
 ## 总结
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\200\273\347\273\223.md" "b/docs/Java/concurrency/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\255\246\344\271\240\346\200\273\347\273\223.md"
similarity index 91%
rename from "docs/java/currency/Java\345\271\266\345\217\221\346\200\273\347\273\223.md"
rename to "docs/Java/concurrency/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\255\246\344\271\240\346\200\273\347\273\223.md"
index 5c0fa32..98f3e38 100644
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\200\273\347\273\223.md"
+++ "b/docs/Java/concurrency/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\255\246\344\271\240\346\200\273\347\273\223.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [线程安全](#线程安全)
   * [互斥和同步](#互斥和同步)
   * [JMM内存模型](#jmm内存模型)
@@ -10,7 +9,6 @@
   * [Lock类](#lock类)
     * [AQS](#aqs)
     * [锁Lock和Conditon](#锁lock和conditon)
-          * [](#)
   * [并发工具类](#并发工具类)
   * [原子数据类型](#原子数据类型)
   * [同步容器](#同步容器)
@@ -19,20 +17,7 @@
     * [类图](#类图)
     * [常用线程池](#常用线程池)
   * [Fork/Join框架](#forkjoin框架)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
 
----
-title: Java并发总结
-date: 2018-07-08 22:06:18
-tags:
-	- Java并发
-categories:
-	- 后端
-	- 技术总结
----
 
 这篇总结主要是基于我Java并发技术系列的文章而形成的的。主要是把重要的知识点用自己的话说了一遍，可能会有一些错误，还望见谅和指点。谢谢
 
@@ -231,20 +216,4 @@ ScheduledThreadPoolExecutor内部使用的是delayqueue队列，内部是一个
 
 窃取的基本思路就是：当worker自己的任务队列里面没有任务时，就去scan别的线程的队列，把别人的任务拿过来执行
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232JDK\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232JDK\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md"
new file mode 100644
index 0000000..ab7b901
--- /dev/null
+++ "b/docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232JDK\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md"
@@ -0,0 +1,322 @@
+# 目录
+
+  * [**一，结构型模式**](#一，结构型模式)
+    * [**1，适配器模式**](#1，适配器模式)
+    * [**2，桥接模式**](#2，桥接模式)
+    * [**3，组合模式**](#3，组合模式)
+    * [**4，装饰者模式**](#4，装饰者模式)
+    * [**5，门面模式**](#5，门面模式)
+    * [**6，享元模式**](#6，享元模式)
+    * [**7，代理模式**](#7，代理模式)
+  * [**二，创建模式**](#二，创建模式)
+    * [**1，抽象工厂模式**](#1，抽象工厂模式)
+    * [**2，建造模式(Builder)**](#2，建造模式builder)
+    * [**3，工厂方法**](#3，工厂方法)
+    * [**4，原型模式**](#4，原型模式)
+    * [**5，单例模式**](#5，单例模式)
+  * [**三，行为模式**](#三，行为模式)
+    * [**1，责任链模式**](#1，责任链模式)
+    * [**2，命令模式**](#2，命令模式)
+    * [**3，解释器模式**](#3，解释器模式)
+    * [**4，迭代器模式**](#4，迭代器模式)
+    * [**5，中介者模式**](#5，中介者模式)
+    * [**6，备忘录模式**](#6，备忘录模式)
+    * [**7，空对象模式**](#7，空对象模式)
+    * [**8，观察者模式**](#8，观察者模式)
+    * [**9，状态模式**](#9，状态模式)
+    * [**10，策略模式**](#10，策略模式)
+    * [**11，模板方法模式**](#11，模板方法模式)
+    * [**12，访问者模式**](#12，访问者模式)
+
+
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star、fork哈
+
+文章也将发表在我的个人博客，阅读体验更佳：
+
+> www.how2playlife.com
+
+本文转自https://www.cnblogs.com/LinkinPark/p/5233075.html
+<!-- more -->
+
+## **一，结构型模式**
+
+### **1，适配器模式**
+
+**用来把一个接口转化成另一个接口**
+
+> **java.util.Arrays#asList()**
+>
+> **javax.swing.JTable(TableModel)**
+>
+> **java.io.InputStreamReader(InputStream)**
+>
+> **java.io.OutputStreamWriter(OutputStream)**
+>
+> **javax.xml.bind.annotation.adapters.XmlAdapter#marshal()**
+>
+> **javax.xml.bind.annotation.adapters.XmlAdapter#unmarshal()**
+
+### **2，桥接模式**
+
+**这个模式将抽象和抽象操作的实现进行了解耦，这样使得抽象和实现可以独立地变化**
+
+> **AWT (It provides an abstraction layer which maps onto the native OS the windowing support.)**
+>
+> **JDBC**
+
+### **3，组合模式**
+
+**使得客户端看来单个对象和对象的组合是同等的。换句话说，某个类型的方法同时也接受自身类型作为参数**
+
+> **javax.swing.JComponent#add(Component)**
+>
+> **java.awt.Container#add(Component)**
+>
+> **java.util.Map#putAll(Map)**
+>
+> **java.util.List#addAll(Collection)**
+>
+> **java.util.Set#addAll(Collection)**
+
+### **4，装饰者模式**
+
+**动态的给一个对象附加额外的功能，这也是子类的一种替代方式。可以看到，在创建一个类型的时候，同时也传入同一类型的对象。这在JDK里随处可见，你会发现它无处不在，所以下面这个列表只是一小部分**
+
+> **java.io.BufferedInputStream(InputStream)**
+>
+> **java.io.DataInputStream(InputStream)**
+>
+> **java.io.BufferedOutputStream(OutputStream)**
+>
+> **java.util.zip.ZipOutputStream(OutputStream)**
+>
+> **java.util.Collections#checked<list |sortedmap |sortedset |set |map>**
+
+### **5，门面模式**
+
+**给一组组件，接口，抽象，或者子系统提供一个简单的接口**
+
+> **java.lang.Class**
+>
+> **javax.faces.webapp.FacesServlet**
+
+### **6，享元模式**
+
+**使用缓存来加速大量小对象的访问时间**
+
+> **java.lang.Integer#valueOf(int)**
+>
+> **java.lang.Boolean#valueOf(boolean)**
+>
+> **java.lang.Byte#valueOf(byte)**
+>
+> **java.lang.Character#valueOf(char)**
+
+### **7，代理模式**
+
+**代理模式是用一个简单的对象来代替一个复杂的或者创建耗时的对象。**
+
+> **java.lang.reflect.Proxy**
+>
+> **RMI**
+
+****
+
+## **二，创建模式**
+
+### **1，抽象工厂模式**
+
+**抽象工厂模式提供了一个协议来生成一系列的相关或者独立的对象，而不用指定具体对象的类型。它使得应用程序能够和使用的框架的具体实现进行解耦。这在JDK或者许多框架比如Spring中都随处可见。它们也很容易识别，一个创建新对象的方法，返回的却是接口或者抽象类的，就是抽象工厂模式了**
+
+> **java.util.Calendar#getInstance()**
+>
+> **java.util.Arrays#asList()**
+>
+> **java.util.ResourceBundle#getBundle()**
+>
+> **java.sql.DriverManager#getConnection()**
+>
+> **java.sql.Connection#createStatement()**
+>
+> **java.sql.Statement#executeQuery()**
+>
+> **java.text.NumberFormat#getInstance()**
+>
+> **javax.xml.transform.TransformerFactory#newInstance()**
+
+### **2，建造模式(Builder)**
+
+**定义了一个新的类来构建另一个类的实例，以简化复杂对象的创建。建造模式通常也使用方法链接来实现**
+
+> **java.lang.StringBuilder#append()**
+>
+> **java.lang.StringBuffer#append()**
+>
+> **java.sql.PreparedStatement**
+>
+> **javax.swing.GroupLayout.Group#addComponent()**
+
+### **3，工厂方法**
+
+**就是一个返回具体对象的方法**
+
+> **java.lang.Proxy#newProxyInstance()**
+>
+> **java.lang.Object#toString()**
+>
+> **java.lang.Class#newInstance()**
+>
+> **java.lang.reflect.Array#newInstance()**
+>
+> **java.lang.reflect.Constructor#newInstance()**
+>
+> **java.lang.Boolean#valueOf(String)**
+>
+> **java.lang.Class#forName()**
+
+### **4，原型模式**
+
+**使得类的实例能够生成自身的拷贝。如果创建一个对象的实例非常复杂且耗时时，就可以使用这种模式，而不重新创建一个新的实例，你可以拷贝一个对象并直接修改它**
+
+> **java.lang.Object#clone()**
+>
+> **java.lang.Cloneable**
+
+### **5，单例模式**
+
+**用来确保类只有一个实例。Joshua Bloch在Effetive Java中建议到，还有一种方法就是使用枚举**
+
+> **java.lang.Runtime#getRuntime()**
+>
+> **java.awt.Toolkit#getDefaultToolkit()**
+>
+> **java.awt.GraphicsEnvironment#getLocalGraphicsEnvironment()**
+>
+> **java.awt.Desktop#getDesktop()**
+
+****
+
+## **三，行为模式**
+
+### **1，责任链模式**
+
+**通过把请求从一个对象传递到链条中下一个对象的方式，直到请求被处理完毕，以实现对象间的解耦**
+
+> **java.util.logging.Logger#log()**
+>
+> **javax.servlet.Filter#doFilter()**
+
+### **2，命令模式**
+
+**将操作封装到对象内，以便存储，传递和返回**
+
+> **java.lang.Runnable**
+>
+> **javax.swing.Action**
+
+### **3，解释器模式**
+
+**这个模式通常定义了一个语言的语法，然后解析相应语法的语句**
+
+> **java.util.Pattern**
+>
+> **java.text.Normalizer**
+>
+> **java.text.Format**
+
+### **4，迭代器模式**
+
+**提供一个一致的方法来顺序访问集合中的对象，这个方法与底层的集合的具体实现无关**
+
+> **java.util.Iterator**
+>
+> **java.util.Enumeration**
+
+### **5，中介者模式**
+
+**通过使用一个中间对象来进行消息分发以及减少类之间的直接依赖**
+
+> **java.util.Timer**
+>
+> **java.util.concurrent.Executor#execute()**
+>
+> **java.util.concurrent.ExecutorService#submit()**
+>
+> **java.lang.reflect.Method#invoke()**
+
+### **6，备忘录模式**
+
+**生成对象状态的一个快照，以便对象可以恢复原始状态而不用暴露自身的内容。Date对象通过自身内部的一个long值来实现备忘录模式**
+
+> **java.util.Date**
+>
+> **java.io.Serializable**
+
+### **7，空对象模式**
+
+**这个模式通过一个无意义的对象来代替没有对象这个状态。它使得你不用额外对空对象进行处理**
+
+> **java.util.Collections#emptyList()**
+>
+> **java.util.Collections#emptyMap()**
+>
+> **java.util.Collections#emptySet()**
+
+### **8，观察者模式**
+
+**它使得一个对象可以灵活的将消息发送给感兴趣的对象**
+
+> **java.util.EventListener**
+>
+> **javax.servlet.http.HttpSessionBindingListener**
+>
+> **javax.servlet.http.HttpSessionAttributeListener**
+>
+> **javax.faces.event.PhaseListener**
+
+### **9，状态模式**
+
+**通过改变对象内部的状态，使得你可以在运行时动态改变一个对象的行为**
+
+> **java.util.Iterator**
+>
+> **javax.faces.lifecycle.LifeCycle#execute()**
+
+### **10，策略模式**
+
+**使用这个模式来将一组算法封装成一系列对象。通过传递这些对象可以灵活的改变程序的功能**
+
+> **java.util.Comparator#compare()**
+>
+> **javax.servlet.http.HttpServlet**
+>
+> **javax.servlet.Filter#doFilter()**
+
+### **11，模板方法模式**
+
+**让子类可以重写方法的一部分，而不是整个重写，你可以控制子类需要重写那些操作**
+
+> **java.util.Collections#sort()**
+>
+> **java.io.InputStream#skip()**
+>
+> **java.io.InputStream#read()**
+>
+> **java.util.AbstractList#indexOf()**
+
+### **12，访问者模式**
+
+**提供一个方便的可维护的方式来操作一组对象。它使得你在不改变操作的对象前提下，可以修改或者扩展对象的行为**
+
+> **javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor**
+>
+> **javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor**
+
+**译者注：很多地方可能会存在争议，是否是某种模式其实并不是特别重要，重要的是它们的设计能为改善我们的代码提供一些经验**
+
+
diff --git "a/docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232Spring\346\266\211\345\217\212\345\210\260\347\232\204\347\247\215\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232Spring\346\266\211\345\217\212\345\210\260\347\232\204\347\247\215\350\256\276\350\256\241\346\250\241\345\274\217.md"
new file mode 100644
index 0000000..4de1f33
--- /dev/null
+++ "b/docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232Spring\346\266\211\345\217\212\345\210\260\347\232\204\347\247\215\350\256\276\350\256\241\346\250\241\345\274\217.md"
@@ -0,0 +1,178 @@
+# 目录
+  * [结构型模式](#结构型模式)
+    * [代理模式](#代理模式)
+    * [适配器模式](#适配器模式)
+    * [桥梁模式](#桥梁模式)
+    * [装饰模式](#装饰模式)
+    * [门面模式](#门面模式)
+    * [组合模式](#组合模式)
+    * [享元模式](#享元模式)
+    * [结构型模式总结](#结构型模式总结)
+  * [参考文章](#参考文章)
+
+
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star、fork哈
+
+文章也将发表在我的个人博客，阅读体验更佳：
+
+> www.how2playlife.com
+<!-- more -->
+
+**设计模式**作为工作学习中的枕边书，却时常处于勤说不用的尴尬境地，也不是我们时常忘记，只是一直没有记忆。
+
+今天，螃蟹在IT学习者网站就设计模式的内在价值做一番探讨，并以spring为例进行讲解，只有领略了其设计的思想理念，才能在工作学习中运用到“无形”。
+
+Spring作为业界的经典框架，无论是在架构设计方面，还是在代码编写方面，都堪称行内典范。好了，话不多说，开始今天的内容。
+
+spring中常用的设计模式达到九种，我们举例说明：
+
+**第一种：简单工厂**
+
+又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。
+简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。
+spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。如下配置，就是在 HelloItxxz 类中创建一个 itxxzBean。
+
+````
+    <beans>
+    
+      <bean id="singletonBean" >
+    
+        <constructor-arg>
+    
+          <value>Hello! 这是singletonBean!value>
+    
+        </constructor-arg>
+    
+     </ bean>
+    
+      <bean id="itxxzBean"
+    
+        singleton="false">
+    
+        <constructor-arg>
+    
+          <value>Hello! 这是itxxzBean! value>
+    
+        </constructor-arg>
+    
+      </bean>
+    
+    </beans>
+````
+
+**第二种：工厂方法（Factory Method）**
+
+通常由应用程序直接使用new创建新的对象，为了将对象的创建和使用相分离，采用工厂模式,即应用程序将对象的创建及初始化职责交给工厂对象。
+
+一般情况下,应用程序有自己的工厂对象来创建bean.如果将应用程序自己的工厂对象交给Spring管理,那么Spring管理的就不是普通的bean,而是工厂Bean。
+
+螃蟹就以工厂方法中的静态方法为例讲解一下：
+````   
+    import java.util.Random;
+    
+    public class StaticFactoryBean{
+    
+       public static Integer createRandom() {
+    
+         return new Integer(new Random().nextInt());
+    
+       }
+    
+    }
+````
+建一个config.xm配置文件，将其纳入Spring容器来管理,需要通过factory-method指定静态方法名称
+````
+    <bean id="random"
+    
+    factory-method="createRandom"//createRandom方法必须是static的,才能找到 scope="prototype"
+    
+    />
+````
+测试:
+````
+    public static void main(String[] args) {
+      //调用getBean()时,返回随机数.如果没有指定factory-method,会返回StaticFactoryBean的实例,即返回工厂Bean的实例   XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("config.xml"));   System.out.println("我是IT学习者创建的实例:"+factory.getBean("random").toString());
+    
+    }
+````
+**第三种：单例模式（Singleton）**
+
+保证一个类仅有一个实例，并提供一个访问它的全局访问点。
+spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例，这是因为spring管理的是是任意的java对象。
+核心提示点：Spring下默认的bean均为singleton，可以通过singleton=“true|false” 或者 scope=“？”来指定
+
+**第四种：适配器（Adapter）**
+
+在Spring的Aop中，使用的Advice（通知）来增强被代理类的功能。Spring实现这一AOP功能的原理就使用代理模式（1、JDK动态代理。2、CGLib字节码生成技术代理。）对类进行方法级别的切面增强，即，生成被代理类的代理类， 并在代理类的方法前，设置拦截器，通过执行拦截器重的内容增强了代理方法的功能，实现的面向切面编程。
+
+**Adapter类接口**：
+````
+    public interface AdvisorAdapter {
+    
+    boolean supportsAdvice(Advice advice);
+    
+      MethodInterceptor getInterceptor(Advisor advisor);
+    
+    }**MethodBeforeAdviceAdapter类**，Adapter
+    
+    class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
+    
+      public boolean supportsAdvice(Advice advice) {
+    
+        return (advice instanceof MethodBeforeAdvice);
+    
+      }
+    
+      public MethodInterceptor getInterceptor(Advisor advisor) {
+    
+        MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
+    
+      return new MethodBeforeAdviceInterceptor(advice);
+    
+      }
+    
+    }
+````
+**第五种：包装器（Decorator）**
+
+在我们的项目中遇到这样一个问题：我们的项目需要连接多个数据库，而且不同的客户在每次访问中根据需要会去访问不同的数据库。我们以往在spring和hibernate框架中总是配置一个数据源，因而sessionFactory的dataSource属性总是指向这个数据源并且恒定不变，所有DAO在使用sessionFactory的时候都是通过这个数据源访问数据库。
+
+但是现在，由于项目的需要，我们的DAO在访问sessionFactory的时候都不得不在多个数据源中不断切换，问题就出现了：如何让sessionFactory在执行数据持久化的时候，根据客户的需求能够动态切换不同的数据源？我们能不能在spring的框架下通过少量修改得到解决？是否有什么设计模式可以利用呢？
+
+
+首先想到在spring的applicationContext中配置所有的dataSource。这些dataSource可能是各种不同类型的，比如不同的数据库：Oracle、SQL Server、MySQL等，也可能是不同的数据源：比如apache提供的org.apache.commons.dbcp.BasicDataSource、spring提供的org.springframework.jndi.JndiObjectFactoryBean等。然后sessionFactory根据客户的每次请求，将dataSource属性设置成不同的数据源，以到达切换数据源的目的。
+
+spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。
+
+**第六种：代理（Proxy）**
+
+为其他对象提供一种代理以控制对这个对象的访问。 从结构上来看和Decorator模式类似，但Proxy是控制，更像是一种对功能的限制，而Decorator是增加职责。
+spring的Proxy模式在aop中有体现，比如JdkDynamicAopProxy和Cglib2AopProxy。
+
+**第七种：观察者（Observer）**
+
+定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
+spring中Observer模式常用的地方是listener的实现。如ApplicationListener。
+
+**第八种：策略（Strategy）**
+
+定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。
+spring中在实例化对象的时候用到Strategy模式
+在SimpleInstantiationStrategy中有如下代码说明了策略模式的使用情况：
+
+**第九种：模板方法（Template Method）**
+
+定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
+Template Method模式一般是需要继承的。这里想要探讨另一种对Template Method的理解。
+
+spring中的JdbcTemplate，在用这个类时并不想去继承这个类，因为这个类的方法太多，但是我们还是想用到JdbcTemplate已有的稳定的、公用的数据库连接，那么我们怎么办呢？我们可以把变化的东西抽出来作为一个参数传入JdbcTemplate的方法中。但是变化的东西是一段代码，而且这段代码会用到JdbcTemplate中的变量。
+
+怎么办？那我们就用回调对象吧。在这个回调对象中定义一个操纵JdbcTemplate中变量的方法，我们去实现这个方法，就把变化的东西集中到这里了。然后我们再传入这个回调对象到JdbcTemplate，从而完成了调用。这可能是Template Method不需要继承的另一种实现方式吧。
+
+
+
diff --git "a/docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2171\357\274\232\345\210\233\345\273\272\345\236\213\346\250\241\345\274\217\357\274\210\345\267\245\345\216\202\357\274\214\345\215\225\344\276\213\347\255\211\357\274\211.md" "b/docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232\345\210\233\345\273\272\345\236\213\346\250\241\345\274\217\357\274\210\345\267\245\345\216\202\357\274\214\345\215\225\344\276\213\347\255\211\357\274\211.md"
similarity index 83%
rename from "docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2171\357\274\232\345\210\233\345\273\272\345\236\213\346\250\241\345\274\217\357\274\210\345\267\245\345\216\202\357\274\214\345\215\225\344\276\213\347\255\211\357\274\211.md"
rename to "docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232\345\210\233\345\273\272\345\236\213\346\250\241\345\274\217\357\274\210\345\267\245\345\216\202\357\274\214\345\215\225\344\276\213\347\255\211\357\274\211.md"
index ebacece..c663f59 100644
--- "a/docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2171\357\274\232\345\210\233\345\273\272\345\236\213\346\250\241\345\274\217\357\274\210\345\267\245\345\216\202\357\274\214\345\215\225\344\276\213\347\255\211\357\274\211.md"
+++ "b/docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232\345\210\233\345\273\272\345\236\213\346\250\241\345\274\217\357\274\210\345\267\245\345\216\202\357\274\214\345\215\225\344\276\213\347\255\211\357\274\211.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [创建型模式](#创建型模式)
     * [简单工厂模式](#简单工厂模式)
     * [工厂模式](#工厂模式)
@@ -9,9 +8,7 @@
     * [原型模式](#原型模式)
     * [创建型模式总结](#创建型模式总结)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 Java 设计模式
@@ -30,7 +27,7 @@ Java 设计模式
 
 一直想写一篇介绍设计模式的文章，让读者可以很快看完，而且一看就懂，看懂就会用，同时不会将各个模式搞混。自认为本文还是写得不错的，花了不少心思来写这文章和做图，力求让读者真的能看着简单同时有所收获。
 
-设计模式是对大家实际工作中写的各种代码进行高层次抽象的总结，其中最出名的当属 _Gang of Four_ (_GoF_) 的分类了，他们将设计模式分类为 23 种经典的模式，根据用途我们又可以分为三大类，分别为创建型模式、结构型模式和行为型模式。是的，我不善于扯这些有的没的，还是少点废话吧~~~
+设计模式是对大家实际工作中写的各种代码进行高层次抽象的总结，其中最出名的当属_Gang of Four_(_GoF_) 的分类了，他们将设计模式分类为 23 种经典的模式，根据用途我们又可以分为三大类，分别为创建型模式、结构型模式和行为型模式。是的，我不善于扯这些有的没的，还是少点废话吧~~~
 
 有一些重要的设计原则在开篇和大家分享下，这些原则将贯通全文：
 
@@ -144,8 +141,7 @@ public class APP {
 
 虽然简单，不过我也把所有的构件都画到一张图上，这样读者看着比较清晰：
 
-![](https://javadoop.com/blogimages/design-pattern/factory-1.png)![](https://csdnimg.cn/release/phoenix/write/assets/uploading.gif)转存失败重新上传取消![factory-1](https://javadoop.com/blogimages/design-pattern/factory-1.png)![](data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw== "点击并拖拽以移动")​
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404211801.png)
 ### 抽象工厂模式
 
 当涉及到**产品族**的时候，就需要引入抽象工厂模式了。
@@ -154,7 +150,7 @@ public class APP {
 
 因为电脑是由许多的构件组成的，我们将 CPU 和主板进行抽象，然后 CPU 由 CPUFactory 生产，主板由 MainBoardFactory 生产，然后，我们再将 CPU 和主板搭配起来组合在一起，如下图：
 
-![](https://javadoop.com/blogimages/design-pattern/abstract-factory-1.png)![](https://csdnimg.cn/release/phoenix/write/assets/uploading.gif)转存失败重新上传取消![factory-1](https://javadoop.com/blogimages/design-pattern/abstract-factory-1.png)![](data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw== "点击并拖拽以移动")​
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404211822.png)
 
 这个时候的客户端调用是这样的：
 
@@ -174,20 +170,15 @@ Computer computer = new Computer(cpu, mainBoard);
 
 单独看 CPU 工厂和主板工厂，它们分别是前面我们说的**工厂模式**。这种方式也容易扩展，因为要给电脑加硬盘的话，只需要加一个 HardDiskFactory 和相应的实现即可，不需要修改现有的工厂。
 
-但是，这种方式有一个问题，那就是如果 **Intel 家产的 CPU 和 AMD 产的主板不能兼容使用**，那么这代码就容易出错，因为客户端并不知道它们不兼容，也就会错误地出现随意组合。
+但是，这种方式有一个问题，那就是如果**Intel 家产的 CPU 和 AMD 产的主板不能兼容使用**，那么这代码就容易出错，因为客户端并不知道它们不兼容，也就会错误地出现随意组合。
 
 下面就是我们要说的**产品族**的概念，它代表了组成某个产品的一系列附件的集合：
 
-![](https://javadoop.com/blogimages/design-pattern/abstract-factory-2.png)
-
-![abstract-factory-2](https://javadoop.com/blogimages/design-pattern/abstract-factory-2.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404211846.png)
 
 当涉及到这种产品族的问题的时候，就需要抽象工厂模式来支持了。我们不再定义 CPU 工厂、主板工厂、硬盘工厂、显示屏工厂等等，我们直接定义电脑工厂，每个电脑工厂负责生产所有的设备，这样能保证肯定不存在兼容问题。
 
-![](https://javadoop.com/blogimages/design-pattern/abstract-factory-3.png)
-
-![abstract-factory-3](https://javadoop.com/blogimages/design-pattern/abstract-factory-3.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212006.png)
 
 这个时候，对于客户端来说，不再需要单独挑选 CPU厂商、主板厂商、硬盘厂商等，直接选择一家品牌工厂，品牌工厂会负责生产所有的东西，而且能保证肯定是兼容可用的。
 
@@ -390,7 +381,7 @@ public class APP {
 
 ```
 
-说实话，建造者模式的**链式**写法很吸引人，但是，多写了很多“无用”的 builder 的代码，感觉这个模式没什么用。不过，当属性很多，而且有些必填，有些选填的时候，这个模式会使代码清晰很多。我们可以在 **Builder 的构造方法**中强制让调用者提供必填字段，还有，在 build() 方法中校验各个参数比在 User 的构造方法中校验，代码要优雅一些。
+说实话，建造者模式的**链式**写法很吸引人，但是，多写了很多“无用”的 builder 的代码，感觉这个模式没什么用。不过，当属性很多，而且有些必填，有些选填的时候，这个模式会使代码清晰很多。我们可以在**Builder 的构造方法**中强制让调用者提供必填字段，还有，在 build() 方法中校验各个参数比在 User 的构造方法中校验，代码要优雅一些。
 
 > 题外话，强烈建议读者使用 lombok，用了 lombok 以后，上面的一大堆代码会变成如下这样:
 
@@ -407,7 +398,7 @@ class User {
 
 > 怎么样，省下来的时间是不是又可以干点别的了。
 
-当然，如果你只是想要链式写法，不想要建造者模式，有个很简单的办法，User 的 getter 方法不变，所有的 setter 方法都让其 **return this** 就可以了，然后就可以像下面这样调用：
+当然，如果你只是想要链式写法，不想要建造者模式，有个很简单的办法，User 的 getter 方法不变，所有的 setter 方法都让其**return this**就可以了，然后就可以像下面这样调用：
 
 ```
 User user = new User().setName("").setPassword("").setAge(20);
@@ -443,20 +434,4 @@ protected native Object clone() throws CloneNotSupportedException;
 转自https://javadoop.com/post/design-pattern
 
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2172\357\274\232\347\273\223\346\236\204\345\236\213\346\250\241\345\274\217\357\274\210\344\273\243\347\220\206\346\250\241\345\274\217\357\274\214\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217\347\255\211\357\274\211.md" "b/docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232\347\273\223\346\236\204\345\236\213\346\250\241\345\274\217\357\274\210\344\273\243\347\220\206\346\250\241\345\274\217\357\274\214\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217\347\255\211\357\274\211.md"
similarity index 88%
rename from "docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2172\357\274\232\347\273\223\346\236\204\345\236\213\346\250\241\345\274\217\357\274\210\344\273\243\347\220\206\346\250\241\345\274\217\357\274\214\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217\347\255\211\357\274\211.md"
rename to "docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232\347\273\223\346\236\204\345\236\213\346\250\241\345\274\217\357\274\210\344\273\243\347\220\206\346\250\241\345\274\217\357\274\214\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217\347\255\211\357\274\211.md"
index a027df7..dddba91 100644
--- "a/docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2172\357\274\232\347\273\223\346\236\204\345\236\213\346\250\241\345\274\217\357\274\210\344\273\243\347\220\206\346\250\241\345\274\217\357\274\214\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217\347\255\211\357\274\211.md"
+++ "b/docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232\347\273\223\346\236\204\345\236\213\346\250\241\345\274\217\357\274\210\344\273\243\347\220\206\346\250\241\345\274\217\357\274\214\351\200\202\351\205\215\345\231\250\346\250\241\345\274\217\347\255\211\357\274\211.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [结构型模式](#结构型模式)
     * [代理模式](#代理模式)
     * [适配器模式](#适配器模式)
@@ -10,9 +9,7 @@
     * [享元模式](#享元模式)
     * [结构型模式总结](#结构型模式总结)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 
@@ -25,6 +22,7 @@
 文章也将发表在我的个人博客，阅读体验更佳：
 
 > www.how2playlife.com
+<!-- more -->
 
 ## 结构型模式
 
@@ -97,8 +95,9 @@ foodService.makeChicken();
 
 ```
 
-![](https://javadoop.com/blogimages/design-pattern/proxy-1.png)
-我们发现没有，代理模式说白了就是做 **“方法包装”** 或做 **“方法增强”**。在面向切面编程中，算了还是不要吹捧这个名词了，在 AOP 中，其实就是动态代理的过程。比如 Spring 中，我们自己不定义代理类，但是 Spring 会帮我们动态来定义代理，然后把我们定义在 @Before、@After、@Around 中的代码逻辑动态添加到代理中。
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212100.png)
+
+我们发现没有，代理模式说白了就是做**“方法包装”**或做**“方法增强”**。在面向切面编程中，算了还是不要吹捧这个名词了，在 AOP 中，其实就是动态代理的过程。比如 Spring 中，我们自己不定义代理类，但是 Spring 会帮我们动态来定义代理，然后把我们定义在 @Before、@After、@Around 中的代码逻辑动态添加到代理中。
 
 说到动态代理，又可以展开说 …… Spring 中实现动态代理有两种，一种是如果我们的类定义了接口，如 UserService 接口和 UserServiceImpl 实现，那么采用 JDK 的动态代理，感兴趣的读者可以去看看 java.lang.reflect.Proxy 类的源码；另一种是我们自己没有定义接口的，Spring 会采用 CGLIB 进行动态代理，它是一个 jar 包，性能还不错。
 
@@ -253,17 +252,16 @@ public static void main(String[] args) {
 
 我们用一个图来简单说明下：
 
-![](https://javadoop.com/blogimages/design-pattern/adapter-1.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212138.png)
 上图应该还是很容易理解的，我就不做更多的解释了。下面，我们看看类适配模式怎么样的。
 
 类适配器模式
 
 废话少说，直接上图：
 
-![](https://javadoop.com/blogimages/design-pattern/adapter-2.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212155.png)
 
-看到这个图，大家应该很容易理解的吧，通过继承的方法，适配器自动获得了所需要的大部分方法。这个时候，客户端使用更加简单，直接 `Target t = new SomeAdapter();` 就可以了。
+看到这个图，大家应该很容易理解的吧，通过继承的方法，适配器自动获得了所需要的大部分方法。这个时候，客户端使用更加简单，直接`Target t = new SomeAdapter();`就可以了。
 
 适配器模式总结
 
@@ -279,7 +277,7 @@ public static void main(String[] args) {
 
     比较这两种模式，其实是比较对象适配器模式和代理模式，在代码结构上，它们很相似，都需要一个具体的实现类的实例。但是它们的目的不一样，代理模式做的是增强原方法的活；适配器做的是适配的活，为的是提供“把鸡包装成鸭，然后当做鸭来使用”，而鸡和鸭它们之间原本没有继承关系。
 
-![](https://javadoop.com/blogimages/design-pattern/adapter-5.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212256.png)
 
 ### 桥梁模式
 
@@ -392,13 +390,12 @@ public static void main(String[] args) {
 
 首先，我们先看一个简单的图，看这个图的时候，了解下层次结构就可以了：
 
-![](https://javadoop.com/blogimages/design-pattern/decorator-1.png)
-
-我们来说说装饰模式的出发点，从图中可以看到，接口 `Component` 其实已经有了 `ConcreteComponentA` 和 `ConcreteComponentB` 两个实现类了，但是，如果我们要**增强**这两个实现类的话，我们就可以采用装饰模式，用具体的装饰器来**装饰**实现类，以达到增强的目的。
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212315.png)
+我们来说说装饰模式的出发点，从图中可以看到，接口`Component`其实已经有了`ConcreteComponentA`和`ConcreteComponentB`两个实现类了，但是，如果我们要**增强**这两个实现类的话，我们就可以采用装饰模式，用具体的装饰器来**装饰**实现类，以达到增强的目的。
 
 > 从名字来简单解释下装饰器。既然说是装饰，那么往往就是**添加小功能**这种，而且，我们要满足可以添加多个小功能。最简单的，代理模式就可以实现功能的增强，但是代理不容易实现多个功能的增强，当然你可以说用代理包装代理的方式，但是那样的话代码就复杂了。
 
-首先明白一些简单的概念，从图中我们看到，所有的具体装饰者们 ConcreteDecorator_ 都可以作为 Component 来使用，因为它们都实现了 Component 中的所有接口。它们和 Component 实现类 ConcreteComponent_ 的区别是，它们只是装饰者，起**装饰**作用，也就是即使它们看上去牛逼轰轰，但是它们都只是在具体的实现中**加了层皮来装饰**而已。
+首先明白一些简单的概念，从图中我们看到，所有的具体装饰者们 ConcreteDecorator_都可以作为 Component 来使用，因为它们都实现了 Component 中的所有接口。它们和 Component 实现类 ConcreteComponent_的区别是，它们只是装饰者，起**装饰**作用，也就是即使它们看上去牛逼轰轰，但是它们都只是在具体的实现中**加了层皮来装饰**而已。
 
 > 注意这段话中混杂在各个名词中的 Component 和 Decorator，别搞混了。
 
@@ -517,13 +514,12 @@ Beverage beverage = new Mongo(new Pearl(new Lemon(new Lemon(new BlackTea()))));
 
 看看下图可能会清晰一些：
 
-![](https://javadoop.com/blogimages/design-pattern/decorator-2.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212336.png)
 到这里，大家应该已经清楚装饰模式了吧。
 
 下面，我们再来说说 java IO 中的装饰模式。看下图 InputStream 派生出来的部分类：
 
-![](https://javadoop.com/blogimages/design-pattern/decorator-3.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212353.png)
 
 我们知道 InputStream 代表了输入流，具体的输入来源可以是文件（FileInputStream）、管道（PipedInputStream）、数组（ByteArrayInputStream）等，这些就像前面奶茶的例子中的红茶、绿茶，属于基础输入流。
 
@@ -711,20 +707,4 @@ public class Employee {
 转自https://javadoop.com/post/design-pattern
 
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2173\357\274\232\350\241\214\344\270\272\345\236\213\346\250\241\345\274\217\357\274\210\347\255\226\347\225\245\357\274\214\350\247\202\345\257\237\350\200\205\347\255\211\357\274\211.md" "b/docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232\350\241\214\344\270\272\345\236\213\346\250\241\345\274\217\357\274\210\347\255\226\347\225\245\357\274\214\350\247\202\345\257\237\350\200\205\347\255\211\357\274\211.md"
similarity index 91%
rename from "docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2173\357\274\232\350\241\214\344\270\272\345\236\213\346\250\241\345\274\217\357\274\210\347\255\226\347\225\245\357\274\214\350\247\202\345\257\237\350\200\205\347\255\211\357\274\211.md"
rename to "docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232\350\241\214\344\270\272\345\236\213\346\250\241\345\274\217\357\274\210\347\255\226\347\225\245\357\274\214\350\247\202\345\257\237\350\200\205\347\255\211\357\274\211.md"
index e24ef16..9e99974 100644
--- "a/docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2173\357\274\232\350\241\214\344\270\272\345\236\213\346\250\241\345\274\217\357\274\210\347\255\226\347\225\245\357\274\214\350\247\202\345\257\237\350\200\205\347\255\211\357\274\211.md"
+++ "b/docs/Java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\217\357\274\232\350\241\214\344\270\272\345\236\213\346\250\241\345\274\217\357\274\210\347\255\226\347\225\245\357\274\214\350\247\202\345\257\237\350\200\205\347\255\211\357\274\211.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [行为型模式](#行为型模式)
     * [策略模式](#策略模式)
     * [观察者模式](#观察者模式)
@@ -18,9 +17,7 @@
     * [享元模式](#享元模式)
     * [结构型模式总结](#结构型模式总结)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 转自https://javadoop.com/post/design-pattern
@@ -44,6 +41,7 @@
 文章也将发表在我的个人博客，阅读体验更佳：
 
 > www.how2playlife.com
+<!-- more -->
 
 ## 行为型模式
 
@@ -117,11 +115,10 @@ public static void main(String[] args) {
 
 放到一张图上，让大家看得清晰些：
 
-![](https://javadoop.com/blogimages/design-pattern/strategy-1.png)![](https://csdnimg.cn/release/phoenix/write/assets/uploading.gif)转存失败重新上传取消![strategy-1](https://javadoop.com/blogimages/design-pattern/strategy-1.png)![](data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw== "点击并拖拽以移动")​
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212514.png)
 这个时候，大家有没有联想到结构型模式中的桥梁模式，它们其实非常相似，我把桥梁模式的图拿过来大家对比下：
 
-![](https://javadoop.com/blogimages/design-pattern/bridge-1.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212533.png)
 
 要我说的话，它们非常相似，桥梁模式在左侧加了一层抽象而已。桥梁模式的耦合更低，结构更复杂一些。
 
@@ -587,8 +584,9 @@ foodService.makeChicken();
 
 ```
 
-![](https://javadoop.com/blogimages/design-pattern/proxy-1.png)
-我们发现没有，代理模式说白了就是做 **“方法包装”** 或做 **“方法增强”**。在面向切面编程中，算了还是不要吹捧这个名词了，在 AOP 中，其实就是动态代理的过程。比如 Spring 中，我们自己不定义代理类，但是 Spring 会帮我们动态来定义代理，然后把我们定义在 @Before、@After、@Around 中的代码逻辑动态添加到代理中。
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212608.png)
+
+我们发现没有，代理模式说白了就是做**“方法包装”**或做**“方法增强”**。在面向切面编程中，算了还是不要吹捧这个名词了，在 AOP 中，其实就是动态代理的过程。比如 Spring 中，我们自己不定义代理类，但是 Spring 会帮我们动态来定义代理，然后把我们定义在 @Before、@After、@Around 中的代码逻辑动态添加到代理中。
 
 说到动态代理，又可以展开说 …… Spring 中实现动态代理有两种，一种是如果我们的类定义了接口，如 UserService 接口和 UserServiceImpl 实现，那么采用 JDK 的动态代理，感兴趣的读者可以去看看 java.lang.reflect.Proxy 类的源码；另一种是我们自己没有定义接口的，Spring 会采用 CGLIB 进行动态代理，它是一个 jar 包，性能还不错。
 
@@ -743,17 +741,15 @@ public static void main(String[] args) {
 
 我们用一个图来简单说明下：
 
-![](https://javadoop.com/blogimages/design-pattern/adapter-1.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212635.png)
 上图应该还是很容易理解的，我就不做更多的解释了。下面，我们看看类适配模式怎么样的。
 
 类适配器模式
 
 废话少说，直接上图：
 
-![](https://javadoop.com/blogimages/design-pattern/adapter-2.png)
-
-看到这个图，大家应该很容易理解的吧，通过继承的方法，适配器自动获得了所需要的大部分方法。这个时候，客户端使用更加简单，直接 `Target t = new SomeAdapter();` 就可以了。
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212648.png)
+看到这个图，大家应该很容易理解的吧，通过继承的方法，适配器自动获得了所需要的大部分方法。这个时候，客户端使用更加简单，直接`Target t = new SomeAdapter();`就可以了。
 
 适配器模式总结
 
@@ -769,8 +765,7 @@ public static void main(String[] args) {
 
     比较这两种模式，其实是比较对象适配器模式和代理模式，在代码结构上，它们很相似，都需要一个具体的实现类的实例。但是它们的目的不一样，代理模式做的是增强原方法的活；适配器做的是适配的活，为的是提供“把鸡包装成鸭，然后当做鸭来使用”，而鸡和鸭它们之间原本没有继承关系。
 
-![](https://javadoop.com/blogimages/design-pattern/adapter-5.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212702.png)
 ### 桥梁模式
 
 理解桥梁模式，其实就是理解代码抽象和解耦。
@@ -870,8 +865,7 @@ public static void main(String[] args) {
 
 可能大家看上面一步步还不是特别清晰，我把所有的东西整合到一张图上：
 
-![](https://javadoop.com/blogimages/design-pattern/bridge-1.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212721.png)
 这回大家应该就知道抽象在哪里，怎么解耦了吧。桥梁模式的优点也是显而易见的，就是非常容易进行扩展。
 
 > 本节引用了[这里](https://www.tutorialspoint.com/design_pattern/bridge_pattern.htm)的例子，并对其进行了修改。
@@ -882,13 +876,12 @@ public static void main(String[] args) {
 
 首先，我们先看一个简单的图，看这个图的时候，了解下层次结构就可以了：
 
-![](https://javadoop.com/blogimages/design-pattern/decorator-1.png)
-
-我们来说说装饰模式的出发点，从图中可以看到，接口 `Component` 其实已经有了 `ConcreteComponentA` 和 `ConcreteComponentB` 两个实现类了，但是，如果我们要**增强**这两个实现类的话，我们就可以采用装饰模式，用具体的装饰器来**装饰**实现类，以达到增强的目的。
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230404212733.png)
+我们来说说装饰模式的出发点，从图中可以看到，接口`Component`其实已经有了`ConcreteComponentA`和`ConcreteComponentB`两个实现类了，但是，如果我们要**增强**这两个实现类的话，我们就可以采用装饰模式，用具体的装饰器来**装饰**实现类，以达到增强的目的。
 
 > 从名字来简单解释下装饰器。既然说是装饰，那么往往就是**添加小功能**这种，而且，我们要满足可以添加多个小功能。最简单的，代理模式就可以实现功能的增强，但是代理不容易实现多个功能的增强，当然你可以说用代理包装代理的方式，但是那样的话代码就复杂了。
 
-首先明白一些简单的概念，从图中我们看到，所有的具体装饰者们 ConcreteDecorator_ 都可以作为 Component 来使用，因为它们都实现了 Component 中的所有接口。它们和 Component 实现类 ConcreteComponent_ 的区别是，它们只是装饰者，起**装饰**作用，也就是即使它们看上去牛逼轰轰，但是它们都只是在具体的实现中**加了层皮来装饰**而已。
+首先明白一些简单的概念，从图中我们看到，所有的具体装饰者们 ConcreteDecorator_都可以作为 Component 来使用，因为它们都实现了 Component 中的所有接口。它们和 Component 实现类 ConcreteComponent_的区别是，它们只是装饰者，起**装饰**作用，也就是即使它们看上去牛逼轰轰，但是它们都只是在具体的实现中**加了层皮来装饰**而已。
 
 > 注意这段话中混杂在各个名词中的 Component 和 Decorator，别搞混了。
 
@@ -1201,20 +1194,4 @@ public class Employee {
 转自https://javadoop.com/post/design-pattern
 
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/design-parttern/\350\256\276\350\256\241\346\250\241\345\274\217\345\255\246\344\271\240\346\200\273\347\273\223.md" "b/docs/Java/design-parttern/\350\256\276\350\256\241\346\250\241\345\274\217\345\255\246\344\271\240\346\200\273\347\273\223.md"
similarity index 86%
rename from "docs/java/design-parttern/\350\256\276\350\256\241\346\250\241\345\274\217\345\255\246\344\271\240\346\200\273\347\273\223.md"
rename to "docs/Java/design-parttern/\350\256\276\350\256\241\346\250\241\345\274\217\345\255\246\344\271\240\346\200\273\347\273\223.md"
index c6595f1..9d0d0ec 100644
--- "a/docs/java/design-parttern/\350\256\276\350\256\241\346\250\241\345\274\217\345\255\246\344\271\240\346\200\273\347\273\223.md"
+++ "b/docs/Java/design-parttern/\350\256\276\350\256\241\346\250\241\345\274\217\345\255\246\344\271\240\346\200\273\347\273\223.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
 * [设计模式](#设计模式)
 * [创建型模式](#创建型模式)
   * [单例](#单例)
@@ -22,25 +21,15 @@
   * [状态模式](#状态模式)
   * [观察者模式和事件监听机制](#观察者模式和事件监听机制)
   * [责任链模式](#责任链模式)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-
----
-title: 设计模式学习总结
-date: 2018-07-09 23:05:07
-tags:
-	- 设计模式
-categories:
-	- 后端
-	- 技术总结
----
+
+
+  
 设计模式基础学习总结
 这篇总结主要是基于我之前设计模式基础系列文章而形成的的。主要是把重要的知识点用自己的话说了一遍，可能会有一些错误，还望见谅和指点。谢谢
 
 更多详细内容可以查看我的专栏文章：设计模式学习
 https://blog.csdn.net/a724888/article/category/6780980
+
 <!-- more -->
 
 # 设计模式
@@ -216,20 +205,4 @@ https://blog.csdn.net/a724888/article/category/6780980
 
 责任链通常需要先建立一个单向链表，然后调用方只需要调用头部节点就可以了，后面会自动流转下去。比如流程审批就是一个很好的例子，只要终端用户提交申请，根据申请的内容信息，自动建立一条责任链，然后就可以开始流转了。
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/network-programming/Java\347\275\221\347\273\234\344\270\216NIO\346\200\273\347\273\223.md" "b/docs/Java/network/Java\347\275\221\347\273\234\344\270\216NIO\346\200\273\347\273\223.md"
similarity index 90%
rename from "docs/java/network-programming/Java\347\275\221\347\273\234\344\270\216NIO\346\200\273\347\273\223.md"
rename to "docs/Java/network/Java\347\275\221\347\273\234\344\270\216NIO\346\200\273\347\273\223.md"
index 259082a..15c003a 100644
--- "a/docs/java/network-programming/Java\347\275\221\347\273\234\344\270\216NIO\346\200\273\347\273\223.md"
+++ "b/docs/Java/network/Java\347\275\221\347\273\234\344\270\216NIO\346\200\273\347\273\223.md"
@@ -1,5 +1,6 @@
-# Table of Contents
+# 目录
 
+* [目录](#目录)
   * [Java IO](#java-io)
   * [Socket编程](#socket编程)
   * [客户端，服务端的线程模型](#客户端，服务端的线程模型)
@@ -9,21 +10,21 @@
   * [Tomcat中的NIO模型](#tomcat中的nio模型)
   * [Tomcat的container](#tomcat的container)
   * [netty](#netty)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-
----
-title: Java网络编程与NIO学习总结
-date: 2018-07-08 22:08:22
-tags:
-	- Java网络编程
-	- NIO
-categories:
-	- 后端
-	- 技术总结
----
+
+
+# 目录
+  * [Java IO](#java-io)
+  * [Socket编程](#socket编程)
+  * [客户端，服务端的线程模型](#客户端，服务端的线程模型)
+  * [IO模型](#io模型)
+  * [NIO](#nio)
+  * [AIO](#aio)
+  * [Tomcat中的NIO模型](#tomcat中的nio模型)
+  * [Tomcat的container](#tomcat的container)
+  * [netty](#netty)
+
+
+
 这篇总结主要是基于我之前Java网络编程与NIO系列文章而形成的的。主要是把重要的知识点用自己的话说了一遍，可能会有一些错误，还望见谅和指点。谢谢
 
 更多详细内容可以查看我的专栏文章：Java网络编程与NIO
@@ -161,6 +162,7 @@ container是一个多级容器，最外层到最内层依次是engine，host，c
 
 下面是个server.xml文件实例，Tomcat根据该文件进行部署
 
+````
 <Server>                                                //顶层类元素，可以包括多个Service   
     <Service>                                           //顶层类元素，可包含一个Engine，多个Connecter
         <Connector>                                     //连接器类元素，代表通信接口
@@ -173,7 +175,7 @@ container是一个多级容器，最外层到最内层依次是engine，host，c
         </Connector>
     </Service>
 </Server>
-
+````
 
 根据配置文件初始化容器信息，当请求到达时进行容器间的请求传递，事实上整个链条被称作pipeline，pipeline连接了各个容器的入口，由于每个容器和组件都实现了lifecycle接口。
 
@@ -229,20 +231,4 @@ bootstrap
 
 对于客户端程序和服务器程序所使用到的Bootstrap类是不同的，后者需要使用ServerBootstrap，这样设计是因为，在如TCP这样有连接的协议中，服务器程序往往需要一个以上的Channel，通过父Channel来接受来自客户端的连接，然后创建子Channel用于它们之间的通信，而像UDP这样无连接的协议，它不需要每个连接都创建子Channel，只需要一个Channel即可。
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2433\357\274\232IO\346\250\241\345\236\213\344\270\216Java\347\275\221\347\273\234\347\274\226\347\250\213\346\250\241\345\236\213.md" "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232IO\346\250\241\345\236\213\344\270\216Java\347\275\221\347\273\234\347\274\226\347\250\213\346\250\241\345\236\213.md"
similarity index 90%
rename from "docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2433\357\274\232IO\346\250\241\345\236\213\344\270\216Java\347\275\221\347\273\234\347\274\226\347\250\213\346\250\241\345\236\213.md"
rename to "docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232IO\346\250\241\345\236\213\344\270\216Java\347\275\221\347\273\234\347\274\226\347\250\213\346\250\241\345\236\213.md"
index 0834cf9..deca42f 100644
--- "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2433\357\274\232IO\346\250\241\345\236\213\344\270\216Java\347\275\221\347\273\234\347\274\226\347\250\213\346\250\241\345\236\213.md"
+++ "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232IO\346\250\241\345\236\213\344\270\216Java\347\275\221\347\273\234\347\274\226\347\250\213\346\250\241\345\236\213.md"
@@ -1,5 +1,22 @@
-# Table of Contents
+# 目录
 
+* [目录](#目录)
+  * [IO模型介绍](#io模型介绍)
+    * [阻塞 I/O（blocking IO）](#阻塞-io（blocking-io）)
+    * [非阻塞 I/O（nonblocking IO）](#非阻塞-io（nonblocking-io）)
+    * [I/O 多路复用（ IO multiplexing）](#io-多路复用（-io-multiplexing）)
+    * [异步 I/O（asynchronous IO）](#异步-io（asynchronous-io）)
+  * [阻塞IO,非阻塞IO 与 同步IO, 异步IO的区别和联系](#阻塞io非阻塞io-与-同步io-异步io的区别和联系)
+    * [IO模型的形象举例](#io模型的形象举例)
+    * [Select/Poll/Epoll 轮询机制](#selectpollepoll-轮询机制)
+  * [Java网络编程模型](#java网络编程模型)
+    * [BIO](#bio)
+    * [NIO](#nio)
+    * [AIO](#aio)
+    * [对比](#对比)
+
+
+# 目录
   * [IO模型介绍](#io模型介绍)
     * [阻塞 I/O（blocking IO）](#阻塞-io（blocking-io）)
     * [非阻塞 I/O（nonblocking IO）](#非阻塞-io（nonblocking-io）)
@@ -91,7 +108,7 @@ asynchronous IO
 
 **_当一个read操作发生时，它会经历两个阶段：_**
 
-*   等待数据准备,比如accept(), recv()等待数据 `(Waiting for the data to be ready)`
+*   等待数据准备,比如accept(), recv()等待数据`(Waiting for the data to be ready)`
 *   将数据从内核拷贝到进程中, 比如 accept()接受到请求,recv()接收连接发送的数据后需要复制到内核,再从内核复制到进程用户空间`(Copying the data from the kernel to the process)`
 
 **_对于socket流而言,数据的流向经历两个阶段：_**
@@ -107,8 +124,7 @@ asynchronous IO
 
 在linux中，默认情况下所有的socket都是blocking，一个典型的读操作流程大概是这样：
 
-![](https://upload-images.jianshu.io/upload_images/1446087-9522cafa9e14abd0.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/552)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405094447.png)
 阻塞IO流程
 
 当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据（对于网络IO来说，很多时候数据在一开始还没有到达。比如，还没有收到一个完整的UDP包。这个时候kernel就要等待足够的数据到来）。这个过程需要等待，也就是说数据被拷贝到**操作系统内核的缓冲区**中是需要一个过程的。而在用户进程这边，整个进程会被阻塞（当然，是进程自己选择的阻塞）。当kernel一直等到数据准备好了，它就会**将数据从kernel中拷贝到用户内存**，然后kernel返回结果，用户进程才解除block的状态，重新运行起来。
@@ -121,8 +137,7 @@ asynchronous IO
 
 linux下，可以通过设置socket使其变为non-blocking。当对一个non-blocking socket执行读操作时，流程是这个样子：
 
-![](https://upload-images.jianshu.io/upload_images/1446087-0c604ff4a2d8dc5d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/603)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405094507.png)
 非阻塞 I/O 流程
 
 当用户进程发出read操作时，如果kernel中的数据还没有准备好，**那么它并不会block用户进程，而是立刻返回一个error**。从用户进程角度讲 ，它发起一个read操作后，并不需要等待，而是马上就得到了一个结果。用户进程判断结果是一个error时，它就知道数据还没有准备好，于是它可以再次发送read操作。一旦kernel中的数据准备好了，并且又再次收到了用户进程的system call，那么它马上就将数据拷贝到了用户内存，然后返回。
@@ -137,7 +152,7 @@ linux下，可以通过设置socket使其变为non-blocking。当对一个non-bl
 
 IO multiplexing就是我们说的select，poll，epoll，有些地方也称这种IO方式为event driven IO。select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO。它的基本原理就是select，poll，epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。
 
-![](https://upload-images.jianshu.io/upload_images/1446087-3b0399b077daf0a8.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/609)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405094539.png)
 
 I/O 多路复用流程
 
@@ -178,22 +193,7 @@ epoll的出现，解决了select、poll的缺点：
 > **_所以, IO多路复用，本质上不会有并发的功能，因为任何时候还是只有一个进程或线程进行工作，它之所以能提高效率是因为select\epoll 把进来的socket放到他们的 '监视' 列表里面，当任何socket有可读可写数据立马处理，那如果select\epoll 手里同时检测着很多socket， 一有动静马上返回给进程处理，总比一个一个socket过来,阻塞等待,处理高效率。_**
 > 当然也可以多线程/多进程方式，一个连接过来开一个进程/线程处理，这样消耗的内存和进程切换页会耗掉更多的系统资源。
 > 所以我们可以结合IO多路复用和多进程/多线程 来高性能并发，IO复用负责提高接受socket的通知效率，收到请求后，交给进程池/线程池来处理逻辑。
-> 
-> ### 信号驱动
-> 
-> 上文的就餐方式还是需要你每次都去问一下饭菜状况。于是，你再次不耐烦了，就跟老板说，哪个饭菜好了就通知我一声吧。然后就自己坐在桌子那里干自己的事情。更甚者，你可以把手机号留给老板，自己出门，等饭菜好了直接发条短信给你。这就类似信号驱动的IO模型。
-> 
-> ![bio](http://www.rowkey.me/images/blog_images/io/sigio.png)
-> 
-> 流程如下：
-> 
-> *   开启套接字信号驱动IO功能
-> *   系统调用sigaction执行信号处理函数（非阻塞，立刻返回）
-> *   数据就绪，生成sigio信号，通过信号回调通知应用来读取数据。
-> 
-> 此种io方式存在的一个很大的问题：Linux中信号队列是有限制的，如果超过这个数字问题就无法读取数据。
-> 
-> ### 异步非阻塞
+>
 
 ### 异步 I/O（asynchronous IO）
 
@@ -201,8 +201,7 @@ epoll的出现，解决了select、poll的缺点：
 
 linux下的asynchronous IO其实用得很少。先看一下它的流程：
 
-![](https://upload-images.jianshu.io/upload_images/1446087-e707464b299104e1.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/572)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405094934.png)
 异步IO 流程
 
 用户进程发起read操作之后，立刻就可以开始去做其它的事。而另一方面，从kernel的角度，当它受到一个asynchronous read之后，首先它会立刻返回，所以不会对用户进程产生任何block。然后，kernel会等待数据准备完成，然后将数据拷贝到用户内存，当这一切都完成之后，kernel会给用户进程发送一个signal，告诉它read操作完成了。
@@ -225,7 +224,7 @@ linux下的asynchronous IO其实用得很少。先看一下它的流程：
 同步IO VS 异步IO：
 
 概念：
-同步与异步同步和异步关注的是___消息通信机制 ___(synchronous communication/ asynchronous communication)所谓同步，就是在发出一个_调用_时，在没有得到结果之前，该_调用_就不返回。但是一旦调用返回，就得到返回值了。换句话说，就是由_调用者_主动等待这个_调用_的结果。而异步则是相反，_调用_在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果。而是在_调用_发出后，_被调用者_通过状态、通知来通知调用者，或通过回调函数处理这个调用。
+同步与异步同步和异步关注的是___消息通信机制___(synchronous communication/ asynchronous communication)所谓同步，就是在发出一个_调用_时，在没有得到结果之前，该_调用_就不返回。但是一旦调用返回，就得到返回值了。换句话说，就是由_调用者_主动等待这个_调用_的结果。而异步则是相反，_调用_在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果。而是在_调用_发出后，_被调用者_通过状态、通知来通知调用者，或通过回调函数处理这个调用。
 
 典型的异步编程模型比如Node.js举个通俗的例子：你打电话问书店老板有没有《分布式系统》这本书，如果是同步通信机制，书店老板会说，你稍等，”我查一下"，然后开始查啊查，等查好了（可能是5秒，也可能是一天）告诉你结果（返回结果）。而异步通信机制，书店老板直接告诉你我查一下啊，查好了打电话给你，然后直接挂电话了（不返回结果）。然后查好了，他会主动打电话给你。在这里老板通过“回电”这种方式来回调。
 
@@ -308,8 +307,6 @@ JDK1.7引入NIO2.0，提供了异步文件通道和异步套接字通道的实
 
 ### 对比
 
-
-
 | . | 同步阻塞IO | 伪异步IO | NIO | AIO |
 | --- | --- | --- | --- | --- |
 | 客户端数目 ：IO线程 | 1 : 1 | m : n | m : 1 | m : 0 |
diff --git "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2431\357\274\232JAVA \344\270\255\345\216\237\347\224\237\347\232\204 socket \351\200\232\344\277\241\346\234\272\345\210\266.md" "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232JAVA\344\270\255\345\216\237\347\224\237\347\232\204socket\351\200\232\344\277\241\346\234\272\345\210\266.md"
similarity index 83%
rename from "docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2431\357\274\232JAVA \344\270\255\345\216\237\347\224\237\347\232\204 socket \351\200\232\344\277\241\346\234\272\345\210\266.md"
rename to "docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232JAVA\344\270\255\345\216\237\347\224\237\347\232\204socket\351\200\232\344\277\241\346\234\272\345\210\266.md"
index b96bfd5..04f25ab 100644
--- "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2431\357\274\232JAVA \344\270\255\345\216\237\347\224\237\347\232\204 socket \351\200\232\344\277\241\346\234\272\345\210\266.md"	
+++ "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232JAVA\344\270\255\345\216\237\347\224\237\347\232\204socket\351\200\232\344\277\241\346\234\272\345\210\266.md"
@@ -1,3 +1,13 @@
+# 目录
+
+  * [当前环境](#当前环境)
+    * [处理 socket 输入输出流](#处理-socket-输入输出流)
+    * [结果展示](#结果展示)
+  * [请求模型优化](#请求模型优化)
+  * [补充1：TCP客户端与服务端](#补充1：tcp客户端与服务端)
+  * [补充2：UDP客户端和服务端](#补充2：udp客户端和服务端)
+
+
 本文转自：https://github.com/jasonGeng88/blog
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -21,24 +31,18 @@
 
 1.  jdk == 1.8
 
-## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E7%9F%A5%E8%AF%86%E7%82%B9)知识点
-
 *   socket 的连接处理
 *   IO 输入、输出流的处理
 *   请求数据格式处理
 *   请求模型优化
 
-## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E5%9C%BA%E6%99%AF)场景
-
 今天，和大家聊一下 JAVA 中的 socket 通信问题。这里采用最简单的一请求一响应模型为例，假设我们现在需要向 baidu 站点进行通信。我们用 JAVA 原生的 socket 该如何实现。
 
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E5%BB%BA%E7%AB%8B-socket-%E8%BF%9E%E6%8E%A5)建立 socket 连接
-
-首先，我们需要建立 socket 连接（_核心代码_）
-
+首先，我们需要建立 socket 连接（核心代码）
 
 
-<pre>import java.net.InetSocketAddress;
+````
+import java.net.InetSocketAddress;
 import java.net.Socket;
 import java.net.SocketAddress;
 
@@ -48,11 +52,11 @@ Socket socket = new Socket();
 SocketAddress remote = new InetSocketAddress(host, port);
 // 建立连接
 socket.connect(remote);
-</pre>
+````
 
 
 
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E5%A4%84%E7%90%86-socket-%E8%BE%93%E5%85%A5%E8%BE%93%E5%87%BA%E6%B5%81)处理 socket 输入输出流
+### 处理 socket 输入输出流
 
 成功建立 socket 连接后，我们就能获得它的输入输出流，通信的本质是对输入输出流的处理。通过输入流，读取网络连接上传来的数据，通过输出流，将本地的数据传出给远端。
 
@@ -61,21 +65,21 @@ _socket 连接实际与处理文件流有点类似，都是在进行 IO 操作
 获取输入、输出流代码如下：
 
 
-
-<pre>// 输入流
+````
+// 输入流
 InputStream in = socket.getInputStream();
 // 输出流
-OutputStream out = socket.getOutputStream();</pre>
-
+OutputStream out = socket.getOutputStream();
+````
 
 
-关于 IO 流的处理，我们一般会用相应的包装类来处理 IO 流，如果直接处理的话，我们需要对 `byte[]` 进行操作，而这是相对比较繁琐的。如果采用包装类，我们可以直接以`string`、`int`等类型进行处理，简化了 IO 字节操作。
+关于 IO 流的处理，我们一般会用相应的包装类来处理 IO 流，如果直接处理的话，我们需要对`byte[]`进行操作，而这是相对比较繁琐的。如果采用包装类，我们可以直接以`string`、`int`等类型进行处理，简化了 IO 字节操作。
 
-下面以 `BufferedReader` 与 `PrintWriter` 作为输入输出的包装类进行处理。
+下面以`BufferedReader`与`PrintWriter`作为输入输出的包装类进行处理。
 
 
 
-<pre>// 获取 socket 输入流
+// 获取 socket 输入流
 private BufferedReader getReader(Socket socket) throws IOException {
     InputStream in = socket.getInputStream();
     return new BufferedReader(new InputStreamReader(in));
@@ -86,11 +90,6 @@ private PrintWriter getWriter(Socket socket) throws IOException {
     OutputStream out = socket.getOutputStream();
     return new PrintWriter(new OutputStreamWriter(out));
 }
-</pre>
-
-
-
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E6%95%B0%E6%8D%AE%E8%AF%B7%E6%B1%82%E4%B8%8E%E5%93%8D%E5%BA%94)数据请求与响应
 
 有了 socket 连接、IO 输入输出流，下面就该向发送请求数据，以及获取请求的响应结果。
 
@@ -100,9 +99,7 @@ private PrintWriter getWriter(Socket socket) throws IOException {
 
 请求的数据内容处理如下：
 
-
-
-<pre>public class HttpUtil {
+public class HttpUtil {
 
     public static String compositeRequest(String host){
 
@@ -112,35 +109,25 @@ private PrintWriter getWriter(Socket socket) throws IOException {
                 "Accept: */*\r\n\r\n";
     }
 
-}</pre>
-
-
+}
 
 发送请求数据代码如下：
 
-
-
-<pre>// 发起请求
+// 发起请求
 PrintWriter writer = getWriter(socket);
 writer.write(HttpUtil.compositeRequest(host));
-writer.flush();</pre>
-
-
+writer.flush();
 
 接收响应数据代码如下：
 
-
-
-<pre>// 读取响应
+// 读取响应
 String msg;
 BufferedReader reader = getReader(socket);
 while ((msg = reader.readLine()) != null){
     System.out.println(msg);
-}</pre>
-
-
+}
 
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E7%BB%93%E6%9E%9C%E5%B1%95%E7%A4%BA)结果展示
+### 结果展示
 
 至此，讲完了原生 socket 下的创建连接、发送请求与接收响应的所有核心代码。
 
@@ -153,23 +140,18 @@ import java.io.*;import java.net.InetSocketAddress;import java.net.Socket;import
 下面，我们通过实例化一个客户端，来展示 socket 通信的结果。
 
 
-
-<pre>public class Application {
+````
+public class Application {
 
     public static void main(String[] args) {
 
         new SocketHttpClient().start("www.baidu.com", 80);
 
     }
-}</pre>
-
-
-
-结果输出：
-
-[![](https://github.com/jasonGeng88/blog/raw/master/201708/assets/java-socket-01.png)](https://github.com/jasonGeng88/blog/blob/master/201708/assets/java-socket-01.png)
+}
+````
 
-## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E8%AF%B7%E6%B1%82%E6%A8%A1%E5%9E%8B%E4%BC%98%E5%8C%96)请求模型优化
+## 请求模型优化
 
 这种方式，虽然实现功能没什么问题。但是我们细看，发现在 IO 写入与读取过程，是发生了 IO 阻塞的情况。即：
 
@@ -180,8 +162,8 @@ import java.io.*;import java.net.InetSocketAddress;import java.net.Socket;import
 所以如果要同时请求10个不同的站点，如下：
 
 
-
-<pre>public class SingleThreadApplication {
+````
+public class SingleThreadApplication {
 
     public static void main(String[] args) {
 
@@ -193,8 +175,8 @@ import java.io.*;import java.net.InetSocketAddress;import java.net.Socket;import
         }
 
     }
-}</pre>
-
+}
+````
 
 
 它一定是第一个请求响应结束后，才会发起下一个站点处理。
@@ -216,8 +198,8 @@ public class MultiThreadApplication {     public static void main(String[] args)
 既然线程太多不行，那我们控制一下线程创建的数目不就行了。只启动固定的线程数来进行 socket 处理，既利用了多线程的处理，又控制了系统的资源消耗。
 
 
-
-<pre>public class ThreadPoolApplication {
+````
+public class ThreadPoolApplication {
 
     public static void main(String[] args) {
 
@@ -237,8 +219,8 @@ public class MultiThreadApplication {     public static void main(String[] args)
         }
 
     }
-}</pre>
-
+}
+````
 
 
 _关于启动的线程数，一般 CPU 密集型会设置在 N+1（N为CPU核数），IO 密集型设置在 2N + 1。_
@@ -248,8 +230,8 @@ _关于启动的线程数，一般 CPU 密集型会设置在 N+1（N为CPU核数
 ## 补充1：TCP客户端与服务端
 
 
-
-<pre>public class TCP客户端 {
+````
+public class TCP客户端 {
     public static void main(String[] args) {
         new Thread(new Runnable() {
             @Override
@@ -272,13 +254,13 @@ _关于启动的线程数，一般 CPU 密集型会设置在 N+1（N为CPU核数
             }
         }).start();
   }
-}</pre>
-
-
+}
+````
 
 
 
-<pre>public class TCP服务端 {
+````
+public class TCP服务端 {
     public static void main(String[] args) {
         new Thread(new Runnable() {
             @Override
@@ -303,11 +285,11 @@ _关于启动的线程数，一般 CPU 密集型会设置在 N+1（N为CPU核数
             }
         }).start();
   }
-}</pre>
-
+}
+````
 ## 补充2：UDP客户端和服务端
-
-<pre>public class UDP客户端 {
+````
+public class UDP客户端 {
     public static void main(String[] args) {
         new Thread(new Runnable() {
             @Override
@@ -329,9 +311,10 @@ _关于启动的线程数，一般 CPU 密集型会设置在 N+1（N为CPU核数
             }
         }).start();
   }
-}</pre>
-
-<pre>public class UDP服务端 {
+}
+````
+````
+public class UDP服务端 {
     public static void main(String[] args) {
         new Thread(new Runnable() {
             @Override
@@ -353,11 +336,5 @@ _关于启动的线程数，一般 CPU 密集型会设置在 N+1（N为CPU核数
         }).start();
   }
 }
-</pre>
-
-
-
-## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E5%90%8E%E7%BB%AD)后续
+````
 
-*   JAVA 中是如何实现 IO多路复用
-*   Netty 下的实现异步请求的
diff --git "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\2432\357\274\232JAVA NIO \344\270\200\346\255\245\346\255\245\346\236\204\345\273\272IO\345\244\232\350\267\257\345\244\215\347\224\250\347\232\204\350\257\267\346\261\202\346\250\241\345\236\213.md" "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232JavaNIO\344\270\200\346\255\245\346\255\245\346\236\204\345\273\272IO\345\244\232\350\267\257\345\244\215\347\224\250\347\232\204\350\257\267\346\261\202\346\250\241\345\236\213.md"
similarity index 72%
rename from "docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\2432\357\274\232JAVA NIO \344\270\200\346\255\245\346\255\245\346\236\204\345\273\272IO\345\244\232\350\267\257\345\244\215\347\224\250\347\232\204\350\257\267\346\261\202\346\250\241\345\236\213.md"
rename to "docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232JavaNIO\344\270\200\346\255\245\346\255\245\346\236\204\345\273\272IO\345\244\232\350\267\257\345\244\215\347\224\250\347\232\204\350\257\267\346\261\202\346\250\241\345\236\213.md"
index 81e4a96..47e6d17 100644
--- "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\2432\357\274\232JAVA NIO \344\270\200\346\255\245\346\255\245\346\236\204\345\273\272IO\345\244\232\350\267\257\345\244\215\347\224\250\347\232\204\350\257\267\346\261\202\346\250\241\345\236\213.md"	
+++ "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232JavaNIO\344\270\200\346\255\245\346\255\245\346\236\204\345\273\272IO\345\244\232\350\267\257\345\244\215\347\224\250\347\232\204\350\257\267\346\261\202\346\250\241\345\236\213.md"
@@ -1,3 +1,13 @@
+# 目录
+
+  * [当前环境](#当前环境)
+  * [代码地址](#代码地址)
+  * [知识点](#知识点)
+    * [获取 socket 连接](#获取-socket-连接)
+    * [完整示例](#完整示例)
+    * [处理连接就绪事件](#处理连接就绪事件)
+
+
 本文转载自：[https://github.com/jasonGeng88/blog](https://github.com/jasonGeng88/blog)
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -20,15 +30,15 @@
 
 *   文章一：[JAVA 中原生的 socket 通信机制](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md)
 
-## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%BD%93%E5%89%8D%E7%8E%AF%E5%A2%83)当前环境
+## 当前环境
 
 1.  jdk == 1.8
 
-## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E4%BB%A3%E7%A0%81%E5%9C%B0%E5%9D%80)代码地址
+## 代码地址
 
 git 地址：[https://github.com/jasonGeng88/java-network-programming](https://github.com/jasonGeng88/java-network-programming)
 
-## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E7%9F%A5%E8%AF%86%E7%82%B9)知识点
+## 知识点
 
 *   nio 下 I/O 阻塞与非阻塞实现
 *   SocketChannel 介绍
@@ -37,67 +47,54 @@ git 地址：[https://github.com/jasonGeng88/java-network-programming](https://g
 *   事件监听类型
 *   字节缓冲 ByteBuffer 数据结构
 
-## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%9C%BA%E6%99%AF)场景
-
 接着上一篇中的站点访问问题，如果我们需要并发访问10个不同的网站，我们该如何处理？
 
 在上一篇中，我们使用了`java.net.socket`类来实现了这样的需求，以一线程处理一连接的方式，并配以线程池的控制，貌似得到了当前的最优解。可是这里也存在一个问题，连接处理是同步的，也就是并发数量增大后，大量请求会在队列中等待，或直接异常抛出。
 
 为解决这问题，我们发现元凶处在“一线程一请求”上，如果一个线程能同时处理多个请求，那么在高并发下性能上会大大改善。这里就借住 JAVA 中的 nio 技术来实现这一模型。
 
-## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#nio-%E7%9A%84%E9%98%BB%E5%A1%9E%E5%AE%9E%E7%8E%B0)nio 的阻塞实现
-
 关于什么是 nio，从字面上理解为 New IO，就是为了弥补原本 I/O 上的不足，而在 JDK 1.4 中引入的一种新的 I/O 实现方式。简单理解，就是它提供了 I/O 的阻塞与非阻塞的两种实现方式（_当然，默认实现方式是阻塞的。_）。
 
 下面，我们先来看下 nio 以阻塞方式是如何处理的。
 
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%BB%BA%E7%AB%8B%E8%BF%9E%E6%8E%A5)建立连接
-
-有了上一篇 socket 的经验，我们的第一步一定也是建立 socket 连接。只不过，这里不是采用 `new socket()` 的方式，而是引入了一个新的概念 `SocketChannel`。它可以看作是 socket 的一个完善类，除了提供 Socket 的相关功能外，还提供了许多其他特性，如后面要讲到的向选择器注册的功能。
+有了上一篇 socket 的经验，我们的第一步一定也是建立 socket 连接。只不过，这里不是采用`new socket()`的方式，而是引入了一个新的概念`SocketChannel`。它可以看作是 socket 的一个完善类，除了提供 Socket 的相关功能外，还提供了许多其他特性，如后面要讲到的向选择器注册的功能。
 
-类图如下： [![](https://github.com/jasonGeng88/blog/raw/master/201708/assets/java-nio-01.jpg)](https://github.com/jasonGeng88/blog/blob/master/201708/assets/java-nio-01.jpg)
+类图如下：
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405094035.png)
 
 建立连接代码实现：
-
-
-
-<pre>// 初始化 socket，建立 socket 与 channel 的绑定关系
+````
+// 初始化 socket，建立 socket 与 channel 的绑定关系
 SocketChannel socketChannel = SocketChannel.open();
 // 初始化远程连接地址
 SocketAddress remote = new InetSocketAddress(this.host, port);
 // I/O 处理设置阻塞，这也是默认的方式，可不设置
 socketChannel.configureBlocking(true);
 // 建立连接
-socketChannel.connect(remote);</pre>
-
-
-
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E8%8E%B7%E5%8F%96-socket-%E8%BF%9E%E6%8E%A5)获取 socket 连接
+socketChannel.connect(remote);
+````
+### 获取 socket 连接
 
 因为是同样是 I/O 阻塞的实现，所以后面的关于 socket 输入输出流的处理，和上一篇的基本相同。唯一差别是，这里需要通过 channel 来获取 socket 连接。
 
 *   获取 socket 连接
-
-
-
-<pre>Socket socket = socketChannel.socket();</pre>
-
-
-
+````
+Socket socket = socketChannel.socket();
+````
 *   处理输入输出流
 
 
-
-<pre>PrintWriter pw = getWriter(socketChannel.socket());
-BufferedReader br = getReader(socketChannel.socket());</pre>
-
+````
+PrintWriter pw = getWriter(socketChannel.socket());
+BufferedReader br = getReader(socketChannel.socket());
+````
 
 
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%AE%8C%E6%95%B4%E7%A4%BA%E4%BE%8B)完整示例
+### 完整示例
 
 
-
-<pre>package com.jason.network.mode.nio;
+````
+package com.jason.network.mode.nio;
 
 import com.jason.network.constant.HttpConstant;
 import com.jason.network.util.HttpUtil;
@@ -153,19 +150,15 @@ public class NioBlockingHttpClient {
         InputStream in = socket.getInputStream();
         return new BufferedReader(new InputStreamReader(in));
     }
-}</pre>
-
-
-
-## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#nio-%E7%9A%84%E9%9D%9E%E9%98%BB%E5%A1%9E%E5%AE%9E%E7%8E%B0)nio 的非阻塞实现
+}
 
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%8E%9F%E7%90%86%E5%88%86%E6%9E%90)原理分析
+````
 
 nio 的阻塞实现，基本与使用原生的 socket 类似，没有什么特别大的差别。
 
 下面我们来看看它真正强大的地方。到目前为止，我们将的都是阻塞 I/O。何为阻塞 I/O，看下图：
 
-[![](https://github.com/jasonGeng88/blog/raw/master/201708/assets/java-nio-02.jpg)](https://github.com/jasonGeng88/blog/blob/master/201708/assets/java-nio-02.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405094141.png)
 
 _我们主要观察图中的前三种 I/O 模型，关于异步 I/O，一般需要依靠操作系统的支持，这里不讨论。_
 
@@ -182,15 +175,12 @@ _我们主要观察图中的前三种 I/O 模型，关于异步 I/O，一般需
 
 废话讲了一大堆，下面就来实际操刀一下。
 
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%88%9B%E5%BB%BA%E9%80%89%E6%8B%A9%E5%99%A8)创建选择器
-
 由上面分析可以，我们得有一个选择器，它能监听所有的 I/O 操作，并且以事件的方式通知我们哪些 I/O 已经就绪了。
 
 代码如下：
 
-
-
-<pre>import java.nio.channels.Selector;
+````
+import java.nio.channels.Selector;
 
 ...
 
@@ -202,39 +192,32 @@ static {
         e.printStackTrace();
     }
 }
-</pre>
-
+````
 
 
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%88%9B%E5%BB%BA%E9%9D%9E%E9%98%BB%E5%A1%9E-io)创建非阻塞 I/O
-
-下面，我们来创建一个非阻塞的 `SocketChannel`，代码与阻塞实现类型，唯一不同是`socketChannel.configureBlocking(false)`。
+下面，我们来创建一个非阻塞的`SocketChannel`，代码与阻塞实现类型，唯一不同是`socketChannel.configureBlocking(false)`。
 
 _**注意：只有在`socketChannel.configureBlocking(false)`之后的代码，才是非阻塞的，如果`socketChannel.connect()`在设置非阻塞模式之前，那么连接操作依旧是阻塞调用的。**_
 
-
-
-<pre>SocketChannel socketChannel = SocketChannel.open();
+````
+SocketChannel socketChannel = SocketChannel.open();
 SocketAddress remote = new InetSocketAddress(host, port);
 // 设置非阻塞模式
 socketChannel.configureBlocking(false);
-socketChannel.connect(remote);</pre>
-
-
+socketChannel.connect(remote);
+````
 
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%BB%BA%E7%AB%8B%E9%80%89%E6%8B%A9%E5%99%A8%E4%B8%8E-socket-%E7%9A%84%E5%85%B3%E8%81%94)建立选择器与 socket 的关联
-
-选择器与 socket 都创建好了，下一步就是将两者进行关联，好让选择器和监听到 Socket 的变化。这里采用了以 `SocketChannel` 主动注册到选择器的方式进行关联绑定，这也就解释了，为什么不直接`new Socket()`，而是以`SocketChannel`的方式来创建 socket。
+选择器与 socket 都创建好了，下一步就是将两者进行关联，好让选择器和监听到 Socket 的变化。这里采用了以`SocketChannel`主动注册到选择器的方式进行关联绑定，这也就解释了，为什么不直接`new Socket()`，而是以`SocketChannel`的方式来创建 socket。
 
 代码如下：
 
 
-
-<pre>socketChannel.register(selector,
+````
+socketChannel.register(selector,
                         SelectionKey.OP_CONNECT
                         | SelectionKey.OP_READ
-                        | SelectionKey.OP_WRITE);</pre>
-
+                        | SelectionKey.OP_WRITE);
+````
 
 
 上面代码，我们将 socketChannel 注册到了选择器中，并且对它的连接、可读、可写事件进行了监听。
@@ -248,8 +231,6 @@ socketChannel.connect(remote);</pre>
 | OP_CONNECT | 1 << 3 | 连接socket操作 | SocketChannel |
 | OP_ACCEPT | 1 << 4 | 接受socket操作 | ServerSocketChannel |
 
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E9%80%89%E6%8B%A9%E5%99%A8%E7%9B%91%E5%90%AC-socket-%E5%8F%98%E5%8C%96)选择器监听 socket 变化
-
 现在，选择器已经与我们关心的 socket 进行了关联。下面就是感知事件的变化，然后调用相应的处理机制。
 
 这里与 Linux 下的 selector 有点不同，nio 下的 selecotr 不会去遍历所有关联的 socket。我们在注册时设置了我们关心的事件类型，每次从选择器中获取的，只会是那些符合事件类型，并且完成就绪操作的 socket，减少了大量无效的遍历操作。
@@ -290,15 +271,15 @@ public void select() throws IOException {
 
 _**注意：这里的`selector.select()`是同步阻塞的，等待有事件发生后，才会被唤醒。这就防止了 CPU 空转的产生。当然，我们也可以给它设置超时时间，`selector.select(long timeout)`来结束阻塞过程。**_
 
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%A4%84%E7%90%86%E8%BF%9E%E6%8E%A5%E5%B0%B1%E7%BB%AA%E4%BA%8B%E4%BB%B6)处理连接就绪事件
+### 处理连接就绪事件
 
 下面，我们分别来看下，一个 socket 是如何来处理连接、写入数据和读取数据的（_这些操作都是阻塞的过程，只是我们将等待就绪的过程变成了非阻塞的了_）。
 
 处理连接代码：
 
 
-
-<pre>// SelectionKey 代表 SocketChannel 在选择器中注册的事件句柄
+````
+// SelectionKey 代表 SocketChannel 在选择器中注册的事件句柄
 private void connect(SelectionKey key) throws IOException {
 	// 获取事件句柄对应的 SocketChannel
     SocketChannel channel = (SocketChannel) key.channel();
@@ -311,15 +292,12 @@ private void connect(SelectionKey key) throws IOException {
     String host = remote.getHostName();
     int port = remote.getPort();
     System.out.println(String.format("访问地址: %s:%s 连接成功!", host, port));
-}</pre>
-
-
-
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%A4%84%E7%90%86%E5%86%99%E5%85%A5%E5%B0%B1%E7%BB%AA%E4%BA%8B%E4%BB%B6)处理写入就绪事件
-
+}
+````
 
 
-<pre>// 字符集处理类
+````
+// 字符集处理类
 private Charset charset = Charset.forName("utf8");
 
 private void write(SelectionKey key) throws IOException {
@@ -335,27 +313,25 @@ private void write(SelectionKey key) throws IOException {
 
     // 修改 SocketChannel 所关心的事件
     key.interestOps(SelectionKey.OP_READ);
-}</pre>
-
+}
+````
 
 
 这里有两个地方需要注意：
 
-*   第一个是使用 `channel.write(charset.encode(request));` 进行数据写入。有人会说，为什么不能像上面同步阻塞那样，通过`PrintWriter`包装类进行操作。因为`PrintWriter`的 `write()` 方法是阻塞的，也就是说要等数据真正从 socket 发送出去后才返回。
-
-这与我们这里所讲的阻塞是不一致的，这里的操作虽然也是阻塞的，但它发生的过程是在数据从用户空间到内核缓冲区拷贝过程。至于系统将缓冲区的数据通过 socket 发送出去，这不在阻塞范围内。也解释了为什么要用 `Charset` 对写入内容进行编码了，因为缓冲区接收的格式是`ByteBuffer`。
+*   第一个是使用`channel.write(charset.encode(request));`进行数据写入。有人会说，为什么不能像上面同步阻塞那样，通过`PrintWriter`包装类进行操作。因为`PrintWriter`的`write()`方法是阻塞的，也就是说要等数据真正从 socket 发送出去后才返回。
 
-*   第二，选择器用来监听事件变化的两个参数是 `interestOps` 与 `readyOps`。
+这与我们这里所讲的阻塞是不一致的，这里的操作虽然也是阻塞的，但它发生的过程是在数据从用户空间到内核缓冲区拷贝过程。至于系统将缓冲区的数据通过 socket 发送出去，这不在阻塞范围内。也解释了为什么要用`Charset`对写入内容进行编码了，因为缓冲区接收的格式是`ByteBuffer`。
 
-    *   interestOps：表示 `SocketChannel` 所关心的事件类型，也就是告诉选择器，当有这几种事件发生时，才来通知我。这里通过`key.interestOps(SelectionKey.OP_READ);`告诉选择器，之后我只关心“读就绪”事件，其他的不用通知我了。
+*   第二，选择器用来监听事件变化的两个参数是`interestOps`与`readyOps`。
 
-    *   readyOps：表示 `SocketChannel` 当前就绪的事件类型。以`key.isReadable()`为例，判断依据就是：`return (readyOps() & OP_READ) != 0;`
+    *   interestOps：表示`SocketChannel`所关心的事件类型，也就是告诉选择器，当有这几种事件发生时，才来通知我。这里通过`key.interestOps(SelectionKey.OP_READ);`告诉选择器，之后我只关心“读就绪”事件，其他的不用通知我了。
 
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%A4%84%E7%90%86%E8%AF%BB%E5%8F%96%E5%B0%B1%E7%BB%AA%E4%BA%8B%E4%BB%B6)处理读取就绪事件
+    *   readyOps：表示`SocketChannel`当前就绪的事件类型。以`key.isReadable()`为例，判断依据就是：`return (readyOps() & OP_READ) != 0;`
 
 
-
-<pre>private void receive(SelectionKey key) throws IOException {
+````
+private void receive(SelectionKey key) throws IOException {
     SocketChannel channel = (SocketChannel) key.channel();
     ByteBuffer buffer = ByteBuffer.allocate(1024);
     channel.read(buffer);
@@ -370,30 +346,26 @@ private void write(SelectionKey key) throws IOException {
     }
 
     System.out.println(receiveData);
-}</pre>
-
+}
+````
 
 
 这里的处理基本与写入一致，唯一要注意的是，这里我们需要自行处理去缓冲区读取数据的操作。首先会分配一个固定大小的缓冲区，然后从内核缓冲区中，拷贝数据至我们刚分配固定缓冲区上。这里存在两种情况：
 
 *   我们分配的缓冲区过大，那多余的部分以0补充（_初始化时，其实会自动补0_）。
-*   我们分配的缓冲去过小，因为选择器会不停的遍历。只要 `SocketChannel` 处理读就绪状态，那下一次会继续读取。当然，分配过小，会增加遍历次数。
-
-最后，将一下 `ByteBuffer` 的结构，它主要有 position, limit,capacity 以及 mark 属性。以 `buffer.flip();` 为例，讲下各属性的作用（_mark 主要是用来标记之前 position 的位置，是在当前 postion 无法满足的情况下使用的，这里不作讨论_）。
+*   我们分配的缓冲去过小，因为选择器会不停的遍历。只要`SocketChannel`处理读就绪状态，那下一次会继续读取。当然，分配过小，会增加遍历次数。
 
-[![](https://github.com/jasonGeng88/blog/raw/master/201708/assets/java-nio-03.png)](https://github.com/jasonGeng88/blog/blob/master/201708/assets/java-nio-03.png)
+最后，将一下`ByteBuffer`的结构，它主要有 position, limit,capacity 以及 mark 属性。以`buffer.flip();`为例，讲下各属性的作用（_mark 主要是用来标记之前 position 的位置，是在当前 postion 无法满足的情况下使用的，这里不作讨论_）。
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405094314.png)
 从图中看出，
 
 *   容量（capacity）：表示缓冲区可以保存的数据容量；
 *   极限（limit）：表示缓冲区的当前终点，即写入、读取都不可超过该重点；
 *   位置（position）：表示缓冲区下一个读写单元的位置；
 
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%AE%8C%E6%95%B4%E4%BB%A3%E7%A0%81)完整代码
-
-
-
-<pre>package com.jason.network.mode.nio;
+````
+package com.jason.network.mode.nio;
 
 import com.jason.network.constant.HttpConstant;
 import com.jason.network.util.HttpUtil;
@@ -509,18 +481,7 @@ public class NioNonBlockingHttpClient {
         System.out.println(receiveData);
     }
 }
-</pre>
-
-
-
-### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E7%A4%BA%E4%BE%8B%E6%95%88%E6%9E%9C)示例效果
-
-[![](https://github.com/jasonGeng88/blog/raw/master/201708/assets/java-nio-04.png)](https://github.com/jasonGeng88/blog/blob/master/201708/assets/java-nio-04.png)
-
-## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E6%80%BB%E7%BB%93)总结
+````
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405094343.png)
 
 本文从 nio 的阻塞方式讲起，介绍了阻塞 I/O 与非阻塞 I/O 的区别，以及在 nio 下是如何一步步构建一个 IO 多路复用的模型的客户端。文中需要理解的内容比较多，如果有理解错误的地方，欢迎指正~
-
-## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%90%8E%E7%BB%AD)后续
-
-*   Netty 下的异步请求实现
diff --git "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2435\357\274\232Java \351\235\236\351\230\273\345\241\236 IO \345\222\214\345\274\202\346\255\245 IO.md" "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232Java\351\235\236\351\230\273\345\241\236IO\345\222\214\345\274\202\346\255\245IO.md"
similarity index 94%
rename from "docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2435\357\274\232Java \351\235\236\351\230\273\345\241\236 IO \345\222\214\345\274\202\346\255\245 IO.md"
rename to "docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232Java\351\235\236\351\230\273\345\241\236IO\345\222\214\345\274\202\346\255\245IO.md"
index 852291a..35be566 100644
--- "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2435\357\274\232Java \351\235\236\351\230\273\345\241\236 IO \345\222\214\345\274\202\346\255\245 IO.md"	
+++ "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232Java\351\235\236\351\230\273\345\241\236IO\345\222\214\345\274\202\346\255\245IO.md"
@@ -1,5 +1,19 @@
-# Table of Contents
+# 目录
 
+* [目录](#目录)
+  * [阻塞模式 IO](#阻塞模式-io)
+  * [非阻塞 IO](#非阻塞-io)
+  * [NIO.2 异步 IO](#nio2-异步-io)
+    * [1、返回 Future 实例](#1、返回-future-实例)
+    * [2、提供 CompletionHandler 回调函数](#2、提供-completionhandler-回调函数)
+    * [AsynchronousFileChannel](#asynchronousfilechannel)
+    * [AsynchronousServerSocketChannel](#asynchronousserversocketchannel)
+    * [AsynchronousSocketChannel](#asynchronoussocketchannel)
+    * [Asynchronous Channel Groups](#asynchronous-channel-groups)
+  * [小结](#小结)
+
+
+# 目录
   * [阻塞模式 IO](#阻塞模式-io)
   * [非阻塞 IO](#非阻塞-io)
   * [NIO.2 异步 IO](#nio2-异步-io)
@@ -33,7 +47,7 @@
 
 上一篇文章介绍了 Java NIO 中 Buffer、Channel 和 Selector 的基本操作，主要是一些接口操作，比较简单。
 
-本文将介绍**非阻塞 IO** 和**异步 IO**，也就是大家耳熟能详的 NIO 和 AIO。很多初学者可能分不清楚异步和非阻塞的区别，只是在各种场合能听到**异步非阻塞**这个词。
+本文将介绍**非阻塞 IO**和**异步 IO**，也就是大家耳熟能详的 NIO 和 AIO。很多初学者可能分不清楚异步和非阻塞的区别，只是在各种场合能听到**异步非阻塞**这个词。
 
 本文会先介绍并演示阻塞模式，然后引入非阻塞模式来对阻塞模式进行优化，最后再介绍 JDK7 引入的异步 IO，由于网上关于异步 IO 的介绍相对较少，所以这部分内容我会介绍得具体一些。
 
@@ -161,7 +175,7 @@ select 和 poll 都有一个共同的问题，那就是**它们都只会告诉
 
 **epoll**：2002 年随 Linux 内核 2.5.44 发布，epoll 能直接返回具体的准备好的通道，时间复杂度 O(1)。
 
-除了 Linux 中的 epoll，2000 年 FreeBSD 出现了 **Kqueue**，还有就是，Solaris 中有 **/dev/poll**。
+除了 Linux 中的 epoll，2000 年 FreeBSD 出现了**Kqueue**，还有就是，Solaris 中有**/dev/poll**。
 
 > 前面说了那么多实现，但是没有出现 Windows，Windows 平台的非阻塞 IO 使用 select，我们也不必觉得 Windows 很落后，在 Windows 中 IOCP 提供的异步 IO 是比较强大的。
 
@@ -240,13 +254,13 @@ More New IO，或称 NIO.2，随 JDK 1.7 发布，包括了引入异步 IO 接
 
 **在 Unix/Linux 等系统中，JDK 使用了并发包中的线程池来管理任务**，具体可以查看 AsynchronousChannelGroup 的源码。
 
-在 Windows 操作系统中，提供了一个叫做 [I/O Completion Ports](https://msdn.microsoft.com/en-us/library/windows/desktop/aa365198.aspx) 的方案，通常简称为 **IOCP**，操作系统负责管理线程池，其性能非常优异，所以**在 Windows 中 JDK 直接采用了 IOCP 的支持**，使用系统支持，把更多的操作信息暴露给操作系统，也使得操作系统能够对我们的 IO 进行一定程度的优化。
+在 Windows 操作系统中，提供了一个叫做[I/O Completion Ports](https://msdn.microsoft.com/en-us/library/windows/desktop/aa365198.aspx)的方案，通常简称为**IOCP**，操作系统负责管理线程池，其性能非常优异，所以**在 Windows 中 JDK 直接采用了 IOCP 的支持**，使用系统支持，把更多的操作信息暴露给操作系统，也使得操作系统能够对我们的 IO 进行一定程度的优化。
 
 > 在 Linux 中其实也是有异步 IO 系统实现的，但是限制比较多，性能也一般，所以 JDK 采用了自建线程池的方式。
 
 本文还是以实用为主，想要了解更多信息请自行查找其他资料，下面对 Java 异步 IO 进行实践性的介绍。
 
-总共有三个类需要我们关注，分别是 **AsynchronousSocketChannel**，**AsynchronousServerSocketChannel** 和 **AsynchronousFileChannel**，只不过是在之前介绍的 FileChannel、SocketChannel 和 ServerSocketChannel 的类名上加了个前缀 **Asynchronous**。
+总共有三个类需要我们关注，分别是**AsynchronousSocketChannel**，**AsynchronousServerSocketChannel**和**AsynchronousFileChannel**，只不过是在之前介绍的 FileChannel、SocketChannel 和 ServerSocketChannel 的类名上加了个前缀**Asynchronous**。
 
 Java 异步 IO 提供了两种使用方式，分别是返回 Future 实例和使用回调函数。
 
diff --git "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2436\357\274\232Linux epoll\345\256\236\347\216\260\345\216\237\347\220\206\350\257\246\350\247\243.md" "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232LinuxEpoll\345\256\236\347\216\260\345\216\237\347\220\206\350\257\246\350\247\243.md"
similarity index 64%
rename from "docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2436\357\274\232Linux epoll\345\256\236\347\216\260\345\216\237\347\220\206\350\257\246\350\247\243.md"
rename to "docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232LinuxEpoll\345\256\236\347\216\260\345\216\237\347\220\206\350\257\246\350\247\243.md"
index e480340..41852cd 100644
--- "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2436\357\274\232Linux epoll\345\256\236\347\216\260\345\216\237\347\220\206\350\257\246\350\247\243.md"	
+++ "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232LinuxEpoll\345\256\236\347\216\260\345\216\237\347\220\206\350\257\246\350\247\243.md"
@@ -1,3 +1,14 @@
+# 目录
+
+  * [为什么要 I/O 多路复用](#为什么要-io-多路复用)
+    * [select](#select)
+    * [poll](#poll)
+    * [epoll](#epoll)
+      * [epoll_create 用来创建一个 epoll 描述符：](#epoll_create-用来创建一个-epoll-描述符：)
+      * [epoll_ctl 用来增/删/改内核中的事件表：](#epoll_ctl-用来增删改内核中的事件表：)
+      * [epoll_wait 用来等待事件](#epoll_wait-用来等待事件)
+
+
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
 
@@ -18,29 +29,29 @@
 
 ## 为什么要 I/O 多路复用
 
-当需要从一个叫 `r_fd` 的描述符不停地读取数据，并把读到的数据写入一个叫 `w_fd` 的描述符时，我们可以用循环使用阻塞 I/O ：
-
+当需要从一个叫`r_fd`的描述符不停地读取数据，并把读到的数据写入一个叫`w_fd`的描述符时，我们可以用循环使用阻塞 I/O ：
+````
     while((n = read(r_fd, buf, BUF_SIZE)) > 0)
         if(write(w_fd, buf, n) != n)
             err_sys("write error");
-
-但是，如果要从两个地方读取数据呢？这时，不能再使用会把程序阻塞住的 `read` 函数。因为可能在阻塞地等待 `r_fd1` 的数据时，来不及处理 `r_fd2`，已经到达的 `r_fd2` 的数据可能会丢失掉。
+````
+但是，如果要从两个地方读取数据呢？这时，不能再使用会把程序阻塞住的`read`函数。因为可能在阻塞地等待`r_fd1`的数据时，来不及处理`r_fd2`，已经到达的`r_fd2`的数据可能会丢失掉。
 
 这个情况下需要使用**非阻塞 I/O**。
 
-只要做个标记，把文件描述符标记为非阻塞的，以后再对它使用 `read` 函数：如果它还没有数据可读，函数会立即返回并把 errorno 这个变量的值设置为 35，于是我们知道它没有数据可读，然后可以立马去对其他描述符使用 `read`；如果它有数据可读，我们就读取它数据。对所有要读的描述符都调用了一遍 `read` 之后，我们可以等一个较长的时间（比如几秒），然后再从第一个文件描述符开始调用 `read` 。这种循环就叫做**轮询**（polling）。
+只要做个标记，把文件描述符标记为非阻塞的，以后再对它使用`read`函数：如果它还没有数据可读，函数会立即返回并把 errorno 这个变量的值设置为 35，于是我们知道它没有数据可读，然后可以立马去对其他描述符使用`read`；如果它有数据可读，我们就读取它数据。对所有要读的描述符都调用了一遍`read`之后，我们可以等一个较长的时间（比如几秒），然后再从第一个文件描述符开始调用`read`。这种循环就叫做**轮询**（polling）。
 
-这样，不会像使用阻塞 I/O 时那样因为一个描述符 `read` 长时间处于等待数据而使程序阻塞。
+这样，不会像使用阻塞 I/O 时那样因为一个描述符`read`长时间处于等待数据而使程序阻塞。
 
-轮询的缺点是浪费太多 CPU 时间。大多数时候我们没有数据可读，但是还是用了 `read` 这个**系统调用**，使用系统调用时会从用户态切换到内核态。而大多数情况下我们调用 `read`，然后陷入内核态，内核发现这个描述符没有准备好，然后切换回用户态并且只得到 EAGAIN （errorno 被设置为 35），做的是无用功。描述符非常多的时候，每次的切换过程就是巨大的浪费。
+轮询的缺点是浪费太多 CPU 时间。大多数时候我们没有数据可读，但是还是用了`read`这个**系统调用**，使用系统调用时会从用户态切换到内核态。而大多数情况下我们调用`read`，然后陷入内核态，内核发现这个描述符没有准备好，然后切换回用户态并且只得到 EAGAIN （errorno 被设置为 35），做的是无用功。描述符非常多的时候，每次的切换过程就是巨大的浪费。
 
-所以，需要 **I/O 多路复用**。I/O 多路复用通过使用一个系统函数，同时等待多个描述符的可读、可写状态。
+所以，需要**I/O 多路复用**。I/O 多路复用通过使用一个系统函数，同时等待多个描述符的可读、可写状态。
 
 为了达到这个目的，我们需要做的是：建立一个描述符列表，以及我们分别关心它们的什么事件（可读还是可写还是发生例外情况）；调用一个系统函数，直到这个描述符列表里有至少一个描述符关联的事件发生时，这个函数才会返回。
 
 select, poll, epoll 就是这样的系统函数。
 
-### [](https://jeff.wtf/2017/02/IO-multiplexing/#select "select")select
+### select
 
 我们可以在所有 POSIX 兼容的系统里使用 select 函数来进行 I/O 多路复用。我们需要通过 select 函数的参数传递给内核的信息有：
 
@@ -52,22 +63,22 @@ select 的返回时，内核会告诉我们：
     
     *   可读的描述符的个数
     *   哪些描述符发生了哪些事件
-
+````
     #include <sys/select.h>
     int select(int maxfdp1, fd_set* readfds,
                fd_set* writefds, fd_set* exceptfds,
                struct timeval* timeout);
     
     // 返回值: 已就绪的描述符的个数。超时时为 0 ，错误时为 -1
+````
+`maxfdp1`意思是 “max file descriptor plus 1” ，就是把你要监视的所有文件描述符里最大的那个加上 1 。（它实际上决定了内核要遍历文件描述符的次数，比如你监视了文件描述符 5 和 20 并把`maxfdp1`设置为 21 ，内核每次都会从描述符 0 依次检查到 20。）
 
-`maxfdp1` 意思是 “max file descriptor plus 1” ，就是把你要监视的所有文件描述符里最大的那个加上 1 。（它实际上决定了内核要遍历文件描述符的次数，比如你监视了文件描述符 5 和 20 并把 `maxfdp1` 设置为 21 ，内核每次都会从描述符 0 依次检查到 20。）
-
-中间的三个参数是你想监视的文件描述符的集合。可以把 fd_set 类型视为 1024 位的二进制数，这意味着 select 只能监视小于 1024 的文件描述符（1024 是由 Linux 的 sys/select.h 里 `FD_SETSIZE` 宏设置的值）。在 select 返回后我们通过 `FD_ISSET` 来判断代表该位的描述符是否是已准备好的状态。
+中间的三个参数是你想监视的文件描述符的集合。可以把 fd_set 类型视为 1024 位的二进制数，这意味着 select 只能监视小于 1024 的文件描述符（1024 是由 Linux 的 sys/select.h 里`FD_SETSIZE`宏设置的值）。在 select 返回后我们通过`FD_ISSET`来判断代表该位的描述符是否是已准备好的状态。
 
 最后一个参数是等待超时的时长：到达这个时长但是没有任一描述符可用时，函数会返回 0 。
 
 用一个代码片段来展示 select 的用法：
-
+````
         // 这个例子要监控文件描述符 3, 4 的可读状态，以及 4, 5 的可写状态
         
         // 初始化两个 fd_set 以及 timeval
@@ -123,76 +134,76 @@ select 的返回时，内核会告诉我们：
             // 上面的 printf 语句换成对应的 read 或者 write 函数就
             // 可以立即读取或者写入相应的描述符而不用等待
         }
-
+````
 可以看到，select 的缺点有：
 
-*   默认能监视的文件描述符不能大于 1024，也代表监视的总数不超过1024。即使你因为需要监视的描述符大于 1024 而改动内核的 `FD_SETSIZE` 值，但由于 select 是每次都会线性扫描整个fd_set，集合越大速度越慢，所以性能会比较差。
-*   select 函数返回时只能看见已准备好的描述符数量，至于是哪个描述符准备好了需要循环用 `FD_ISSET` 来检查，当未准备好的描述符很多而准备好的很少时，效率比较低。
+*   默认能监视的文件描述符不能大于 1024，也代表监视的总数不超过1024。即使你因为需要监视的描述符大于 1024 而改动内核的`FD_SETSIZE`值，但由于 select 是每次都会线性扫描整个fd_set，集合越大速度越慢，所以性能会比较差。
+*   select 函数返回时只能看见已准备好的描述符数量，至于是哪个描述符准备好了需要循环用`FD_ISSET`来检查，当未准备好的描述符很多而准备好的很少时，效率比较低。
 *   select 函数每次执行的时候，都把参数里传入的三个 fd_set 从用户空间复制到内核空间。而每次 fd_set 里要监视的描述符变化不大时，全部重新复制一遍并不划算。同样在每次都是未准备好的描述符很多而准备好的很少时，调用 select 会很频繁，用户/内核间的的数据复制就成了一个大的开销。
 
 还有一个问题是在代码的写法上给我一些困扰的，就是每次调用 select 前必须重新设置三个 fd_set。 fd_set 类型只是 1024 位的二进制数（实际上结构体里是几个 long 变量的数组；比如 64 位机器上 long 是 64 bit，那么 fd_set 里就是 16 个 long 变量的数组），由一位的 1 和 0 代表一个文件描述符的状态，但是其实调用 select 前后位的 1/0 状态意义是不一样的。
 
-先讲一下几个对 fd_set 操作的函数的作用：`FD_ZERO` 把 fd_set 所有位设置为 0 ；`FD_SET` 把一个位设置为 1 ；`FD_ISSET` 判断一个位是否为 1 。
+先讲一下几个对 fd_set 操作的函数的作用：`FD_ZERO`把 fd_set 所有位设置为 0 ；`FD_SET`把一个位设置为 1 ；`FD_ISSET`判断一个位是否为 1 。
 
-调用 select 前：我们用 `FD_ZERO` 把 fd_set 先全部初始化，然后用 `FD_SET` 把我们关心的代表描述符的位设置为 1 。我们这时可以用 `FD_ISSET` 判断这个位是否被我们设置，这时的含义是**我们想要监视的描述符是否被设置为被监视的状态**。
+调用 select 前：我们用`FD_ZERO`把 fd_set 先全部初始化，然后用`FD_SET`把我们关心的代表描述符的位设置为 1 。我们这时可以用`FD_ISSET`判断这个位是否被我们设置，这时的含义是**我们想要监视的描述符是否被设置为被监视的状态**。
 
 调用 select 时：内核判断 fd_set 里的位并把各个 fd_set 里所有值为 1 的位记录下来，然后把 fd_set 全部设置成 0 ；一个描述符上有对应的事件发生时，把对应 fd_set 里代表这个描述符的位设置为 1 。
 
-在 select 返回之后：我们同样用 `FD_ISSET` 判断各个我们关心的位是 0 还是 1 ，这时的含义是，**这个位是否是发生了我们关心的事件**。
+在 select 返回之后：我们同样用`FD_ISSET`判断各个我们关心的位是 0 还是 1 ，这时的含义是，**这个位是否是发生了我们关心的事件**。
 
 所以，在下一次调用 select 前，我们不得不把已经被内核改掉的 fd_set 全部重新设置一下。
 
 select 在监视大量描述符尤其是更多的描述符未准备好的情况时性能很差。《Unix 高级编程》里写，用 select 的程序通常只使用 3 到 10 个描述符。
 
-### [](https://jeff.wtf/2017/02/IO-multiplexing/#poll "poll")poll
+### poll
 
 poll 和 select 是相似的，只是给的接口不同。
-
+````
     #include <poll.h>
     int poll(struct pollfd fdarray[], nfds_t nfds, int timeout);
     
     // 返回值: 已就绪的描述符的个数。超时时为 0 ，错误时为 -1
-`fdarray` 是 `pollfd` 的数组。`pollfd` 结构体是这样的：
+`fdarray`是`pollfd`的数组。`pollfd`结构体是这样的：
 
     struct pollfd {
         int fd;         // 文件描述符
         short events;   // 我期待的事件
         short revents;  // 实际发生的事件：我期待的事件中发生的；或者异常情况
     };
+````
+`nfds`是`fdarray`的长度，也就是 pollfd 的个数。
 
-`nfds` 是 `fdarray` 的长度，也就是 pollfd 的个数。
-
-`timeout` 代表等待超时的毫秒数。
+`timeout`代表等待超时的毫秒数。
 
-相比 select ，poll 有这些优点：由于 poll 在 pollfd 里用 `int fd` 来表示文件描述符而不像 select 里用的 fd_set 来分别表示描述符，所以没有必须小于 1024 的限制，也没有数量限制；由于 poll 用 `events` 表示期待的事件，通过修改 `revents` 来表示发生的事件，所以不需要像 select 在每次调用前重新设置描述符和期待的事件。
+相比 select ，poll 有这些优点：由于 poll 在 pollfd 里用`int fd`来表示文件描述符而不像 select 里用的 fd_set 来分别表示描述符，所以没有必须小于 1024 的限制，也没有数量限制；由于 poll 用`events`表示期待的事件，通过修改`revents`来表示发生的事件，所以不需要像 select 在每次调用前重新设置描述符和期待的事件。
 
-除此之外，poll 和 select 几乎相同。在 poll 返回后，需要遍历 `fdarray` 来检查各个 `pollfd` 里的 `revents` 是否发生了期待的事件；每次调用 poll 时，把 `fdarray` 复制到内核空间。在描述符太多而每次准备好的较少时，poll 有同样的性能问题。
+除此之外，poll 和 select 几乎相同。在 poll 返回后，需要遍历`fdarray`来检查各个`pollfd`里的`revents`是否发生了期待的事件；每次调用 poll 时，把`fdarray`复制到内核空间。在描述符太多而每次准备好的较少时，poll 有同样的性能问题。
 
-### [](https://jeff.wtf/2017/02/IO-multiplexing/#epoll "epoll")epoll
+### epoll
 
 epoll 是在 Linux 2.5.44 中首度登场的。不像 select 和 poll ，它提供了三个系统函数而不是一个。
 
-#### [](https://jeff.wtf/2017/02/IO-multiplexing/#epoll-create-%E7%94%A8%E6%9D%A5%E5%88%9B%E5%BB%BA%E4%B8%80%E4%B8%AA-epoll-%E6%8F%8F%E8%BF%B0%E7%AC%A6%EF%BC%9A "epoll_create 用来创建一个 epoll 描述符：")epoll_create 用来创建一个 epoll 描述符：
+#### epoll_create 用来创建一个 epoll 描述符：
 
     #include <sys/epoll.h>
     int epoll_create(int size);
     
     // 返回值：epoll 描述符
-`size` 用来告诉内核你想监视的文件描述符的数目，但是它**并不是限制了能监视的描述符的最大个数**，而是给内核最初分配的空间一个建议。然后系统会在内核中分配一个空间来存放事件表，并返回一个 **epoll 描述符**，用来操作这个事件表。
+`size`用来告诉内核你想监视的文件描述符的数目，但是它**并不是限制了能监视的描述符的最大个数**，而是给内核最初分配的空间一个建议。然后系统会在内核中分配一个空间来存放事件表，并返回一个**epoll 描述符**，用来操作这个事件表。
 
-#### [](https://jeff.wtf/2017/02/IO-multiplexing/#epoll-ctl-%E7%94%A8%E6%9D%A5%E5%A2%9E-%E5%88%A0-%E6%94%B9%E5%86%85%E6%A0%B8%E4%B8%AD%E7%9A%84%E4%BA%8B%E4%BB%B6%E8%A1%A8%EF%BC%9A "epoll_ctl 用来增/删/改内核中的事件表：")epoll_ctl 用来增/删/改内核中的事件表：
+#### epoll_ctl 用来增/删/改内核中的事件表：
 
     int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
     
     // 返回值：成功时返回 0 ，失败时返回 -1
 
-`epfd` 是 epoll 描述符。
+`epfd`是 epoll 描述符。
 
-`op` 是操作类型（增加/删除/修改）。
+`op`是操作类型（增加/删除/修改）。
 
-`fd` 是希望监视的文件描述符。
+`fd`是希望监视的文件描述符。
 
-`event` 是一个 epoll_event 结构体的指针。epoll_event 的定义是这样的：
+`event`是一个 epoll_event 结构体的指针。epoll_event 的定义是这样的：
 
     typedef union epoll_data {
        void        *ptr;
@@ -206,21 +217,21 @@ epoll 是在 Linux 2.5.44 中首度登场的。不像 select 和 poll ，它提
        epoll_data_t data;        // 用户数据变量
     };
 
-这个结构体里，除了期待的事件外，还有一个 `data` ，是一个 union，它是用来让我们在得到下面第三个函数的返回值以后方便的定位文件描述符的。
+这个结构体里，除了期待的事件外，还有一个`data`，是一个 union，它是用来让我们在得到下面第三个函数的返回值以后方便的定位文件描述符的。
 
-#### [](https://jeff.wtf/2017/02/IO-multiplexing/#epoll-wait-%E7%94%A8%E6%9D%A5%E7%AD%89%E5%BE%85%E4%BA%8B%E4%BB%B6 "epoll_wait 用来等待事件")epoll_wait 用来等待事件
+#### epoll_wait 用来等待事件
 
     int epoll_wait(int epfd, struct epoll_event *result_events,
                   int maxevents, int timeout);
     
     // 返回值：已就绪的描述符个数。超时时为 0 ，错误时为 -1
-`epfd` 是 epoll 描述符。
+`epfd`是 epoll 描述符。
 
-`result_events` 是 epoll_event 结构体的指针，它将指向的是所有已经准备好的事件描述符相关联的 epoll_event（在上个步骤里调用 epoll_ctl 时关联起来的）。下面的例子可以让你知道这个参数的意义。
+`result_events`是 epoll_event 结构体的指针，它将指向的是所有已经准备好的事件描述符相关联的 epoll_event（在上个步骤里调用 epoll_ctl 时关联起来的）。下面的例子可以让你知道这个参数的意义。
 
-`maxevents` 是返回的最大事件个数，也就是你能通过 result_events 指针遍历到的最大的次数。
+`maxevents`是返回的最大事件个数，也就是你能通过 result_events 指针遍历到的最大的次数。
 
-`timeout` 是等待超时的毫秒数。
+`timeout`是等待超时的毫秒数。
 
 用一个代码片段来展示 epoll 的用法：
     // 这个例子要监控文件描述符 3, 4 的可读状态，以及 4, 5 的可写状态
@@ -271,14 +282,14 @@ epoll 是在 Linux 2.5.44 中首度登场的。不像 select 和 poll ，它提
 
 所以 epoll 解决了 poll 和 select 的问题：
 
-*   只在 epoll_ctl 的时候把数据复制到内核空间，这保证了每个描述符和事件一定只会被复制到内核空间一次；每次调用 epoll_wait 都不会复制新数据到内核空间。相比之下，select 每次调用都会把三个 fd_set 复制一遍；poll 每次调用都会把 `fdarray` 复制一遍。
+*   只在 epoll_ctl 的时候把数据复制到内核空间，这保证了每个描述符和事件一定只会被复制到内核空间一次；每次调用 epoll_wait 都不会复制新数据到内核空间。相比之下，select 每次调用都会把三个 fd_set 复制一遍；poll 每次调用都会把`fdarray`复制一遍。
 
-*   epoll_wait 返回 n ，那么只需要做 n 次循环，可以保证遍历的每一次都是有意义的。相比之下，select 需要做至少 n 次至多 `maxfdp1` 次循环；poll 需要遍历完 fdarray 即做 `nfds` 次循环。
+*   epoll_wait 返回 n ，那么只需要做 n 次循环，可以保证遍历的每一次都是有意义的。相比之下，select 需要做至少 n 次至多`maxfdp1`次循环；poll 需要遍历完 fdarray 即做`nfds`次循环。
 
-*   在内部实现上，epoll 使用了回调的方法。调用 epoll_ctl 时，就是注册了一个事件：在集合中放入文件描述符以及事件数据，并且加上一个回调函数。一旦文件描述符上的对应事件发生，就会调用回调函数，这个函数会把这个文件描述符加入到**就绪队列**上。当你调用 epoll_wait 时，它只是在查看就绪队列上是否有内容，有的话就返回给你的程序。`select()` `poll()` `epoll_wait()` 三个函数在操作系统看来，都是睡眠一会儿然后判断一会儿的循环，但是 select 和 poll 在醒着的时候要遍历整个文件描述符集合，而 epoll_wait 只是看看就绪队列是否为空而已。这是 epoll 高性能的理由，使得其 I/O 的效率不会像使用轮询的 select/poll 随着描述符增加而大大降低。
+*   在内部实现上，epoll 使用了回调的方法。调用 epoll_ctl 时，就是注册了一个事件：在集合中放入文件描述符以及事件数据，并且加上一个回调函数。一旦文件描述符上的对应事件发生，就会调用回调函数，这个函数会把这个文件描述符加入到**就绪队列**上。当你调用 epoll_wait 时，它只是在查看就绪队列上是否有内容，有的话就返回给你的程序。`select()``poll()``epoll_wait()`三个函数在操作系统看来，都是睡眠一会儿然后判断一会儿的循环，但是 select 和 poll 在醒着的时候要遍历整个文件描述符集合，而 epoll_wait 只是看看就绪队列是否为空而已。这是 epoll 高性能的理由，使得其 I/O 的效率不会像使用轮询的 select/poll 随着描述符增加而大大降低。
 
 > 注 1 ：select/poll/epoll_wait 三个函数的等待超时时间都有一样的特性：等待时间设置为 0 时函数不阻塞而是立即返回，不论是否有文件描述符已准备好；poll/epoll_wait 中的 timeout 为 -1，select 中的 timeout 为 NULL 时，则无限等待，直到有描述符已准备好才会返回。
 
-> 注 2 ：有的新手会把文件描述符是否标记为阻塞 I/O 等同于 I/O 多路复用函数是否阻塞。其实文件描述符是否标记为阻塞，决定了你 `read` 或 `write` 它时如果它未准备好是阻塞等待，还是立即返回 EAGAIN ；而 I/O 多路复用函数除非你把 timeout 设置为 0 ，否则它总是会阻塞住你的程序。
+> 注 2 ：有的新手会把文件描述符是否标记为阻塞 I/O 等同于 I/O 多路复用函数是否阻塞。其实文件描述符是否标记为阻塞，决定了你`read`或`write`它时如果它未准备好是阻塞等待，还是立即返回 EAGAIN ；而 I/O 多路复用函数除非你把 timeout 设置为 0 ，否则它总是会阻塞住你的程序。
 
 > 注 3 ：上面的例子只是入门，可能是不准确或不全面的：一是数据要立即处理防止丢失；二是 EPOLLIN/EPOLLOUT 不完全等同于可读可写事件，具体要去搜索 poll/epoll 的事件具体有哪些；三是大多数实际例子里，比如一个 tcp server ，都会在运行中不断增加/删除的文件描述符而不是记住固定的 3 4 5 几个描述符（用这种例子更能看出 epoll 的优势）；四是 epoll 的优势更多的体现在处理大量闲连接的情况，如果场景是处理少量短连接，用 select 反而更好，而且用 select 的代码能运行在所有平台上。
diff --git "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\24311\357\274\232Tomcat\344\270\255\347\232\204Connector\346\272\220\347\240\201\345\210\206\346\236\220\357\274\210NIO\357\274\211.md" "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232Tomcat\344\270\255\347\232\204Connector\346\272\220\347\240\201\345\210\206\346\236\220\357\274\210NIO\357\274\211.md"
similarity index 93%
rename from "docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\24311\357\274\232Tomcat\344\270\255\347\232\204Connector\346\272\220\347\240\201\345\210\206\346\236\220\357\274\210NIO\357\274\211.md"
rename to "docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232Tomcat\344\270\255\347\232\204Connector\346\272\220\347\240\201\345\210\206\346\236\220\357\274\210NIO\357\274\211.md"
index ec325ea..7404a6e 100644
--- "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\24311\357\274\232Tomcat\344\270\255\347\232\204Connector\346\272\220\347\240\201\345\210\206\346\236\220\357\274\210NIO\357\274\211.md"
+++ "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232Tomcat\344\270\255\347\232\204Connector\346\272\220\347\240\201\345\210\206\346\236\220\357\274\210NIO\357\274\211.md"
@@ -1,5 +1,18 @@
-# Table of Contents
+# 目录
 
+* [目录](#目录)
+  * [前言](#前言)
+  * [源码环境准备](#源码环境准备)
+  * [endpoint](#endpoint)
+  * [init 过程分析](#init-过程分析)
+  * [start 过程分析](#start-过程分析)
+  * [Acceptor](#acceptor)
+  * [Poller](#poller)
+  * [processKey](#processkey)
+  * [总结](#总结)
+
+
+# 目录
   * [前言](#前言)
   * [源码环境准备](#源码环境准备)
   * [endpoint](#endpoint)
@@ -43,7 +56,7 @@
 
 先简单画一张图示意一下本文的主要内容：
 
-![0](https://www.javadoop.com/blogimages/tomcat-nio/0.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105401.png)
 
 **目录**
 
@@ -87,7 +100,7 @@ public static void main(String[] args) throws LifecycleException {
 
 这里，介绍第一个重要的概念：**Connector**。在 Tomcat 中，使用 Connector 来处理连接，一个 Tomcat 可以配置多个 Connector，分别用于监听不同端口，或处理不同协议。
 
-在 Connector 的构造方法中，我们可以传 `HTTP/1.1` 或 `AJP/1.3` 用于指定协议，也可以传入相应的协议处理类，毕竟协议不是重点，将不同端口进来的连接对应不同处理类才是正道。典型地，我们可以指定以下几个协议处理类：
+在 Connector 的构造方法中，我们可以传`HTTP/1.1`或`AJP/1.3`用于指定协议，也可以传入相应的协议处理类，毕竟协议不是重点，将不同端口进来的连接对应不同处理类才是正道。典型地，我们可以指定以下几个协议处理类：
 
 *   org.apache.coyote.http11.Http11NioProtocol：对应非阻塞 IO
 *   org.apache.coyote.http11.Http11Nio2Protocol：对应异步 IO
@@ -119,9 +132,9 @@ public static void main(String[] args) throws LifecycleException {
 
 ## endpoint
 
-前面我们说过一个 Connector 对应一个协议，当然这描述也不太对，NIO 和 NIO2 就都是处理 HTTP/1.1 的，只不过一个使用非阻塞，一个使用异步。进到指定 protocol 代码，我们就会发现，它们的代码及其简单，只不过是指定了特定的 **endpoint**。
+前面我们说过一个 Connector 对应一个协议，当然这描述也不太对，NIO 和 NIO2 就都是处理 HTTP/1.1 的，只不过一个使用非阻塞，一个使用异步。进到指定 protocol 代码，我们就会发现，它们的代码及其简单，只不过是指定了特定的**endpoint**。
 
-打开 `Http11NioProtocol` 和 `Http11Nio2Protocol`源码，我们可以看到，在构造方法中，它们分别指定了 NioEndpoint 和 Nio2Endpoint。
+打开`Http11NioProtocol`和`Http11Nio2Protocol`源码，我们可以看到，在构造方法中，它们分别指定了 NioEndpoint 和 Nio2Endpoint。
 
 ```
 // 非阻塞模式
@@ -143,15 +156,15 @@ public class Http11Nio2Protocol extends AbstractHttp11JsseProtocol<Nio2Channel>
 }
 ```
 
-这里介绍第二个重要的概念：**endpoint**。Tomcat 使用不同的 endpoint 来处理不同的协议请求，今天我们的重点是 **NioEndpoint**，其使用**非阻塞 IO** 来进行处理 HTTP/1.1 协议的请求。
+这里介绍第二个重要的概念：**endpoint**。Tomcat 使用不同的 endpoint 来处理不同的协议请求，今天我们的重点是**NioEndpoint**，其使用**非阻塞 IO**来进行处理 HTTP/1.1 协议的请求。
 
-**NioEndpoint** 继承 => **AbstractJsseEndpoint** 继承 => **AbstractEndpoint**。中间的 AbstractJsseEndpoint 主要是提供了一些关于 `HTTPS` 的方法，这块我们暂时忽略它，后面所有关于 HTTPS 的我们都直接忽略，感兴趣的读者请自行分析。
+**NioEndpoint**继承 =>**AbstractJsseEndpoint**继承 =>**AbstractEndpoint**。中间的 AbstractJsseEndpoint 主要是提供了一些关于`HTTPS`的方法，这块我们暂时忽略它，后面所有关于 HTTPS 的我们都直接忽略，感兴趣的读者请自行分析。
 
 ## init 过程分析
 
 下面，我们看看从 tomcat.start() 一直到 NioEndpoint 的过程。
 
-**1\. AbstractProtocol** # **init**
+**1\. AbstractProtocol**#**init**
 
 ```
 @Override
@@ -165,7 +178,7 @@ public void init() throws Exception {
 }
 ```
 
-**2\. AbstractEndpoint** # **init**
+**2\. AbstractEndpoint**#**init**
 
 ```
 public final void init() throws Exception {
@@ -177,7 +190,7 @@ public final void init() throws Exception {
 }
 ```
 
-**3\. NioEndpoint** # **bind**
+**3\. NioEndpoint**#**bind**
 
 这里就到我们的 NioEndpoint 了，要使用到我们之前学习的 NIO 的知识了。
 
@@ -321,9 +334,9 @@ public void startInternal() throws Exception {
 }
 ```
 
-到这里，我们启动了**工作线程池**、 **poller 线程组**、**acceptor 线程组**。同时，工作线程池初始就已经启动了 10 个线程。我们用 **jconsole** 来看看此时的线程，请看下图：
+到这里，我们启动了**工作线程池**、**poller 线程组**、**acceptor 线程组**。同时，工作线程池初始就已经启动了 10 个线程。我们用**jconsole**来看看此时的线程，请看下图：
 
-![1](https://www.javadoop.com/blogimages/tomcat-nio/1.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105500.png)
 
 从 jconsole 中，我们可以看到，此时启动了 BlockPoller、worker、poller、acceptor、AsyncTimeout，大家应该都已经清楚了每个线程是哪里启动的吧。
 
@@ -345,7 +358,7 @@ public Acceptor(AbstractEndpoint<?,U> endpoint) {
 }
 ```
 
-**threadName** 就是一个线程名字而已，Acceptor 的状态 **state** 主要是随着 endpoint 来的。
+**threadName**就是一个线程名字而已，Acceptor 的状态**state**主要是随着 endpoint 来的。
 
 ```
 public enum AcceptorState {
@@ -498,7 +511,7 @@ protected boolean setSocketOptions(SocketChannel socket) {
 }
 ```
 
-我们看到，这里又没有进行实际的处理，而是将这个 SocketChannel **注册**到了其中一个 poller 上。因为我们知道，acceptor 应该尽可能的简单，只做 accept 的工作，简单处理下就往后面扔。acceptor 还得回到之前的循环去 accept 新的连接呢。
+我们看到，这里又没有进行实际的处理，而是将这个 SocketChannel**注册**到了其中一个 poller 上。因为我们知道，acceptor 应该尽可能的简单，只做 accept 的工作，简单处理下就往后面扔。acceptor 还得回到之前的循环去 accept 新的连接呢。
 
 我们只需要明白，此时，往 poller 中注册了一个 NioChannel 实例，此实例包含客户端过来的 SocketChannel 和一个 SocketBufferHandler 实例。
 
@@ -820,7 +833,7 @@ protected SocketProcessorBase<NioChannel> createSocketProcessor(
 
 最后，再祭出文章开始的那张图来总结一下：
 
-![0](https://www.javadoop.com/blogimages/tomcat-nio/0.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105530.png)
 
 这里简单梳理下前面我们说的流程，帮大家回忆一下：
 
diff --git "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2439\357\274\232\345\237\272\344\272\216NIO\347\232\204\347\275\221\347\273\234\347\274\226\347\250\213\346\241\206\346\236\266Netty.md" "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\345\237\272\344\272\216NIO\347\232\204\347\275\221\347\273\234\347\274\226\347\250\213\346\241\206\346\236\266Netty.md"
similarity index 95%
rename from "docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2439\357\274\232\345\237\272\344\272\216NIO\347\232\204\347\275\221\347\273\234\347\274\226\347\250\213\346\241\206\346\236\266Netty.md"
rename to "docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\345\237\272\344\272\216NIO\347\232\204\347\275\221\347\273\234\347\274\226\347\250\213\346\241\206\346\236\266Netty.md"
index a7a948b..f2d39e8 100644
--- "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2439\357\274\232\345\237\272\344\272\216NIO\347\232\204\347\275\221\347\273\234\347\274\226\347\250\213\346\241\206\346\236\266Netty.md"
+++ "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\345\237\272\344\272\216NIO\347\232\204\347\275\221\347\273\234\347\274\226\347\250\213\346\241\206\346\236\266Netty.md"
@@ -1,5 +1,24 @@
-# Table of Contents
+# 目录
 
+* [目录](#目录)
+  * [Netty概述](#netty概述)
+  * [Netty简介](#netty简介)
+    * [Netty都有哪些组件？](#netty都有哪些组件？)
+    * [Netty是如何处理连接请求和业务逻辑的呢？](#netty是如何处理连接请求和业务逻辑的呢？)
+    * [如何配置一个Netty应用？](#如何配置一个netty应用？)
+    * [Netty是如何处理数据的？](#netty是如何处理数据的？)
+    * [如何处理我们的业务逻辑？](#如何处理我们的业务逻辑？)
+    * [ByteBuf](#bytebuf)
+    * [Channel](#channel)
+    * [ChannelHandler](#channelhandler)
+    * [ChannelPipeline](#channelpipeline)
+    * [EventLoop](#eventloop)
+    * [Bootstrap](#bootstrap)
+    * [Echo示例](#echo示例)
+  * [参考文献](#参考文献)
+
+
+# 目录
   * [Netty概述](#netty概述)
   * [etty简介](#etty简介)
     * [Netty都有哪些组件？](#netty都有哪些组件？)
@@ -38,6 +57,7 @@
 <!-- more -->
 
 ## Netty概述
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405103849.png)
 
 **Netty是一个基于异步与事件驱动的网络应用程序框架，它支持快速与简单地开发可维护的高性能的服务器与客户端。**
 
@@ -57,13 +77,13 @@ Netty提供了高性能与易用性，它具有以下特点：
 
 大多数人使用Netty主要还是为了**提高应用的性能**，而高性能则离不开非阻塞IO。Netty的非阻塞IO是基于Java NIO的，并且对其进行了封装（直接使用Java NIO API在高复杂度下的应用中是一项非常繁琐且容易出错的操作，而Netty帮你封装了这些复杂操作）。
 
-## etty简介
+## Netty简介
 
-<pre>读完这一章，我们基本上可以了解到Netty所有重要的组件，对Netty有一个全面的认识，这对下一步深入学习Netty是十分重要的，而学完这一章，我们其实已经可以用Netty解决一些常规的问题了。</pre>
+读完这一章，我们基本上可以了解到Netty所有重要的组件，对Netty有一个全面的认识，这对下一步深入学习Netty是十分重要的，而学完这一章，我们其实已经可以用Netty解决一些常规的问题了。
 
 ### Netty都有哪些组件？
 
-<pre>为了更好的理解和进一步深入Netty，我们先总体认识一下Netty用到的组件及它们在整个Netty架构中是怎么协调工作的。Netty应用中必不可少的组件：</pre>
+为了更好的理解和进一步深入Netty，我们先总体认识一下Netty用到的组件及它们在整个Netty架构中是怎么协调工作的。Netty应用中必不可少的组件：
 
 *   Bootstrap or ServerBootstrap
 
@@ -109,16 +129,13 @@ Netty是一个**非阻塞的、事件驱动的、网络编程**框架。当然
 
 关于这些名词之间的关系，可以见下图：
 
-![](https://img-blog.csdn.net/20140606104845234?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc3VpZmVuZzMwNTE=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405102033.png)
 
 如图所示：当一个连接到达，Netty会注册一个channel，然后EventLoopGroup会**分配一个EventLoop绑定到这个channel**,在这个channel的整个生命周期过程中，都会由绑定的这个EventLoop来为它服务，而这个**EventLoop就是一个线程**。
 
 说到这里，那么EventLoops和EventLoopGroups关系是如何的呢？我们前面说过一个EventLoopGroup包含多个Eventloop，但是我们看一下下面这幅图，这幅图是一个继承树，从这幅图中我们可以看出，EventLoop其实继承自EventloopGroup，也就是说，在某些情况下，我们可以把一个EventLoopGroup当做一个EventLoop来用。
 
-<pre>​</pre>
-
-[![](https://img-blog.csdn.net/20140606104919140?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc3VpZmVuZzMwNTE=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)](https://img-blog.csdn.net/20140606104919140?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc3VpZmVuZzMwNTE=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405102103.png)
 ### 如何配置一个Netty应用？
 
 BootsStrapping
@@ -129,15 +146,14 @@ BootsStrapping
 
 2.**客户端**的Bootstrap一般用**一个EventLoopGroup**，而**服务器**端的ServerBootstrap会用到**两个**（这两个也可以是同一个实例）。为何服务器端要用到两个EventLoopGroup呢？这么设计有明显的好处，如果一个ServerBootstrap有两个EventLoopGroup，那么就可以把**第一个**EventLoopGroup用来**专门负责绑定到端口监听连接事件**，而把**第二个**EventLoopGroup用来**处理每个接收到的连接**，下面我们用一幅图来展现一下这种模式：
 
-![](https://img-blog.csdn.net/20140606104949484?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc3VpZmVuZzMwNTE=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405102127.png)
 PS: 如果仅由一个EventLoopGroup处理所有请求和连接的话，在并发量很大的情况下，这个EventLoopGroup有可能会忙于处理已经接收到的连接而不能及时处理新的连接请求，**用两个的话**，会有专门的线程来处理连接请求，不会导致请求超时的情况，大大**提高了并发处理能力**。
 
 我们知道一个Channel需要由一个EventLoop来绑定，而且两者**一旦绑定就不会再改变**。一般情况下一个EventLoopGroup中的**EventLoop数量会少于Channel数量**，那么就很**有可能出现一个多个Channel公用一个EventLoop**的情况，这就意味着如果一个Channel中的**EventLoop很忙**的话，会**影响**到这个Eventloop**对其它Channel的处理**，**这也就是为什么我们不能阻塞EventLoop的原因。**
 
 当然，我们的Server也可以只用一个EventLoopGroup,由一个实例来处理连接请求和IO事件，请看下面这幅图：
 
-![](https://img-blog.csdn.net/20140606105016890?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc3VpZmVuZzMwNTE=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405102142.png)
 
 ### Netty是如何处理数据的？
 
@@ -149,11 +165,11 @@ ChannelPipeline and handlers
 
 我们的应用程序中用到的最多的应该就是ChannelHandler，我们可以这么想象，数据在一个ChannelPipeline中流动，而ChannelHandler便是其中的一个个的小阀门，这些数据都会经过每一个ChannelHandler并且被它处理。这里有一个公共接口ChannelHandler:
 
-![](https://img-blog.csdn.net/20140606105045406?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc3VpZmVuZzMwNTE=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405102205.png)
 
 从上图中我们可以看到，ChannelHandler有两个子类ChannelInboundHandler和ChannelOutboundHandler，这两个类对应了两个数据流向，如果数据是**从外部流入**我们的应用程序，我们就看做是**inbound**，相反便是outbound。其实ChannelHandler和Servlet有些类似，一个ChannelHandler处理完接收到的数据会传给下一个Handler，或者什么不处理，直接传递给下一个。下面我们看一下ChannelPipeline是如何安排ChannelHandler的：
 
-![](https://img-blog.csdn.net/20140606105113171?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc3VpZmVuZzMwNTE=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405102222.png)
 
 从上图中我们可以看到，**一个ChannelPipeline可以把两种Handler（ChannelInboundHandler和ChannelOutboundHandler）混合在一起**，当一个数据流进入ChannelPipeline时，它会从ChannelPipeline头部开始传给第一个ChannelInboundHandler，当第一个处理完后再传给下一个，一直传递到管道的尾部。与之相对应的是，当数据被写出时，它会从管道的尾部开始，先经过管道尾部的“最后”一个ChannelOutboundHandler，当它处理完成后会传递给前一个ChannelOutboundHandler。
 
@@ -173,7 +189,7 @@ Encoders和Decoders
 
 因为我们在网络传输时只能传输字节流，因此，在发送数据之前，我们必须把我们的message型转换为bytes，与之对应，我们在接收数据后，必须把接收到的bytes再转换成message。我们把bytes to message这个过程称作Decode(解码成我们可以理解的)，把message to bytes这个过程成为Encode。
 
-Netty中提供了很多现成的编码/解码器，我们一般从他们的名字中便可知道他们的用途，如**ByteToMessageDecoder**、**MessageToByteEncoder**，如专门用来处理Google Protobuf协议的**ProtobufEncoder**、 **ProtobufDecoder**。
+Netty中提供了很多现成的编码/解码器，我们一般从他们的名字中便可知道他们的用途，如**ByteToMessageDecoder**、**MessageToByteEncoder**，如专门用来处理Google Protobuf协议的**ProtobufEncoder**、**ProtobufDecoder**。
 
 我们前面说过，具体是哪种Handler就要看它们继承的是InboundAdapter还是OutboundAdapter，对于**Decoders**,很容易便可以知道它是继承自**ChannelInboundHandlerAdapter**或 ChannelInboundHandler，因为解码的意思是把ChannelPipeline**传入的bytes解码成我们可以理解的message**（即Java Object），而ChannelInboundHandler正是处理Inbound Event，而Inbound Event中传入的正是字节流。Decoder会覆盖其中的“ChannelRead()”方法，在这个方法中来调用具体的decode方法解码传递过来的字节流，然后通过调用ChannelHandlerContext.fireChannelRead(decodedMessage)方法把编码好的Message传递给下一个Handler。与之类似，Encoder就不必多少了。
 
@@ -191,7 +207,7 @@ NIO可以称为New IO也可以称为Non-blocking IO，它比Java旧的阻塞IO
 
 *   Selector：选择器是NIO实现的关键，NIO采用的是I/O多路复用的方式来实现非阻塞，Selector通过在**一个线程中监听每个Channel的IO事件来确定有哪些已经准备好进行IO操作的Channel**，因此可**以在任何时间检查任意的读操作或写操作的完成状态**。这种方式**避免了等待IO操作准备数据时的阻塞**，使用较少的线程便可以处理许多连接，减少了线程切换与维护的开销。
 
-    [![](http://wx2.sinaimg.cn/large/63503acbly1flys7n7hvaj20h90doglj.jpg)](http://wx2.sinaimg.cn/large/63503acbly1flys7n7hvaj20h90doglj.jpg)
+[![](http://wx2.sinaimg.cn/large/63503acbly1flys7n7hvaj20h90doglj.jpg)](http://wx2.sinaimg.cn/large/63503acbly1flys7n7hvaj20h90doglj.jpg)
 
 了解了NIO的实现思想之后，我觉得还很有必要了解一下Unix中的I/O模型，Unix中拥有以下5种I/O模型：
 
@@ -233,21 +249,21 @@ Unix中提供了两种I/O多路复用函数，select()和poll()。select()的兼
 还有一种比select()与poll()更加高效的实现叫做epoll()，它是由Linux内核2.6推出的可伸缩的I/O多路复用实现，目的是为了替代select()与poll()。epoll()同样**没有文件描述符上限的限制**，它**使用一个文件描述符来管理多个文件描述符**，并**使用一个红黑树来作为存储结构**。同时它还支持边缘触发（edge-triggered）与水平触发（level-triggered）两种模式（poll()只支持水平触发），在**边缘触发模式**下，**`epoll_wait`仅会在新的事件对象首次被加入到epoll时返回**，而在**水平触发**模式下，**`epoll_wait`会在事件状态未变更前不断地触发**。也就是说，边缘触发模式**只会**在文件描述符**变为就绪状态时通知一次**，水平触发模式会**不断地通知**该文件描述符**直到被处理**。
 
 关于`epoll_wait`请参考如下epoll API。
-
-<pre>// 创建一个epoll对象并返回它的文件描述符。
+````
+// 创建一个epoll对象并返回它的文件描述符。
 // 参数flags允许修改epoll的行为，它只有一个有效值EPOLL_CLOEXEC。
 int epoll_create1(int flags);
 // 配置对象，该对象负责描述监控哪些文件描述符和哪些事件。
 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
 // 等待与epoll_ctl注册的任何事件，直至事件发生一次或超时。
 // 返回在events中发生的事件，最多同时返回maxevents个。
-int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);</pre>
-
+int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
+````
 epoll另一亮点是**采用了事件驱动的方式而不是轮询**，在**epoll_ctl**中注册的文件描述符**在事件触发的时候会通过一个回调机制**来激活该文件描述符，**`epoll_wait`便可以收到通知**。这样效率就不会与文件描述符的数量成正比
 
 在Java NIO2（从JDK1.7开始引入）中，只要Linux内核版本在2.6以上，就会采用epoll，如下源码所示（DefaultSelectorProvider.java）。
-
-<pre>public static SelectorProvider create() {
+````
+public static SelectorProvider create() {
 String osname = AccessController.doPrivileged(
 new GetPropertyAction("os.name"));
 if ("SunOS".equals(osname)) {
@@ -271,7 +287,8 @@ return new sun.nio.ch.EPollSelectorProvider();
 }
 }
 return new sun.nio.ch.PollSelectorProvider();
-}</pre>
+}
+````
 
 [![](http://wx3.sinaimg.cn/large/63503acbly1flz1e9uk8aj20wb0ft3zn.jpg)](http://wx3.sinaimg.cn/large/63503acbly1flz1e9uk8aj20wb0ft3zn.jpg)
 
@@ -336,7 +353,7 @@ ByteBuffer继承于`abstract class Buffer`（所以还有LongBuffer、IntBuffer
 
 *   调用buffer.clear()或者buffer.compact()清理缓冲区，以便下次写入数据。
 
-<pre>RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");
+RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");
 FileChannel inChannel = aFile.getChannel();
 // 分配一个48字节大小的缓冲区
 ByteBuffer buf = ByteBuffer.allocate(48);
@@ -350,11 +367,12 @@ buf.clear(); // 清理缓冲区
 bytesRead = inChannel.read(buf);
 }
 aFile.close();
-Buffer中核心方法的实现也非常简单，主要就是在操作指针position。</pre>
+Buffer中核心方法的实现也非常简单，主要就是在操作指针position。
 
 Buffer中核心方法的实现也非常简单，主要就是在操作指针position。
 
-<pre>/**
+````
+/**
 * Sets this buffer's mark at its position.
 *
 * @return This buffer
@@ -389,13 +407,14 @@ return this;
 // 返回剩余空间
 public final int remaining() {
 return limit - position;
-}</pre>
+}
+````
 
 Java NIO中的**Buffer API操作的麻烦之处就在于读写转换需要手动重置指针。而ByteBuf没有这种繁琐性，它维护了两个不同的索引，一个用于读取，一个用于写入**。当你从ByteBuf读取数据时，它的readerIndex将会被递增已经被读取的字节数，同样的，当你写入数据时，writerIndex则会递增。readerIndex的最大范围在writerIndex的所在位置，如果试图移动readerIndex超过该值则会触发异常。
 
 ByteBuf中名称以read或write开头的方法将会递增它们其对应的索引，而名称以get或set开头的方法则不会。ByteBuf同样可以指定一个最大容量，试图移动writerIndex超过该值则会触发异常。
-
-<pre>public byte readByte() {
+````
+public byte readByte() {
  this.checkReadableBytes0(1); // 检查readerIndex是否已越界
  int i = this.readerIndex;
  byte b = this._getByte(i);
@@ -433,11 +452,11 @@ public ByteBuf setByte(int index, int value) {
  this.checkIndex(index);
  this._setByte(index, value);
  return this;
-}</pre>
-
+}
+````
 ByteBuf同样支持在**堆内和堆外进行分配**。在**堆内分配**也被称为**支撑数组模式**，它能在**没有使用池化**的情况下**提供快速的分配和释放**。
-
-<pre>ByteBuf heapBuf = Unpooled.copiedBuffer(bytes);
+````
+ByteBuf heapBuf = Unpooled.copiedBuffer(bytes);
 if (heapBuf.hasArray()) { // 判断是否有一个支撑数组
 byte[] array = heapBuf.array();
 // 计算第一个字节的偏移量
@@ -445,11 +464,11 @@ int offset = heapBuf.arrayOffset() + heapBuf.readerIndex();
 int length = heapBuf.readableBytes(); // 获得可读字节
 handleArray(array,offset,length); // 调用你的处理方法
 }
-</pre>
+````
 
 另一种模式为**堆外分配**，Java NIO ByteBuffer类在JDK1.4时就已经允许JVM实现通过JNI调用来在堆外分配内存（调用malloc()函数在JVM堆外分配内存），这主要是**为了避免额外的缓冲区复制操作**。
-
-<pre>ByteBuf directBuf = Unpooled.directBuffer(capacity);
+````
+ByteBuf directBuf = Unpooled.directBuffer(capacity);
 if (!directBuf.hasArray()) {
 int length = directBuf.readableBytes();
 byte[] array = new byte[length];
@@ -457,26 +476,26 @@ byte[] array = new byte[length];
 directBuf.getBytes(directBuf.readerIndex(),array);
 handleArray(array,0,length);
 }
-</pre>
+````
 
 ByteBuf还支持第三种模式，它被称为**复合缓冲区**，为多个ByteBuf**提供**了一个**聚合视图**。在这个视图中，你可以根据需要添加或者删除ByteBuf实例，ByteBuf的子类**CompositeByteBuf实现了该模式**。
 
 一个适合使用**复合缓冲区的场景是HTTP协议**，通过HTTP协议传输的消息都会被分成两部分——头部和主体，如果这两部分由应用程序的不同模块产生，将在消息发送时进行组装，并且该应用程序还会为多个消息复用相同的消息主体，这样对于每个消息都将会创建一个新的头部，产生了很多不必要的内存操作。使用CompositeByteBuf是一个很好的选择，它消除了这些额外的复制，以帮助你复用这些消息。
-
-<pre>CompositeByteBuf messageBuf = Unpooled.compositeBuffer();
+````
+CompositeByteBuf messageBuf = Unpooled.compositeBuffer();
 ByteBuf headerBuf = ....;
 ByteBuf bodyBuf = ....;
 messageBuf.addComponents(headerBuf,bodyBuf);
 for (ByteBuf buf : messageBuf) {
 System.out.println(buf.toString());
 }
-</pre>
+````
 
 CompositeByteBuf透明的实现了**zero-copy**，zero-copy其实就是避免数据在两个内存区域中来回的复制。从操作系统层面上来讲，zero-copy指的是**避免在内核态与用户态之间的数据缓冲区复制（通过mmap避免）**，而Netty中的zero-copy更偏向于在用户态中的数据操作的优化，就像使用CompositeByteBuf来复用多个ByteBuf以避免额外的复制，也可以使用wrap()方法来将一个字节数组包装成ByteBuf，又或者使用ByteBuf的slice()方法把它分割为多个共享同一内存区域的ByteBuf，这些都是为了优化内存的使用率。
 
 那么如何创建ByteBuf呢？在上面的代码中使用到了**Unpooled**，它是Netty提供的一个用于创建与分配ByteBuf的工具类，建议都使用这个工具类来创建你的缓冲区，不要自己去调用构造函数。经常使用的是wrappedBuffer()与copiedBuffer()，它们一个是用于将一个字节数组或ByteBuffer包装为一个ByteBuf，一个是根据传入的字节数组与ByteBuffer/ByteBuf来复制出一个新的ByteBuf。
-
-<pre>// 通过array.clone()来复制一个数组进行包装
+````
+// 通过array.clone()来复制一个数组进行包装
 public static ByteBuf copiedBuffer(byte[] array) {
 return array.length == 0?EMPTY_BUFFER:wrappedBuffer((byte[])array.clone());
 }
@@ -489,21 +508,21 @@ private static final ByteBufAllocator ALLOC;
 public static ByteBuf directBuffer(int initialCapacity) {
 return ALLOC.directBuffer(initialCapacity);
 }
-</pre>
+````
 
 相对底层的分配方法是使用ByteBufAllocator，Netty实现了PooledByteBufAllocator和UnpooledByteBufAllocator，前者使用了[jemalloc（一种malloc()的实现）](https://github.com/jemalloc/jemalloc)来分配内存，并且实现了对ByteBuf的池化以提高性能。后者分配的是未池化的ByteBuf，其分配方式与之前讲的一致。
-
-<pre>Channel channel = ...;
+````
+Channel channel = ...;
 ByteBufAllocator allocator = channel.alloc();
 ByteBuf buffer = allocator.directBuffer();
 do something.......
-</pre>
+````
 
 为了优化内存使用率，**Netty提供了一套手动的方式来追踪不活跃对象**，像UnpooledHeapByteBuf这种分配在堆内的对象得益于JVM的GC管理，无需额外操心，而UnpooledDirectByteBuf是在堆外分配的，它的内部基于DirectByteBuffer，DirectByteBuffer会先向Bits类申请一个额度（Bits还拥有一个全局变量totalCapacity，记录了所有DirectByteBuffer总大小），每次申请前都会查看是否已经超过-XX:MaxDirectMemorySize所设置的上限，**如果超限就会尝试调用System.gc()**，**以试图回收一部分内存，然后休眠100毫秒，如果内存还是不足，则只能抛出OOM异常**。堆外内存的回收虽然有了这么一层保障，但为了提高性能与使用率，主动回收也是很有必要的。由于Netty还实现了ByteBuf的池化，像PooledHeapByteBuf和PooledDirectByteBuf就必须**依赖于手动的方式来进行回收**（放回池中）。
 
 Netty使用了**引用计数器的方式来追踪那些不活跃的对象**。引用计数的接口为**ReferenceCounted**，它的思想很简单，只要ByteBuf对象的**引用计数大于0**，就保证该对象**不会被释放回收**，可以通过**手动调用release()与retain()**方法来操作该对象的引用计数值**递减或递增**。用户也可以通过自定义一个ReferenceCounted的实现类，以满足自定义的规则。
-
-<pre>package io.netty.buffer;
+````
+package io.netty.buffer;
 public abstract class AbstractReferenceCountedByteBuf extends AbstractByteBuf {
 // 由于ByteBuf的实例对象会非常多,所以这里没有将refCnt包装为AtomicInteger
 // 而是使用一个全局的AtomicIntegerFieldUpdater来负责操作refCnt
@@ -566,7 +585,7 @@ return false;
 }
 protected abstract void deallocate();
 }
-</pre>
+````
 
 ### Channel
 
@@ -583,8 +602,8 @@ Netty中的Channel与Java NIO的概念一样，都是对**一个实体或连接
 每个Channel最终都会被分配一个**ChannelPipeline**和**ChannelConfig**，前者持有所有负责**处理入站与出站数据**以及**事件**的ChannelHandler，后者包含了该Channel的**所有配置设置**，并且**支持热更新**，由于不同的传输类型可能具有其特别的配置，所以该类可能会实现为ChannelConfig的不同子类。
 
 **Channel是线程安全的**（与之后要讲的线程模型有关），因此你完全可以在多个线程中复用同一个Channel，就像如下代码所示。
-
-<pre>final Channel channel = ...
+````
+final Channel channel = ...
 final ByteBuf buffer = Unpooled.copiedBuffer("Hello,World!", CharsetUtil.UTF_8).retain();
 Runnable writer = new Runnable() {
 @Override
@@ -595,8 +614,7 @@ channel.writeAndFlush(buffer.duplicate());
 Executor executor = Executors.newCachedThreadPool();
 executor.execute(writer);
 executor.execute(writer);
-.......
-</pre>
+````
 
 Netty除了支持常见的NIO与OIO，还内置了其他的传输类型。
 
@@ -645,8 +663,8 @@ ChannelHandler的主要用途包括：
 Netty中到处都充满了异步与事件驱动，而**回调函数**正是用于**响应事件之后的操作**。由于异步会直接返回一个结果，所以Netty提供了ChannelFuture（实现了java.util.concurrent.Future）来作为异步调用返回的占位符，真正的结果会在未来的某个时刻完成，到时候就可以通过ChannelFuture对其进行访问，每个Netty的出站I/O操作都将会返回一个ChannelFuture。
 
 Netty还提供了**ChannelFutureListener**接口来**监听ChannelFuture**是否成功，并采取对应的操作。
-
-<pre>Channel channel = ...
+````
+Channel channel = ...
 ChannelFuture future = channel.connect(new InetSocketAddress("192.168.0.1",6666));
 // 注册一个监听器
 future.addListener(new ChannelFutureListener() {
@@ -662,11 +680,11 @@ cause.printStackTrace();
 }
 }
 });
-</pre>
+````
 
 ChannelFutureListener接口中还提供了几个简单的默认实现，方便我们使用。
-
-<pre>package io.netty.channel;
+````
+package io.netty.channel;
 import io.netty.channel.ChannelFuture;
 import io.netty.util.concurrent.GenericFutureListener;
 public interface ChannelFutureListener extends GenericFutureListener<ChannelFuture> {
@@ -693,11 +711,11 @@ future.channel().pipeline().fireExceptionCaught(future.cause());
 }
 };
 }
-</pre>
+````
 
 ChannelHandler接口**定义了对它生命周期进行监听的回调函数**，在ChannelHandler被添加到ChannelPipeline或者被移除时都会调用这些函数。
-
-<pre>package io.netty.channel;
+````
+package io.netty.channel;
 public interface ChannelHandler {
 void handlerAdded(ChannelHandlerContext var1) throws Exception;
 void handlerRemoved(ChannelHandlerContext var1) throws Exception;
@@ -712,12 +730,12 @@ void exceptionCaught(ChannelHandlerContext var1, Throwable var2) throws Exceptio
 public @interface Sharable {
 }
 }
+````
 
-</pre>
 
 **入站消息与出站消息**由其对应的接口**ChannelInboundHandler与ChannelOutboundHandle**r负责，这两个接口定义了监听Channel的**生命周期的状态改变事件**的回调函数。
-
-<pre>package io.netty.channel;
+````
+package io.netty.channel;
 import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelHandlerContext;
 public interface ChannelInboundHandler extends ChannelHandler {
@@ -740,7 +758,8 @@ void channelWritabilityChanged(ChannelHandlerContext var1) throws Exception;
 // 当处理过程中发生异常时被调用
 void exceptionCaught(ChannelHandlerContext var1, Throwable var2) throws Exception;
 }
-
+````
+````
 package io.netty.channel;
 import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelHandlerContext;
@@ -765,13 +784,13 @@ void write(ChannelHandlerContext var1, Object var2, ChannelPromise var3) throws
 // 当请求通过Channel将缓冲中的数据冲刷到远程节点时被调用
 void flush(ChannelHandlerContext var1) throws Exception;
 }
-</pre>
+````
 
 通过实现ChannelInboundHandler或者ChannelOutboundHandler就可以完成用户自定义的应用逻辑处理程序，不过Netty已经帮你实**现了一些基本操作，用户只需要继承并扩展ChannelInboundHandlerAdapter或ChannelOutboundHandlerAdapter**来作为自定义实现的起始点。
 
 ChannelInboundHandlerAdapter与ChannelOutboundHandlerAdapter都继承于ChannelHandlerAdapter，该抽象类简单实现了ChannelHandler接口。
-
-<pre>public abstract class ChannelHandlerAdapter implements ChannelHandler {
+````
+public abstract class ChannelHandlerAdapter implements ChannelHandler {
 boolean added;
 public ChannelHandlerAdapter() {
 }
@@ -800,11 +819,11 @@ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws E
 ctx.fireExceptionCaught(cause);
 }
 }
-</pre>
+````
 
 ChannelInboundHandlerAdapter与ChannelOutboundHandlerAdapter**默认只是简单地将请求传递给ChannelPipeline中的下一个ChannelHandler**，源码如下：
-
-<pre>public class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelInboundHandler {
+````
+public class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelInboundHandler {
 public ChannelInboundHandlerAdapter() {
 }
 public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
@@ -863,13 +882,13 @@ public void flush(ChannelHandlerContext ctx) throws Exception {
 ctx.flush();
 }
 }
-</pre>
+````
 
 对于处理入站消息，另外一种选择是**继承SimpleChannelInboundHandler**，它是Netty的一个继承于ChannelInboundHandlerAdapter的抽象类，并在其之上实现了**自动释放资源的功能**。
 
 我们在了解ByteBuf时就已经知道了**Netty使用了一套自己实现的引用计数算法来主动释放资源**，假设你的ChannelHandler继承于ChannelInboundHandlerAdapter或ChannelOutboundHandlerAdapter，那么你就有责任去管理你所分配的ByteBuf，一般来说，一个消息对象（**ByteBuf**）已经被消费（或丢弃）了，**并不会传递给ChannelHandler链中的下一个处理器**（如果该消息到达了实际的传输层，那么当它被写入或Channel关闭时，都会被自动释放），所以你就需要去手动释放它。通过一个简单的工具类**ReferenceCountUtil的release方法**，就可以做到这一点。
-
-<pre>// 这个泛型为消息对象的类型
+````
+// 这个泛型为消息对象的类型
 public abstract class SimpleChannelInboundHandler<I> extends ChannelInboundHandlerAdapter {
 private final TypeParameterMatcher matcher;
 private final boolean autoRelease;
@@ -919,7 +938,7 @@ protected abstract void channelRead0(ChannelHandlerContext var1, I var2) throws
 public static boolean release(Object msg) {
 return msg instanceof ReferenceCounted?((ReferenceCounted)msg).release():false;
 }
-</pre>
+````
 
 ### ChannelPipeline
 
@@ -940,8 +959,8 @@ return msg instanceof ReferenceCounted?((ReferenceCounted)msg).release():false;
 在阅读ChannelHandler的源码时，发现很多方法需要一个ChannelHandlerContext类型的参数，该接口是ChannelPipeline与ChannelHandler之间相关联的关键。ChannelHandlerContext可以通知ChannelPipeline中的当前ChannelHandler的下一个ChannelHandler，还可以动态地改变当前ChannelHandler在ChannelPipeline中的位置（通过调用ChannelPipeline中的各种方法来修改）。
 
 ChannelHandlerContext负责了在同一个ChannelPipeline中的ChannelHandler与其他ChannelHandler之间的交互，每个ChannelHandlerContext都对应了一个ChannelHandler。在DefaultChannelPipeline的源码中，已经表现的很明显了。
-
-<pre>public class DefaultChannelPipeline implements ChannelPipeline {
+````
+public class DefaultChannelPipeline implements ChannelPipeline {
 .........
 // 头部节点和尾部节点的引用变量
 // ChannelHandlerContext在ChannelPipeline中是以链表的形式组织的
@@ -992,19 +1011,19 @@ this.tail.prev = newCtx;
 }
 .....
 }
-</pre>
+````
 
 ChannelHandlerContext还定义了许多与Channel和ChannelPipeline重合的方法（像read()、write()、connect()这些用于出站的方法或者如fireChannelXXXX()这样用于**入站的方法**），不同之处在于**调用Channel或者ChannelPipeline上的这些方法，它们将会从头沿着整个ChannelHandler实例链进行传播，而调用位于ChannelHandlerContext上的相同方法，则会从当前所关联的ChannelHandler开始，且只会传播给实例链中的下一个ChannelHandler**。而且，**事件之间的移动**（从一个ChannelHandler到下一个ChannelHandler）也是**通过ChannelHandlerContext中的方法调用完成**的。
-
-<pre>public class DefaultChannelPipeline implements ChannelPipeline {
+````
+public class DefaultChannelPipeline implements ChannelPipeline {
 public final ChannelPipeline fireChannelRead(Object msg) {
 // 注意这里将头节点传入了进去
 AbstractChannelHandlerContext.invokeChannelRead(this.head, msg);
 return this;
 }
 }
----------------------------------------------------------------
-
+````
+````
 abstract class AbstractChannelHandlerContext extends DefaultAttributeMap implements ChannelHandlerContext, ResourceLeakHint {
 static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
 final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
@@ -1043,7 +1062,7 @@ ctx = ctx.next;
 return ctx;
 }
 }
-</pre>
+````
 
 ### EventLoop
 
@@ -1060,8 +1079,8 @@ return ctx;
 [![](http://wx3.sinaimg.cn/large/63503acbly1fm296hz0p9j20ff0kc3z2.jpg)](http://wx3.sinaimg.cn/large/63503acbly1fm296hz0p9j20ff0kc3z2.jpg)
 
 在Netty的线程模型中，一个EventLoop将由一个永远不会改变的Thread驱动，而一个Channel一生只会使用一个EventLoop（但是一个EventLoop可能会被指派用于服务多个Channel），在Channel中的所有I/O操作和事件都由EventLoop中的线程处理，也就是说**一个Channel的一生之中都只会使用到一个线程**。不过在Netty3，只有入站事件会被EventLoop处理，所有出站事件都会由调用线程处理，这种设计导致了ChannelHandler的线程安全问题。Netty4简化了线程模型，通过在同一个线程处理所有事件，既解决了这个问题，还提供了一个更加简单的架构。
-
-<pre>package io.netty.channel;
+````
+package io.netty.channel;
 public abstract class SingleThreadEventLoop extends SingleThreadEventExecutor implements EventLoop {
 protected static final int DEFAULT_MAX_PENDING_TASKS = Math.max(16, SystemPropertyUtil.getInt("io.netty.eventLoop.maxPendingTasks", 2147483647));
     //内部队列
@@ -1127,15 +1146,15 @@ return super.pendingTasks() + this.tailTasks.size();
 interface NonWakeupRunnable extends Runnable {
 }
 }
-</pre>
+````
 
 为了确保一个Channel的整个生命周期中的I/O事件会被一个EventLoop负责，Netty通过**inEventLoop()**方法来**判断当前执行的线程的身份**，确定它是否是分配给当前Channel以及它的EventLoop的那一个线程。
 
 如果当前（调用）线程正是EventLoop中的线程，那么所提交的任务将会被**(true)直接执行**，否则，EventLoop将调度该任务以便**(false)稍后执行**，并将它**放入内部的任务队列**（每个EventLoop都有它自己的任务队列，SingleThreadEventLoop的源码就能发现很多用于调度内部任务队列的方法），在下次处理它的事件时，将会执行队列中的那些任务。这种设计可以让任何线程与Channel直接交互，而无需在ChannelHandler中进行额外的同步。
 
 从性能上来考虑，千万**不要将一个需要长时间来运行的任务放入到任务队列中**，它会影响到该队列中的其他任务的执行。**解决方案**是**使用一个专门的EventExecutor来执行它**（ChannelPipeline提供了带有EventExecutorGroup参数的addXXX()方法，该方法可以**将传入的ChannelHandler绑定到你传入的EventExecutor之中**），这样它就会在另一条线程中执行，与其他任务隔离。
-
-<pre>public abstract class SingleThreadEventExecutor extends AbstractScheduledEventExecutor implements OrderedEventExecutor {
+````
+public abstract class SingleThreadEventExecutor extends AbstractScheduledEventExecutor implements OrderedEventExecutor {
 .....
 public void execute(Runnable task) {
 if(task == null) {
@@ -1161,8 +1180,8 @@ return thread == this.thread;
 }
 .....
 }
-</pre>
 
+````
 EventLoopGroup**负责管理和分配EventLoop（创建EventLoop和为每个新创建的Channel分配EventLoop），根据不同的传输类型，EventLoop的创建和分配方式也不同**。例如，使用NIO传输类型，EventLoopGroup就会只使用较少的EventLoop（一个EventLoop服务于多个Channel），这是因为NIO基于I/O多路复用，一个线程可以处理多个连接，而如果使用的是OIO，那么新创建一个Channel（连接）就需要分配一个EventLoop（线程）。
 
 ### Bootstrap
@@ -1176,8 +1195,8 @@ EventLoopGroup**负责管理和分配EventLoop（创建EventLoop和为每个新
 在深入了解地Netty的核心组件之后，发现它们的**设计**都很**模块化**，如果想要实现你自己的应用程序，就需要**将这些组件组装到一起**。Netty通过Bootstrap类，以对一个Netty应用程序进行配置（**组装各个组件**），并最终使它运行起来。对于客户端程序和服务器程序所使用到的Bootstrap类是不同的，后者需要使用ServerBootstrap，这样设计是因为，在如TCP这样有连接的协议中，服务器程序往往需要一个以上的Channel，通过父Channel来接受来自客户端的连接，然后创建子Channel用于它们之间的通信，而像UDP这样无连接的协议，它不需要每个连接都创建子Channel，只需要一个Channel即可。
 
 一个比较明显的差异就是Bootstrap与ServerBootstrap的group()方法，后者提供了一个接收2个EventLoopGroup的版本。
-
-<pre>// 该方法在Bootstrap的父类AbstractBootstrap中，泛型B为它当前子类的类型（为了链式调用）
+````
+// 该方法在Bootstrap的父类AbstractBootstrap中，泛型B为它当前子类的类型（为了链式调用）
 public B group(EventLoopGroup group) {
 if(group == null) {
 throw new NullPointerException("group");
@@ -1203,7 +1222,7 @@ this.childGroup = childGroup;
 return this;
 }
 }
-</pre>
+````
 
 Bootstrap其实没有什么可以好说的，它就只是一个**装配工**，将各个组件拼装组合到一起，然后进行一些配置，有关它的详细API请参考[Netty JavaDoc](http://netty.io/4.1/api/index.html)。
 
@@ -1212,8 +1231,8 @@ Bootstrap其实没有什么可以好说的，它就只是一个**装配工**，
 下面我们将通过一个经典的Echo客户端与服务器的例子，来梳理一遍创建Netty应用的流程。
 
 首先实现的是服务器，我们先实现一个EchoServerInboundHandler，处理入站消息。
-
-<pre>public class EchoServerInboundHandler extends ChannelInboundHandlerAdapter {
+````
+public class EchoServerInboundHandler extends ChannelInboundHandlerAdapter {
 @Override
 public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
 ByteBuf in = (ByteBuf) msg;
@@ -1235,11 +1254,11 @@ cause.printStackTrace();
 ctx.close();
 }
 }
-</pre>
 
+````
 服务器的应用逻辑只有这么多，剩下就是用ServerBootstrap进行配置了。
-
-<pre>public class EchoServer {
+````
+public class EchoServer {
 private final int port;
 public EchoServer(int port) {
 this.port = port;
@@ -1280,11 +1299,11 @@ int port = Integer.parseInt(args[0]);
 new EchoServer(port).start();
 }
 }
-</pre>
+````
 
 接下来实现客户端，同样需要先实现一个入站消息处理器。
-
-<pre>public class EchoClientInboundHandler extends SimpleChannelInboundHandler<ByteBuf> {
+````
+public class EchoClientInboundHandler extends SimpleChannelInboundHandler<ByteBuf> {
 /**
 * 我们在Channel连接到远程节点直接发送一条消息给服务器
 */
@@ -1303,11 +1322,11 @@ cause.printStackTrace();
 ctx.close();
 }
 }
-</pre>
+````
 
 然后配置客户端。
-
-<pre>public class EchoClient {
+````
+public class EchoClient {
 private final String host;
 private final int port;
 public EchoClient(String host, int port) {
@@ -1343,18 +1362,14 @@ int port = Integer.parseInt(args[1]);
 new EchoClient(host, port).start();
 }
 }
-</pre>
+````
 
 实现一个Netty应用程序就是如此简单，用户大多数都是在编写各种应用逻辑的ChannelHandler（或者使用Netty内置的各种实用ChannelHandler），然后只需要将它们全部添加到ChannelPipeline即可。
 
 ## 参考文献
 
-
-
 * * *
 
-
-
 *   [Netty: Home](https://netty.io/)
 
 *   [Chapter 6\. I/O Multiplexing: The select and poll Functions - Shichao’s Notes](https://notes.shichao.io/unp/ch6/#io-multiplexing-model)
diff --git "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\2434\357\274\232\346\265\205\346\236\220NIO\345\214\205\344\270\255\347\232\204Buffer\343\200\201Channel \345\222\214 Selector.md" "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\346\265\205\346\236\220NIO\345\214\205\344\270\255\347\232\204Buffer\343\200\201Channel\345\222\214Selector.md"
similarity index 87%
rename from "docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\2434\357\274\232\346\265\205\346\236\220NIO\345\214\205\344\270\255\347\232\204Buffer\343\200\201Channel \345\222\214 Selector.md"
rename to "docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\346\265\205\346\236\220NIO\345\214\205\344\270\255\347\232\204Buffer\343\200\201Channel\345\222\214Selector.md"
index 0720132..5d47624 100644
--- "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\2434\357\274\232\346\265\205\346\236\220NIO\345\214\205\344\270\255\347\232\204Buffer\343\200\201Channel \345\222\214 Selector.md"	
+++ "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\346\265\205\346\236\220NIO\345\214\205\344\270\255\347\232\204Buffer\343\200\201Channel\345\222\214Selector.md"
@@ -1,5 +1,23 @@
-# Table of Contents
+# 目录
 
+* [目录](#目录)
+  * [Buffer](#buffer)
+    * [position、limit、capacity](#position、limit、capacity)
+    * [初始化 Buffer](#初始化-buffer)
+    * [填充 Buffer](#填充-buffer)
+    * [提取 Buffer 中的值](#提取-buffer-中的值)
+    * [mark() & reset()](#mark--reset)
+    * [rewind() & clear() & compact()](#rewind--clear--compact)
+  * [Channel](#channel)
+    * [FileChannel](#filechannel)
+    * [SocketChannel](#socketchannel)
+    * [ServerSocketChannel](#serversocketchannel)
+    * [DatagramChannel](#datagramchannel)
+  * [Selector](#selector)
+  * [小结](#小结)
+
+
+# 目录
   * [Buffer](#buffer)
     * [position、limit、capacity](#position、limit、capacity)
     * [初始化 Buffer](#初始化-buffer)
@@ -36,9 +54,9 @@
 
 <!-- more -->
 
-本文将介绍 Java NIO 中三大组件 **Buffer、Channel、Selector** 的使用。
+本文将介绍 Java NIO 中三大组件**Buffer、Channel、Selector**的使用。
 
-本来要一起介绍**非阻塞 IO** 和 JDK7 的**异步 IO** 的，不过因为之前的文章真的太长了，有点影响读者阅读，所以这里将它们放到另一篇文章中进行介绍。
+本来要一起介绍**非阻塞 IO**和 JDK7 的**异步 IO**的，不过因为之前的文章真的太长了，有点影响读者阅读，所以这里将它们放到另一篇文章中进行介绍。
 
 ## Buffer
 
@@ -46,9 +64,9 @@
 
 java.nio 定义了以下几个 Buffer 的实现，这个图读者应该也在不少地方见过了吧。
 
-![6](https://www.javadoop.com/blogimages/nio/6.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405095127.png)
 
-其实核心是最后的 **ByteBuffer**，前面的一大串类只是包装了一下它而已，我们使用最多的通常也是 ByteBuffer。
+其实核心是最后的**ByteBuffer**，前面的一大串类只是包装了一下它而已，我们使用最多的通常也是 ByteBuffer。
 
 我们应该将 Buffer 理解为一个数组，IntBuffer、CharBuffer、DoubleBuffer 等分别对应 int[]、char[]、double[] 等。
 
@@ -60,23 +78,23 @@ MappedByteBuffer 用于实现内存映射文件，也不是本文关注的重点
 
 就像数组有数组容量，每次访问元素要指定下标，Buffer 中也有几个重要属性：position、limit、capacity。
 
-![5](https://www.javadoop.com/blogimages/nio/5.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405095151.png)
 
 最好理解的当然是 capacity，它代表这个缓冲区的容量，一旦设定就不可以更改。比如 capacity 为 1024 的 IntBuffer，代表其一次可以存放 1024 个 int 类型的值。一旦 Buffer 的容量达到 capacity，需要清空 Buffer，才能重新写入值。
 
 position 和 limit 是变化的，我们分别看下读和写操作下，它们是如何变化的。
 
-**position** 的初始值是 0，每往 Buffer 中写入一个值，position 就自动加 1，代表下一次的写入位置。读操作的时候也是类似的，每读一个值，position 就自动加 1。
+**position**的初始值是 0，每往 Buffer 中写入一个值，position 就自动加 1，代表下一次的写入位置。读操作的时候也是类似的，每读一个值，position 就自动加 1。
 
 从写操作模式到读操作模式切换的时候（**flip**），position 都会归零，这样就可以从头开始读写了。
 
 **Limit**：写操作模式下，limit 代表的是最大能写入的数据，这个时候 limit 等于 capacity。写结束后，切换到读模式，此时的 limit 等于 Buffer 中实际的数据大小，因为 Buffer 不一定被写满了。
 
-![7](https://www.javadoop.com/blogimages/nio/7.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405095206.png)
 
 ### 初始化 Buffer
 
-每个 Buffer 实现类都提供了一个静态方法 `allocate(int capacity)` 帮助我们快速实例化一个 Buffer。如：
+每个 Buffer 实现类都提供了一个静态方法`allocate(int capacity)`帮助我们快速实例化一个 Buffer。如：
 
 ```
 ByteBuffer byteBuf = ByteBuffer.allocate(1024);
@@ -123,7 +141,7 @@ int num = channel.read(buf);
 
 如果要读 Buffer 中的值，需要切换模式，从写入模式切换到读出模式。注意，通常在说 NIO 的读操作的时候，我们说的是从 Channel 中读数据到 Buffer 中，对应的是对 Buffer 的写入操作，初学者需要理清楚这个。
 
-调用 Buffer 的 **flip()** 方法，可以从写入模式切换到读取模式。其实这个方法也就是设置了一下 position 和 limit 值罢了。
+调用 Buffer 的**flip()**方法，可以从写入模式切换到读取模式。其实这个方法也就是设置了一下 position 和 limit 值罢了。
 
 ```
 public final Buffer flip() {
@@ -217,7 +235,7 @@ public final Buffer clear() {
 
 所有的 NIO 操作始于通道，通道是数据来源或数据写入的目的地，主要地，我们将关心 java.nio 包中实现的以下几个 Channel：
 
-![8](https://www.javadoop.com/blogimages/nio/8.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405095238.png)
 
 *   FileChannel：文件通道，用于文件的读和写
 *   DatagramChannel：用于 UDP 连接的接收和发送
@@ -228,10 +246,9 @@ public final Buffer clear() {
 
 Channel 经常翻译为通道，类似 IO 中的流，用于读取和写入。它与前面介绍的 Buffer 打交道，读操作的时候将 Channel 中的数据填充到 Buffer 中，而写操作时将 Buffer 中的数据写入到 Channel 中。
 
-![9](https://www.javadoop.com/blogimages/nio/9.png)
-
-![10](https://www.javadoop.com/blogimages/nio/10.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405095252.png)
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405095318.png)
 至少读者应该记住一点，这两个方法都是 channel 实例的方法。
 
 ### FileChannel
@@ -363,7 +380,7 @@ int bytesSent = channel.send(buf, new InetSocketAddress("jenkov.com", 80));
 
 ## Selector
 
-NIO 三大组件就剩 Selector 了，Selector 建立在非阻塞的基础之上，大家经常听到的 **多路复用** 在 Java 世界中指的就是它，用于实现一个线程管理多个 Channel。
+NIO 三大组件就剩 Selector 了，Selector 建立在非阻塞的基础之上，大家经常听到的**多路复用**在 Java 世界中指的就是它，用于实现一个线程管理多个 Channel。
 
 读者在这一节不能消化 Selector 也没关系，因为后续在介绍非阻塞 IO 的时候还得说到这个，这里先介绍一些基本的接口操作。
 
@@ -400,9 +417,9 @@ NIO 三大组件就剩 Selector 了，Selector 建立在非阻塞的基础之上
 
         > 对应 00010000，接受 TCP 连接
 
-    我们可以同时监听一个 Channel 中的发生的多个事件，比如我们要监听 ACCEPT 和 READ 事件，那么指定参数为二进制的 000**1**000**1** 即十进制数值 17 即可。
+    我们可以同时监听一个 Channel 中的发生的多个事件，比如我们要监听 ACCEPT 和 READ 事件，那么指定参数为二进制的 000**1**000**1**即十进制数值 17 即可。
 
-    注册方法返回值是 **SelectionKey** 实例，它包含了 Channel 和 Selector 信息，也包括了一个叫做 Interest Set 的信息，即我们设置的我们感兴趣的正在监听的事件集合。
+    注册方法返回值是**SelectionKey**实例，它包含了 Channel 和 Selector 信息，也包括了一个叫做 Interest Set 的信息，即我们设置的我们感兴趣的正在监听的事件集合。
 
 3.  调用 select() 方法获取通道信息。用于判断是否有我们感兴趣的事件已经发生了。
 
diff --git "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\2438\357\274\232\346\265\205\346\236\220mmap\345\222\214Direct Buffer.md" "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\346\265\205\346\236\220mmap\345\222\214DirectBuffer.md"
similarity index 80%
rename from "docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\2438\357\274\232\346\265\205\346\236\220mmap\345\222\214Direct Buffer.md"
rename to "docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\346\265\205\346\236\220mmap\345\222\214DirectBuffer.md"
index 631e0e1..8256703 100644
--- "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\2438\357\274\232\346\265\205\346\236\220mmap\345\222\214Direct Buffer.md"	
+++ "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\346\265\205\346\236\220mmap\345\222\214DirectBuffer.md"
@@ -1,5 +1,31 @@
-# Table of Contents
+# 目录
 
+* [目录](#目录)
+* [mmap基础概念](#mmap基础概念)
+* [mmap内存映射原理](#mmap内存映射原理)
+* [mmap和常规文件操作的区别](#mmap和常规文件操作的区别)
+* [mmap优点总结](#mmap优点总结)
+* [mmap使用细节](#mmap使用细节)
+    * [堆外内存](#堆外内存)
+    * [在讲解DirectByteBuffer之前，需要先简单了解两个知识点](#在讲解directbytebuffer之前，需要先简单了解两个知识点)
+      * [java引用类型，因为DirectByteBuffer是通过虚引用(Phantom Reference)来实现堆外内存的释放的。](#java引用类型，因为directbytebuffer是通过虚引用phantom-reference来实现堆外内存的释放的。)
+      * [关于linux的内核态和用户态](#关于linux的内核态和用户态)
+    * [DirectByteBuffer ———— 直接缓冲](#directbytebuffer--直接缓冲)
+    * [DirectByteBuffer堆外内存的创建和回收的源码解读](#directbytebuffer堆外内存的创建和回收的源码解读)
+      * [堆外内存分配](#堆外内存分配)
+      * [Bits.reserveMemory(size, cap) 方法](#bitsreservememorysize-cap-方法)
+      * [堆外内存回收](#堆外内存回收)
+      * [通过配置参数的方式来回收堆外内存](#通过配置参数的方式来回收堆外内存)
+    * [堆外内存那些事](#堆外内存那些事)
+      * [使用堆外内存的原因](#使用堆外内存的原因)
+      * [什么情况下使用堆外内存](#什么情况下使用堆外内存)
+      * [堆外内存 VS 内存池](#堆外内存-vs-内存池)
+      * [堆外内存的特点](#堆外内存的特点)
+      * [堆外内存的一些问题](#堆外内存的一些问题)
+  * [参考文章](#参考文章)
+
+
+# 目录
 * [mmap基础概念](#mmap基础概念)
 * [mmap内存映射原理](#mmap内存映射原理)
 * [mmap和常规文件操作的区别](#mmap和常规文件操作的区别)
@@ -57,25 +83,23 @@
 
 mmap是一种内存映射文件的方法，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作而不必再调用read,write等系统调用函数。相反，内核空间对这段区域的修改也直接反映用户空间，从而可以实现不同进程间的文件共享。如下图所示：
 
-          ![](https://images0.cnblogs.com/blog2015/571793/201507/200501092691998.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405100810.png)
 
 由上图可以看出，进程的虚拟地址空间，由多个虚拟内存区域构成。虚拟内存区域是进程的虚拟地址空间中的一个同质区间，即具有同样特性的连续地址范围。上图中所示的text数据段（代码段）、初始数据段、BSS数据段、堆、栈和内存映射，都是一个独立的虚拟内存区域。而为内存映射服务的地址空间处在堆栈之间的空余部分。
 
 linux内核使用vm_area_struct结构来表示一个独立的虚拟内存区域，由于每个不同质的虚拟内存区域功能和内部机制都不同，因此一个进程使用多个vm_area_struct结构来分别表示不同类型的虚拟内存区域。各个vm_area_struct结构使用链表或者树形结构链接，方便进程快速访问，如下图所示：
 
-         ![](https://images0.cnblogs.com/blog2015/571793/201507/200501434261629.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405100838.png)
 
 vm_area_struct结构中包含区域起始和终止地址以及其他相关信息，同时也包含一个vm_ops指针，其内部可引出所有针对这个区域可以使用的系统调用函数。这样，进程对某一虚拟内存区域的任何操作需要用要的信息，都可以从vm_area_struct中获得。mmap函数就是要创建一个新的vm_area_struct结构，并将其与文件的物理磁盘地址相连。具体步骤请看下一节。
 
-[回到顶部](https://www.cnblogs.com/huxiao-tee/p/4660352.html#_labelTop)
-
 # mmap内存映射原理
 
 mmap内存映射的实现过程，总的来说可以分为三个阶段：
 
 **（一）进程启动映射过程，并在虚拟地址空间中为映射创建虚拟映射区域**
 
-1、进程在用户空间调用库函数mmap，原型：void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
+1、进程在用户空间调用库函数mmap，原型：void*mmap(void*start,size_tlength,intprot,intflags, intfd,off_toffset);
 
 2、在当前进程的虚拟地址空间中，寻找一段空闲的满足要求的连续的虚拟地址
 
@@ -87,7 +111,7 @@ mmap内存映射的实现过程，总的来说可以分为三个阶段：
 
 5、为映射分配了新的虚拟地址区域后，通过待映射的文件指针，在文件描述符表中找到对应的文件描述符，通过文件描述符，链接到内核“已打开文件集”中该文件的文件结构体（struct file），每个文件结构体维护着和这个已打开文件相关各项信息。
 
-6、通过该文件的文件结构体，链接到file_operations模块，调用内核函数mmap，其原型为：int mmap(struct file *filp, struct vm_area_struct *vma)，不同于用户空间库函数。
+6、通过该文件的文件结构体，链接到file_operations模块，调用内核函数mmap，其原型为：int mmap(structfile*filp,structvm_area_struct*vma)，不同于用户空间库函数。
 
 7、内核mmap函数通过虚拟文件系统inode模块定位到文件磁盘物理地址。
 
@@ -101,14 +125,12 @@ mmap内存映射的实现过程，总的来说可以分为三个阶段：
 
 10、缺页异常进行一系列判断，确定无非法操作后，内核发起请求调页过程。
 
-11、调页过程先在交换缓存空间（swap cache）中寻找需要访问的内存页，如果没有则调用nopage函数把所缺的页从磁盘装入到主存中。
+11、调页过程先在交换缓存空间（swapcache）中寻找需要访问的内存页，如果没有则调用nopage函数把所缺的页从磁盘装入到主存中。
 
 12、之后进程即可对这片主存进行读或者写的操作，如果写操作改变了其内容，一定时间后系统会自动回写脏页面到对应磁盘地址，也即完成了写入到文件的过程。
 
 注：修改过的脏页面并不会立即更新回文件中，而是有一段时间的延迟，可以调用msync()来强制同步, 这样所写的内容就能立即保存到文件里了。
 
-[回到顶部](https://www.cnblogs.com/huxiao-tee/p/4660352.html#_labelTop)
-
 # mmap和常规文件操作的区别
 
 对linux文件系统不了解的朋友，请参阅我之前写的博文《[从内核文件系统看文件读写过程](http://www.cnblogs.com/huxiao-tee/p/4657851.html)》，我们首先简单的回顾一下常规文件系统操作（调用read/fread等类函数）中，函数的调用过程：
@@ -127,8 +149,6 @@ mmap内存映射的实现过程，总的来说可以分为三个阶段：
 
 **总而言之，常规文件操作需要从磁盘到页缓存再到用户主存的两次数据拷贝。而mmap操控文件，只需要从磁盘到用户主存的一次数据拷贝过程。**说白了，mmap的关键点是实现了用户空间和内核空间的数据直接交互而省去了空间不同数据不通的繁琐过程。因此mmap效率更高。
 
-[回到顶部](https://www.cnblogs.com/huxiao-tee/p/4660352.html#_labelTop)
-
 # mmap优点总结
 
 由上文讨论可知，mmap优点共有一下几点：
@@ -139,12 +159,10 @@ mmap内存映射的实现过程，总的来说可以分为三个阶段：
 
 3、提供进程间共享内存及相互通信的方式。不管是父子进程还是无亲缘关系的进程，都可以将自身用户空间映射到同一个文件或匿名映射到同一片区域。从而通过各自对映射区域的改动，达到进程间通信和进程间共享的目的。
 
-     同时，如果进程A和进程B都映射了区域C，当A第一次读取C时通过缺页从磁盘复制文件页到内存中；但当B再读C的相同页面时，虽然也会产生缺页异常，但是不再需要从磁盘中复制文件过来，而可直接使用已经保存在内存中的文件数据。
+  同时，如果进程A和进程B都映射了区域C，当A第一次读取C时通过缺页从磁盘复制文件页到内存中；但当B再读C的相同页面时，虽然也会产生缺页异常，但是不再需要从磁盘中复制文件过来，而可直接使用已经保存在内存中的文件数据。
 
 4、可用于实现高效的大规模数据传输。内存空间不足，是制约大数据操作的一个方面，解决方案往往是借助硬盘空间协助操作，补充内存的不足。但是进一步会造成大量的文件I/O操作，极大影响效率。这个问题可以通过mmap映射很好的解决。换句话说，但凡是需要用磁盘空间代替内存的时候，mmap都可以发挥其功效。
 
-
-
 # mmap使用细节
 
 1、使用mmap需要注意的一个关键点是，mmap映射区域大小必须是物理页大小(page_size)的整倍数（32位系统中通常是4k字节）。原因是，内存的最小粒度是页，而进程虚拟地址空间和内存的映射也是以页为单位。为了匹配内存的操作，mmap从磁盘到虚拟地址空间的映射也必须是页。
@@ -159,8 +177,7 @@ mmap内存映射的实现过程，总的来说可以分为三个阶段：
 
 分析：因为单位物理页面的大小是4096字节，虽然被映射的文件只有5000字节，但是对应到进程虚拟地址区域的大小需要满足整页大小，因此mmap函数执行后，实际映射到虚拟内存区域8192个 字节，5000~8191的字节部分用零填充。映射后的对应关系如下图所示：
 
-               ![](https://images0.cnblogs.com/blog2015/571793/201507/200521495513717.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405100908.png)
 此时：
 
 （1）读/写前5000个字节（0~4999），会返回操作文件内容。
@@ -173,7 +190,7 @@ mmap内存映射的实现过程，总的来说可以分为三个阶段：
 
 分析：由于文件的大小是5000字节，和情形一一样，其对应的两个物理页。那么这两个物理页都是合法可以读写的，只是超出5000的部分不会体现在原文件中。由于程序要求映射15000字节，而文件只占两个物理页，因此8192字节~15000字节都不能读写，操作时会返回异常。如下图所示：
 
-                 ![](https://images0.cnblogs.com/blog2015/571793/201507/200522381763096.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405100917.png)
 
 此时：
 
@@ -205,33 +222,17 @@ mmap内存映射的实现过程，总的来说可以分为三个阶段：
 
 PhantomReference 是所有“弱引用”中最弱的引用类型。不同于软引用和弱引用，虚引用无法通过 get() 方法来取得目标对象的强引用从而使用目标对象，观察源码可以发现 get() 被重写为永远返回 null。
 那虚引用到底有什么作用？其实虚引用主要被用来 跟踪对象被垃圾回收的状态，通过查看引用队列中是否包含对象所对应的虚引用来判断它是否 即将被垃圾回收，从而采取行动。它并不被期待用来取得目标对象的引用，而目标对象被回收前，它的引用会被放入一个 ReferenceQueue 对象中，从而达到跟踪对象垃圾回收的作用。
-关于java引用类型的实现和原理可以阅读之前的文章[Reference 、ReferenceQueue 详解](https://www.jianshu.com/p/f86d3a43eec5) 和[Java 引用类型简述](https://www.jianshu.com/p/9a089a37f78d)
+关于java引用类型的实现和原理可以阅读之前的文章[Reference 、ReferenceQueue 详解](https://www.jianshu.com/p/f86d3a43eec5)和[Java 引用类型简述](https://www.jianshu.com/p/9a089a37f78d)
 
 #### 关于linux的内核态和用户态
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4235178-7c5ca2cb236fd2eb.png?imageMogr2/auto-orient/strip|imageView2/2/w/752/format/webp)
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405100942.png)
 
 *   内核态：控制计算机的硬件资源，并提供上层应用程序运行的环境。比如socket I/0操作或者文件的读写操作等
 *   用户态：上层应用程序的活动空间，应用程序的执行必须依托于内核提供的资源。
 *   系统调用：为了使上层应用能够访问到这些资源，内核为上层应用提供访问的接口。
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4235178-2393d0797135217b.png?imageMogr2/auto-orient/strip|imageView2/2/w/1200/format/webp)
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405100954.png)
 
 因此我们可以得知当我们通过JNI调用的native方法实际上就是从用户态切换到了内核态的一种方式。并且通过该系统调用使用操作系统所提供的功能。
 
@@ -242,15 +243,7 @@ A：intel cpu提供Ring0-Ring3四种级别的运行模式，Ring0级别最高，
 
 DirectByteBuffer是Java用于实现堆外内存的一个重要类，我们可以通过该类实现堆外内存的创建、使用和销毁。
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4235178-fc2ae3eac18813d3.png?imageMogr2/auto-orient/strip|imageView2/2/w/726/format/webp)
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405101025.png)
 
 DirectByteBuffer该类本身还是位于Java内存模型的堆中。堆内内存是JVM可以直接管控、操纵。
 而DirectByteBuffer中的unsafe.allocateMemory(size);是个一个native方法，这个方法分配的是堆外内存，通过C的malloc来进行分配的。分配的内存是系统本地的内存，并不在Java的内存中，也不属于JVM管控范围，所以在DirectByteBuffer一定会存在某种方式来操纵堆外内存。
@@ -266,15 +259,7 @@ DirectByteBuffer该类本身还是位于Java内存模型的堆中。堆内内存
 address只会被直接缓存给使用到。之所以将address属性升级放在Buffer中，是为了在JNI调用GetDirectBufferAddress时提升它调用的速率。
 address表示分配的堆外内存的地址。
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4235178-5e010dc58916b102.png?imageMogr2/auto-orient/strip|imageView2/2/w/1200/format/webp)
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405101047.png)
 
 unsafe.allocateMemory(size);分配完堆外内存后就会返回分配的堆外内存基地址，并将这个地址赋值给了address属性。这样我们后面通过JNI对这个堆外内存操作时都是通过这个address来实现的了。
 
@@ -285,45 +270,36 @@ A：这是因为JNI方法访问的内存区域是一个已经确定了的内存
 Q：如上面所说，JNI调用的内存是不能进行GC操作的，那该如何解决了？
 A：①堆内内存与堆外内存之间数据拷贝的方式(并且在将堆内内存拷贝到堆外内存的过程JVM会保证不会进行GC操作)：比如我们要完成一个从文件中读数据到堆内内存的操作，即FileChannelImpl.read(HeapByteBuffer)。这里实际上File I/O会将数据读到堆外内存中，然后堆外内存再讲数据拷贝到堆内内存，这样我们就读到了文件中的内存。
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4235178-f94db8df14023550.png?imageMogr2/auto-orient/strip|imageView2/2/w/1194/format/webp)
-
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405101116.png)
 ```
-    static int read(FileDescriptor var0, ByteBuffer var1, long var2, NativeDispatcher var4) throws IOException {
-        if (var1.isReadOnly()) {
-            throw new IllegalArgumentException("Read-only buffer");
-        } else if (var1 instanceof DirectBuffer) {
-            return readIntoNativeBuffer(var0, var1, var2, var4);
-        } else {
-            // 分配临时的堆外内存
-            ByteBuffer var5 = Util.getTemporaryDirectBuffer(var1.remaining());
-
-            int var7;
-            try {
-                // File I/O 操作会将数据读入到堆外内存中
-                int var6 = readIntoNativeBuffer(var0, var5, var2, var4);
-                var5.flip();
-                if (var6 > 0) {
-                    // 将堆外内存的数据拷贝到堆外内存中
-                    var1.put(var5);
-                }
-
-                var7 = var6;
-            } finally {
-                // 里面会调用DirectBuffer.cleaner().clean()来释放临时的堆外内存
-                Util.offerFirstTemporaryDirectBuffer(var5);
+static int read(FileDescriptor var0, ByteBuffer var1, long var2, NativeDispatcher var4) throws IOException {
+    if (var1.isReadOnly()) {
+        throw new IllegalArgumentException("Read-only buffer");
+    } else if (var1 instanceof DirectBuffer) {
+        return readIntoNativeBuffer(var0, var1, var2, var4);
+    } else {
+        // 分配临时的堆外内存
+        ByteBuffer var5 = Util.getTemporaryDirectBuffer(var1.remaining());
+
+        int var7;
+        try {
+            // File I/O 操作会将数据读入到堆外内存中
+            int var6 = readIntoNativeBuffer(var0, var5, var2, var4);
+            var5.flip();
+            if (var6 > 0) {
+                // 将堆外内存的数据拷贝到堆外内存中
+                var1.put(var5);
             }
 
-            return var7;
+            var7 = var6;
+        } finally {
+            // 里面会调用DirectBuffer.cleaner().clean()来释放临时的堆外内存
+            Util.offerFirstTemporaryDirectBuffer(var5);
         }
+
+        return var7;
     }
+}
 
 ```
 
@@ -335,99 +311,99 @@ A：①堆内内存与堆外内存之间数据拷贝的方式(并且在将堆内
 #### 堆外内存分配
 
 ```
-    DirectByteBuffer(int cap) {                   // package-private
-        super(-1, 0, cap, cap);
-        boolean pa = VM.isDirectMemoryPageAligned();
-        int ps = Bits.pageSize();
-        long size = Math.max(1L, (long)cap + (pa ? ps : 0));
-        // 保留总分配内存(按页分配)的大小和实际内存的大小
-        Bits.reserveMemory(size, cap);
-
-        long base = 0;
-        try {
-            // 通过unsafe.allocateMemory分配堆外内存，并返回堆外内存的基地址
-            base = unsafe.allocateMemory(size);
-        } catch (OutOfMemoryError x) {
-            Bits.unreserveMemory(size, cap);
-            throw x;
-        }
-        unsafe.setMemory(base, size, (byte) 0);
-        if (pa && (base % ps != 0)) {
-            // Round up to page boundary
-            address = base + ps - (base & (ps - 1));
-        } else {
-            address = base;
-        }
-        // 构建Cleaner对象用于跟踪DirectByteBuffer对象的垃圾回收，以实现当DirectByteBuffer被垃圾回收时，堆外内存也会被释放
-        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
-        att = null;
+DirectByteBuffer(int cap) {                   // package-private
+    super(-1, 0, cap, cap);
+    boolean pa = VM.isDirectMemoryPageAligned();
+    int ps = Bits.pageSize();
+    long size = Math.max(1L, (long)cap + (pa ? ps : 0));
+    // 保留总分配内存(按页分配)的大小和实际内存的大小
+    Bits.reserveMemory(size, cap);
+
+    long base = 0;
+    try {
+        // 通过unsafe.allocateMemory分配堆外内存，并返回堆外内存的基地址
+        base = unsafe.allocateMemory(size);
+    } catch (OutOfMemoryError x) {
+        Bits.unreserveMemory(size, cap);
+        throw x;
+    }
+    unsafe.setMemory(base, size, (byte) 0);
+    if (pa && (base % ps != 0)) {
+        // Round up to page boundary
+        address = base + ps - (base & (ps - 1));
+    } else {
+        address = base;
     }
+    // 构建Cleaner对象用于跟踪DirectByteBuffer对象的垃圾回收，以实现当DirectByteBuffer被垃圾回收时，堆外内存也会被释放
+    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
+    att = null;
+}
 
 ```
 
 #### Bits.reserveMemory(size, cap) 方法
 
 ```
-    static void reserveMemory(long size, int cap) {
+static void reserveMemory(long size, int cap) {
 
-        if (!memoryLimitSet && VM.isBooted()) {
-            maxMemory = VM.maxDirectMemory();
-            memoryLimitSet = true;
-        }
+    if (!memoryLimitSet && VM.isBooted()) {
+        maxMemory = VM.maxDirectMemory();
+        memoryLimitSet = true;
+    }
+
+    // optimist!
+    if (tryReserveMemory(size, cap)) {
+        return;
+    }
+
+    final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();
 
-        // optimist!
+    // retry while helping enqueue pending Reference objects
+    // which includes executing pending Cleaner(s) which includes
+    // Cleaner(s) that free direct buffer memory
+    while (jlra.tryHandlePendingReference()) {
         if (tryReserveMemory(size, cap)) {
             return;
         }
+    }
 
-        final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();
+    // trigger VM's Reference processing
+    System.gc();
 
-        // retry while helping enqueue pending Reference objects
-        // which includes executing pending Cleaner(s) which includes
-        // Cleaner(s) that free direct buffer memory
-        while (jlra.tryHandlePendingReference()) {
+    // a retry loop with exponential back-off delays
+    // (this gives VM some time to do it's job)
+    boolean interrupted = false;
+    try {
+        long sleepTime = 1;
+        int sleeps = 0;
+        while (true) {
             if (tryReserveMemory(size, cap)) {
                 return;
             }
-        }
-
-        // trigger VM's Reference processing
-        System.gc();
-
-        // a retry loop with exponential back-off delays
-        // (this gives VM some time to do it's job)
-        boolean interrupted = false;
-        try {
-            long sleepTime = 1;
-            int sleeps = 0;
-            while (true) {
-                if (tryReserveMemory(size, cap)) {
-                    return;
-                }
-                if (sleeps >= MAX_SLEEPS) {
-                    break;
-                }
-                if (!jlra.tryHandlePendingReference()) {
-                    try {
-                        Thread.sleep(sleepTime);
-                        sleepTime <<= 1;
-                        sleeps++;
-                    } catch (InterruptedException e) {
-                        interrupted = true;
-                    }
+            if (sleeps >= MAX_SLEEPS) {
+                break;
+            }
+            if (!jlra.tryHandlePendingReference()) {
+                try {
+                    Thread.sleep(sleepTime);
+                    sleepTime <<= 1;
+                    sleeps++;
+                } catch (InterruptedException e) {
+                    interrupted = true;
                 }
             }
+        }
 
-            // no luck
-            throw new OutOfMemoryError("Direct buffer memory");
+        // no luck
+        throw new OutOfMemoryError("Direct buffer memory");
 
-        } finally {
-            if (interrupted) {
-                // don't swallow interrupts
-                Thread.currentThread().interrupt();
-            }
+    } finally {
+        if (interrupted) {
+            // don't swallow interrupts
+            Thread.currentThread().interrupt();
         }
     }
+}
 
 ```
 
@@ -436,16 +412,16 @@ A：①堆内内存与堆外内存之间数据拷贝的方式(并且在将堆内
 其中，如果系统中内存( 即，堆外内存 )不够的话：
 
 ```
-        final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();
-
-        // retry while helping enqueue pending Reference objects
-        // which includes executing pending Cleaner(s) which includes
-        // Cleaner(s) that free direct buffer memory
-        while (jlra.tryHandlePendingReference()) {
-            if (tryReserveMemory(size, cap)) {
-                return;
-            }
-        }
+final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();
+
+// retry while helping enqueue pending Reference objects
+// which includes executing pending Cleaner(s) which includes
+// Cleaner(s) that free direct buffer memory
+while (jlra.tryHandlePendingReference()) {
+    if (tryReserveMemory(size, cap)) {
+        return;
+    }
+}
 
 ```
 
@@ -453,20 +429,20 @@ jlra.tryHandlePendingReference()会触发一次非堵塞的Reference#tryHandlePe
 因为在Reference的静态代码块中定义了：
 
 ```
-        SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {
-            @Override
-            public boolean tryHandlePendingReference() {
-                return tryHandlePending(false);
-            }
-        });
+SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {
+    @Override
+    public boolean tryHandlePendingReference() {
+        return tryHandlePending(false);
+    }
+});
 
 ```
 
 如果在进行一次堆外内存资源回收后，还不够进行本次堆外内存分配的话，则
 
 ```
-        // trigger VM's Reference processing
-        System.gc();
+// trigger VM's Reference processing
+System.gc();
 
 ```
 
@@ -474,14 +450,7 @@ System.gc()会触发一个full gc，当然前提是你没有显示的设置-XX:+
 所以在后面打代码中，会进行最多9次尝试，看是否有足够的可用堆外内存来分配堆外内存。并且每次尝试之前，都对延迟等待时间，已给JVM足够的时间去完成full gc操作。如果9次尝试后依旧没有足够的可用堆外内存来分配本次堆外内存，则抛出OutOfMemoryError("Direct buffer memory”)异常。
 
 
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4235178-6da0d60191992f59.png?imageMogr2/auto-orient/strip|imageView2/2/w/449/format/webp)
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405101406.png)
 
 注意，这里之所以用使用full gc的很重要的一个原因是：System.gc()会对新生代的老生代都会进行内存回收，这样会比较彻底地回收DirectByteBuffer对象以及他们关联的堆外内存.
 DirectByteBuffer对象本身其实是很小的，但是它后面可能关联了一个非常大的堆外内存，因此我们通常称之为冰山对象.
@@ -526,8 +495,7 @@ Cleaner是PhantomReference的子类，并通过自身的next和prev字段维护
 
 
 
-![](https://upload-images.jianshu.io/upload_images/4235178-792afac32aefd061.png?imageMogr2/auto-orient/strip|imageView2/2/w/713/format/webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405101539.png)
 
 
 
@@ -536,8 +504,7 @@ Cleaner是PhantomReference的子类，并通过自身的next和prev字段维护
 
 
 
-![](https://upload-images.jianshu.io/upload_images/4235178-07eaab88f1d02927.png?imageMogr2/auto-orient/strip|imageView2/2/w/750/format/webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405101614.png)
 
 
 
@@ -548,13 +515,7 @@ thunk方法：
 
 
 
-
-
-![](https://upload-images.jianshu.io/upload_images/4235178-ebeffa00197df134.png?imageMogr2/auto-orient/strip|imageView2/2/w/515/format/webp)
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405101655.png)
 
 #### 通过配置参数的方式来回收堆外内存
 
@@ -593,6 +554,7 @@ thunk方法：
 ## 参考文章
 
 [http://lovestblog.cn/blog/2015/05/12/direct-buffer/](https://link.jianshu.com/?t=http://lovestblog.cn/blog/2015/05/12/direct-buffer/)
+
 [http://www.infoq.com/cn/news/2014/12/external-memory-heap-memory](https://link.jianshu.com/?t=http://www.infoq.com/cn/news/2014/12/external-memory-heap-memory)
+
 [http://www.jianshu.com/p/85e931636f27](https://www.jianshu.com/p/85e931636f27)
-圣思园《并发与Netty》课程
diff --git "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2437\357\274\232\346\265\205\350\260\210 Linux \344\270\255NIO Selector \347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md" "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\346\265\205\350\260\210Linux\344\270\255Selector\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
similarity index 64%
rename from "docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2437\357\274\232\346\265\205\350\260\210 Linux \344\270\255NIO Selector \347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
rename to "docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\346\265\205\350\260\210Linux\344\270\255Selector\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
index 23676d9..550f7ab 100644
--- "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\345\222\214NIO\350\257\246\350\247\2437\357\274\232\346\265\205\350\260\210 Linux \344\270\255NIO Selector \347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"	
+++ "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\346\265\205\350\260\210Linux\344\270\255Selector\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
@@ -1,5 +1,23 @@
-# Table of Contents
+# 目录
 
+* [目录](#目录)
+  * [概述](#概述)
+  * [Selector的中的重要属性](#selector的中的重要属性)
+  * [Selector 源码解析](#selector-源码解析)
+    * [1、Selector的构建](#1、selector的构建)
+          * [接下来看下 selector.open()：](#接下来看下-selectoropen：)
+    * [EPollSelectorImpl](#epollselectorimpl)
+    * [EPollArrayWrapper](#epollarraywrapper)
+    * [ServerSocketChannel的构建](#serversocketchannel的构建)
+    * [将ServerSocketChannel注册到Selector](#将serversocketchannel注册到selector)
+    * [EPollSelectorImpl. implRegister](#epollselectorimpl-implregister)
+    * [Selection操作](#selection操作)
+    * [epoll原理](#epoll原理)
+  * [后记](#后记)
+  * [参考文章](#参考文章)
+
+
+# 目录
   * [概述](#概述)
   * [Selector的中的重要属性](#selector的中的重要属性)
   * [Selector 源码解析](#selector-源码解析)
@@ -63,23 +81,23 @@ Selector中维护3个特别重要的SelectionKey集合，分别是
 首先先来段Selector最简单的使用片段
 
 ```
-        ServerSocketChannel serverChannel = ServerSocketChannel.open();
-        serverChannel.configureBlocking(false);
-        int port = 5566;          
-        serverChannel.socket().bind(new InetSocketAddress(port));
-        Selector selector = Selector.open();
-        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
-        while(true){
-            int n = selector.select();
-            if(n > 0) {
-                Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
-                while (iter.hasNext()) {
-                    SelectionKey selectionKey = iter.next();
-                    ......
-                    iter.remove();
-                }
-            }
+ServerSocketChannel serverChannel = ServerSocketChannel.open();
+serverChannel.configureBlocking(false);
+int port = 5566;          
+serverChannel.socket().bind(new InetSocketAddress(port));
+Selector selector = Selector.open();
+serverChannel.register(selector, SelectionKey.OP_ACCEPT);
+while(true){
+    int n = selector.select();
+    if(n > 0) {
+        Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
+        while (iter.hasNext()) {
+            SelectionKey selectionKey = iter.next();
+            ......
+            iter.remove();
         }
+    }
+}
 
 ```
 
@@ -90,50 +108,50 @@ SocketChannel、ServerSocketChannel和Selector的实例初始化都通过Selecto
 ServerSocketChannel.open();
 
 ```
-    public static ServerSocketChannel open() throws IOException {
-        return SelectorProvider.provider().openServerSocketChannel();
-    }
+public static ServerSocketChannel open() throws IOException {
+    return SelectorProvider.provider().openServerSocketChannel();
+}
 
 ```
 
 SocketChannel.open();
 
 ```
-    public static SocketChannel open() throws IOException {
-        return SelectorProvider.provider().openSocketChannel();
-    }
+public static SocketChannel open() throws IOException {
+    return SelectorProvider.provider().openSocketChannel();
+}
 
 ```
 
 Selector.open();
 
 ```
-    public static Selector open() throws IOException {
-        return SelectorProvider.provider().openSelector();
-    }
+public static Selector open() throws IOException {
+    return SelectorProvider.provider().openSelector();
+}
 
 ```
 
 我们来进一步的了解下SelectorProvider.provider()
 
 ```
-    public static SelectorProvider provider() {
-        synchronized (lock) {
-            if (provider != null)
-                return provider;
-            return AccessController.doPrivileged(
-                new PrivilegedAction<>() {
-                    public SelectorProvider run() {
-                            if (loadProviderFromProperty())
-                                return provider;
-                            if (loadProviderAsService())
-                                return provider;
-                            provider = sun.nio.ch.DefaultSelectorProvider.create();
+public static SelectorProvider provider() {
+    synchronized (lock) {
+        if (provider != null)
+            return provider;
+        return AccessController.doPrivileged(
+            new PrivilegedAction<>() {
+                public SelectorProvider run() {
+                        if (loadProviderFromProperty())
                             return provider;
-                        }
-                    });
-        }
+                        if (loadProviderAsService())
+                            return provider;
+                        provider = sun.nio.ch.DefaultSelectorProvider.create();
+                        return provider;
+                    }
+                });
     }
+}
 
 ```
 
@@ -145,14 +163,7 @@ Selector.open();
 不同系统对应着不同的sun.nio.ch.DefaultSelectorProvider
 
 
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4235178-a02c498e08979aff.png?imageMogr2/auto-orient/strip|imageView2/2/w/640/format/webp)
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405100409.png)
 
 这里我们看linux下面的sun.nio.ch.DefaultSelectorProvider
 
@@ -222,28 +233,28 @@ class EPollSelectorImpl
 
 ```
 EPollSelectorImpl(SelectorProvider sp) throws IOException {
-        super(sp);
-        long pipeFds = IOUtil.makePipe(false);
-        fd0 = (int) (pipeFds >>> 32);
-        fd1 = (int) pipeFds;
+    super(sp);
+    long pipeFds = IOUtil.makePipe(false);
+    fd0 = (int) (pipeFds >>> 32);
+    fd1 = (int) pipeFds;
+    try {
+        pollWrapper = new EPollArrayWrapper();
+        pollWrapper.initInterrupt(fd0, fd1);
+        fdToKey = new HashMap<>();
+    } catch (Throwable t) {
         try {
-            pollWrapper = new EPollArrayWrapper();
-            pollWrapper.initInterrupt(fd0, fd1);
-            fdToKey = new HashMap<>();
-        } catch (Throwable t) {
-            try {
-                FileDispatcherImpl.closeIntFD(fd0);
-            } catch (IOException ioe0) {
-                t.addSuppressed(ioe0);
-            }
-            try {
-                FileDispatcherImpl.closeIntFD(fd1);
-            } catch (IOException ioe1) {
-                t.addSuppressed(ioe1);
-            }
-            throw t;
+            FileDispatcherImpl.closeIntFD(fd0);
+        } catch (IOException ioe0) {
+            t.addSuppressed(ioe0);
+        }
+        try {
+            FileDispatcherImpl.closeIntFD(fd1);
+        } catch (IOException ioe1) {
+            t.addSuppressed(ioe1);
         }
+        throw t;
     }
+}
 
 ```
 
@@ -252,11 +263,11 @@ EPollSelectorImpl构造函数完成：
 ② 通过EPollArrayWrapper向epoll注册中断事件
 
 ```
-    void initInterrupt(int fd0, int fd1) {
-        outgoingInterruptFD = fd1;
-        incomingInterruptFD = fd0;
-        epollCtl(epfd, EPOLL_CTL_ADD, fd0, EPOLLIN);
-    }
+void initInterrupt(int fd0, int fd1) {
+    outgoingInterruptFD = fd1;
+    incomingInterruptFD = fd0;
+    epollCtl(epfd, EPOLL_CTL_ADD, fd0, EPOLLIN);
+}
 
 ```
 
@@ -287,44 +298,44 @@ epoll_event的数据成员(epoll_data_t data)包含有与通过epoll_ctl将文
 EPollArrayWrapper将Linux的epoll相关系统调用封装成了native方法供EpollSelectorImpl使用。
 
 ```
-    private native int epollCreate();
-    private native void epollCtl(int epfd, int opcode, int fd, int events);
-    private native int epollWait(long pollAddress, int numfds, long timeout,
-                                 int epfd) throws IOException;
+private native int epollCreate();
+private native void epollCtl(int epfd, int opcode, int fd, int events);
+private native int epollWait(long pollAddress, int numfds, long timeout,
+                             int epfd) throws IOException;
 
 ```
 
 上述三个native方法就对应Linux下epoll相关的三个系统调用
 
 ```
-    // The fd of the epoll driver
-    private final int epfd;
+// The fd of the epoll driver
+private final int epfd;
 
-     // The epoll_event array for results from epoll_wait
-    private final AllocatedNativeObject pollArray;
+ // The epoll_event array for results from epoll_wait
+private final AllocatedNativeObject pollArray;
 
-    // Base address of the epoll_event array
-    private final long pollArrayAddress;
+// Base address of the epoll_event array
+private final long pollArrayAddress;
 
 ```
 
 ```
-    // 用于存储已经注册的文件描述符和其注册等待改变的事件的关联关系。在epoll_wait操作就是要检测这里文件描述法注册的事件是否有发生。
-    private final byte[] eventsLow = new byte[MAX_UPDATE_ARRAY_SIZE];
-    private final Map<Integer,Byte> eventsHigh = new HashMap<>();
+// 用于存储已经注册的文件描述符和其注册等待改变的事件的关联关系。在epoll_wait操作就是要检测这里文件描述法注册的事件是否有发生。
+private final byte[] eventsLow = new byte[MAX_UPDATE_ARRAY_SIZE];
+private final Map<Integer,Byte> eventsHigh = new HashMap<>();
 
 ```
 
 ```
-    EPollArrayWrapper() throws IOException {
-        // creates the epoll file descriptor
-        epfd = epollCreate();
+EPollArrayWrapper() throws IOException {
+    // creates the epoll file descriptor
+    epfd = epollCreate();
 
-        // the epoll_event array passed to epoll_wait
-        int allocationSize = NUM_EPOLLEVENTS * SIZE_EPOLLEVENT;
-        pollArray = new AllocatedNativeObject(allocationSize, true);
-        pollArrayAddress = pollArray.address();
-    }
+    // the epoll_event array passed to epoll_wait
+    int allocationSize = NUM_EPOLLEVENTS * SIZE_EPOLLEVENT;
+    pollArray = new AllocatedNativeObject(allocationSize, true);
+    pollArrayAddress = pollArray.address();
+}
 
 ```
 
@@ -337,22 +348,22 @@ ServerSocketChannel.open();
 返回ServerSocketChannelImpl对象，构建linux系统下ServerSocket的文件描述符。
 
 ```
-    // Our file descriptor
-    private final FileDescriptor fd;
+// Our file descriptor
+private final FileDescriptor fd;
 
-    // fd value needed for dev/poll. This value will remain valid
-    // even after the value in the file descriptor object has been set to -1
-    private int fdVal;
+// fd value needed for dev/poll. This value will remain valid
+// even after the value in the file descriptor object has been set to -1
+private int fdVal;
 
 ```
 
 ```
-    ServerSocketChannelImpl(SelectorProvider sp) throws IOException {
-        super(sp);
-        this.fd =  Net.serverSocket(true);
-        this.fdVal = IOUtil.fdVal(fd);
-        this.state = ST_INUSE;
-    }
+ServerSocketChannelImpl(SelectorProvider sp) throws IOException {
+    super(sp);
+    this.fd =  Net.serverSocket(true);
+    this.fdVal = IOUtil.fdVal(fd);
+    this.state = ST_INUSE;
+}
 
 ```
 
@@ -361,52 +372,52 @@ ServerSocketChannel.open();
 serverChannel.register(selector, SelectionKey.OP_ACCEPT);
 
 ```
-    public final SelectionKey register(Selector sel, int ops,
-                                       Object att)
-        throws ClosedChannelException
-    {
-        synchronized (regLock) {
-            if (!isOpen())
-                throw new ClosedChannelException();
-            if ((ops & ~validOps()) != 0)
-                throw new IllegalArgumentException();
-            if (blocking)
-                throw new IllegalBlockingModeException();
-            SelectionKey k = findKey(sel);
-            if (k != null) {
-                k.interestOps(ops);
-                k.attach(att);
-            }
-            if (k == null) {
-                // New registration
-                synchronized (keyLock) {
-                    if (!isOpen())
-                        throw new ClosedChannelException();
-                    k = ((AbstractSelector)sel).register(this, ops, att);
-                    addKey(k);
-                }
+public final SelectionKey register(Selector sel, int ops,
+                                   Object att)
+    throws ClosedChannelException
+{
+    synchronized (regLock) {
+        if (!isOpen())
+            throw new ClosedChannelException();
+        if ((ops & ~validOps()) != 0)
+            throw new IllegalArgumentException();
+        if (blocking)
+            throw new IllegalBlockingModeException();
+        SelectionKey k = findKey(sel);
+        if (k != null) {
+            k.interestOps(ops);
+            k.attach(att);
+        }
+        if (k == null) {
+            // New registration
+            synchronized (keyLock) {
+                if (!isOpen())
+                    throw new ClosedChannelException();
+                k = ((AbstractSelector)sel).register(this, ops, att);
+                addKey(k);
             }
-            return k;
         }
+        return k;
     }
+}
 
 ```
 
 ```
-    protected final SelectionKey register(AbstractSelectableChannel ch,
-                                          int ops,
-                                          Object attachment)
-    {
-        if (!(ch instanceof SelChImpl))
-            throw new IllegalSelectorException();
-        SelectionKeyImpl k = new SelectionKeyImpl((SelChImpl)ch, this);
-        k.attach(attachment);
-        synchronized (publicKeys) {
-            implRegister(k);
-        }
-        k.interestOps(ops);
-        return k;
+protected final SelectionKey register(AbstractSelectableChannel ch,
+                                      int ops,
+                                      Object attachment)
+{
+    if (!(ch instanceof SelChImpl))
+        throw new IllegalSelectorException();
+    SelectionKeyImpl k = new SelectionKeyImpl((SelChImpl)ch, this);
+    k.attach(attachment);
+    synchronized (publicKeys) {
+        implRegister(k);
     }
+    k.interestOps(ops);
+    return k;
+}
 
 ```
 
@@ -419,15 +430,15 @@ b) 同时该操作还会将设置SelectionKey的interestOps字段，这是给我
 ### EPollSelectorImpl. implRegister
 
 ```
-    protected void implRegister(SelectionKeyImpl ski) {
-        if (closed)
-            throw new ClosedSelectorException();
-        SelChImpl ch = ski.channel;
-        int fd = Integer.valueOf(ch.getFDVal());
-        fdToKey.put(fd, ski);
-        pollWrapper.add(fd);
-        keys.add(ski);
-    }
+protected void implRegister(SelectionKeyImpl ski) {
+    if (closed)
+        throw new ClosedSelectorException();
+    SelChImpl ch = ski.channel;
+    int fd = Integer.valueOf(ch.getFDVal());
+    fdToKey.put(fd, ski);
+    pollWrapper.add(fd);
+    keys.add(ski);
+}
 
 ```
 
@@ -445,38 +456,38 @@ selection操作有3中类型：
 我们主要来看看select()的实现 ：int n = selector.select();
 
 ```
-    public int select() throws IOException {
-        return select(0);
-    }
+public int select() throws IOException {
+    return select(0);
+}
 
 ```
 
 最终会调用到EPollSelectorImpl的doSelect
 
 ```
-    protected int doSelect(long timeout) throws IOException {
-        if (closed)
-            throw new ClosedSelectorException();
-        processDeregisterQueue();
-        try {
-            begin();
-            pollWrapper.poll(timeout);
-        } finally {
-            end();
-        }
-        processDeregisterQueue();
-        int numKeysUpdated = updateSelectedKeys();
-        if (pollWrapper.interrupted()) {
-            // Clear the wakeup pipe
-            pollWrapper.putEventOps(pollWrapper.interruptedIndex(), 0);
-            synchronized (interruptLock) {
-                pollWrapper.clearInterrupted();
-                IOUtil.drain(fd0);
-                interruptTriggered = false;
-            }
+protected int doSelect(long timeout) throws IOException {
+    if (closed)
+        throw new ClosedSelectorException();
+    processDeregisterQueue();
+    try {
+        begin();
+        pollWrapper.poll(timeout);
+    } finally {
+        end();
+    }
+    processDeregisterQueue();
+    int numKeysUpdated = updateSelectedKeys();
+    if (pollWrapper.interrupted()) {
+        // Clear the wakeup pipe
+        pollWrapper.putEventOps(pollWrapper.interruptedIndex(), 0);
+        synchronized (interruptLock) {
+            pollWrapper.clearInterrupted();
+            IOUtil.drain(fd0);
+            interruptTriggered = false;
         }
-        return numKeysUpdated;
     }
+    return numKeysUpdated;
+}
 
 ```
 
@@ -488,49 +499,49 @@ selection操作有3中类型：
 先来看processDeregisterQueue():
 
 ```
-    void processDeregisterQueue() throws IOException {
-        Set var1 = this.cancelledKeys();
-        synchronized(var1) {
-            if (!var1.isEmpty()) {
-                Iterator var3 = var1.iterator();
+void processDeregisterQueue() throws IOException {
+    Set var1 = this.cancelledKeys();
+    synchronized(var1) {
+        if (!var1.isEmpty()) {
+            Iterator var3 = var1.iterator();
 
-                while(var3.hasNext()) {
-                    SelectionKeyImpl var4 = (SelectionKeyImpl)var3.next();
+            while(var3.hasNext()) {
+                SelectionKeyImpl var4 = (SelectionKeyImpl)var3.next();
 
-                    try {
-                        this.implDereg(var4);
-                    } catch (SocketException var12) {
-                        IOException var6 = new IOException("Error deregistering key");
-                        var6.initCause(var12);
-                        throw var6;
-                    } finally {
-                        var3.remove();
-                    }
+                try {
+                    this.implDereg(var4);
+                } catch (SocketException var12) {
+                    IOException var6 = new IOException("Error deregistering key");
+                    var6.initCause(var12);
+                    throw var6;
+                } finally {
+                    var3.remove();
                 }
             }
-
         }
+
     }
+}
 
 ```
 
 从cancelledKeys集合中依次取出注销的SelectionKey，执行注销操作，将处理后的SelectionKey从cancelledKeys集合中移除。执行processDeregisterQueue()后cancelledKeys集合会为空。
 
 ```
-    protected void implDereg(SelectionKeyImpl ski) throws IOException {
-        assert (ski.getIndex() >= 0);
-        SelChImpl ch = ski.channel;
-        int fd = ch.getFDVal();
-        fdToKey.remove(Integer.valueOf(fd));
-        pollWrapper.remove(fd);
-        ski.setIndex(-1);
-        keys.remove(ski);
-        selectedKeys.remove(ski);
-        deregister((AbstractSelectionKey)ski);
-        SelectableChannel selch = ski.channel();
-        if (!selch.isOpen() && !selch.isRegistered())
-            ((SelChImpl)selch).kill();
-    }
+protected void implDereg(SelectionKeyImpl ski) throws IOException {
+    assert (ski.getIndex() >= 0);
+    SelChImpl ch = ski.channel;
+    int fd = ch.getFDVal();
+    fdToKey.remove(Integer.valueOf(fd));
+    pollWrapper.remove(fd);
+    ski.setIndex(-1);
+    keys.remove(ski);
+    selectedKeys.remove(ski);
+    deregister((AbstractSelectionKey)ski);
+    SelectableChannel selch = ski.channel();
+    if (!selch.isOpen() && !selch.isRegistered())
+        ((SelChImpl)selch).kill();
+}
 
 ```
 
@@ -545,18 +556,18 @@ selection操作有3中类型：
 接着我们来看EPollArrayWrapper.poll(timeout)：
 
 ```
-    int poll(long timeout) throws IOException {
-        updateRegistrations();
-        updated = epollWait(pollArrayAddress, NUM_EPOLLEVENTS, timeout, epfd);
-        for (int i=0; i<updated; i++) {
-            if (getDescriptor(i) == incomingInterruptFD) {
-                interruptedIndex = i;
-                interrupted = true;
-                break;
-            }
+int poll(long timeout) throws IOException {
+    updateRegistrations();
+    updated = epollWait(pollArrayAddress, NUM_EPOLLEVENTS, timeout, epfd);
+    for (int i=0; i<updated; i++) {
+        if (getDescriptor(i) == incomingInterruptFD) {
+            interruptedIndex = i;
+            interrupted = true;
+            break;
         }
-        return updated;
     }
+    return updated;
+}
 
 ```
 
@@ -566,30 +577,30 @@ updateRegistrations()方法会将已经注册到该selector的事件(eventsLow
 再看updateSelectedKeys()：
 
 ```
-    private int updateSelectedKeys() {
-        int entries = pollWrapper.updated;
-        int numKeysUpdated = 0;
-        for (int i=0; i<entries; i++) {
-            int nextFD = pollWrapper.getDescriptor(i);
-            SelectionKeyImpl ski = fdToKey.get(Integer.valueOf(nextFD));
-            // ski is null in the case of an interrupt
-            if (ski != null) {
-                int rOps = pollWrapper.getEventOps(i);
-                if (selectedKeys.contains(ski)) {
-                    if (ski.channel.translateAndSetReadyOps(rOps, ski)) {
-                        numKeysUpdated++;
-                    }
-                } else {
-                    ski.channel.translateAndSetReadyOps(rOps, ski);
-                    if ((ski.nioReadyOps() & ski.nioInterestOps()) != 0) {
-                        selectedKeys.add(ski);
-                        numKeysUpdated++;
-                    }
+private int updateSelectedKeys() {
+    int entries = pollWrapper.updated;
+    int numKeysUpdated = 0;
+    for (int i=0; i<entries; i++) {
+        int nextFD = pollWrapper.getDescriptor(i);
+        SelectionKeyImpl ski = fdToKey.get(Integer.valueOf(nextFD));
+        // ski is null in the case of an interrupt
+        if (ski != null) {
+            int rOps = pollWrapper.getEventOps(i);
+            if (selectedKeys.contains(ski)) {
+                if (ski.channel.translateAndSetReadyOps(rOps, ski)) {
+                    numKeysUpdated++;
+                }
+            } else {
+                ski.channel.translateAndSetReadyOps(rOps, ski);
+                if ((ski.nioReadyOps() & ski.nioInterestOps()) != 0) {
+                    selectedKeys.add(ski);
+                    numKeysUpdated++;
                 }
             }
         }
-        return numKeysUpdated;
     }
+    return numKeysUpdated;
+}
 
 ```
 
@@ -643,27 +654,13 @@ epoll是Linux下的一种IO多路复用技术，可以非常高效的处理数
 
 socket读数据
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4235178-55ea1cf846c7d84c.png?imageMogr2/auto-orient/strip|imageView2/2/w/540/format/webp)
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405100605.png)
 
 
 socket写数据
 
 
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4235178-39c86c1d52d6abce.png?imageMogr2/auto-orient/strip|imageView2/2/w/585/format/webp)
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405100624.png)
 
 最后顺便说下在Linux系统中JDK NIO使用的是 LT ，而Netty epoll使用的是 ET。
 
@@ -675,4 +672,4 @@ socket写数据
 
 [http://www.jianshu.com/p/0d497fe5484a](https://www.jianshu.com/p/0d497fe5484a)
 [http://remcarpediem.com/2017/04/02/Netty](https://link.jianshu.com/?t=http://remcarpediem.com/2017/04/02/Netty)源码-三-I-O模型和Java-NIO底层原理/
-圣思园netty课程
+
diff --git "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\24310\357\274\232\346\267\261\345\272\246\350\247\243\350\257\273Tomcat\344\270\255\347\232\204NIO\346\250\241\345\236\213.md" "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\346\267\261\345\272\246\350\247\243\350\257\273Tomcat\344\270\255\347\232\204NIO\346\250\241\345\236\213.md"
similarity index 83%
rename from "docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\24310\357\274\232\346\267\261\345\272\246\350\247\243\350\257\273Tomcat\344\270\255\347\232\204NIO\346\250\241\345\236\213.md"
rename to "docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\346\267\261\345\272\246\350\247\243\350\257\273Tomcat\344\270\255\347\232\204NIO\346\250\241\345\236\213.md"
index 72e8943..65f5206 100644
--- "a/docs/java/network-programming/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\24310\357\274\232\346\267\261\345\272\246\350\247\243\350\257\273Tomcat\344\270\255\347\232\204NIO\346\250\241\345\236\213.md"
+++ "b/docs/Java/network/Java\347\275\221\347\273\234\347\274\226\347\250\213\344\270\216NIO\350\257\246\350\247\243\357\274\232\346\267\261\345\272\246\350\247\243\350\257\273Tomcat\344\270\255\347\232\204NIO\346\250\241\345\236\213.md"
@@ -1,5 +1,6 @@
-# Table of Contents
+# 目录
 
+* [目录](#目录)
   * [一、I/O复用模型解读](#一、io复用模型解读)
   * [二、TOMCAT对IO模型的支持](#二、tomcat对io模型的支持)
   * [三、TOMCAT中NIO的配置与使用](#三、tomcat中nio的配置与使用)
@@ -10,6 +11,16 @@
   * [八、总结](#八、总结)
 
 
+# 目录
+  * [一、I/O复用模型解读](#一、io复用模型解读)
+  * [二、TOMCAT对IO模型的支持](#二、tomcat对io模型的支持)
+  * [三、TOMCAT中NIO的配置与使用](#三、tomcat中nio的配置与使用)
+  * [四、NioEndpoint组件关系图解读](#四、nioendpoint组件关系图解读)
+  * [五、NioEndpoint执行序列图](#五、nioendpoint执行序列图)
+  * [六、NioEndpoint源码解读](#六、nioendpoint源码解读)
+  * [七、关于性能](#七、关于性能)
+  * [八、总结](#八、总结)
+
 本文转自：http://www.sohu.com/a/203838233_827544
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -37,8 +48,7 @@
 
 Tomcat的NIO是基于I/O复用来实现的。对这点一定要清楚，不然我们的讨论就不在一个逻辑线上。下面这张图学习过I/O模型知识的一般都见过，出自《UNIX网络编程》，I/O模型一共有阻塞式I/O，非阻塞式I/O，I/O复用(select/poll/epoll)，信号驱动式I/O和异步I/O。这篇文章讲的是I/O复用。
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/0ab0b70be5a64b0e9014de867235da73.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104442.png)
 IO复用.png
 
 这里先来说下用户态和内核态，直白来讲，如果线程执行的是用户代码，当前线程处在用户态，如果线程执行的是内核里面的代码，当前线程处在内核态。更深层来讲，操作系统为代码所处的特权级别分了4个级别。
@@ -51,13 +61,12 @@ IO复用.png
 
 上面提到的网络事件有连接就绪，接收就绪，读就绪，写就绪四个网络事件。I/O复用主要是通过Selector复用器来实现的，可以结合下面这个图理解上面的叙述。
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/3a18d371c9c848479ca39d8eb4e57ce4.jpeg)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104504.png)
 Selector图解.png
 
 ## 二、TOMCAT对IO模型的支持
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/983c122c2a924e01b9f898279e2bd0b5.jpeg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104517.png)
 
 tomcat支持IO类型图.png
 
@@ -71,7 +80,7 @@ tomcat从6以后开始支持NIO模型，实现是基于JDK的java.nio包。这
 
 ## 四、NioEndpoint组件关系图解读
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/4e1a924a60974c76ab5115007562e563.jpeg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104543.png)
 
 tomcatnio组成.png
 
@@ -87,8 +96,7 @@ LimitLatch是连接控制器，它负责维护连接数的计算，nio模式下
 
 ## 五、NioEndpoint执行序列图
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/d69c2ef5110d4706aa7284c616d62927.jpeg)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104621.png)
 tomcatnio序列图.png
 
 在下一小节NioEndpoint源码解读中我们将对步骤1-步骤11依次找到对应的代码来说明。
@@ -99,8 +107,7 @@ tomcatnio序列图.png
 
 无论是BIO还是NIO，开始都会初始化连接限制，不可能无限增大，NIO模式下默认是10000。
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/332338f6d2c8488e9b35cd4fd76f078a.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104637.png)
 **6.2、步骤解读**
 
 下面我们着重叙述跟NIO相关的流程，共分为11个步骤，分别对应上面序列图中的步骤。
@@ -111,15 +118,13 @@ tomcatnio序列图.png
 
 Socket，NIO下这里返回的是SocketChannel。
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/ca01395590944a35b4717b15c984849e.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104855.png)
 **步骤2**：启动接收线程
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/e7c40dc6f84b48f4915ca854c2a3b2cc.png)
 
 **步骤3**：ServerSocketChannel.accept()接收新连接
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/50ddbfe042514ba29a8bcd606b125f76.jpeg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104937.png)
 
 **步骤4**：将接收到的链接通道设置为非阻塞
 
@@ -127,30 +132,27 @@ Socket，NIO下这里返回的是SocketChannel。
 
 **步骤6**：register注册到轮询线程
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/f3f5130bcf7a4348bc9752bd009c1b72.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104957.png)
 
 **步骤7**：构造PollerEvent，并添加到事件队列
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/65de3c5cebea42c59ff19e8a168cf406.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105014.png)
 
 **步骤8**：启动轮询线程
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/5c097feaa2324a2da082a81287f9e862.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105027.png)
 
 **步骤9**：取出队列中新增的PollerEvent并注册到Selector
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/8ac5e80b9aa84f57b4c3f7ecd4e2ea1d.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105043.png)
 
 **步骤10**：Selector.select()
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/82d20de2a4614eab9fe14e58234db552.jpeg)
-
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/75641a4b8d444f8ab7a033bee9497c2b.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105057.png)
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105110.png)
 **步骤11**：根据选择的SelectionKey构造SocketProcessor提交到请求处理线程
-
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/b8ec9bbcbdcd4088841741acb20152f8.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105154.png)
 **6.3、NioBlockingSelector和BlockPoller介绍**
 
 上面的序列图有个地方我没有描述，就是NioSelectorPool这个内部类，是因为在整体理解tomcat的nio上面在序列图里面不包括它更好理解。
@@ -159,13 +161,13 @@ Socket，NIO下这里返回的是SocketChannel。
 
 以执行servlet后，得到response，往socket中写数据为例，最终写的过程调用NioBlockingSelector的write方法。代码如下：
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/4ac6ac8fdb0a4b24bdcb646a09cbb13e.jpeg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105223.png)
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/549283c8059b4e3c8798077b654dc3d1.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105237.png)
 
 也就是说当socket.write()返回0时，说明网络状态不稳定，这时将socket注册OP_WRITE事件到辅Selector，由BlockPoller线程不断轮询这个辅Selector，直到发现这个socket的写状态恢复了，通过那个倒数计数器，通知Worker线程继续写socket动作。看一下BlockSelector线程的代码逻辑：
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/626817ca25fc4a439dbf5d23c2c08d0e.jpeg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105251.png)
 
 使用这个辅Selector主要是减少线程间的切换，同时还可减轻主Selector的负担。
 
@@ -175,13 +177,9 @@ Socket，NIO下这里返回的是SocketChannel。
 
 NIO的优势更在于用少量的线程hold住大量的连接。还有一点，我们在压测的过程中，遇到在NIO模式下刚开始的一小段时间内容，会有错误，这是因为一般的压测工具是基于一种长连接，也就是说比如模拟1000并发，那么同时建立1000个连接，下一时刻再发送请求就是基于先前的这1000个连接来发送，还有TOMCAT的NIO处理是有POLLER线程来接管的，它的线程数一般等于CPU的核数，如果一瞬间有大量并发过来，POLLER也会顿时处理不过来。
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/7d62f8792e1c41f090d945c755bba6c7.jpeg)
-
-压测1.jpeg
-
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/e8ec450685d64e5785db44a0bb60660c.jpeg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105304.png)
 
-压测2.jpeg
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105318.png)
 
 ## 八、总结
 
diff --git "a/docs/java-web/JavaWeb\346\212\200\346\234\257\346\200\273\347\273\223.md" "b/docs/JavaWeb/JavaWeb\346\212\200\346\234\257\346\200\273\347\273\223.md"
similarity index 76%
rename from "docs/java-web/JavaWeb\346\212\200\346\234\257\346\200\273\347\273\223.md"
rename to "docs/JavaWeb/JavaWeb\346\212\200\346\234\257\346\200\273\347\273\223.md"
index 39d6ef8..0e0ba42 100644
--- "a/docs/java-web/JavaWeb\346\212\200\346\234\257\346\200\273\347\273\223.md"
+++ "b/docs/JavaWeb/JavaWeb\346\212\200\346\234\257\346\200\273\347\273\223.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [Servlet及相关类](#servlet及相关类)
   * [Jsp和ViewResolver](#jsp和viewresolver)
   * [filter，listener](#filter，listener)
@@ -13,22 +12,9 @@
   * [Git](#git)
   * [Json和xml](#json和xml)
   * [hibernate和mybatis](#hibernate和mybatis)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-
----
-title: JavaWeb技术总结
-date: 2018-07-08 22:13:33
-tags:
-	- JavaWeb
-categories:
-	- 后端
-	- 技术总结
----
 
 
+    
 这篇总结主要是基于我之前两个系列的文章而来。主要是把重要的知识点用自己的话说了一遍，可能会有一些错误，还望见谅和指点。谢谢
 
 更多详细内容可以查看我的专栏文章：
@@ -69,7 +55,7 @@ JAVA WEB工程，都是打成WAR包进行发布。
 典型的war包内部结构如下：
 
 webapp.war
-
+````
   |    index.jsp
 
   |
@@ -95,7 +81,7 @@ webapp.war
                     other.jar             // 依赖的jar包
     
                     share.jar
-
+````
 ## tomcat基础
 
 上一篇文章关于网络编程和NIO已经讲过了，这里按住不表。
@@ -137,20 +123,4 @@ git是分布式的代码管理工具，比起svn有着分布式的优势。太
 
 mybatis比hibernate更轻量级，mybatis支持原生sql查询，并且也可以使用bean映射，同时还可以自定义地配置映射对象，更加灵活，并且在多表查询上更有优势。
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Hibernate\345\205\245\351\227\250\347\273\217\345\205\270\344\270\216\346\263\250\350\247\243\345\274\217\345\274\200\345\217\221.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Hibernate\345\205\245\351\227\250\347\273\217\345\205\270\344\270\216\346\263\250\350\247\243\345\274\217\345\274\200\345\217\221.md"
new file mode 100644
index 0000000..76dfece
--- /dev/null
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Hibernate\345\205\245\351\227\250\347\273\217\345\205\270\344\270\216\346\263\250\350\247\243\345\274\217\345\274\200\345\217\221.md"
@@ -0,0 +1,1063 @@
+# 目录
+* [前言](#前言)
+* [ORM概述](#orm概述)
+* [测试](#测试)
+* [相关类](#相关类)
+* [扩展](#扩展)
+* [参考文章](#参考文章)
+
+
+本文转载自互联网，侵删
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+本系列文章将同步到我的个人博客：
+
+> www.how2playlife.com
+
+更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
+
+本文是《走进JavaWeb技术世界》系列博文的其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+
+该系列博文会告诉你如何从入门到进阶，从servlet到框架，从ssm再到SpringBoot，一步步地学习JavaWeb基础知识，并上手进行实战，接着了解JavaWeb项目中经常要使用的技术和组件，包括日志组件、Maven、Junit，等等内容，以便让你更完整地了解整个JavaWeb技术体系，形成自己的知识框架。为了更好地总结和检验你的学习成果，本系列文章也会提供每个知识点对应的面试题以及参考答案。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+**文末赠送8000G的Java架构师学习资料，需要的朋友可以到文末了解领取方式，资料包括Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源）**
+<!-- more -->
+
+## 前言
+
+本博文主要讲解介绍Hibernate框架，ORM的概念和Hibernate入门，相信你们看了就会使用Hibernate了!
+
+什么是Hibernate框架？
+Hibernate是一种ORM框架，全称为 Object_Relative DateBase-Mapping，在Java对象与关系数据库之间建立某种映射，以实现直接存取Java对象！
+
+为什么要使用Hibernate？
+既然Hibernate是关于Java对象和关系数据库之间的联系的话，也就是我们MVC中的数据持久层->在编写程序中的DAO层...
+
+首先，我们来回顾一下我们在DAO层写程序的历程吧：
+
+在DAO层操作XML，将数据封装到XML文件上，读写XML文件数据实现CRUD
+在DAO层使用原生JDBC连接数据库，实现CRUD
+嫌弃JDBC的ConnectionStatementResultSet等对象太繁琐，使用对原生JDBC的封装组件-->DbUtils组件
+我们来看看使用DbUtils之后，程序的代码是怎么样的：
+
+````
+public class CategoryDAOImpl implements zhongfucheng.dao.CategoryDao {
+
+    @Override
+    public void addCategory(Category category) {
+
+        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
+
+        String sql = "INSERT INTO category (id, name, description) VALUES(?,?,?)";
+        try {
+            queryRunner.update(sql, new Object[]{category.getId(), category.getName(), category.getDescription()});
+
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public Category findCategory(String id) {
+        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
+        String sql = "SELECT * FROM category WHERE id=?";
+
+        try {
+            Category category = (Category) queryRunner.query(sql, id, new BeanHandler(Category.class));
+
+            return category;
+
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+
+    }
+
+    @Override
+    public List<Category> getAllCategory() {
+        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
+        String sql = "SELECT * FROM category";
+
+        try {
+            List<Category> categories = (List<Category>) queryRunner.query(sql, new BeanListHandler(Category.class));
+
+            return categories;
+        } catch (SQLException e) {
+            throw  new RuntimeException(e);
+        }
+
+    }
+}
+````
+其实使用DbUtils时，DAO层中的代码编写是很有规律的。
+
+当插入数据的时候，就将JavaBean对象拆分，拼装成SQL语句
+当查询数据的时候，用SQL把数据库表中的列组合，拼装成JavaBean对象
+也就是说：javaBean对象和数据表中的列存在映射关系!如果程序能够自动生成SQL语句就好了....那么Hibernate就实现了这个功能！
+
+简单来说：我们使用Hibernate框架就不用我们写很多繁琐的SQL语句，从而简化我们的开发！
+
+
+## ORM概述
+
+在介绍Hibernate的时候，说了Hibernate是一种ORM的框架。那什么是ORM呢？ORM是一种思想
+
+O代表的是Objcet
+R代表的是Relative
+M代表的是Mapping
+ORM->对象关系映射....ORM关注是对象与数据库中的列的关系
+
+
+
+Hibernate快速入门
+学习一个框架无非就是三个步骤：
+
+引入jar开发包
+配置相关的XML文件
+熟悉API
+引入相关jar包
+我们使用的是Hibernate3.6的版本
+
+hibernate3.jar核心 + required 必须引入的(6个) + jpa 目录 + 数据库驱动包
+
+
+编写对象和对象映射
+编写一个User对象->User.java
+
+````
+public class User {
+
+    private int id;
+    private String username;
+    private String password;
+    private String cellphone;
+
+    //各种setter和getter
+}
+````
+编写对象映射->User.hbm.xml。一般它和JavaBean对象放在同一目录下
+
+我们是不知道该XML是怎么写的，可以搜索一下Hibernate文件夹中后缀为.hbm.xml。看看它们是怎么写的。然后复制一份过来
+
+````
+<?xml version="1.0"?>
+<!DOCTYPE hibernate-mapping PUBLIC 
+    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
+    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
+
+<!-- 
+
+  This mapping demonstrates content-based discrimination for the
+  table-per-hierarchy mapping strategy, using a formula
+  discriminator.
+
+-->
+
+<hibernate-mapping 
+    package="org.hibernate.test.array">
+
+    <class name="A" lazy="true" table="aaa">
+
+        <id name="id">
+            <generator class="native"/>
+        </id>
+
+
+
+
+            <key column="a_id"/>
+            <list-index column="idx"/>
+            <one-to-many class="B"/>
+
+
+
+
+    </class>
+
+    <class name="B" lazy="true" table="bbb">
+        <id name="id">
+            <generator class="native"/>
+        </id>
+    </class>
+
+</hibernate-mapping>
+````
+在上面的模板上修改～下面会具体讲解这个配置文件!
+````
+<!--在domain包下-->
+<hibernate-mapping package="zhongfucheng.domain">
+
+    <!--类名为User，表名也为User-->
+    <class name="User"  table="user">
+
+        <!--主键映射，属性名为id，列名也为id-->
+        <id name="id" column="id">
+            <!--根据底层数据库主键自动增长-->
+            <generator class="native"/>
+
+        </id>
+
+        <!--非主键映射，属性和列名一一对应-->
+        <property name="username" column="username"/>
+        <property name="cellphone" column="cellphone"/>
+        <property name="password" column="password"/>
+    </class>
+</hibernate-mapping>
+````
+如果使用Intellij Idea生成的Hibernate可以指定生成出主配置文件hibernate.cfg.xml，它是要放在src目录下的
+
+如果不是自动生成的，我们可以在Hibernate的hibernate-distribution-3.6.0.Final\project\etc这个目录下可以找到
+
+它长得这个样子：
+
+````
+<?xml version='1.0' encoding='utf-8'?>
+<!DOCTYPE hibernate-configuration PUBLIC
+        "-//Hibernate/Hibernate Configuration DTD//EN"
+        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
+<hibernate-configuration>
+    <session-factory>
+        <property name="connection.url."/>
+        <property name="connection.driver_class"/>
+        <property name="connection.username"/>
+        <property name="connection.password"/>
+        <!-- DB schema will be updated if needed -->
+        <!-- <property name="hbm2ddl.auto">update</property> -->
+    </session-factory>
+</hibernate-configuration>
+````
+通过上面的模板进行修改，后面会有对该配置文件进行讲解！
+
+````
+<hibernate-configuration>
+    <!-- 通常，一个session-factory节点代表一个数据库 -->
+    <session-factory>
+
+        <!-- 1\. 数据库连接配置 -->
+        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
+        <property name="hibernate.connection.url">jdbc:mysql:///zhongfucheng</property>
+        <property name="hibernate.connection.username">root</property>
+        <property name="hibernate.connection.password">root</property>
+        <!--
+            数据库方法配置， hibernate在运行的时候，会根据不同的方言生成符合当前数据库语法的sql
+         -->
+        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
+
+        <!-- 2\. 其他相关配置 -->
+        <!-- 2.1 显示hibernate在运行时候执行的sql语句 -->
+        <property name="hibernate.show_sql">true</property>
+        <!-- 2.2 格式化sql -->
+        <property name="hibernate.format_sql">true</property>
+        <!-- 2.3 自动建表  -->
+        <property name="hibernate.hbm2ddl.auto">create</property>
+
+        <!--3\. 加载所有映射-->
+        <mapping resource="zhongfucheng/domain/User.hbm.xml"/>
+
+    </session-factory>
+</hibernate-configuration>
+````
+## 测试
+````
+package zhongfucheng.domain;
+
+import org.hibernate.SessionFactory;
+import org.hibernate.Transaction;
+import org.hibernate.cfg.Configuration;
+import org.hibernate.classic.Session;
+
+/**
+ * Created by ozc on 2017/5/6.
+ */
+public class App {
+    public static void main(String[] args) {
+
+        //创建对象
+        User user = new User();
+        user.setPassword("123");
+        user.setCellphone("122222");
+        user.setUsername("nihao");
+
+        //获取加载配置管理类
+        Configuration configuration = new Configuration();
+
+        //不给参数就默认加载hibernate.cfg.xml文件，
+        configuration.configure();
+
+        //创建Session工厂对象
+        SessionFactory factory = configuration.buildSessionFactory();
+
+        //得到Session对象
+        Session session = factory.openSession();
+
+        //使用Hibernate操作数据库，都要开启事务,得到事务对象
+        Transaction transaction = session.getTransaction();
+
+        //开启事务
+        transaction.begin();
+
+        //把对象添加到数据库中
+        session.save(user);
+
+        //提交事务
+        transaction.commit();
+
+        //关闭Session
+        session.close();
+    }
+}
+````
+值得注意的是：JavaBean的主键类型只能是int类型，因为在映射关系中配置是自动增长的，String类型是不能自动增长的。如果是你设置了String类型，又使用了自动增长，那么就会报出下面的错误！
+
+
+    Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Table 'zhongfucheng.user' does
+
+执行完程序后，Hibernate就为我们创建对应的表，并把数据存进了数据库了
+
+我们看看快速入门案例的代码用到了什么对象吧，然后一个一个讲解
+
+````
+public static void main(String[] args) {
+
+    //创建对象
+    User user = new User();
+    user.setPassword("123");
+    user.setCellphone("122222");
+    user.setUsername("nihao");
+
+    //获取加载配置管理类
+    Configuration configuration = new Configuration();
+
+    //不给参数就默认加载hibernate.cfg.xml文件，
+    configuration.configure();
+
+    //创建Session工厂对象
+    SessionFactory factory = configuration.buildSessionFactory();
+
+    //得到Session对象
+    Session session = factory.openSession();
+
+    //使用Hibernate操作数据库，都要开启事务,得到事务对象
+    Transaction transaction = session.getTransaction();
+
+    //开启事务
+    transaction.begin();
+
+    //把对象添加到数据库中
+    session.save(user);
+
+    //提交事务
+    transaction.commit();
+
+    //关闭Session
+    session.close();
+}
+````
+## 相关类
+
+Configuration
+配置管理类：主要管理配置文件的一个类
+
+它拥有一个子类AnnotationConfiguration，也就是说：我们可以使用注解来代替XML配置文件来配置相对应的信息
+
+
+configure方法
+configure()方法用于加载配置文件
+
+加载主配置文件的方法
+
+如果指定参数，那么加载参数的路径配置文件
+如果不指定参数，默认加载src/目录下的hibernate.cfg.xml
+
+buildSessionFactory方法
+buildSessionFactory()用于创建Session工厂
+
+
+SessionFactory
+SessionFactory-->Session的工厂，也可以说代表了hibernate.cfg.xml这个文件...hibernate.cfg.xml的就有<session-factory>这么一个节点
+
+openSession方法
+创建一个Session对象
+
+getCurrentSession方法
+创建Session对象或取出Session对象
+
+Session
+Session是Hibernate最重要的对象，Session维护了一个连接（Connection），只要使用Hibernate操作数据库，都需要用到Session对象
+
+通常我们在DAO层中都会有以下的方法，Session也为我们提供了对应的方法来实现！
+
+````
+public interface IEmployeeDao {
+
+    void save(Employee emp);
+    void update(Employee emp);
+    Employee findById(Serializable id);
+    List<Employee> getAll();
+    List<Employee> getAll(String employeeName);
+    List<Employee> getAll(int index, int count);
+    void delete(Serializable id);
+
+}
+````
+更新操作
+
+我们在快速入门中使用到了save(Objcet o)方法，调用了这个方法就把对象保存在数据库之中了。Session对象还提供着其他的方法来进行对数据库的更新
+
+session.save(obj); 【保存一个对象】
+session.update(obj); 【更新一个对象】
+session.saveOrUpdate(obj); 【保存或者更新的方法】
+
+没有设置主键，执行保存；
+有设置主键，执行更新操作;
+如果设置主键不存在报错！
+我们来使用一下update()方法吧....既然是更新操作了，那么肯定需要设置主键的，不设置主键，数据库怎么知道你要更新什么。将id为1的记录修改成如下：
+````
+user.setId(1);
+user.setPassword("qwer");
+user.setCellphone("1111");
+user.setUsername("zhongfucheng");
+````
+主键查询
+
+通过主键来查询数据库的记录，从而返回一个JavaBean对象
+
+session.get(javaBean.class, int id); 【传入对应的class和id就可以查询】
+session.load(javaBean.class, int id); 【支持懒加载】
+User重写toString()来看一下效果：
+
+````
+User user1 = (User) session.get(User.class, 1);
+System.out.println(user1);
+````
+HQL查询
+
+HQL:hibernate query language 即hibernate提供的面向对象的查询语言
+
+查询的是对象以及对象的属性【它查询的是对象以及属性，因此是区分大小写的！】。
+
+    SQL：Struct query language 结构化查询语言
+
+查询的是表以及列【不区分大小写】
+HQL是面向对象的查询语言，可以用来查询全部的数据！
+
+````
+Query query = session.createQuery("FROM User");
+
+List list = query.list();
+System.out.println(list);
+````
+当然啦，它也可以传递参数进去查询
+
+````
+Query query = session.createQuery("FROM User WHERE id=?");
+
+//这里的？号是从0开始的，并不像JDBC从1开始的！
+query.setParameter(0, user.getId());
+
+List list = query.list();
+System.out.println(list);
+````
+
+
+QBC查询
+
+QBC查询: query by criteria 完全面向对象的查询
+
+从上面的HQL查询，我们就可以发现：HQL查询是需要SQL的基础的，因为还是要写少部分的SQL代码....QBC查询就是完全的面向对象查询...但是呢，我们用得比较少
+
+我们来看一下怎么使用吧：
+
+````
+//创建关于user对象的criteria对象
+Criteria criteria = session.createCriteria(User.class);
+
+//添加条件
+criteria.add(Restrictions.eq("id", 1));
+
+//查询全部数据
+List list = criteria.list();
+System.out.println(list);
+````
+
+本地SQL查询
+
+有的时候，如果SQL是非常复杂的，我们不能靠HQL查询来实现功能的话，我们就需要使用原生的SQL来进行复杂查询了！
+
+但是呢，它有一个缺陷：它是不能跨平台的...因此我们在主配置文件中已经配置了数据库的“方言“了。
+
+我们来简单使用一下把：
+
+````
+//将所有的记录封装成User对象存进List集合中
+SQLQuery sqlQuery = session.createSQLQuery("SELECT * FROM user").addEntity(User.class);
+
+List list = sqlQuery.list();
+
+System.out.println(list);
+````
+beginTransaction方法
+
+开启事务，返回的是一个事务对象....Hibernate规定所有的数据库操作都必须在事务环境下进行，否则报错！
+
+
+
+Hibernate注解开发
+
+在Hibernate中我们一般都会使用注解，这样可以帮助我们大大简化hbm映射文件的配置。下面我就来为大家详细介绍。
+
+PO类注解配置
+
+首先肯定是搭建好Hibernate的开发环境啦，我在此也不过多赘述，读者自行实践。接着在src目录下创建一个cn.itheima.domain包，并在该包下创建一个Book实体类，由于Book实体类中写有注解配置，所以就不用编写那个映射配置文件啦！
+````
+@Entity // 定义了一个实体
+@Table(name="t_book",catalog="hibernateTest")
+public class Book {
+    
+    @Id // 这表示一个主键
+    // @GeneratedValue 相当于native主键生成策略
+    @GeneratedValue(strategy=GenerationType.IDENTITY) // 相当于identity主键生成策略
+    private Integer id; // 主键
+    
+    @Column(name="c_name", length=30, nullable=true)
+    private String name;
+    
+    @Temporal(TemporalType.TIMESTAMP) // 是用来定义日期类型
+    private Date publicationDate; // 出版日期
+    
+    @Type(type="double") // 允许你去指定Hibernate里面的一些类型
+    private Double price; // 价格，如果没有添加注解，也会自动的生成在表中
+    
+    public Integer getId() {
+        return id;
+    }
+    public void setId(Integer id) {
+        this.id = id;
+    }
+    public String getName() {
+        return name;
+    }
+    public void setName(String name) {
+        this.name = name;
+    }
+    public Date getPublicationDate() {
+        return publicationDate;
+    }
+    public void setPublicationDate(Date publicationDate) {
+        this.publicationDate = publicationDate;
+    }
+    public Double getPrice() {
+        return price;
+    }
+    public void setPrice(Double price) {
+        this.price = price;
+    }
+
+}
+````
+下面我就来详细说一下Book实体类中的注解。
+````
+    @Entity：声明一个实体。
+    @Table：来描述类与表之间的对应关系。
+    
+    @Entity // 定义了一个实体
+    @Table(name="t_book",catalog="hibernateTest")
+    public class Book {
+        ......
+    }
+    
+    @id：声明一个主键。
+    @GeneratedValue：用它来声明一个主键生成策略。默认情况是native主键生成策略。可以选择的主键生成策略有：AUTO、IDENTITY、SEQUENCE
+    
+    @Id // 这表示一个主键
+    // @GeneratedValue 相当于native主键生成策略
+    @GeneratedValue(strategy=GenerationType.IDENTITY) // 相当于identity主键生成策略
+    private Integer id; // 主键
+    
+    @Column：定义列。
+    
+    @Column(name="c_name", length=30, nullable=true)
+    private String name;
+````
+**注意：对于PO类中所有属性，如果你不写注解，默认情况下也会在表中生成对应的列，列的名称就是属性的名称，列的类型也即属性的类型**。
+@Temporal：声明日期类型。
+
+````
+    @Temporal(TemporalType.TIMESTAMP) // 是用来定义日期类型
+    private Date publicationDate; // 出版日期
+````
+日期类型可以选择的有：
+````
+    *   TemporalType.DATA：只有年月日。
+    *   TemporalType.TIME：只有小时分钟秒。
+    *   TemporalType.TIMESTAMP：有年月日小时分钟秒。
+    @Type：可允许你去指定Hibernate里面的一些类型。
+    
+    @Type(type="double") // 允许你去指定Hibernate里面的一些类型
+    private Double price; // 价格，如果没有添加注解，也会自动的生成在表中
+````
+最后我们在src目录下创建一个cn.itheima.test包，在该包下编写一个HibernateAnnotationTest单元测试类，并在该类中编写一个用于测试PO类的注解开发的方法：
+````
+public class HibernateAnnotationTest {
+
+    // 测试PO的注解开发
+    @Test
+    public void test1() {
+        Session session = HibernateUtils.openSession();
+        session.beginTransaction();
+
+        Book b = new Book();
+        b.setName("情书");
+        b.setPrice(56.78);
+        b.setPublicationDate(new Date());
+
+        session.save(b);
+
+        session.getTransaction().commit();
+        session.close();
+    }
+
+}
+````
+现在来思考两个问题：
+
+如果主键生成策略我们想使用UUID类型呢？
+如何设定类的属性不在表中映射？
+这两个问题我们一起解决。废话不多说，直接上例子。在cn.itheima.domain包下再编写一个Person实体类，同样使用注解配置。
+````
+@Entity
+@Table(name="t_person", catalog="hibernateTest")
+public class Person {
+
+    // 生成UUID的主键生成策略
+    @Id
+    @GenericGenerator(name="myuuid", strategy="uuid") // 声明一种主键生成策略(uuid)
+    @GeneratedValue(generator="myuuid") // 引用uuid主键生成策略
+    private String id;
+
+    @Type(type="string") // 允许你去指定Hibernate里面的一些类型
+    private String name;
+
+    @Transient
+    private String msg; // 现在这个属性不想生成在表中
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getMsg() {
+        return msg;
+    }
+
+    public void setMsg(String msg) {
+        this.msg = msg;
+    }
+
+}
+
+````
+
+最后在HibernateAnnotationTest单元测试类中编写如下一个方法：
+````
+public class HibernateAnnotationTest {
+
+    // 测试uuid的主键生成策略及不生成表中映射
+    @Test
+    public void test2() {
+        Session session = HibernateUtils.openSession();
+        session.beginTransaction();
+
+        Person p = new Person();
+        p.setName("李四");
+        p.setMsg("这是一个好人");
+
+        session.save(p);
+
+        session.getTransaction().commit();
+        session.close();
+    }
+
+}
+````
+至此，两个问题就解决了。
+注意：对于我们以上讲解的关于属性配置的注解，我们也可以在其对应的getXxx方法去使用。
+
+Hibernate关联映射——一对多（多对一）
+仍以客户(Customer)和订单(Order)为例来开始我的表演。
+在src目录下创建一个cn.itheima.oneToMany包，并在该包编写这两个实体类：
+
+客户(Customer)类
+
+````
+// 客户 ---- 一的一方
+@Entity
+@Table(name="t_customer")
+public class Customer {
+
+@Id
+@GeneratedValue(strategy=GenerationType.IDENTITY)
+private Integer id; // 主键
+private String name; // 姓名
+
+// 描述客户可以有多个订单
+/*
+ * targetEntity="..."：相当于<one-to-many >
+ */
+@OneToMany(targetEntity=Order.class,mappedBy="c")
+private Set<Order> orders = new HashSet<Order>();
+
+public Set<Order> getOrders() {
+    return orders;
+}
+public void setOrders(Set<Order> orders) {
+    this.orders = orders;
+}
+public Integer getId() {
+    return id;
+}
+public void setId(Integer id) {
+    this.id = id;
+}
+public String getName() {
+    return name;
+}
+public void setName(String name) {
+    this.name = name;
+}
+
+}
+
+
+
+
+订单(Order)类
+
+// 订单 ---- 多的一方
+@Entity
+@Table(name="t_order")
+public class Order {
+
+@Id
+@GeneratedValue(strategy=GenerationType.IDENTITY)
+private Integer id;
+private Double money;
+private String receiverInfo; // 收货地址
+
+// 订单与客户关联
+@ManyToOne(targetEntity=Customer.class)
+@JoinColumn(name="c_customer_id") // 指定外键列
+private Customer c; // 描述订单属于某一个客户
+
+public Customer getC() {
+    return c;
+}
+public void setC(Customer c) {
+    this.c = c;
+}
+public Integer getId() {
+    return id;
+}
+public void setId(Integer id) {
+    this.id = id;
+}
+public Double getMoney() {
+    return money;
+}
+public void setMoney(Double money) {
+    this.money = money;
+}
+public String getReceiverInfo() {
+    return receiverInfo;
+}
+public void setReceiverInfo(String receiverInfo) {
+    this.receiverInfo = receiverInfo;
+}
+
+}
+````
+
+这儿用到了`@OneToMany`和`@ManyToOne`这两个注解。
+以上两个实体类编写好之后，可以很明显的看出我们不需要写它们对应的映射配置文件了，是不是很爽呢！接下来，我就要编写测试程序测试一下了。现在我的需求是保存客户时，顺便保存订单，对于这种情况我们需要在Customer类中配置cascade操作，即配置cascade="save-update"，配置的方式有两种，下面我细细说来：
+
+第一种方式，可以使用JPA提供的注解。
+那么@OneToMany注解就应修改为：
+````
+@OneToMany(targetEntity=Order.class,mappedBy="c",cascade=CascadeType.ALL)
+private Set<Order> orders = new HashSet<Order>();
+````
+第二种方式，可以使用Hibernate提供的注解。
+那么@OneToMany注解就应修改为：
+````
+@OneToMany(targetEntity=Order.class,mappedBy="c")
+@Cascade(CascadeType.SAVE_UPDATE)
+private Set<Order> orders = new HashSet<Order>();
+````
+两种方式都可以，口味任君选择，不过我倾向于第二种方式。
+接下来在HibernateAnnotationTest单元测试类中编写如下方法进行测试：
+````
+public class HibernateAnnotationTest {
+
+    // 测试one-to-many注解操作(保存客户时级联保存订单)
+    @Test
+    public void test3() {
+        Session session = HibernateUtils.openSession();
+        session.beginTransaction();
+
+        // 1.创建一个客户
+        Customer c = new Customer();
+        c.setName("叶子");
+
+        // 2.创建两个订单
+        Order o1 = new Order();
+        o1.setMoney(1000d);
+        o1.setReceiverInfo("武汉");
+        Order o2 = new Order();
+        o2.setMoney(2000d);
+        o2.setReceiverInfo("天门");
+
+        // 3.建立关系
+        c.getOrders().add(o1);
+        c.getOrders().add(o2);
+
+        // 4.保存客户，并级联保存订单
+        session.save(c);
+
+        session.getTransaction().commit();
+        session.close();
+    }
+
+}
+````
+这时运行以上方法，会发现虽然客户表的那条记录插进去了，但是订单表就变成这个鬼样了：
+
+订单表中没有关联客户的id，这是为什么呢？原因是我们在Customer类中配置了mappedBy=”c”，它代表的是外键的维护由Order方来维护，而Customer不维护，这时你在保存客户时，级联保存订单，是可以的，但是不能维护外键，所以，我们必须在代码中添加订单与客户之间的关系。所以须将test3方法修改为：
+````
+public class HibernateAnnotationTest {
+
+    // 测试one-to-many注解操作(保存客户时级联保存订单)
+    @Test
+    public void test3() {
+        Session session = HibernateUtils.openSession();
+        session.beginTransaction();
+
+        // 1.创建一个客户
+        Customer c = new Customer();
+        c.setName("叶子");
+
+        // 2.创建两个订单
+        Order o1 = new Order();
+        o1.setMoney(1000d);
+        o1.setReceiverInfo("武汉");
+        Order o2 = new Order();
+        o2.setMoney(2000d);
+        o2.setReceiverInfo("天门");
+
+        // 3.建立关系
+        // 原因：是为了维护外键，不然的话，外键就不能正确的生成！！！
+        o1.setC(c);
+        o2.setC(c);
+
+        // 原因：是为了进行级联操作
+        c.getOrders().add(o1);
+        c.getOrders().add(o2);
+
+        // 4.保存客户，并级联保存订单
+        session.save(c);
+
+        session.getTransaction().commit();
+        session.close();
+    }
+
+}
+````
+这时再测试，就没有任何问题啦！
+
+## 扩展
+
+Hibernate注解@Cascade中的DELETE_ORPHAN已经过时了，如下：
+
+可使用下面方案来替换过时方案：
+
+Hibernate关联映射——多对多
+以学生与老师为例开始我的表演，我是使用注解完成这种多对多的配置。使用@ManyToMany注解来配置多对多，只需要在一端配置中间表，另一端使用mappedBy表示放置外键的维护权。
+在src目录下创建一个cn.itheima.manyToMany包，并在该包编写这两个实体类：
+
+学生类
+````
+@Entity
+@Table(name="t_student")
+public class Student {
+
+    @Id
+    @GeneratedValue(strategy=GenerationType.IDENTITY)
+    private Integer id;
+
+    private String name;
+
+    @ManyToMany(targetEntity=Teacher.class)
+    // @JoinTable：使用@JoinTable来描述中间表，并描述中间表中外键与Student、Teacher的映射关系
+    // joinColumns：它是用来描述Student与中间表的映射关系
+    // inverseJoinColumns：它是用来描述Teacher与中间表的映射关系
+    @JoinTable(name="s_t", joinColumns={@JoinColumn(name="c_student_id",referencedColumnName="id")}, inverseJoinColumns={@JoinColumn(name="c_teacher_id")}) 
+    private Set<Teacher> teachers = new HashSet<Teacher>();
+
+    public Integer getId() {
+        return id;
+    }
+    public void setId(Integer id) {
+        this.id = id;
+    }
+    public String getName() {
+        return name;
+    }
+    public void setName(String name) {
+        this.name = name;
+    }
+    public Set<Teacher> getTeachers() {
+        return teachers;
+    }
+    public void setTeachers(Set<Teacher> teachers) {
+        this.teachers = teachers;
+    }
+
+}
+````
+老师类
+````
+@Entity
+@Table(name="t_teacher")
+public class Teacher {
+
+    @Id
+    @GeneratedValue(strategy=GenerationType.IDENTITY)
+    private Integer id;
+
+    private String name;
+
+    @ManyToMany(targetEntity=Student.class, mappedBy="teachers") // 代表由对方来维护外键
+    private Set<Student> students = new HashSet<Student>();
+
+    public Integer getId() {
+        return id;
+    }
+    public void setId(Integer id) {
+        this.id = id;
+    }
+    public String getName() {
+        return name;
+    }
+    public void setName(String name) {
+        this.name = name;
+    }
+    public Set<Student> getStudents() {
+        return students;
+    }
+    public void setStudents(Set<Student> students) {
+        this.students = students;
+    }
+
+}
+````
+接下来，我就要编写测试程序测试一下了。 从上面可看出我们将外键的维护权利交由Student类来维护，现在我们演示保存学生时，将老师也级联保存，对于这种情况我们需要在Student类中配置cascade操作，即配置cascade=”save-update”，如下：
+````
+    @JoinTable(name="s_t", joinColumns={@JoinColumn(name="c_student_id",referencedColumnName="id")}, inverseJoinColumns={@JoinColumn(name="c_teacher_id")}) 
+    @Cascade(CascadeType.SAVE_UPDATE)
+    private Set<Teacher> teachers = new HashSet<Teacher>();
+````
+接下来在HibernateAnnotationTest单元测试类中编写如下方法进行测试：
+````
+    public class HibernateAnnotationTest {
+    
+        // 测试多对多级联保存(保存学生时同时保存老师)
+        @Test
+        public void test4() {
+            Session session = HibernateUtils.openSession();
+            session.beginTransaction();
+    
+            // 1.创建两个老师
+            Teacher t1 = new Teacher();
+            t1.setName("Tom");
+    
+            Teacher t2 = new Teacher();
+            t2.setName("Fox");
+    
+            // 2.创建两个学生
+            Student s1 = new Student();
+            s1.setName("张丹");
+    
+            Student s2 = new Student();
+            s2.setName("叶紫");
+    
+            // 3.学生关联老师
+            s1.getTeachers().add(t1);
+            s1.getTeachers().add(t2);
+    
+            s2.getTeachers().add(t1);
+            s2.getTeachers().add(t2);
+    
+            // 保存学生同时保存老师
+            session.save(s1);
+            session.save(s2);
+    
+            session.getTransaction().commit();
+            session.close();
+        }
+    
+    }
+````
+运行以上方法，一切正常。
+接着我们测试级联删除操作。见下图：
+这里写图片描述
+
+可在HibernateAnnotationTest单元测试类中编写如下方法进行测试：
+````
+    public class HibernateAnnotationTest {
+    
+        // 测试多对多级联删除(前提是建立了双向的级联)
+        @Test
+        public void test5() {
+            Session session = HibernateUtils.openSession();
+            session.beginTransaction();
+    
+            Student s = session.get(Student.class, 1);
+            session.delete(s);
+    
+            session.getTransaction().commit();
+            session.close();
+        }
+    
+    }
+````
+## 参考文章
+
+<https://segmentfault.com/a/1190000009707894>
+
+<https://www.cnblogs.com/hysum/p/7100874.html>
+
+<http://c.biancheng.net/view/939.html>
+
+<https://www.runoob.com/>
+
+https://blog.csdn.net/android_hl/article/details/53228348
+
+
+
+                     
\ No newline at end of file
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2143\357\274\232JDBC\347\232\204\350\277\233\345\214\226\344\270\216\350\277\236\346\216\245\346\261\240\346\212\200\346\234\257.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232JDBC\347\232\204\350\277\233\345\214\226\344\270\216\350\277\236\346\216\245\346\261\240\346\212\200\346\234\257.md"
similarity index 69%
rename from "docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2143\357\274\232JDBC\347\232\204\350\277\233\345\214\226\344\270\216\350\277\236\346\216\245\346\261\240\346\212\200\346\234\257.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232JDBC\347\232\204\350\277\233\345\214\226\344\270\216\350\277\236\346\216\245\346\261\240\346\212\200\346\234\257.md"
index 898f592..1071b29 100644
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2143\357\274\232JDBC\347\232\204\350\277\233\345\214\226\344\270\216\350\277\236\346\216\245\346\261\240\346\212\200\346\234\257.md"
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232JDBC\347\232\204\350\277\233\345\214\226\344\270\216\350\277\236\346\216\245\346\261\240\346\212\200\346\234\257.md"
@@ -1,8 +1,7 @@
-# Table of Contents
-
+# 目录
 * [JDBC数据库连接池](#jdbc数据库连接池)
   * [谈谈连接池、线程池技术原理](#谈谈连接池、线程池技术原理)
-* [JDBC 数据库连接池 ](#jdbc-数据库连接池 )
+* [JDBC 数据库连接池](#jdbc-数据库连接池)
     * [什么情况下使用连接池?](#什么情况下使用连接池)
     * [使用连接池的好处](#使用连接池的好处)
     * [连接池的实现](#连接池的实现)
@@ -43,35 +42,35 @@
 
 做互联网研发，最早接触使用jdbc技术，为了数据库连接能够复用，会用到c3p0、dbcp等数据库连接池。应该是研发人员最早接触的数据库连接池，再到httpclient http连接池，再到微服务netty连接池，redis客户端连接池，以及jdk中线程池技术。
 
-       这么多数据库、http、netty连接池，jdk线程池，本质上都是连接池技术，连接池技术核心是连接或者说创建的资源复用。
+   这么多数据库、http、netty连接池，jdk线程池，本质上都是连接池技术，连接池技术核心是连接或者说创建的资源复用。
 
-       连接池技术核心：通过减少对于连接创建、关闭来提升性能。用于用户后续使用，好处是后续使用不用在创建连接以及线程，因为这些都需要相关很多文件、连接资源、操作系统内核资源支持来完成构建，会消耗大量资源，并且创建、关闭会消耗应用程序大量性能。
+   连接池技术核心：通过减少对于连接创建、关闭来提升性能。用于用户后续使用，好处是后续使用不用在创建连接以及线程，因为这些都需要相关很多文件、连接资源、操作系统内核资源支持来完成构建，会消耗大量资源，并且创建、关闭会消耗应用程序大量性能。
 
-       网络连接本身会消耗大量内核资源，在linux系统下，网络连接创建本身tcp/ip协议栈在内核里面，连接创建关闭会消耗大量文件句柄（linux中万物皆文件，一种厉害抽象手段）系统资源。当下更多是应用tcp技术完成网络传输，反复打开关闭，需要操作系统维护大量tcp协议栈状态。
+   网络连接本身会消耗大量内核资源，在linux系统下，网络连接创建本身tcp/ip协议栈在内核里面，连接创建关闭会消耗大量文件句柄（linux中万物皆文件，一种厉害抽象手段）系统资源。当下更多是应用tcp技术完成网络传输，反复打开关闭，需要操作系统维护大量tcp协议栈状态。
 
-       连接池本质上是构建一个容器，容器来存储创建好的线程、http连接、数据库连接、netty连接等。对于使用方相当于黑盒，按照接口进行使用就可以了。各个连接池构建、使用管理详细过程大概分成以下三部分。
+   连接池本质上是构建一个容器，容器来存储创建好的线程、http连接、数据库连接、netty连接等。对于使用方相当于黑盒，按照接口进行使用就可以了。各个连接池构建、使用管理详细过程大概分成以下三部分。
 
-       第一部分：首先初始化连接池，根据设置相应参数，连接池大小、核心线程数、核心连接数等参数，初始化创建数据库、http、netty连接以及jdk线程。
+   第一部分：首先初始化连接池，根据设置相应参数，连接池大小、核心线程数、核心连接数等参数，初始化创建数据库、http、netty连接以及jdk线程。
 
-       第二部分：连接池使用，前边初始化好的连接池、线程池，直接从连接池、线程中取出资源即可进行使用，使用完后要记得交还连接池、线程池，通过池容器来对资源进行管理。
+   第二部分：连接池使用，前边初始化好的连接池、线程池，直接从连接池、线程中取出资源即可进行使用，使用完后要记得交还连接池、线程池，通过池容器来对资源进行管理。
 
-       第三部分：对于连接池维护，连接池、线程池来维护连接、线程状态，不可用连接、线程进行销毁，正在使用连接、线程进行状态标注，连接、线程不够后并且少于设置最大连接、线程数，要进行新连接、线程创建。
+   第三部分：对于连接池维护，连接池、线程池来维护连接、线程状态，不可用连接、线程进行销毁，正在使用连接、线程进行状态标注，连接、线程不够后并且少于设置最大连接、线程数，要进行新连接、线程创建。
 
-       通过上边可以了解到各种连接池技术以及线程池原理或者说套路，理解原理才能不被纷繁复杂表象掩盖。
+   通过上边可以了解到各种连接池技术以及线程池原理或者说套路，理解原理才能不被纷繁复杂表象掩盖。
 
-       下面谈谈构建自己连接池，其实理解了连接池、线程原理，可以使用ArrayList来构建自己连接池、线程池。初始化时创建配置连接数、线程，存储在ArrayList容器中，使用时从ArrayList从取出连接、线程进行使用，执行完任务后，提交回ArrayList容器。前提条件是单线程，在多线程状态下要用线程安全容器。
+   下面谈谈构建自己连接池，其实理解了连接池、线程原理，可以使用ArrayList来构建自己连接池、线程池。初始化时创建配置连接数、线程，存储在ArrayList容器中，使用时从ArrayList从取出连接、线程进行使用，执行完任务后，提交回ArrayList容器。前提条件是单线程，在多线程状态下要用线程安全容器。
 
-       前边根据原理介绍了一个简单连接池、线程池怎样构建，实际工业级别线程池还要考虑到连接状态，短连接重连，线程池维护管理高效，线程池稳定等多个因素。
+   前边根据原理介绍了一个简单连接池、线程池怎样构建，实际工业级别线程池还要考虑到连接状态，短连接重连，线程池维护管理高效，线程池稳定等多个因素。
 
-       需要用到连接池而又没有相关开源产品可用时，java连接池可以使用common-pool2来构建，比如google开源gRPC技术，本身是高性能跨平台技术，但目前作为微服务使用，没有连接池、负载均衡等相应配套，这时可以根据需要自己基于Java容器构建自己连接池。也可以利用common-pool2构建连接池来提升应用性能，以及保持高可用。common-pool2本身不仅仅可以构建连接池使用，还可以用来构建对象池。
+   需要用到连接池而又没有相关开源产品可用时，java连接池可以使用common-pool2来构建，比如google开源gRPC技术，本身是高性能跨平台技术，但目前作为微服务使用，没有连接池、负载均衡等相应配套，这时可以根据需要自己基于Java容器构建自己连接池。也可以利用common-pool2构建连接池来提升应用性能，以及保持高可用。common-pool2本身不仅仅可以构建连接池使用，还可以用来构建对象池。
 
-       连接池还有一个副作用就是实现了高可用，在微服务场景下一个连接不可用，那么再从netty连接池中取出一个进行使用，避免了连接不可用问题。
+   连接池还有一个副作用就是实现了高可用，在微服务场景下一个连接不可用，那么再从netty连接池中取出一个进行使用，避免了连接不可用问题。
 
-       掌握原理从比较全面掌握各种池技术，避免数据库连接池，再到httpclient http连接池，再到微服务netty连接池，redis客户端连接池，以及jdk中线程池，对象池各种各样池技术，使我们眼花缭乱，花费过多时间，掌握原理机制以不变应万变。
+   掌握原理从比较全面掌握各种池技术，避免数据库连接池，再到httpclient http连接池，再到微服务netty连接池，redis客户端连接池，以及jdk中线程池，对象池各种各样池技术，使我们眼花缭乱，花费过多时间，掌握原理机制以不变应万变。
 
-       推广一下这个方法，其他技术也是类似，深入掌握其原理，就可以明白其他类似技术相似原理，避免疲于应对各种新技术。但每一种架构设计与实现又与领域有着关系，也不可讲原理不顾实际情况扩展。理论与架构设计、源码学习相结合才是最好的，希望有帮助。
+   推广一下这个方法，其他技术也是类似，深入掌握其原理，就可以明白其他类似技术相似原理，避免疲于应对各种新技术。但每一种架构设计与实现又与领域有着关系，也不可讲原理不顾实际情况扩展。理论与架构设计、源码学习相结合才是最好的，希望有帮助。
 
-# JDBC 数据库连接池 
+# JDBC 数据库连接池
 
 转自：
 
@@ -132,11 +131,10 @@ Java 中有一个 DataSource 接口, 数据库连接池就是 DataSource 的一
 
 　　数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。
 
-![](https://images2017.cnblogs.com/blog/1268854/201802/1268854-20180206120921810-2114372389.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151824.png)
 ### 　　数据库连接池工作原理：
 
-![](https://images2017.cnblogs.com/blog/1268854/201802/1268854-20180206121141185-2090100662.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151846.png)
 
 ### 　　数据库连接池技术的优点
 
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2142\357\274\232JSP\344\270\216Servlet\347\232\204\346\233\276\347\273\217\344\270\216\347\216\260\345\234\250.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232JSP\344\270\216Servlet\347\232\204\346\233\276\347\273\217\344\270\216\347\216\260\345\234\250.md"
similarity index 90%
rename from "docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2142\357\274\232JSP\344\270\216Servlet\347\232\204\346\233\276\347\273\217\344\270\216\347\216\260\345\234\250.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232JSP\344\270\216Servlet\347\232\204\346\233\276\347\273\217\344\270\216\347\216\260\345\234\250.md"
index e396253..10d7b96 100644
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2142\357\274\232JSP\344\270\216Servlet\347\232\204\346\233\276\347\273\217\344\270\216\347\216\260\345\234\250.md"
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232JSP\344\270\216Servlet\347\232\204\346\233\276\347\273\217\344\270\216\347\216\260\345\234\250.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [servlet和jsp的区别](#servlet和jsp的区别)
   * [servlet和jsp各自的特点](#servlet和jsp各自的特点)
   * [通过MVC双剑合璧](#通过mvc双剑合璧)
@@ -8,7 +7,7 @@
     * [二、Servlet的生命周期](#二、servlet的生命周期)
       * [init() 方法](#init-方法)
       * [service() 方法](#service-方法)
-      * [ destroy() 方法](# destroy-方法)
+      * [destroy() 方法](#destroy-方法)
   * [相关面试题](#相关面试题)
     * [怎样理解Servlet的单实例多线程？**](#怎样理解servlet的单实例多线程？)
     * [JSP的中存在的多线程问题：](#jsp的中存在的多线程问题：)
@@ -66,7 +65,7 @@ Model——业务功能编写（例如算法实现）、数据库设计以及数
 
 在JSP/Servlet开发的软件系统中，这三个部分的描述如下所示：
 
-![229cf9ff5b1729eaf408fac56238eeb3_hd](https://atts.w3cschool.cn/attachments/image/20180428/1524895758222687.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151458.png)
 
 1、Web浏览器发送HTTP请求到服务端，然后被Controller(Servlet)获取并进行处理（例如参数解析、请求转发）
 
@@ -82,11 +81,11 @@ MVC模式在Web开发中有很大的优势，它完美规避了JSP与Servlet各
 
 ### 一、Servlet 是什么？
 
-[Java ](http://lib.csdn.net/base/java "Java 知识库")Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的[数据库](http://lib.csdn.net/base/mysql "MySQL知识库")或应用程序之间的中间层。
+[Java](http://lib.csdn.net/base/java "Java 知识库")Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的[数据库](http://lib.csdn.net/base/mysql "MySQL知识库")或应用程序之间的中间层。
 
 使用 Servlet，您可以收集来自网页表单的用户输入，呈现来自数据库或者其他源的记录，还可以动态创建网页。
 
-[Java](http://lib.csdn.net/base/javase "Java SE知识库") Servlet 通常情况下与使用 CGI（Common Gateway Interface，公共网关接口）实现的程序可以达到异曲同工的效果。但是相比于 CGI，Servlet 有以下几点优势：
+[Java](http://lib.csdn.net/base/javase "Java SE知识库")Servlet 通常情况下与使用 CGI（Common Gateway Interface，公共网关接口）实现的程序可以达到异曲同工的效果。但是相比于 CGI，Servlet 有以下几点优势：
 
 *   **1、性能明显更好。**
 *   **2、Servlet 在 Web 服务器的地址空间内执行。这样它就没有必要再创建一个单独的进程来处理每个客户端请求。**
@@ -96,13 +95,11 @@ MVC模式在Web开发中有很大的优势，它完美规避了JSP与Servlet各
 
 ### 二、Servlet的生命周期
 
-
-
 Servlet 生命周期可被定义为从创建直到毁灭的整个过程。以下是 Servlet 遵循的过程：
 
-*   **1、Servlet 通过调用 init () 方法进行初始化。**
-*   **2、Servlet 调用 service() 方法来处理客户端的请求。**
-*   **3、Servlet 通过调用 destroy() 方法终止（结束）。**
+*   **1、Servlet 通过调用init ()方法进行初始化。**
+*   **2、Servlet 调用service()方法来处理客户端的请求。**
+*   **3、Servlet 通过调用destroy()方法终止（结束）。**
 *   **4、最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。**
 
 #### init() 方法
@@ -117,21 +114,19 @@ service() 方法是执行实际任务的主要方法。Servlet 容器（即 Web
 
 每次服务器接收到一个 Servlet 请求时，服务器会产生一个新的线程并调用服务。service() 方法检查 HTTP 请求类型（GET、POST、PUT、DELETE 等），并在适当的时候调用 doGet、doPost、doPut，doDelete 等方法。
 
-####  destroy() 方法
+#### destroy() 方法
 
 destroy() 方法只会被调用一次，在 Servlet 生命周期结束时被调用。destroy() 方法可以让您的 Servlet 关闭数据库连接、停止后台线程、把 Cookie 列表或点击计数器写入到磁盘，并执行其他类似的清理活动。
 
 在调用 destroy() 方法之后，servlet 对象被标记为垃圾回收。
 
-![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif) 示例
-
 执行后：
 
-![](https://images2015.cnblogs.com/blog/920105/201705/920105-20170514031238707-1640484760.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151559.png)
 
 以后继续请求时：
 
-![](https://images2015.cnblogs.com/blog/920105/201705/920105-20170514031335051-175078972.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151623.png)
 
 可见，就绪请求时只有service()方法执行！
 ## 相关面试题
@@ -169,7 +164,7 @@ Servlet采用多线程来处理多个请求同时访问。servlet依赖于一个
 
 当这个线程正在执行的时候,容器收到另外一个请求,调度线程同样从线程池中选出另一个工作者线程来服务新的请求,容器并不关心这个请求是否访问的是同一个Servlet.当容器同时收到对同一个Servlet的多个请求的时候，那么这个Servlet的service()方法将在多线程中并发执行。
 
-Servlet容器默认采用单实例多线程的方式来处理请求，这样减少产生Servlet实例的开销，提升了对请求的响应时间，对于Tomcat可以在server.xml中通过<Connector>元素设置线程池中线程的数目。 
+Servlet容器默认采用单实例多线程的方式来处理请求，这样减少产生Servlet实例的开销，提升了对请求的响应时间，对于Tomcat可以在server.xml中通过<Connector>元素设置线程池中线程的数目。
 
 ### 如何开发线程安全的Servlet
 
@@ -177,17 +172,12 @@ Servlet容器默认采用单实例多线程的方式来处理请求，这样减
 
 该接口指定了系统如何处理对同一个Servlet的调用。如果一个Servlet被这个接口指定,那么在这个Servlet中的service方法将不会有两个线程被同时执行，当然也就不存在线程安全的问题。这种方法只要将前面的Concurrent Test类的类头定义更改为：
 
+````
 
-
-<pre>Public class Concurrent Test extends HttpServlet implements SingleThreadModel { 
+Public class Concurrent Test extends HttpServlet implements SingleThreadModel { 
 ………… 
-}  </pre>
-
-
-
-
-
-
+}  
+````
 
 ## 同步对共享数据的操作
 使用synchronized 关键字能保证一次只有一个线程可以访问被保护的区段
@@ -213,7 +203,6 @@ Struts2 Action对象为每一个请求产生一个实例，因此没有线程安
 ## 五、servlet与jsp的区别
 
 
-
 1.jsp经编译后就变成了Servlet.(JSP的本质就是Servlet，JVM只能识别java的类，不能识别JSP的代码,Web容器将JSP的代码编译成JVM能够识别的java类)
 
 2.jsp更擅长表现于页面显示,servlet更擅长于逻辑控制.
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2141\357\274\232JavaWeb\347\232\204\347\224\261\346\235\245\345\222\214\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232JavaWeb\347\232\204\347\224\261\346\235\245\345\222\214\345\237\272\347\241\200\347\237\245\350\257\206.md"
similarity index 69%
rename from "docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2141\357\274\232JavaWeb\347\232\204\347\224\261\346\235\245\345\222\214\345\237\272\347\241\200\347\237\245\350\257\206.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232JavaWeb\347\232\204\347\224\261\346\235\245\345\222\214\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 1377342..7733b1c 100644
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2141\357\274\232JavaWeb\347\232\204\347\224\261\346\235\245\345\222\214\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232JavaWeb\347\232\204\347\224\261\346\235\245\345\222\214\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [什么是 Java Web](#什么是-java-web)
     * [Web开发的历史](#web开发的历史)
     * [开源框架时代](#开源框架时代)
@@ -10,9 +9,6 @@
       * [2、web服务器](#2、web服务器)
     * [三、JavaWeb项目结构](#三、javaweb项目结构)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [个人公众号：程序员黄小斜](#个人公众号：程序员黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
 
 本文转载自互联网，侵删
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -48,8 +44,7 @@ web开发的历史其实并不久远，要搞清楚java web开发的特点（主
 
 
 
-![](https://img2018.cnblogs.com/blog/1813823/201910/1813823-20191020130358732-639047052.webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151003.png)
 
 
 
@@ -62,8 +57,7 @@ web开发的历史其实并不久远，要搞清楚java web开发的特点（主
 
 
 
-![](https://img2018.cnblogs.com/blog/1813823/201910/1813823-20191020130358904-1951595187.webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151021.png)
 
 
 
@@ -76,8 +70,7 @@ web开发的历史其实并不久远，要搞清楚java web开发的特点（主
 
 
 
-![](https://img2018.cnblogs.com/blog/1813823/201910/1813823-20191020130359318-309106335.webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151039.png)
 
 
 
@@ -88,8 +81,7 @@ CGI的推出，使得web开发正式进入了动态处理时代，服务器能
 
 
 
-![](https://img2018.cnblogs.com/blog/1813823/201910/1813823-20191020130359489-1405737926.webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151104.png)
 
 
 
@@ -100,8 +92,7 @@ CGI的推出，使得web开发正式进入了动态处理时代，服务器能
 
 
 
-![](https://img2018.cnblogs.com/blog/1813823/201910/1813823-20191020130359667-1843065714.webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151117.png)
 
 
 
@@ -114,8 +105,7 @@ CGI的推出，使得web开发正式进入了动态处理时代，服务器能
 
 
 
-![](https://img2018.cnblogs.com/blog/1813823/201910/1813823-20191020130359840-877994653.webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151132.png)
 
 
 
@@ -126,8 +116,7 @@ CGI的推出，使得web开发正式进入了动态处理时代，服务器能
 
 
 
-![](https://img2018.cnblogs.com/blog/1813823/201910/1813823-20191020130400036-383481569.webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151210.png)
 
 
 
@@ -138,8 +127,7 @@ java web开发的技术体系还包括javabean和jsp，采用MVC结构来组合
 
 
 
-![](https://img2018.cnblogs.com/blog/1813823/201910/1813823-20191020130400263-672191254.webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151230.png)
 
 
 
@@ -150,8 +138,7 @@ java web开发的技术体系还包括javabean和jsp，采用MVC结构来组合
 
 
 
-![](https://img2018.cnblogs.com/blog/1813823/201910/1813823-20191020130400442-2098958889.webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405151248.png)
 
 
 
@@ -197,7 +184,7 @@ HTTP是基于请求（request）和响应（response）的模型
 
 注意：C/S架构可选的协议有多种，例如：TCP/IP,UDP,HTTP
 
-​ 而B/S架构通常只支持HTTP协议
+ 而B/S架构通常只支持HTTP协议
 
 ### 二、服务器
 
@@ -221,15 +208,15 @@ web服务器是提供服务端程序运行的一个环境，它本身也是一
 
 ### 三、JavaWeb项目结构
 
-| 项目根目录，例如：myweb、ch01 |   |   | 通常存放静态资源文件（如：html等等） |
+| 项目根目录，例如：myweb、ch01 |  |  | 通常存放静态资源文件（如：html等等） |
 | --- | --- | --- | --- |
-|   | WEB-INF |   | 这个目录是当前项目私有的一个文件夹，只能提供给项目内部访问，对于客户端来说是访问不到了，通常这个目录下存放的是Java源代码、编译后的字节码文件以及Servlet的核心配置文件web.xml |
-|   |   | src | 存放java源代码的目录 |
-|   |   | classes | 存放编译后的字节码文件 |
-|   |   | lib | lib目录存放当前项目所需要的jar文件 |
-|   |   | JSP | 用于存放JSP动态页面 |
-|   |   | web.xml | 项目的配置文件，用于配置Servlet的请求映射、过滤器、监听器等等信息。每一个web项目都对应一个web.xml配置文件 |
-|   | META-INF |   | 配置应用程序、扩展程序、类加载服务等等 |
+|  | WEB-INF |  | 这个目录是当前项目私有的一个文件夹，只能提供给项目内部访问，对于客户端来说是访问不到了，通常这个目录下存放的是Java源代码、编译后的字节码文件以及Servlet的核心配置文件web.xml |
+|  |  | src | 存放java源代码的目录 |
+|  |  | classes | 存放编译后的字节码文件 |
+|  |  | lib | lib目录存放当前项目所需要的jar文件 |
+|  |  | JSP | 用于存放JSP动态页面 |
+|  |  | web.xml | 项目的配置文件，用于配置Servlet的请求映射、过滤器、监听器等等信息。每一个web项目都对应一个web.xml配置文件 |
+|  | META-INF |  | 配置应用程序、扩展程序、类加载服务等等 |
 
 
 
@@ -241,37 +228,6 @@ https://www.cnblogs.com/albertrui/p/8427661.html
 https://blog.csdn.net/qq_41911570/article/details/83279327
 
 
-## 微信公众号
-
-### 个人公众号：程序员黄小斜
-
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注微信公众号【程序员黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
-
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的微信公众号【Java技术江湖】
-
-这是一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-
-**Java工程师必备学习资源:** 
-关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
-
 
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
 
-​                     
+                     
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2149\357\274\232Java\346\227\245\345\277\227\347\263\273\347\273\237\347\232\204\350\257\236\347\224\237\344\270\216\345\217\221\345\261\225.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Java\346\227\245\345\277\227\347\263\273\347\273\237\347\232\204\350\257\236\347\224\237\344\270\216\345\217\221\345\261\225.md"
similarity index 79%
rename from "docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2149\357\274\232Java\346\227\245\345\277\227\347\263\273\347\273\237\347\232\204\350\257\236\347\224\237\344\270\216\345\217\221\345\261\225.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Java\346\227\245\345\277\227\347\263\273\347\273\237\347\232\204\350\257\236\347\224\237\344\270\216\345\217\221\345\261\225.md"
index d265b76..15b371c 100644
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2149\357\274\232Java\346\227\245\345\277\227\347\263\273\347\273\237\347\232\204\350\257\236\347\224\237\344\270\216\345\217\221\345\261\225.md"
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Java\346\227\245\345\277\227\347\263\273\347\273\237\347\232\204\350\257\236\347\224\237\344\270\216\345\217\221\345\261\225.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [Java日志系统的演变史](#java日志系统的演变史)
     * [阶段一](#阶段一)
     * [阶段二](#阶段二)
@@ -13,9 +12,6 @@
     * [JCL（commons-logging）](#jcl（commons-logging）)
     * [SLF4J & Logback](#slf4j--logback)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [个人公众号：程序员黄小斜](#个人公众号：程序员黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
 
 
 
@@ -49,15 +45,6 @@
 ### 阶段二
 此时小B被借调到其他项目，小C加入到了项目组中。此时项目经理A要求改造日志系统，要求能把日志写到一个文件中，方便以后分析用户行为。小C在查看了以前的日志方式之后，感觉特别low，于是自己写了一个日志框架，命名为xiaoC-logging.jar，此举收到了项目经理A的好评。
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/11968147-7072fc51b9dfc62d.png?imageMogr2/auto-orient/strip|imageView2/2/w/472/format/webp)
-
-
-
-
 ### 阶段三
 项目组中加入了一个大牛老D，老D发现xiaoC-logging.jar这个日志框架虽然可以满足基本的日志要求，但是还不够高大上，没有一些诸如自动归档，异步写入文件，把日志文件写入NoSQL数据库中等功能。于是老D开发了一个更高级的日志框架叫oldD-logging.jar。
 
@@ -65,21 +52,12 @@
 oldD-logging.jar开发完成之后，需要把原来的xiaoC-logging.jar中的日志API做修改，把之前的日志实现写下来，换上高大上的oldD-logging.jar。
 
 ### 阶段五
-在这个卸载与上新的过程中，老D的工作量陡增，他感觉很累。不过姜还是老的辣，他参考了JDBC和spring中面向接口的编程方式，制定了一个日志的门面（一系列的接口），以后所有的日志的记录，都只面向接口编程，至于今后怎么去实现，都要遵循这个接口就可以了。 
+在这个卸载与上新的过程中，老D的工作量陡增，他感觉很累。不过姜还是老的辣，他参考了JDBC和spring中面向接口的编程方式，制定了一个日志的门面（一系列的接口），以后所有的日志的记录，都只面向接口编程，至于今后怎么去实现，都要遵循这个接口就可以了。
 
 
 那么在JAVA开发中，这正的日志系统是怎么演变的呢？简短地描述下日志发展，最先出现的是apache开源社区的log4j，这个日志确实是应用最广泛的日志工具，成为了java日志的事实上的标准。然而，当时Sun公司在jdk1.4中增加了JUL日志实现，企图对抗log4j，但是却造成了混乱，这个也是被人诟病的一点。当然也有其他日志工具的出现，这样必然造成开发者的混乱，因为这些日志系统互相没有关联，替换和统一也就变成了比较棘手的一件事。想象下你的应用使用log4j，然后使用了一个其他团队的库，他们使用了JUL，你的应用就得使用两个日志系统了，然后又有第二个库出现了，使用了simplelog。
 
 
-
-
-
-![](https://upload-images.jianshu.io/upload_images/11968147-b042d013f85e993f.png?imageMogr2/auto-orient/strip|imageView2/2/w/441/format/webp)
-
-
-
-
-
 这个时候估计让你崩溃了，这是要闹哪样？这个状况交给你来想想办法，你该如何解决呢？进行抽象，抽象出一个接口层，对每个日志实现都适配或者转接，这样这些提供给别人的库都直接使用抽象层即可。不错，开源社区提供了commons-logging抽象，被称为JCL，也就是日志框架了，确实出色地完成了兼容主流的日志实现（log4j、JUL、simplelog），基本一统江湖，就连顶顶大名的spring也是依赖了JCL。
 
 看起来事物确实是美好，但是美好的日子不长，接下来另一个优秀的日志框架slf4j的加入导致了更加混乱的场面。比较巧的是slf4j的作者(Ceki Gülcü)就是log4j的作者，他觉得JCL不够优秀，所以他要自己搞一套更优雅的出来，于是slf4j日志体系诞生了，并为slf4j实现了一个亲子——logback，确实更加优雅，但是由于之前很多代码库已经使用JCL，虽然出现slf4j和JCL之间的桥接转换，但是集成的时候问题依然多多，对很多新手来说确实会很懊恼，因为比单独的log4j时代“复杂”多了，抱怨声确实很多。
@@ -94,22 +72,16 @@ oldD-logging.jar开发完成之后，需要把原来的xiaoC-logging.jar中的
 *   门面型日志框架：
 
 1.  JCL：　　Apache基金会所属的项目，是一套Java日志接口，之前叫Jakarta Commons Logging，后更名为Commons Logging
-2.  SLF4J：  是一套简易Java日志门面，**本身并无日志的实现**。（Simple Logging Facade for Java，缩写Slf4j）
+2.  SLF4J： 是一套简易Java日志门面，**本身并无日志的实现**。（Simple Logging Facade for Java，缩写Slf4j）
 
 *   记录型日志框架:
 
 1.  JUL：　　JDK中的日志记录工具，也常称为JDKLog、jdk-logging，自Java1.4以来的官方日志实现。
 2.  Log4j：　 一个具体的日志实现框架。
-3.  Log4j2：   一个具体的日志实现框架，是LOG4J1的下一个版本，与Log4j 1发生了很大的变化，Log4j 2不兼容Log4j 1。
+3.  Log4j2：  一个具体的日志实现框架，是LOG4J1的下一个版本，与Log4j 1发生了很大的变化，Log4j 2不兼容Log4j 1。
 4.  Logback：一个具体的日志实现框架，和Slf4j是同一个作者，但其性能更好。
 
-　　　　　　　　　　　　　　![](https://img2018.cnblogs.com/blog/1577453/201908/1577453-20190801222005588-1535811596.png)
-
-
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405154329.png)
 
 ## 二、发展历程
 
@@ -132,11 +104,7 @@ oldD-logging.jar开发完成之后，需要把原来的xiaoC-logging.jar中的
 不过，commons-logging对Log4j和j.u.l的配置问题兼容的并不好，使用commons-loggings还可能会遇到类加载问题，导致NoClassDefFoundError的错误出现。
 
 
-
-　　　　　　　　　　　　　　　　　　　　　　　　![](https://img2018.cnblogs.com/blog/1577453/201908/1577453-20190801215840541-1005764017.png)
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405154402.png)
 
 
 到这个时候一切看起来都很简单，很美好。接口和实现做了良好的分离，在统一的JCL之下，不改变任何代码，就可以通过配置就换用功能更强大，或者性能更好的日志库实现。
@@ -177,13 +145,7 @@ Logback相较于log4j有更多的优点：
 
 现在事情就变复杂了。我们有了两个流行的 Log Facade，以及三个流行的 Log Implementation。Gülcü 是个追求完美的人，他决定让这些Log之间都能够方便的互相替换，所以做了各种 Adapter 和 Bridge 来连接:
 
-
-
-　　　　　　　　　　　　　　![](https://img2018.cnblogs.com/blog/1577453/201908/1577453-20190801220018444-1557580371.png)
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405154425.png)
 
 可以看到甚至 Log4j 和 JUL 都可以桥接到SLF4J，再通过 SLF4J 适配到到 Logback！需要注意的是不能有循环的桥接，比如下面这些依赖就不能同时存在:
 
@@ -201,19 +163,10 @@ Log4j2 和 Log4j1.x 并不兼容，设计上很大程度上模仿了 SLF4J/Logba
 
 现在好了，我们有了三个流行的Log 接口和四个流行的Log实现，如果画出桥接关系的图来回事什么样子呢?
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405154503.png)
 
-
-　　　　　　　　　　　　![](https://img2018.cnblogs.com/blog/1577453/201908/1577453-20190801220108556-715466336.png)
 看到这里是不是感觉有点晕呢？是的，我也有这种感觉。同样，在添加依赖的时候，要小心不要有循环依赖。
 
-
-
-
-
-
-
-
-
 ## 参考文章
 
 <https://segmentfault.com/a/1190000009707894>
@@ -226,37 +179,6 @@ Log4j2 和 Log4j1.x 并不兼容，设计上很大程度上模仿了 SLF4J/Logba
 
 https://blog.csdn.net/android_hl/article/details/53228348
 
-## 微信公众号
-
-### 个人公众号：程序员黄小斜
-
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注微信公众号【程序员黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
-
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的微信公众号【Java技术江湖】
-
-这是一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-
-**Java工程师必备学习资源:** 
-关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
-
 
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
 
-​                     
+                     
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21414\357\274\232Mybatis\345\205\245\351\227\250.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Mybatis\345\205\245\351\227\250.md"
similarity index 69%
rename from "docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21414\357\274\232Mybatis\345\205\245\351\227\250.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Mybatis\345\205\245\351\227\250.md"
index 6a2976a..bc23655 100644
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21414\357\274\232Mybatis\345\205\245\351\227\250.md"
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Mybatis\345\205\245\351\227\250.md"
@@ -1,36 +1,34 @@
-# Table of Contents
-
-  * [前言](#前言)
-  * [Mybatis是什么](#mybatis是什么)
+# 目录
+* [前言](#前言)
+* [Mybatis是什么](#mybatis是什么)
     * [特点](#特点)
     * [核心类介绍](#核心类介绍)
     * [功能架构：我们把Mybatis的功能架构分为三层](#功能架构：我们把mybatis的功能架构分为三层)
     * [框架结构：](#框架结构：)
     * [执行流程：](#执行流程：)
-  * [与Hibernate的异同](#与hibernate的异同)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
+* [与Hibernate的异同](#与hibernate的异同)
+* [参考文章](#参考文章)
+* [微信公众号](#微信公众号)
     * [个人公众号：黄小斜](#个人公众号：黄小斜)
 * [mybatis新手上路](#mybatis新手上路)
-  * [MyBatis简介](#mybatis简介)
-  * [MyBatis整体架构及运行流程](#mybatis整体架构及运行流程)
-    * [1.数据源配置文件](#1数据源配置文件)
-    * [2.Sql映射文件](#2sql映射文件)
-    * [3.会话工厂与会话](#3会话工厂与会话)
-    * [4.运行流程](#4运行流程)
-  * [测试工程搭建](#测试工程搭建)
-  * [微信公众号](#微信公众号-1)
-    * [个人公众号：程序员黄小斜](#个人公众号：程序员黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
+    * [MyBatis简介](#mybatis简介)
+    * [MyBatis整体架构及运行流程](#mybatis整体架构及运行流程)
+        * [1.数据源配置文件](#1数据源配置文件)
+        * [2.Sql映射文件](#2sql映射文件)
+        * [3.会话工厂与会话](#3会话工厂与会话)
+        * [4.运行流程](#4运行流程)
+    * [测试工程搭建](#测试工程搭建)
 
 
 本文转载自互联网，侵删
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本系列文章将同步到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -52,20 +50,12 @@ _PS:文末有参考列表_
 
 Mybatis是一个持久层框架，用于数据的持久化。主要表现为将SQL与POJO进行一个映射，将SQL从代码中解耦。基本概念如图：
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4226917-700b83c25876d6d0.png?imageMogr2/auto-orient/strip|imageView2/2/w/462/format/webp)
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/4226917-700b83c25876d6d0.png)
 
 
 使用时，以User为例，UserMapper定义了`findById`接口，该接口返回一个User对象，接口的实现为一个xml配置文件。该xml文件中定义对应接口中的实现所需要的SQL。从而达到将SQL与代码解耦的目标。
 
 ```
-
 <?xml version="1.0" encoding="UTF-8"?>  
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"   
 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
@@ -79,7 +69,8 @@ Mybatis是一个持久层框架，用于数据的持久化。主要表现为将S
 </mapper> 
 
 ```
-        MyBatis 是Apache的一个Java开源项目，是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。Mybatis可以将Sql语句配置在XML文件中，避免将Sql语句硬编码在Java类中。
+
+MyBatis 是Apache的一个Java开源项目，是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。Mybatis可以将Sql语句配置在XML文件中，避免将Sql语句硬编码在Java类中。
 
 ### 特点
 
@@ -97,13 +88,13 @@ Mybatis是一个持久层框架，用于数据的持久化。主要表现为将S
 
 3.SqlSession ：SqlSession 相当于一个会话, 每次访问数据库都需要这样一个会话, 大家可能会想起了 JDBC 中的 Connection, 很类似, 但还是有区别的, 何况现在几乎所有的连接都是使用的连接池技术, 用完后直接归还而不会像 Session 一样销毁. 注意: 他是一个线程不安全的对象, 在设计多线程的时候我们需要特别的当心, 操作数据库需要注意其隔离级别, 数据库锁等高级特性, 此外, 每次创建的 SqlSession 都必须及时关闭它, 它长期存在就会使数据库连接池的活动资源减少, 对系统性能的影响很大, 我们一般在 finally 块中将其关闭. 还有, SqlSession 存活于一个应用的请求和操作, 可以执行多条 Sql, 保证事务的一致性。SqlSession在执行过程中，有包含了几大对象：
 
-         3.1.Executor ：执行器，由它调度 StatementHandler、ParameterHandler、ResultSetHandler 等来执行对应的 SQL。其中 StatementHandler 是最重要的。
+3.1.Executor ：执行器，由它调度 StatementHandler、ParameterHandler、ResultSetHandler 等来执行对应的 SQL。其中 StatementHandler 是最重要的。
 
-         3.2.StatementHandler ：作用是使用数据库的 Statement（PreparedStatement）执行操作，它是四大对象的核心，起到承上启下的作用，许多重要的插件都是通过拦截它来实现的。
+3.2.StatementHandler ：作用是使用数据库的 Statement（PreparedStatement）执行操作，它是四大对象的核心，起到承上启下的作用，许多重要的插件都是通过拦截它来实现的。
 
-         3.3.ParamentHandler ：用来处理 SQL 参数的。
+3.3.ParamentHandler ：用来处理 SQL 参数的。
 
-         3.4.ResultSetHandler ：进行数据集的封装返回处理的。
+3.4.ResultSetHandler ：进行数据集的封装返回处理的。
 
 4.Mapper ：映射器是一些由你创建的、绑定你映射的语句的接口。映射器接口的实例是从 SqlSession 中获得的, 他的作用是发送 SQL, 然后返回我们需要的结果. 或者执行 SQL 从而更改数据库的数据, 因此它应该在 SqlSession 的事务方法之内, 在 Spring 管理的 Bean 中, Mapper 是单例的。
 
@@ -115,7 +106,7 @@ Mybatis是一个持久层框架，用于数据的持久化。主要表现为将S
 
 (3)基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。
 
-![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9nc3MwLmJkc3RhdGljLmNvbS8tNG8zZFNhZ194STRraEdrcG9XSzFIRjZoaHkvYmFpa2UvYzAlM0RiYWlrZTgwJTJDNSUyQzUlMkM4MCUyQzI2L3NpZ249NGRmM2FiMTQzOWRiYjZmZDMxNTZlZDc0Njg0ZGMwN2QvMGI0NmYyMWZiZTA5NmI2M2VhMGQ0MWJmMGMzMzg3NDRlYWY4YWNjYy5qcGc)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405164855.png)
 
 ### 框架结构：
 
@@ -127,7 +118,7 @@ Mybatis是一个持久层框架，用于数据的持久化。主要表现为将S
 
 (4)结果映射：将操作数据库的结果按照映射的配置进行转换，可以转换成HashMap、JavaBean或者基本数据类型，并将最终结果返回。
 
-![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9nc3MxLmJkc3RhdGljLmNvbS85dm8zZFNhZ194STRraEdrcG9XSzFIRjZoaHkvYmFpa2UvYzAlM0RiYWlrZTgwJTJDNSUyQzUlMkM4MCUyQzI2L3NpZ249ZjZjYzY5NzY4MjI2Y2ZmYzdkMjdiN2UwZDg2ODIxZjUvNjQzODBjZDc5MTIzOTdkZGUwY2Q4N2ViNTk4MmIyYjdkMWEyODdhYy5qcGc)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405164952.png)
 
 ### 执行流程：
 
@@ -139,17 +130,17 @@ Mybatis是一个持久层框架，用于数据的持久化。主要表现为将S
 
 4.执行增删改查
 
-     1、调用DefaultSqlSession增删改查
+1、调用DefaultSqlSession增删改查
 
-     2、创建StatementHandler （同时创建ParameterHandler,ResultSetHandler）
+2、创建StatementHandler （同时创建ParameterHandler,ResultSetHandler）
 
-     3、调用StatementHandler预编译参数以及设置参数值，使用ParameterHandler给sql设置参数
+3、调用StatementHandler预编译参数以及设置参数值，使用ParameterHandler给sql设置参数
 
-     4、调用StatementHandler增删改查
+4、调用StatementHandler增删改查
 
-     5、ResultSetHandler封装结果
+5、ResultSetHandler封装结果
 
-![](https://img-blog.csdnimg.cn/20190821203129674.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phZGViYWk=,size_16,color_FFFFFF,t_70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20190821203129674.png)
 
 
 ## 与Hibernate的异同
@@ -174,25 +165,6 @@ Mybatis开始逐渐流行起来，必然有其原因，简单了解了一下它
 <https://www.runoob.com/>
 
 https://blog.csdn.net/android_hl/article/details/53228348
-## 微信公众号
-
-### 个人公众号：黄小斜
-
-黄小斜是跨考软件工程的 985 硕士，自学 Java 两年，拿到了 BAT 等近十家大厂 offer，从技术小白成长为阿里工程师。
-
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得和程序人生，目前黄小斜的CSDN博客有百万+访问量，知乎粉丝2W+，全网已有10W+读者。
-
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注公众号【黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-**考研复习资料：** 
-计算机考研大礼包，都是我自己考研复习时用的一些复习资料,包括公共课和专业的复习视频，这里也推荐给大家，关注公众号后，后台回复关键字 **“考研”** 即可免费获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
 
 # mybatis新手上路
 
@@ -215,7 +187,7 @@ Mybatis整体构造由 数据源配置文件、Sql映射文件、会话工厂、
 一个SqlMapConfig.xml基本的配置信息如下：
 
 
-<pre><configuration>
+<configuration>
     <!-- 加载数据库属性文件 -->
     <properties resource="db.properties"></properties>
     <environments default="development">
@@ -231,7 +203,8 @@ Mybatis整体构造由 数据源配置文件、Sql映射文件、会话工厂、
             </dataSource>
         </environment>
     </environments>
-</configuration></pre>
+</configuration>
+
 
 
 
@@ -242,8 +215,8 @@ Mybatis中所有数据库的操作都会基于该映射文件和配置的sql语
 Mapper.xml配置文件大致如下：
 
 
-
-<pre><!DOCTYPE mapper 
+````
+<!DOCTYPE mapper 
     PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
     "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.sl.dao.ProductDao">
@@ -252,7 +225,8 @@ Mapper.xml配置文件大致如下：
         parameterType:参数类型，也就是查询条件的类型 -->
     <select id="selectProductById" resultType="com.sl.po.Product" parameterType="int">
      <!-- 这里和普通的sql 查询语句差不多，对于只有一个参数，后面的 #{id}表示占位符，里面不一定要写id,写啥都可以，但是不要空着，如果有多个参数则必须写pojo类里面的属性 --> select * from products where id = #{id} </select>
-</mapper></pre>
+</mapper>
+````
 
 
 ### 3.会话工厂与会话
@@ -271,20 +245,20 @@ Mybatis通过执行器与Mappered Statement的结合实现与数据库的交互
 
 执行流程图：
 
-![](https://images2018.cnblogs.com/blog/577318/201807/577318-20180702181255132-2135681101.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/577318-20180702181255132-2135681101.png)
 
 ## 测试工程搭建
 
- 1. 新建maven工程
+1.新建maven工程
 
-![](https://images2018.cnblogs.com/blog/577318/201807/577318-20180702181320571-1138935145.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/577318-20180702181320571-1138935145.png)
 
 2\. 添加依赖pom.xml
 
 
 
-
-<pre><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">
+````
+<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.sl</groupId>
     <artifactId>mybatis-demo</artifactId>
@@ -322,14 +296,15 @@ Mybatis通过执行器与Mappered Statement的结合实现与数据库的交互
             <version>${log4j.version}</version>
         </dependency>
     </dependencies>
-</project></pre>
+</project>
 
+````
 
 
 3.编写数据源配置文件SqlMapConfig.xml
 
-
-<pre><?xml version="1.0" encoding="UTF-8"?>
+````
+<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
 <configuration>
 <!-- 加载配置文件 -->
@@ -352,35 +327,38 @@ Mybatis通过执行器与Mappered Statement的结合实现与数据库的交互
         <!-- xml实现    注册productMapper.xml文件 -->
         <mapper resource="mapper/productMapper.xml"></mapper>
     </mappers>
-</configuration></pre>
+</configuration>
+````
 
 
 4.编写SQL映射配置文件productMapper.xml
 
-![](https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif)
 
+````
 
-
-<pre><?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper 
     PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
     "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.sl.mapper.ProductMapper">
 
-    <select id="selectAllProduct" resultType="com.sl.po.Product"> select * from products </select>
 
-</mapper></pre>
+    <select id="selectAllProduct" resultType="com.sl.po.Product"> select * from products </select>
 
+</mapper>
 
+````
 5.编写测试代码TestClient.java
 
-
-<pre>//使用productMapper.xml配置文件
+````
+//使用productMapper.xml配置文件
 public class TestClient { //定义会话SqlSession
     SqlSession session =null;
 
+
     @Before public void init() throws IOException { //定义mabatis全局配置文件
         String resource = "SqlMapConfig.xml"; //加载mybatis全局配置文件 //InputStream inputStream = TestClient.class.getClassLoader().getResourceAsStream(resource);
+
  InputStream inputStream = Resources.getResourceAsStream(resource);
         SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
         SqlSessionFactory factory = builder.build(inputStream); //根据sqlSessionFactory产生会话sqlsession
@@ -395,9 +373,11 @@ public class TestClient { //定义会话SqlSession
  session.close();    
     }
 
-}</pre>
+}
+````
 
-<pre>public class Product { private int Id; private String Name; private String Description; private BigDecimal UnitPrice; private String ImageUrl; private Boolean IsNew; public int getId() { return Id;
+````
+public class Product { private int Id; private String Name; private String Description; private BigDecimal UnitPrice; private String ImageUrl; private Boolean IsNew; public int getId() { return Id;
     } public void setId(int id) { this.Id = id;
     } public String getName() { return Name;
     } public void setName(String name) { this.Name = name;
@@ -411,46 +391,17 @@ public class TestClient { //定义会话SqlSession
     } public void setIsNew(boolean isnew) { this.IsNew = isnew;
     }
 
+
     @Override public String toString() { return "Product [id=" + Id + ", Name=" + Name + ", Description=" + Description + ", UnitPrice=" + UnitPrice + ", ImageUrl=" + ImageUrl + ", IsNew=" + IsNew+ "]";
     }
-}</pre>
 
+}
+````
 6.运行测试用例
 
-![](https://images2018.cnblogs.com/blog/577318/201807/577318-20180702181558003-1700599553.png)
-
-
-## 微信公众号
-
-### 个人公众号：程序员黄小斜
-
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注微信公众号【程序员黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
-
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的微信公众号【Java技术江湖】
-
-这是一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/577318-20180702181558003-1700599553.png)
 
-**Java工程师必备学习资源:** 
-关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
 
 
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
 
-​                     
+                     
\ No newline at end of file
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2144\357\274\232Servlet \345\267\245\344\275\234\345\216\237\347\220\206\350\257\246\350\247\243.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Servlet\345\267\245\344\275\234\345\216\237\347\220\206\350\257\246\350\247\243.md"
similarity index 84%
rename from "docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2144\357\274\232Servlet \345\267\245\344\275\234\345\216\237\347\220\206\350\257\246\350\247\243.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Servlet\345\267\245\344\275\234\345\216\237\347\220\206\350\257\246\350\247\243.md"
index 4e4c0db..468e261 100644
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2144\357\274\232Servlet \345\267\245\344\275\234\345\216\237\347\220\206\350\257\246\350\247\243.md"	
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Servlet\345\267\245\344\275\234\345\216\237\347\220\206\350\257\246\350\247\243.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [什么是Servlet](#什么是servlet)
   * [Servlet体系结构](#servlet体系结构)
   * [Servlet工作原理](#servlet工作原理)
@@ -7,9 +6,6 @@
   * [Servlet中的Listener](#servlet中的listener)
 * [Cookie与Session](#cookie与session)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [个人公众号：程序员黄小斜](#个人公众号：程序员黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
 
 
 
@@ -44,14 +40,7 @@ HTTP 协议只是一个规范，定义服务请求和响应的大致式样。Jav
 
 ## Servlet体系结构
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/6807865-fde8eafd9ebb9fa7.png?imageMogr2/auto-orient/strip|imageView2/2/w/434/format/webp)
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405152028.png)
 Servlet顶级类关联图
 
 
@@ -60,12 +49,7 @@ Servlet顶级类关联图
 
 Servlet的框架是由两个Java包组成的：javax.servlet与javax.servlet.http。在javax.servlet包中定义了所有的Servlet类都必须实现或者扩展的通用接口和类。在javax.servlet.http包中定义了采用Http协议通信的HttpServlet类。Servlet的框架的核心是javax.servlet.Servlet接口，所有的Servlet都必须实现这个接口。
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/6807865-c4f29f8263377807.png?imageMogr2/auto-orient/strip|imageView2/2/w/495/format/webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405152057.png)
 
 
 Servlet接口
@@ -129,8 +113,7 @@ public void init(ServletConfig config) throws ServletException {
 
 
 
-![](https://upload-images.jianshu.io/upload_images/6807865-b62549f0e7ece508.png?imageMogr2/auto-orient/strip|imageView2/2/w/548/format/webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405152119.png)
 
 
 Web服务器工作流程
@@ -143,8 +126,7 @@ Web服务器工作流程
 
 
 
-![](https://upload-images.jianshu.io/upload_images/6807865-6ba5b5d7a6206830.png?imageMogr2/auto-orient/strip|imageView2/2/w/700/format/webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405152142.png)
 
 
 Servlet工作原理时序图
@@ -211,18 +193,11 @@ Servlet类加载--->实例化--->服务--->销毁；
 
 ```
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/6807865-2868e60f05e4c34d.png?imageMogr2/auto-orient/strip|imageView2/2/w/700/format/webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405152215.png)
 
 
 Servlet生命周期
 
-
-
 **创建Servlet对象的时机：**
 
 1.  **默认情况下**，在Servlet容器启动后：客户首次向Servlet发出请求，Servlet容器会判断内存中是否存在指定的Servlet对象，如果没有则创建它，然后根据客户的请求创建HttpRequest、HttpResponse对象，从而调用Servlet对象的service方法；
@@ -272,17 +247,12 @@ Servlet生命周期
 在整个Servlet的生命周期过程中，**创建Servlet实例、调用实例的init()和destroy()方法都只进行一次**，当初始化完成后，Servlet容器会将该实例保存在内存中，通过调用它的service()方法，为接收到的请求服务。下面给出Servlet整个生命周期过程的UML序列图，如图所示：
 
 
-
-
-
-![](https://upload-images.jianshu.io/upload_images/6807865-aec8736ee84fab58.png?imageMogr2/auto-orient/strip|imageView2/2/w/664/format/webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405152252.png)
 
 
 Servlet生命周期
 
 
-
 > 如果需要让Servlet容器在启动时即加载Servlet，可以在web.xml文件中配置<load-on-startup>元素。
 
 ## Servlet中的Listener
@@ -290,17 +260,11 @@ Servlet生命周期
 Listener 使用的非常广泛，它是基于观察者模式设计的，Listener 的设计对开发 Servlet 应用程序提供了一种快捷的手段，能够方便的从另一个纵向维度控制程序和数据。目前 Servlet 中提供了 5 种两类事件的观察者接口，它们分别是：4 个 EventListeners 类型的，ServletContextAttributeListener、ServletRequestAttributeListener、ServletRequestListener、HttpSessionAttributeListener 和 2 个 LifecycleListeners 类型的，ServletContextListener、HttpSessionListener。如下图所示：
 
 
-
-
-
-![](https://upload-images.jianshu.io/upload_images/6807865-3cd97763331db274.png?imageMogr2/auto-orient/strip|imageView2/2/w/495/format/webp)
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405152314.png)
 
 Servlet中的Listener
 
 
-
 它们基本上涵盖了整个 Servlet 生命周期中，你感兴趣的每种事件。这些 Listener 的实现类可以配置在 web.xml 中的 <listener> 标签中。当然也可以在应用程序中动态添加 Listener，需要注意的是 ServletContextListener 在容器启动之后就不能再添加新的，因为它所监听的事件已经不会再出现。掌握这些 Listener 的使用，能够让我们的程序设计的更加灵活。
 
 # Cookie与Session
@@ -334,8 +298,7 @@ Session 与 Cookie 的作用都是为了保持访问用户与后端服务器的
 
 
 
-![](https://upload-images.jianshu.io/upload_images/6807865-c49338a0725008c1.png?imageMogr2/auto-orient/strip|imageView2/2/w/386/format/webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405152357.png)
 
 
 Session相关类图
@@ -348,8 +311,7 @@ Session相关类图
 
 
 
-![](https://upload-images.jianshu.io/upload_images/6807865-0f293008a947ad0e.png?imageMogr2/auto-orient/strip|imageView2/2/w/568/format/webp)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405152416.png)
 
 
 Session工作的时序图
@@ -371,37 +333,6 @@ Session工作的时序图
 
 https://blog.csdn.net/android_hl/article/details/53228348
 
-## 微信公众号
-
-### 个人公众号：程序员黄小斜
-
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注微信公众号【程序员黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
-
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的微信公众号【Java技术江湖】
-
-这是一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-
-**Java工程师必备学习资源:** 
-关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
-
 
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
 
-​                     
+                     
diff --git "a/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Tomcat5\346\200\273\344\275\223\346\236\266\346\236\204\345\211\226\346\236\220.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Tomcat5\346\200\273\344\275\223\346\236\266\346\236\204\345\211\226\346\236\220.md"
new file mode 100644
index 0000000..5937ec0
--- /dev/null
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Tomcat5\346\200\273\344\275\223\346\236\266\346\236\204\345\211\226\346\236\220.md"
@@ -0,0 +1,196 @@
+# 目录
+
+  * [连接器（Connector）](#连接器（connector）)
+  * [容器（Container）](#容器（container）)
+
+
+ 
+本文转载自互联网，侵删
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+本系列文章将同步到我的个人博客：
+> www.how2playlife.com
+
+更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
+
+本文是《走进JavaWeb技术世界》系列博文的其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+
+该系列博文会告诉你如何从入门到进阶，从servlet到框架，从ssm再到SpringBoot，一步步地学习JavaWeb基础知识，并上手进行实战，接着了解JavaWeb项目中经常要使用的技术和组件，包括日志组件、Maven、Junit，等等内容，以便让你更完整地了解整个JavaWeb技术体系，形成自己的知识框架。为了更好地总结和检验你的学习成果，本系列文章也会提供每个知识点对应的面试题以及参考答案。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+**文末赠送8000G的Java架构师学习资料，需要的朋友可以到文末了解领取方式，资料包括Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源）**
+<!-- more -->
+
+Tomcat 是 Java WEB 开发接触最多的 Servlet 容器，但它不仅仅是一个 Servlet 容器，它还是一个 WEB 应用服务器，在微服务架构体系下，为了降低部署成本，减少资源的开销，追求的是轻量化与稳定，而 Tomcat 是一个轻量级应用服务器，自然被很多开发人员所接受。
+
+Tomcat 里面藏着很多值得我们每个 Java WEB 开发者学习的知识，可以这么说，当你弄懂了 Tomcat 的设计原理，Java WEB 开发对你来说已经没有什么秘密可言了。本篇文章主要是跟大家聊聊 Tomcat 的内部架构体系，让大家对 Tomcat 有个整体的认知。
+
+前面我也说了，Tomcat 的本质其实就是一个 WEB 服务器 + 一个 Servlet 容器，那么它必然需要处理网络的连接与 Servlet 的管理，因此，Tomcat 设计了两个核心组件来实现这两个功能，分别是连接器和容器，连接器用来处理外部网络连接，容器用来处理内部 Servlet，我用一张图来表示它们的关系：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405153506.png)
+
+一个 Tomcat 代表一个 Server 服务器，一个 Server 服务器可以包含多个 Service 服务，Tomcat 默认的 Service 服务是 Catalina，而一个 Service 服务可以包含多个连接器，因为 Tomcat 支持多种网络协议，包括 HTTP/1.1、HTTP/2、AJP 等等，一个 Service 服务还会包括一个容器，容器外部会有一层 Engine 引擎所包裹，负责与处理连接器的请求与响应，连接器与容器之间通过 ServletRequest 和 ServletResponse 对象进行交流。
+
+也可以从 server.xml 的配置结构可以看出 tomcat 整体的内部结构：
+
+<section>
+
+```
+<Server port="8005" shutdown="SHUTDOWN">
+```
+
+</section>
+
+## 连接器（Connector）
+
+连接器负责将各种网络协议封装起来，对外部屏蔽了网络连接与 IO 处理的细节，将处理得到的 Request 对象传递给容器处理，Tomcat 将处理请求的细节封装到 ProtocolHandler，ProtocolHandler 是一个接口类型，通过实现 ProtocolHandler 来实现各种协议的处理，如 Http11AprProtocol：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405153520.png)
+
+ProtocolHandler 采用组件模式的设计，将处理网络连接，字节流封装成 Request 对象，再将 Request 适配成 Servlet 处理 ServletRequest 对象这几个动作，用组件封装起来了，ProtocolHandler 包括了三个组件：Endpoint、Processor、Adapter。
+
+Endpoint 在 ProtocolHandler 实现类的构造方法中创建，如下：
+
+<section>
+
+```
+public Http11AprProtocol() {
+```
+
+</section>
+
+**Endpoint 组件用来处理底层的 Socket 网络连接**，AprEndpoint 里面有个叫 SocketProcessor 的内部类，它负责为 AprEndpoint 将接收到的 Socket 请求转化成 Request 对象，SocketProcessor 实现了 Runnable 接口，它会有一个专门的线程池来处理，后面我会单独从源码的角度分析 Endpoint 组件的设计原理。
+
+org.apache.tomcat.util.net.AprEndpoint.SocketProcessor#doRun：
+
+<section>
+
+```
+// Process the request from this socket
+```
+
+</section>
+
+process 方法会创建一个 processor 对象，**调用它的 process 方法将 Socket 字节流封装成 Request 对象**，在创建 Processor 组件时，会将 Adapter 组件添加到 Processor 组件中：
+
+org.apache.coyote.http11.AbstractHttp11Protocol#createProcessor：
+
+<section>
+
+```
+protected Processor createProcessor() {
+```
+
+</section>
+
+而 Adapter 组件在连接器初始化时就已经创建好了：
+
+org.apache.catalina.connector.Connector#initInternal：
+
+<section>
+
+```
+// Initialize adapter
+```
+
+</section>
+
+目前为止，Tomcat 只有一个 Adapter 实现类，就是 CoyoteAdapter。**Adapter 的主要作用是将 Request 对象适配成容器能够识别的 Request 对象**，比如 Servlet 容器，它的只能识别 ServletRequest 对象，这时候就需要 Adapter 适配器类作一层适配。
+
+以上连接器的各个组件，我用一张图说明它们直接的关系：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405153534.png)
+
+## 容器（Container）
+
+在 Tomcat 中一共设计了 4 种容器，它们分别为 Engine、Host、Context、Wrapper，它们的关系如下图所示：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405153549.png)
+
+•**Engine：表示一个虚拟主机的引擎，一个 Tomcat Server 只有一个 引擎，连接器所有的请求都交给引擎处理，而引擎则会交给相应的虚拟主机去处理请求；**•**Host：表示虚拟主机，一个容器可以有多个虚拟主机，每个主机都有对应的域名，在 Tomcat 中，一个 webapps 就代表一个虚拟主机，当然 webapps 可以配置多个；**•**Context：表示一个应用容器，一个虚拟主机可以拥有多个应用，webapps 中每个目录都代表一个 Context，每个应用可以配置多个 Servlet。**
+
+从上图可看出，**各个容器组件之间的关系是由大到小，即父子关系，它们之间关系形成一个树状的结构**，它们的实现类都实现了 Container 接口，它有如下方法来控制容器组件之间的关系：
+
+<section>
+
+```
+ublic interface Container extends Lifecycle {
+```
+
+</section>
+
+容器组件之间通过以上几个方法，即可实现它们之间的父子关系，有没有发现，Container 接口还继承了 Lifecycle 接口，它有如下方法：
+
+<section>
+
+```
+public interface Lifecycle {   
+```
+
+</section>
+
+Tomcat 中有很多组件，组件通过实现 Lifecycle 接口，Tomcat 通过事件机制来实现对这些组件生命周期的管理。
+
+**Tomcat 的这种容器设计思想，其实是运用了组合设计模式的思想，组合设计模式最大的优点是可以自由添加节点，这样也就使得 Tomcat 的容器组件非常地容易进行扩展，符合设计模式中的开闭原则。**
+
+现在我们知道了 Tomcat 的容器组件的组合方式，那我们现在就来想一个问题：
+
+当一个请求过来时，Tomcat 是如何识别请求并将它交给特定 Servlet 来处理呢？
+
+从容器的组合关系可以看出，它们调用顺序必定是：
+
+<section>
+
+```
+Engine -> Host -> Context -> Wrapper -> Servlet
+```
+
+</section>
+
+那么 Tomcat 是如何来定位 Servlet 的呢？答案是利用 Mapper 组件来完成定位的工作。
+
+**Mapper 最主要的核心功能是保存容器组件之间访问路径的映射关系**，它是如何做到这点的呢？
+
+我们不妨先从源码入手：
+
+org.apache.catalina.core.StandardService：
+
+<section>
+
+```
+protected final Mapper mapper = new Mapper();
+```
+
+</section>
+
+Service 实现类中，已经初始化了 Mapper 组件以及它的监听类 MapperListener，这里先说明一下，在 Tomcat 组件中，标准的实现组件类前缀会有 Standard，比如：
+
+<section>
+
+```
+org.apache.catalina.core.StandardServer
+```
+
+</section>
+
+在 Service 服务启动的时候，会调用 MapperListener.start() 方法，最终会执行 MapperListener 的 startInternal 方法：
+
+org.apache.catalina.mapper.MapperListener#startInternal：
+
+<section>
+
+```
+Container[] conHosts = engine.findChildren();
+```
+
+</section>
+
+该方法会注册新的虚拟主机，接着 registerHost() 方法会注册 context，以此类推，从而将容器组件直接的访问的路径都注册到 Mapper 中。
+
+定位 Servlet 的流程图：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405153609.png)
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2147\357\274\232Tomcat\345\222\214\345\205\266\344\273\226WEB\345\256\271\345\231\250\347\232\204\345\214\272\345\210\253.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Tomcat\345\222\214\345\205\266\344\273\226WEB\345\256\271\345\231\250\347\232\204\345\214\272\345\210\253.md"
similarity index 67%
rename from "docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2147\357\274\232Tomcat\345\222\214\345\205\266\344\273\226WEB\345\256\271\345\231\250\347\232\204\345\214\272\345\210\253.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Tomcat\345\222\214\345\205\266\344\273\226WEB\345\256\271\345\231\250\347\232\204\345\214\272\345\210\253.md"
index db38428..45dbdde 100644
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2147\357\274\232Tomcat\345\222\214\345\205\266\344\273\226WEB\345\256\271\345\231\250\347\232\204\345\214\272\345\210\253.md"
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232Tomcat\345\222\214\345\205\266\344\273\226WEB\345\256\271\345\231\250\347\232\204\345\214\272\345\210\253.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [Tomcat和物理服务器的区别](#tomcat和物理服务器的区别)
     * [Tomcat：](#tomcat：)
     * [物理服务器：](#物理服务器：)
@@ -7,9 +6,6 @@
     * [定义：](#定义：)
     * [区别](#区别)
     * [总结](#总结)
-  * [微信公众号](#微信公众号)
-    * [个人公众号：程序员黄小斜](#个人公众号：程序员黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
 
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -46,11 +42,11 @@
 
 ### Tomcat：
 
-1.     本质：软件 Web 应用服务器----一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。
+1.本质：软件 Web 应用服务器----一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。
 
-2.     用途：
+2.用途：
 
-a．  当在一台机器（即物理服务器，也就是物理机）上配置好Apache 服务器，可利用它响应HTML页面的访问请求。实际上Tomcat是Apache 服务器的扩展，但运行时它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache 独立的进程单独运行的，Tomcat 实际上运行JSP 页面和Servlet
+a． 当在一台机器（即物理服务器，也就是物理机）上配置好Apache 服务器，可利用它响应HTML页面的访问请求。实际上Tomcat是Apache 服务器的扩展，但运行时它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache 独立的进程单独运行的，Tomcat 实际上运行JSP 页面和Servlet
 
 b． Tomcat和IIS等Web服务器一样，具有处理HTML页面的功能，另外它还是一个Servlet和JSP容器，独立的Servlet容器是Tomcat的默认模式。
 
@@ -66,25 +62,23 @@ b． Tomcat和IIS等Web服务器一样，具有处理HTML页面的功能，另
 
 ### 定义：
 
-1\. Apache
+1. Apache
 
 Apache HTTP服务器是一个模块化的服务器，可以运行在几乎所有广泛使用的计算机平台上。其属于应用服务器。Apache支持支持模块多，性能稳定，Apache本身是静态解析，适合静态HTML、图片等，但可以通过扩展脚本、模块等支持动态页面等。
 
 (Apche可以支持PHPcgiperl,但是要使用Java的话，你需要Tomcat在Apache后台支撑，将Java请求由Apache转发给Tomcat处理。) 缺点：配置相对复杂，自身不支持动态页面。
 
-2\. Tomcat：
+2. Tomcat：
 
 Tomcat是应用(Java)服务器，它只是一个Servlet(JSP也翻译成Servlet)容器，可以认为是Apache的扩展，但是可以独立于Apache运行。
 
-3\. Nginx
+3. Nginx
 
 Nginx是俄罗斯人编写的十分轻量级的HTTP服务器,Nginx，它的发音为“engine X”，是一个高性能的HTTP和反向代理服务器，同时也是一个IMAP/POP3/SMTP 代理服务器。
 
-[![](https://server.zzidc.com/uploads/allimg/181211/1-1Q211140I2H2.jpg)](http://s1.51cto.com/oss/201812/11/0b70cbd49f22c2bfd4bf6cd5da29335f.jpg-wh_651x-s_227048833.jpg)
-
 ### 区别
 
-1\. Apache与Tomcat的比较
+Apache与Tomcat的比较
 
 相同点：
 
@@ -92,8 +86,6 @@ Nginx是俄罗斯人编写的十分轻量级的HTTP服务器,Nginx，它的发
 
 Apache是专门用了提供HTTP服务的，以及相关配置的(例如虚拟主机、URL转发等等)，而Tomcat是Apache组织在符合Java EE的JSP、Servlet标准下开发的一个JSP服务器.
 
-[![](https://server.zzidc.com/uploads/allimg/181211/140P921b-0.jpg)](https://server.zzidc.com/uploads/allimg/181211/140P921b-0.jpg)
-
 Apache是一个Web服务器环境程序,启用他可以作为Web服务器使用,不过只支持静态网页如(ASP,PHP,CGI,JSP)等动态网页的就不行。如果要在Apache环境下运行JSP的话就需要一个解释器来执行JSP网页,而这个JSP解释器就是Tomcat。
 
 Apache:侧重于HTTPServer ，Tomcat:侧重于Servlet引擎，如果以Standalone方式运行，功能上与Apache等效，支持JSP，但对静态网页不太理想;
@@ -152,37 +144,6 @@ Tomcat：动态解析容器，处理动态请求，是编译JSPServlet的容器
 
 Apache在处理动态有优势，Nginx并发性比较好，CPU内存占用低，如果rewrite频繁，那还是Apache较适合。
 
-## 微信公众号
-
-### 个人公众号：程序员黄小斜
-
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注微信公众号【程序员黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
-
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的微信公众号【Java技术江湖】
-
-这是一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-
-**Java工程师必备学习资源:** 
-关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
-
 
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
 
-​                     
+                     
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21410\357\274\232\344\273\216JavaBean\350\256\262\345\210\260Spring.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\344\273\216JavaBean\350\256\262\345\210\260Spring.md"
similarity index 62%
rename from "docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21410\357\274\232\344\273\216JavaBean\350\256\262\345\210\260Spring.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\344\273\216JavaBean\350\256\262\345\210\260Spring.md"
index 985e2e4..c4829c0 100644
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21410\357\274\232\344\273\216JavaBean\350\256\262\345\210\260Spring.md"
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\344\273\216JavaBean\350\256\262\345\210\260Spring.md"
@@ -1,16 +1,12 @@
-# Table of Contents
-
+# 目录
   * [**Java Bean**](#java-bean)
   * [**JSP + Java Bean**](#jsp--java-bean)
   * [Enterprise Java bean](#enterprise-java-bean)
   * [Spring](#spring)
   * [JavaBean 和 Spring中Bean的区别](#javabean-和-spring中bean的区别)
     * [Jave bean](#jave-bean)
-    * [spring bean](#spring bean)
+    * [springbean](#springbean)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [个人公众号：程序员黄小斜](#个人公众号：程序员黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
 
 本文转载自互联网，侵删
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -37,14 +33,7 @@ Java语言欠缺属性、事件、多重继承功能。所以，如果要在Java
 
 举个例子，假如有人要用Java实现一个单向链表类，可能会这样写：
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/9915352-8a35b591c3c78ed3.png)
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405154643.png)
 
 
 上述实现为了能够快速获取链表的大小，把链表大小缓存在size变量中。用法如下：
@@ -55,15 +44,7 @@ System.out.println(myList.size);
 
 要节省内存，不要缓存size变量了，把代码改成这样：
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/9915352-55f1e5d91f50eb68.png)
-
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405154703.png)
 
 发现找不到什么size变量。如果要找到size变量，你就必须保持向后兼容性。所以Java标准库中，绝对不会出现public int size这样的代码，而一定会一开始就写成：
 
@@ -75,73 +56,65 @@ public int getSize( ){return size;}
 
 ## **JSP + Java Bean**
 
-在jsp上，  可以用java bean 来封装业务逻辑，保存数据到数据库， 像这样：
-
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/9915352-8793c939542d7910.png)
-
-
+在jsp上， 可以用java bean 来封装业务逻辑，保存数据到数据库， 像这样：
 
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405154720.png)
 
 其中jsp 直接用来接受用户的请求， 然后通过java bean 来处理业务， 具体的使用方法是：
 
-这就能把HTTP request中的所有参数都设置到 user 这个java bean 对应的属性上去。 
-
-只要保证 http request中的参数名和 java bean 中的属性名是一样的。 
+这就能把HTTP request中的所有参数都设置到 user 这个java bean 对应的属性上去。
 
-这个叫做JSP Model 1 的模型受到了很多Java程序员的欢迎 ,  因为他们的应用规模都很小， 用Model 1 使得开发很快速，实际上， 这种方式和微软的asp , 以及和开源的php 几乎一样。 
+只要保证 http request中的参数名和 java bean 中的属性名是一样的。
 
-但在项目中频繁使用了Model 1 导致整个系统的崩溃，因为系统中有好几千个jsp， 这些jsp互相调用(通过GET/POST), 到了最后调用关系无人能搞懂。 
+这个叫做JSP Model 1 的模型受到了很多Java程序员的欢迎 , 因为他们的应用规模都很小， 用Model 1 使得开发很快速，实际上， 这种方式和微软的asp , 以及和开源的php 几乎一样。
 
-为了解决这个问题，又推出了 ：JSP Model 2 ,    这是个模型真正的体现了Model-View-Controller的思想：
+但在项目中频繁使用了Model 1 导致整个系统的崩溃，因为系统中有好几千个jsp， 这些jsp互相调用(通过GET/POST), 到了最后调用关系无人能搞懂。
 
+为了解决这个问题，又推出了 ：JSP Model 2 ,  这是个模型真正的体现了Model-View-Controller的思想：
 
 
 
 
-![](https://upload-images.jianshu.io/upload_images/9915352-b5fe81e22fca9339.png)
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405154740.png)
 
 
 
 
-Servlet 充当Controller ,  jsp 充当 View ，Java bean 当然就是Model 了！
+Servlet 充当Controller , jsp 充当 View ，Java bean 当然就是Model 了！
 
-业务逻辑， 页面显示， 和处理过程做了很好的分离。 
+业务逻辑， 页面显示， 和处理过程做了很好的分离。
 
-基于这个模型的扩展和改进，  很多Web开发框架开始如雨后春笋一样出现， 其中最著名的就是 SpringMVC了。
+基于这个模型的扩展和改进， 很多Web开发框架开始如雨后春笋一样出现， 其中最著名的就是 SpringMVC了。
 
 ## Enterprise Java bean
 
 越来越多企业程序员提出诉求：要分布式、要安全、要事务、要高可用性。
 
-诉求可以归结为：“我们只想关注我们的业务逻辑， 我们不想， 也不应该由我们来处理‘低级’的事务， 多线程，连接池，以及其他各种各种的‘低级’API， 此外Java帝国一定得提供集群功能， 这样我们的一台机器死机以后，整个系统还能运转。 ”
+诉求可以归结为：“我们只想关注我们的业务逻辑，我们不想，也不应该由我们来处理‘低级’的事务，多线程，连接池，以及其他各种各种的‘低级’API， 此外Java帝国一定得提供集群功能， 这样我们的一台机器死机以后，整个系统还能运转。 ”
 
 于是推出了J2EE， 像Java bean 一样， 这还是一个规范， 但是比Java bean 复杂的多， 其中有：
 
-**JDBC**:  Java 数据库连接
+**JDBC**: Java 数据库连接
 
-**JNDI** :  Java 命名和目录接口， 通过一个名称就可以定位到一个数据源， 连jdbc连接都不用了
+**JNDI**: Java 命名和目录接口， 通过一个名称就可以定位到一个数据源， 连jdbc连接都不用了
 
-**RMI**：  远程过程调用，  让一个机器上的java 对象可以调用另外一个机器上的java 对象 
+**RMI**： 远程过程调用， 让一个机器上的java 对象可以调用另外一个机器上的java 对象
 
-**JMS** :   Java 消息服务，  可以使用消息队列了
+**JMS**:  Java 消息服务， 可以使用消息队列了
 
-**JTA**：  Java 事务管理， 支持分布式事务， 能在访问、更新多个数据库的时候，仍然保证事务， 还是分布式。
+**JTA**： Java 事务管理， 支持分布式事务， 能在访问、更新多个数据库的时候，仍然保证事务， 还是分布式。
 
-**Java mail** : 收发邮件
+**Java mail**: 收发邮件
 
 J2EE 后来改成了Java EE。
 
-当然最重要的是， java bean 变成了 **Enterprise Java bean **, 简称 **EJB**。
+当然最重要的是， java bean 变成了**Enterprise Java bean**, 简称**EJB**。
 
-使用了EJB， 你就可以把精力只放在业务上了， 那些烦人的事务管理， 安全管理，线程 统统交给容器（应用服务器）来处理吧。 
+使用了EJB， 你就可以把精力只放在业务上了， 那些烦人的事务管理， 安全管理，线程 统统交给容器（应用服务器）来处理吧。
 
-我们还提供了额外的福利， 只要你的应用服务器是由多个机器组成的集群， EJB就可以无缝的运行在这个集群上， 你完全不用考虑一个机器死掉了应用该怎么办。我们都帮你搞定了。 
+我们还提供了额外的福利， 只要你的应用服务器是由多个机器组成的集群， EJB就可以无缝的运行在这个集群上， 你完全不用考虑一个机器死掉了应用该怎么办。我们都帮你搞定了。
 
 使用Session Bean ， 可以轻松的处理你的业务。
 
@@ -151,37 +124,37 @@ J2EE 后来改成了Java EE。
 
 ## Spring
 
-然而，大部分的程序员就发现，  EJB中用起来极为繁琐和笨重， 性能也不好， 为了获得所谓的分布式，反而背上了沉重的枷锁。 
+然而，大部分的程序员就发现， EJB中用起来极为繁琐和笨重， 性能也不好， 为了获得所谓的分布式，反而背上了沉重的枷锁。
 
 实体Bean很快没人用了， 就连简单的无状态Session bean 也被大家所诟病， 其中一条罪状就是“代码的侵入性”。
 
-在定义EJB的时候没考虑那么多，程序员在定义一个Session bean的时候，需要写一大堆和业务完全没有关系的类。 
-
-还需要被迫实现一些根本不应该实现的接口及其方法： 
+在定义EJB的时候没考虑那么多，程序员在定义一个Session bean的时候，需要写一大堆和业务完全没有关系的类。
 
+还需要被迫实现一些根本不应该实现的接口及其方法：
 
 
 
 
-![](https://upload-images.jianshu.io/upload_images/9915352-535d649b27315b2a.png)
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/9915352-535d649b27315b2a.png)
 
 
 
 
 他们希望这个样子：
-
+````
 public class HelloworldBean{
 
-    public String hello(){
+  public String hello(){
 
-        return "hello world"
+    return "hello world"
 
-   }
+ }
 
 }
+````
 
-与此同时，他们还过分的要求保留事务、 安全这些必备的东西。 
+与此同时，他们还过分的要求保留事务、 安全这些必备的东西。
 
 Spring 框架顺应了POJO的潮流， 提供了一个spring 的容器来管理这些POJO, 也叫bean 。
 
@@ -189,7 +162,7 @@ Spring 框架顺应了POJO的潮流， 提供了一个spring 的容器来管理
 
 后来 Martin flower 给这种方式起来个更好的名字，叫“依赖注入”（DI）。
 
-如果一个Bean 需要一些像事务，日志，安全这样的通用的服务， 也是只需要声明即可， spring 容器在运行时能够动态的“织入”这些服务， 这叫面向切面（AOP）。 
+如果一个Bean 需要一些像事务，日志，安全这样的通用的服务， 也是只需要声明即可， spring 容器在运行时能够动态的“织入”这些服务， 这叫面向切面（AOP）。
 
 总之，spring和spring mvc极大的增加了Java对web开发领地的统治力。
 
@@ -199,7 +172,7 @@ Spring 框架顺应了POJO的潮流， 提供了一个spring 的容器来管理
 ### Jave bean
 javaBean简单的讲就是实体类，用来封装对象，这个类里面全部都是属性值，和get，set方法。简单笼统的说就是一个类，一个可复用的类。javaBean在MVC设计模型中是model，又称模型层，在一般的程序中，我们称它为数据层，就是用来设置数据的属性和一些行为，然后我会提供获取属性和设置属性的get/set方法JavaBean是一种JAVA语言写成的可重用组件。为写成JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。
 
-### spring bean
+### springbean
 对于使用Spring框架的开发人员来说，我们主要做的主要有两件事情：①开发Bean;②配置Bean;而Spring帮我们做的就是根据配置文件来创建Bean实例，并调用Bean实例的方法来完成“依赖注入”，可以把Spring容器理解成一个大型工厂，Bean就是该工厂的产品，工厂(Spirng容器)里能生产出来什么样的产品（Bean），完全取决于我们在配置文件中的配置。其实就是根据配置文件产生对象,而不需要人为的手动去创造对象,降低了耦合.
 
 用处不同：传统javabean更多地作为值传递参数，而spring中的bean用处几乎无处不在，任何组件都可以被称为bean。
@@ -207,7 +180,7 @@ javaBean简单的讲就是实体类，用来封装对象，这个类里面全部
 写法不同：传统javabean作为值对象，要求每个属性都提供getter和setter方法；但spring中的bean只需为接受设值注入的属性提供setter方法。
 
 javabean的写法:
-
+````
     public class A{
     private String a;
     private void setA(String a){
@@ -217,15 +190,15 @@ javabean的写法:
     return a;
     }
     }
-    spring bean的写法
+    springbean的写法
     
     <bean id="p1" class="com.zking.Pojo.Person" scope="prototype">
     //及时加载 加载你的xml配置文件
     ApplicationContext applicationContext = new ClassPathXmlApplicationContext("ApplicationContext.xml");
     //getbean输入你配置类的别名得到 person对象
      Person p = (Person) applicationContext.getBean("p1");
-     
-id是给这个对象定的别名 class是这个实体类的全路径名 根据配置文件来创建Bean实例，并调用Bean实例的方法 bean里面还有很多属性
+````     
+id是给这个对象定的别名class是这个实体类的全路径名根据配置文件来创建Bean实例，并调用Bean实例的方法bean里面还有很多属性
 
 生命周期不同：传统javabean作为值对象传递，不接受任何容器管理其生命周期；spring中的bean有spring管理其生命周期行为。
 
@@ -242,38 +215,4 @@ https://www.cnblogs.com/xll1025/p/11366413.html
 https://blog.csdn.net/qqqnzhky/article/details/82747333
 https://www.cnblogs.com/mike-mei/p/9712836.html
 https://blog.csdn.net/qq_42245219/article/details/82748460
-
-## 微信公众号
-
-### 个人公众号：程序员黄小斜
-
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注微信公众号【程序员黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
-
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的微信公众号【Java技术江湖】
-
-这是一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-
-**Java工程师必备学习资源:** 
-关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
-
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-​                     
+                     
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21412\357\274\232\344\273\216\346\211\213\345\212\250\347\274\226\350\257\221\346\211\223\345\214\205\345\210\260\351\241\271\347\233\256\346\236\204\345\273\272\345\267\245\345\205\267Maven.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\344\273\216\346\211\213\345\212\250\347\274\226\350\257\221\346\211\223\345\214\205\345\210\260\351\241\271\347\233\256\346\236\204\345\273\272\345\267\245\345\205\267Maven.md"
similarity index 86%
rename from "docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21412\357\274\232\344\273\216\346\211\213\345\212\250\347\274\226\350\257\221\346\211\223\345\214\205\345\210\260\351\241\271\347\233\256\346\236\204\345\273\272\345\267\245\345\205\267Maven.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\344\273\216\346\211\213\345\212\250\347\274\226\350\257\221\346\211\223\345\214\205\345\210\260\351\241\271\347\233\256\346\236\204\345\273\272\345\267\245\345\205\267Maven.md"
index dac71a8..d6cfa8c 100644
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21412\357\274\232\344\273\216\346\211\213\345\212\250\347\274\226\350\257\221\346\211\223\345\214\205\345\210\260\351\241\271\347\233\256\346\236\204\345\273\272\345\267\245\345\205\267Maven.md"
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\344\273\216\346\211\213\345\212\250\347\274\226\350\257\221\346\211\223\345\214\205\345\210\260\351\241\271\347\233\256\346\236\204\345\273\272\345\267\245\345\205\267Maven.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [maven简介](#maven简介)
     * [1.1 Maven是什么](#11-maven是什么)
     * [1.2 Maven发展史](#12-maven发展史)
@@ -10,8 +9,6 @@
     * [maven目录](#maven目录)
     * [Maven常用命令说明](#maven常用命令说明)
     * [Maven使用](#maven使用)
-  * [[](http://tengj.top/2018/01/01/maven/#%E4%BE%9D%E8%B5%96%E7%9A%84%E9%85%8D%E7%BD%AE "依赖的配置")依赖的配置](#[]httptengjtop20180101mavene4be9de8b596e79a84e9858de7bdae-依赖的配置依赖的配置)
-  * [[](http://tengj.top/2018/01/01/maven/#%E4%BE%9D%E8%B5%96%E8%8C%83%E5%9B%B4 "依赖范围")依赖范围](#[]httptengjtop20180101mavene4be9de8b596e88c83e59bb4-依赖范围依赖范围)
     * [传递性依赖](#传递性依赖)
     * [依赖范围](#依赖范围)
   * [Maven和Gradle的比较](#maven和gradle的比较)
@@ -21,9 +18,6 @@
     * [一致的构建模型](#一致的构建模型)
     * [插件机制](#插件机制)
   * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [个人公众号：程序员黄小斜](#个人公众号：程序员黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
 
 
 
@@ -94,7 +88,7 @@ Maven不仅是构建工具，还是一个依赖管理工具和项目管理工具
 
 [![image.png](http://www.pianshen.com/images/370/fb1719c12ec1fec62d766168eb5fb2d2.png "image.png")](http://upload-images.jianshu.io/upload_images/5811881-7482108a7ff71031.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240 "image.png")
 
-三：最后设置一下环境变量，将Maven安装配置到操作系统环境中，主要就是配置M2_HOME 和PATH两项，如图
+三：最后设置一下环境变量，将Maven安装配置到操作系统环境中，主要就是配置M2_HOME和PATH两项，如图
 [![image.png](http://www.pianshen.com/images/162/46a29661ccbce3f798e931c61c9b39aa.png "image.png")](http://upload-images.jianshu.io/upload_images/5811881-ffdf167e64415703.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240 "image.png")
 
 都搞定后，验证一下，打开doc输入 mvn -v如何得到下面信息就说明配置成功了
@@ -152,7 +146,7 @@ version指定了项目当前的版本0.0.1-SNAPSHOT,SNAPSHOT意为快照，说
 
 name元素生命了一个对于用户更为友好的项目名称，虽然这不是必须的，但还是推荐为每个POM声明name,以方便信息交流
 
-## [](http://tengj.top/2018/01/01/maven/#%E4%BE%9D%E8%B5%96%E7%9A%84%E9%85%8D%E7%BD%AE "依赖的配置")依赖的配置
+## 依赖的配置
 
 
 
@@ -186,12 +180,12 @@ name元素生命了一个对于用户更为友好的项目名称，虽然这不
 *   optional:标记依赖是否可选
 *   exclusions:用来排除传递性依赖
 
-## [](http://tengj.top/2018/01/01/maven/#%E4%BE%9D%E8%B5%96%E8%8C%83%E5%9B%B4 "依赖范围")依赖范围
+## 依赖范围
 
 依赖范围就是用来控制依赖和三种classpath(编译classpath，测试classpath、运行classpath)的关系，Maven有如下几种依赖范围：
 
 *   compile:编译依赖范围。如果没有指定，就会默认使用该依赖范围。使用此依赖范围的Maven依赖，对于编译、测试、运行三种classpath都有效。典型的例子是spring-code,在编译、测试和运行的时候都需要使用该依赖。
-*   test: 测试依赖范围。使用次依赖范围的Maven依赖，只对于测试classpath有效，在编译主代码或者运行项目的使用时将无法使用此依赖。典型的例子是Jnuit,它只有在编译测试代码及运行测试的时候才需要。
+*   test:测试依赖范围。使用次依赖范围的Maven依赖，只对于测试classpath有效，在编译主代码或者运行项目的使用时将无法使用此依赖。典型的例子是Jnuit,它只有在编译测试代码及运行测试的时候才需要。
 *   provided:已提供依赖范围。使用此依赖范围的Maven依赖，对于编译和测试classpath有效，但在运行时候无效。典型的例子是servlet-api,编译和测试项目的时候需要该依赖，但在运行项目的时候，由于容器以及提供，就不需要Maven重复地引入一遍。
 *   runtime:运行时依赖范围。使用此依赖范围的Maven依赖，对于测试和运行classpath有效，但在编译主代码时无效。典型的例子是JDBC驱动实现，项目主代码的编译只需要JDK提供的JDBC接口，只有在执行测试或者运行项目的时候才需要实现上述接口的具体JDBC驱动。
 *   system:系统依赖范围。该依赖与三种classpath的关系，和provided依赖范围完全一致，但是，使用system范围的依赖时必须通过systemPath元素显示地指定依赖文件的路径。由于此类依赖不是通过Maven仓库解析的，而且往往与本机系统绑定，可能构成构建的不可移植，因此应该谨慎使用。systemPath元素可以引用环境变量，如：
@@ -321,37 +315,6 @@ https://blog.csdn.net/u012131888/article/details/78209514
 https://blog.csdn.net/belvine/article/details/81073365
 https://blog.csdn.net/u012131888/article/details/78209514
 
-## 微信公众号
-
-### 个人公众号：程序员黄小斜
-
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注微信公众号【程序员黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
-
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的微信公众号【Java技术江湖】
-
-这是一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-
-**Java工程师必备学习资源:** 
-关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
-
 
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
 
-​                     
+                     
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2145\357\274\232\345\210\235\346\216\242Tomcat\347\232\204HTTP\350\257\267\346\261\202\350\277\207\347\250\213.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\345\210\235\346\216\242Tomcat9\347\232\204HTTP\350\257\267\346\261\202\350\277\207\347\250\213.md"
similarity index 51%
rename from "docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2145\357\274\232\345\210\235\346\216\242Tomcat\347\232\204HTTP\350\257\267\346\261\202\350\277\207\347\250\213.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\345\210\235\346\216\242Tomcat9\347\232\204HTTP\350\257\267\346\261\202\350\277\207\347\250\213.md"
index 921ddf8..1ecfd2a 100644
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2145\357\274\232\345\210\235\346\216\242Tomcat\347\232\204HTTP\350\257\267\346\261\202\350\277\207\347\250\213.md"
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\345\210\235\346\216\242Tomcat9\347\232\204HTTP\350\257\267\346\261\202\350\277\207\347\250\213.md"
@@ -1,14 +1,10 @@
-# Table of Contents
-
-* [[走进JavaWeb技术世界5：初探Tomcat的HTTP请求过程](https://www.cnblogs.com/xll1025/p/11366264.html)](#[走进javaweb技术世界5：初探tomcat的http请求过程]httpswwwcnblogscomxll1025p11366264html)
+# 目录
   * [初探Tomcat的HTTP请求过程](#初探tomcat的http请求过程)
   * [Tomcat的组织结构](#tomcat的组织结构)
     * [由Server.xml的结构看Tomcat的体系结构](#由serverxml的结构看tomcat的体系结构)
   * [Tomcat Server处理一个HTTP请求的过程](#tomcat-server处理一个http请求的过程)
   * [参考文章](#参考文章)
 
-
-
 本文转载自互联网，侵删
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -29,22 +25,14 @@
 **文末赠送8000G的Java架构师学习资料，需要的朋友可以到文末了解领取方式，资料包括Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源）**
 <!-- more -->
 
-# [走进JavaWeb技术世界5：初探Tomcat的HTTP请求过程](https://www.cnblogs.com/xll1025/p/11366264.html)
-
-
-
-
-
 ## 初探Tomcat的HTTP请求过程
 
-![图片描述](https://img.mukewang.com/5a26678e0001e76d03630101.png)
-
 前言：
 1.作为Java开发人员，大多都对Tomcat不陌生，由Apache基金会提供技术支持与维护，因为其免费开源且易用，作为Web服务器深受市场欢迎，所以有必要对其进行深入的研究，本系列皆以Tomcat 8.5为研究课题，下载地址：[https://tomcat.apache.org/download-80.cgi](https://tomcat.apache.org/download-80.cgi)
 
 2.下图为 apache-tomcat-8.5.23.zip 在windows解压后的目录。
 
-![图片描述](https://img.mukewang.com/5a26681100015daf10210411.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405152548.png)
 
 下面是解压后的一些关键目录:
 
@@ -81,264 +69,266 @@ Resource模块: 这个子模块包含一些资源文件，如Server.xml及Web.xm
 
 ## Tomcat的组织结构
 
-*   Tomcat是一个基于组件的服务器，它的构成组件都是可配置的，其中最外层的是Catalina servlet容器，其他组件按照一定的格式要求配置在这个顶层容器中。 
+*   Tomcat是一个基于组件的服务器，它的构成组件都是可配置的，其中最外层的是Catalina servlet容器，其他组件按照一定的格式要求配置在这个顶层容器中。
     Tomcat的各种组件都是在Tomcat安装目录下的/conf/server.xml文件中配置的。
 
 ### 由Server.xml的结构看Tomcat的体系结构
+````
+<Server>                                                //顶层类元素，可以包括多个Service   
+
+    <Service>                                           //顶层类元素，可包含一个Engine，多个Connecter
+
+        <Connector>                                     //连接器类元素，代表通信接口
+
+                <Engine>                                //容器类元素，为特定的Service组件处理客户请求，要包含多个Host
+
+                        <Host>                          //容器类元素，为特定的虚拟主机组件处理客户请求，可包含多个Context
+
+                                <Context>               //容器类元素，为特定的Web应用处理所有的客户请求
+
+                                </Context>
+
+                        </Host>
+
+                </Engine>
 
-    <Server>                                                //顶层类元素，可以包括多个Service   
-    
-        <Service>                                           //顶层类元素，可包含一个Engine，多个Connecter
-    
-            <Connector>                                     //连接器类元素，代表通信接口
-    
-                    <Engine>                                //容器类元素，为特定的Service组件处理客户请求，要包含多个Host
-    
-                            <Host>                          //容器类元素，为特定的虚拟主机组件处理客户请求，可包含多个Context
-    
-                                    <Context>               //容器类元素，为特定的Web应用处理所有的客户请求
-    
-                                    </Context>
-    
-                            </Host>
-    
-                    </Engine>
-    
-            </Connector>
-    
-        </Service>
-    
-    </Server>
+        </Connector>
 
+    </Service>
+
+</Server>
+````
 实际源码如下：
+````
+<?xml version='1.0' encoding='utf-8'?>
+
+<Server port="8005" shutdown="SHUTDOWN">
+
+  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
+
+  <!-- Security listener. Documentation at /docs/config/listeners.html
+
+  <Listener className="org.apache.catalina.security.SecurityListener" />
+
+  -->
+
+  <!--APR library loader. Documentation at /docs/apr.html -->
+
+  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
+
+  <!--Initialize Jasper prior to webapps are loaded. Documentation at /docs/jasper-howto.html -->
+
+  <Listener className="org.apache.catalina.core.JasperListener" />
+
+  <!-- Prevent memory leaks due to use of particular java/javax APIs-->
+
+  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
+
+  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
+
+  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
+
+  <!-- Global JNDI resources
+
+       Documentation at /docs/jndi-resources-howto.html
+
+  -->
+
+  <GlobalNamingResources>
+
+    <!-- Editable user database that can also be used by
+
+         UserDatabaseRealm to authenticate users
+
+    -->
+
+    <Resource name="UserDatabase" auth="Container"
+
+              type="org.apache.catalina.UserDatabase"
+
+              description="User database that can be updated and saved"
+
+              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
+
+              pathname="conf/tomcat-users.xml" />
+
+  </GlobalNamingResources>
+
+  <!-- A "Service" is a collection of one or more "Connectors" that share
+
+       a single "Container" Note:  A "Service" is not itself a "Container",
+
+       so you may not define subcomponents such as "Valves" at this level.
+
+       Documentation at /docs/config/service.html
+
+   -->
+
+  <Service name="Catalina">
+
+    <!--The connectors can use a shared executor, you can define one or more named thread pools-->
+
+    <!--
+
+    <Executor name="tomcatThreadPool" namePrefix="catalina-exec-"
+
+        maxThreads="150" minSpareThreads="4"/>
+
+    -->
+
+    <!-- A "Connector" represents an endpoint by which requests are received
+
+         and responses are returned. Documentation at :
+
+         Java HTTP Connector: /docs/config/http.html (blocking & non-blocking)
+
+         Java AJP  Connector: /docs/config/ajp.html
+
+         APR (HTTP/AJP) Connector: /docs/apr.html
+
+         Define a non-SSL HTTP/1.1 Connector on port 8080
+
+    -->
+
+    <Connector port="8080" protocol="HTTP/1.1"
+
+               connectionTimeout="20000"
+
+               redirectPort="8443" />
+
+    <!-- A "Connector" using the shared thread pool-->
+
+    <!--
+
+    <Connector executor="tomcatThreadPool"
+
+               port="8080" protocol="HTTP/1.1"
+
+               connectionTimeout="20000"
+
+               redirectPort="8443" />
+
+    -->
+
+    <!-- Define a SSL HTTP/1.1 Connector on port 8443
+
+         This connector uses the BIO implementation that requires the JSSE
+
+         style configuration. When using the APR/native implementation, the
+
+         OpenSSL style configuration is required as described in the APR/native
+
+         documentation -->
+
+    <!--
+
+    <Connector port="8443" protocol="org.apache.coyote.http11.Http11Protocol"
+
+               maxThreads="150" SSLEnabled="true" scheme="https" secure="true"
+
+               clientAuth="false" sslProtocol="TLS" />
+
+    -->
+
+    <!-- Define an AJP 1.3 Connector on port 8009 -->
+
+    <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
+
+    <!-- An Engine represents the entry point (within Catalina) that processes
+
+         every request.  The Engine implementation for Tomcat stand alone
+
+         analyzes the HTTP headers included with the request, and passes them
+
+         on to the appropriate Host (virtual host).
+
+         Documentation at /docs/config/engine.html -->
+
+    <!-- You should set jvmRoute to support load-balancing via AJP ie :
+
+    <Engine name="Catalina" defaultHost="localhost" jvmRoute="jvm1">
+
+    -->
+
+    <Engine name="Catalina" defaultHost="localhost">
+
+      <!--For clustering, please take a look at documentation at:
+
+          /docs/cluster-howto.html  (simple how to)
+
+          /docs/config/cluster.html (reference documentation) -->
+
+      <!--
+
+      <Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/>
 
-    <?xml version='1.0' encoding='utf-8'?>
-    
-    <Server port="8005" shutdown="SHUTDOWN">
-    
-      <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
-    
-      <!-- Security listener. Documentation at /docs/config/listeners.html
-    
-      <Listener className="org.apache.catalina.security.SecurityListener" />
-    
-      -->
-    
-      <!--APR library loader. Documentation at /docs/apr.html -->
-    
-      <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
-    
-      <!--Initialize Jasper prior to webapps are loaded. Documentation at /docs/jasper-howto.html -->
-    
-      <Listener className="org.apache.catalina.core.JasperListener" />
-    
-      <!-- Prevent memory leaks due to use of particular java/javax APIs-->
-    
-      <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
-    
-      <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
-    
-      <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
-    
-      <!-- Global JNDI resources
-    
-           Documentation at /docs/jndi-resources-howto.html
-    
       -->
-    
-      <GlobalNamingResources>
-    
-        <!-- Editable user database that can also be used by
-    
-             UserDatabaseRealm to authenticate users
-    
-        -->
-    
-        <Resource name="UserDatabase" auth="Container"
-    
-                  type="org.apache.catalina.UserDatabase"
-    
-                  description="User database that can be updated and saved"
-    
-                  factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
-    
-                  pathname="conf/tomcat-users.xml" />
-    
-      </GlobalNamingResources>
-    
-      <!-- A "Service" is a collection of one or more "Connectors" that share
-    
-           a single "Container" Note:  A "Service" is not itself a "Container",
-    
-           so you may not define subcomponents such as "Valves" at this level.
-    
-           Documentation at /docs/config/service.html
-    
-       -->
-    
-      <Service name="Catalina">
-    
-        <!--The connectors can use a shared executor, you can define one or more named thread pools-->
-    
-        <!--
-    
-        <Executor name="tomcatThreadPool" namePrefix="catalina-exec-"
-    
-            maxThreads="150" minSpareThreads="4"/>
-    
-        -->
-    
-        <!-- A "Connector" represents an endpoint by which requests are received
-    
-             and responses are returned. Documentation at :
-    
-             Java HTTP Connector: /docs/config/http.html (blocking & non-blocking)
-    
-             Java AJP  Connector: /docs/config/ajp.html
-    
-             APR (HTTP/AJP) Connector: /docs/apr.html
-    
-             Define a non-SSL HTTP/1.1 Connector on port 8080
-    
-        -->
-    
-        <Connector port="8080" protocol="HTTP/1.1"
-    
-                   connectionTimeout="20000"
-    
-                   redirectPort="8443" />
-    
-        <!-- A "Connector" using the shared thread pool-->
-    
-        <!--
-    
-        <Connector executor="tomcatThreadPool"
-    
-                   port="8080" protocol="HTTP/1.1"
-    
-                   connectionTimeout="20000"
-    
-                   redirectPort="8443" />
-    
-        -->
-    
-        <!-- Define a SSL HTTP/1.1 Connector on port 8443
-    
-             This connector uses the BIO implementation that requires the JSSE
-    
-             style configuration. When using the APR/native implementation, the
-    
-             OpenSSL style configuration is required as described in the APR/native
-    
-             documentation -->
-    
+
+      <!-- Use the LockOutRealm to prevent attempts to guess user passwords
+
+           via a brute-force attack -->
+
+      <Realm className="org.apache.catalina.realm.LockOutRealm">
+
+        <!-- This Realm uses the UserDatabase configured in the global JNDI
+
+             resources under the key "UserDatabase".  Any edits
+
+             that are performed against this UserDatabase are immediately
+
+             available for use by the Realm.  -->
+
+        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
+
+               resourceName="UserDatabase"/>
+
+      </Realm>
+
+      <Host name="localhost"  appBase="webapps"
+
+            unpackWARs="true" autoDeploy="true">
+
+        <!-- SingleSignOn valve, share authentication between web applications
+
+             Documentation at: /docs/config/valve.html -->
+
         <!--
-    
-        <Connector port="8443" protocol="org.apache.coyote.http11.Http11Protocol"
-    
-                   maxThreads="150" SSLEnabled="true" scheme="https" secure="true"
-    
-                   clientAuth="false" sslProtocol="TLS" />
-    
-        -->
-    
-        <!-- Define an AJP 1.3 Connector on port 8009 -->
-    
-        <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
-    
-        <!-- An Engine represents the entry point (within Catalina) that processes
-    
-             every request.  The Engine implementation for Tomcat stand alone
-    
-             analyzes the HTTP headers included with the request, and passes them
-    
-             on to the appropriate Host (virtual host).
-    
-             Documentation at /docs/config/engine.html -->
-    
-        <!-- You should set jvmRoute to support load-balancing via AJP ie :
-    
-        <Engine name="Catalina" defaultHost="localhost" jvmRoute="jvm1">
-    
+
+        <Valve className="org.apache.catalina.authenticator.SingleSignOn" />
+
         -->
-    
-        <Engine name="Catalina" defaultHost="localhost">
-    
-          <!--For clustering, please take a look at documentation at:
-    
-              /docs/cluster-howto.html  (simple how to)
-    
-              /docs/config/cluster.html (reference documentation) -->
-    
-          <!--
-    
-          <Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/>
-    
-          -->
-    
-          <!-- Use the LockOutRealm to prevent attempts to guess user passwords
-    
-               via a brute-force attack -->
-    
-          <Realm className="org.apache.catalina.realm.LockOutRealm">
-    
-            <!-- This Realm uses the UserDatabase configured in the global JNDI
-    
-                 resources under the key "UserDatabase".  Any edits
-    
-                 that are performed against this UserDatabase are immediately
-    
-                 available for use by the Realm.  -->
-    
-            <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
-    
-                   resourceName="UserDatabase"/>
-    
-          </Realm>
-    
-          <Host name="localhost"  appBase="webapps"
-    
-                unpackWARs="true" autoDeploy="true">
-    
-            <!-- SingleSignOn valve, share authentication between web applications
-    
-                 Documentation at: /docs/config/valve.html -->
-    
-            <!--
-    
-            <Valve className="org.apache.catalina.authenticator.SingleSignOn" />
-    
-            -->
-    
-            <!-- Access log processes all example.
-    
-                 Documentation at: /docs/config/valve.html
-    
-                 Note: The pattern used is equivalent to using pattern="common" -->
-    
-            <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
-    
-                   prefix="localhost_access_log." suffix=".txt"
-    
-                   pattern="%h %l %u %t "%r" %s %b" />
-    
-          </Host>
-    
-        </Engine>
-    
-      </Service>
-    
-    </Server>
-
-由上可得出Tomcat的体系结构： 
-![](https://images2015.cnblogs.com/blog/665375/201601/665375-20160119185045031-1958903281.jpg) 
+
+        <!-- Access log processes all example.
+
+             Documentation at: /docs/config/valve.html
+
+             Note: The pattern used is equivalent to using pattern="common" -->
+
+        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
+
+               prefix="localhost_access_log." suffix=".txt"
+
+               pattern="%h %l %u %t "%r" %s %b" />
+
+      </Host>
+
+    </Engine>
+
+  </Service>
+
+</Server>
+````
+由上可得出Tomcat的体系结构：
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405152741.png)
+
 图一：Tomcat的体系结构
 
 由上图可看出Tomca的心脏是两个组件：Connecter和Container。一个Container可以选择多个Connecter，多个Connector和一个Container就形成了一个Service。Service可以对外提供服务，而Server服务器控制整个Tomcat的生命周期。
 
 ## Tomcat Server处理一个HTTP请求的过程
 
-![](https://images2015.cnblogs.com/blog/665375/201601/665375-20160119184923890-1995839223.png) 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405152756.png)
+
 图三：Tomcat Server处理一个HTTP请求的过程
 
 Tomcat Server处理一个HTTP请求的过程
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21411\357\274\232\345\215\225\345\205\203\346\265\213\350\257\225\346\241\206\346\236\266Junit.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\345\215\225\345\205\203\346\265\213\350\257\225\346\241\206\346\236\266Junit.md"
similarity index 53%
rename from "docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21411\357\274\232\345\215\225\345\205\203\346\265\213\350\257\225\346\241\206\346\236\266Junit.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\345\215\225\345\205\203\346\265\213\350\257\225\346\241\206\346\236\266Junit.md"
index 3c00524..ee6dffc 100644
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21411\357\274\232\345\215\225\345\205\203\346\265\213\350\257\225\346\241\206\346\236\266Junit.md"
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\345\215\225\345\205\203\346\265\213\350\257\225\346\241\206\346\236\266Junit.md"
@@ -1,25 +1,21 @@
-# Table of Contents
-
-  * [简介](#简介)
-  * [概述](#概述)
-  * [好处](#好处)
-  * [Junit单元测试](#junit单元测试)
+# 目录
+* [简介](#简介)
+* [概述](#概述)
+* [好处](#好处)
+* [Junit单元测试](#junit单元测试)
     * [1 简介](#1-简介)
     * [2 特点](#2-特点)
     * [3 内容](#3-内容)
-      * [3.1 注解](#31-注解)
-      * [3.2 断言](#32-断言)
+        * [3.1 注解](#31-注解)
+        * [3.2 断言](#32-断言)
     * [4 JUnit 3.X 和 JUnit 4.X 的区别](#4-junit-3x-和-junit-4x-的区别)
-      * [4.1 JUnit 3.X](#41-junit-3x)
-      * [4.2 JUnit 4.X](#42-junit-4x)
-      * [4.3 特别提醒](#43-特别提醒)
+        * [4.1 JUnit 3.X](#41-junit-3x)
+        * [4.2 JUnit 4.X](#42-junit-4x)
+        * [4.3 特别提醒](#43-特别提醒)
     * [5 测试示例](#5-测试示例)
-      * [5.1 示例一：简单的 JUnit 3.X 测试](#51-示例一：简单的-junit-3x-测试)
+        * [5.1 示例一：简单的 JUnit 3.X 测试](#51-示例一：简单的-junit-3x-测试)
     * [6 个人建议](#6-个人建议)
-  * [8 大单元测试框架](#8-大单元测试框架)
-  * [微信公众号](#微信公众号)
-    * [个人公众号：程序员黄小斜](#个人公众号：程序员黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
+* [8 大单元测试框架](#8-大单元测试框架)
 
 
 
@@ -46,11 +42,11 @@
 
 ## 简介
 
-测试 在软件开发中是一个很重要的方面，良好的测试可以在很大程度决定一个应用的命运。
+测试在软件开发中是一个很重要的方面，良好的测试可以在很大程度决定一个应用的命运。
 软件测试中，主要有3大种类：
 
 *   [单元测试](https://en.wikipedia.org/wiki/Unit_testing)
-    单元测试主要是用于测试程序模块，确保代码运行正确。单元测试是由开发者编写并进行运行测试。一般使用的测试框架是 [JUnit](http://junit.org/junit4/) 或者 [TestNG](https://github.com/cbeust/testng)。测试用例一般是针对_方法_ 级别的测试。
+    单元测试主要是用于测试程序模块，确保代码运行正确。单元测试是由开发者编写并进行运行测试。一般使用的测试框架是[JUnit](http://junit.org/junit4/)或者[TestNG](https://github.com/cbeust/testng)。测试用例一般是针对_方法_级别的测试。
 *   [集成测试](https://en.wikipedia.org/wiki/Integration_testing)
     集成测试用于检测系统是否能正常工作。集成测试也是由开发者共同进行测试，与单元测试专注测试个人代码组件不同的是，集成测试是系统进行跨组件测试。
 *   [功能性测试](https://en.wikipedia.org/wiki/Functional_testing)
@@ -58,18 +54,18 @@
 
 ## 概述
 
-本文只对 [单元测试](https://en.wikipedia.org/wiki/Unit_testing) 进行介绍，主要介绍如何在 [Android Studio](https://developer.android.com/studio/index.html?gclid=Cj0KCQjwgIPOBRDnARIsAHA1X3SC5vOHyIHQnIIfJ8hqJSuTiCG6p3u2ff_ti3EIVeCIGJLnP82YCKoaArSPEALw_wcB) 下进行单元测试，单元测试使用的测试框架为 [JUnit](http://junit.org/junit4/)
+本文只对[单元测试](https://en.wikipedia.org/wiki/Unit_testing)进行介绍，主要介绍如何在[Android Studio](https://developer.android.com/studio/index.html?gclid=Cj0KCQjwgIPOBRDnARIsAHA1X3SC5vOHyIHQnIIfJ8hqJSuTiCG6p3u2ff_ti3EIVeCIGJLnP82YCKoaArSPEALw_wcB)下进行单元测试，单元测试使用的测试框架为[JUnit](http://junit.org/junit4/)
 
 ## 好处
 
-可能目前仍有很大一部分开发者未使用 [单元测试](https://en.wikipedia.org/wiki/Unit_testing) 对他们的代码进行测试，一方面可能是觉得没有必要，因为即使没有进行单元测试，程序照样运行得很好；另一方面，也许有些人也认同单元测试的好处，但是由于需要额外的学习成本，所以很多人也是没有时间或者说是没有耐心进行学习······
-这里我想说的是，如果大家去看下 [github](https://www.jianshu.com/p/www.github.com) 上目前主流的开源框架，star 数比较多的项目，一般都有很详尽的测试用例。所以说，单元测试对于我们的项目开发，还是挺有好处的。
+可能目前仍有很大一部分开发者未使用[单元测试](https://en.wikipedia.org/wiki/Unit_testing)对他们的代码进行测试，一方面可能是觉得没有必要，因为即使没有进行单元测试，程序照样运行得很好；另一方面，也许有些人也认同单元测试的好处，但是由于需要额外的学习成本，所以很多人也是没有时间或者说是没有耐心进行学习······
+这里我想说的是，如果大家去看下[github](https://www.jianshu.com/p/www.github.com)上目前主流的开源框架，star 数比较多的项目，一般都有很详尽的测试用例。所以说，单元测试对于我们的项目开发，还是挺有好处的。
 至于单元测试的好处，我这里提及几点：
 
 *   保证代码运行与我们预想的一样，代码正确性可以得到保证
 *   程序运行出错时，有利于我们对错误进行查找（因为我们忽略我们测试通过的代码）
 *   有利于提升代码架构设计（用于测试的用例应力求简单低耦合，因此编写代码的时候，开发者往往会为了对代码进行测试，将其他耦合的部分进行解耦处理）
-    ······
+    
 
 ## Junit单元测试
 
@@ -110,20 +106,20 @@ JUnit有它自己的JUnit扩展生态圈，多数Java的开发环境都已经集
 @Ignore ：该注释表示，当想暂时禁用特定的测试执行可以使用忽略注释，每个被注解为@Ignore的方法将不被执行。
 
 
+````
+/
+* JUnit 注解示例
+*/
+@Test
+public void testYeepay(){
+  Syetem.out.println("用@Test标示测试方法！");
+}
+@AfterClass
+public static void paylus(){
+  Syetem.out.println("用@AfterClass标示的方法在测试用例类执行完之后！");
+}
 
-    /
-    * JUnit 注解示例
-    */
-    @Test
-    public void testYeepay(){
-      Syetem.out.println("用@Test标示测试方法！");
-    }
-    @AfterClass
-    public static void paylus(){
-      Syetem.out.println("用@AfterClass标示的方法在测试用例类执行完之后！");
-    }
-
-
+````
 
 
 
@@ -132,17 +128,17 @@ JUnit有它自己的JUnit扩展生态圈，多数Java的开发环境都已经集
 #### 3.2 断言
 
 在这里，作者将介绍一些断言方法，所有这些方法都来自 org.junit.Assert 类，其扩展了 java.lang.Object 类并为它们提供编写测试，以便检测故障。简而言之，我们就是通过断言方法来判断实际结果与我们预期的结果是否相同，如果相同，则测试成功，反之，则测试失败。
-
-    void assertEquals([String message], expected value, actual value) ：断言两个值相等，值的类型可以为int、short、long、byte、char 或者
-    java.lang.Object，其中第一个参数是一个可选的字符串消息；
-    void assertTrue([String message], boolean condition) ：断言一个条件为真；
-    void assertFalse([String message],boolean condition) ：断言一个条件为假；
-    void assertNotNull([String message], java.lang.Object object) ：断言一个对象不为空(null)；
-    void assertNull([String message], java.lang.Object object) ：断言一个对象为空(null)；
-    void assertSame([String message], java.lang.Object expected, java.lang.Object actual) ：断言两个对象引用相同的对象；
-    void assertNotSame([String message], java.lang.Object unexpected, java.lang.Object actual) ：断言两个对象不是引用同一个对象；
-    void assertArrayEquals([String message], expectedArray, resultArray) ：断言预期数组和结果数组相等，数组的类型可以为int、long、short、char、byte 或者 java.lang.Object
-
+````
+void assertEquals([String message], expected value, actual value)：断言两个值相等，值的类型可以为int、short、long、byte、char 或者
+java.lang.Object，其中第一个参数是一个可选的字符串消息；
+void assertTrue([String message], boolean condition)：断言一个条件为真；
+void assertFalse([String message],boolean condition)：断言一个条件为假；
+void assertNotNull([String message], java.lang.Object object)：断言一个对象不为空(null)；
+void assertNull([String message], java.lang.Object object)：断言一个对象为空(null)；
+void assertSame([String message], java.lang.Object expected, java.lang.Object actual)：断言两个对象引用相同的对象；
+void assertNotSame([String message], java.lang.Object unexpected, java.lang.Object actual)：断言两个对象不是引用同一个对象；
+void assertArrayEquals([String message], expectedArray, resultArray)：断言预期数组和结果数组相等，数组的类型可以为int、long、short、char、byte 或者 java.lang.Object
+````
 ### 4 JUnit 3.X 和 JUnit 4.X 的区别
 
 #### 4.1 JUnit 3.X
@@ -159,43 +155,40 @@ JUnit有它自己的JUnit扩展生态圈，多数Java的开发环境都已经集
 
 （4）要掌握好测试方法的顺序，不能依赖于测试方法自己的执行顺序。
 
-
-    /
-    * 用 JUnit 3.X 进行测试
-    */
-    import junit.framework.Assert;
-    import junit.framework.TestCase;
-    public class TestOperation extends TestCase {
-      private Operation operation;
-      public TestOperation(String name) { // 构造函数
-        super(name);
-      }
-      @Override
-      public void setUp() throws Exception { // 在每个测试方法执行 [之前] 都会被调用，多用于初始化
-        System.out.println("欢迎使用Junit进行单元测试...");
-        operation = new Operation();
-      }
-      @Override
-      public void tearDown() throws Exception { // 在每个测试方法执行 [之后] 都会被调用，多用于释放资源
-        System.out.println("Junit单元测试结束...");
-      }
-      public void testDivideByZero() {
-        Throwable te = null;
-        try {
-          operation.divide(6, 0);
-          Assert.fail("测试失败"); //断言失败
-        } catch (Exception e) {
-          e.printStackTrace();
-          te = e;
-        }
-        Assert.assertEquals(Exception.class, te.getClass());
-        Assert.assertEquals("除数不能为 0 ", te.getMessage());
-      }
+````
+/
+* 用 JUnit 3.X 进行测试
+*/
+import junit.framework.Assert;
+import junit.framework.TestCase;
+public class TestOperation extends TestCase {
+  private Operation operation;
+  public TestOperation(String name) { // 构造函数
+    super(name);
+  }
+  @Override
+  public void setUp() throws Exception { // 在每个测试方法执行 [之前] 都会被调用，多用于初始化
+    System.out.println("欢迎使用Junit进行单元测试...");
+    operation = new Operation();
+  }
+  @Override
+  public void tearDown() throws Exception { // 在每个测试方法执行 [之后] 都会被调用，多用于释放资源
+    System.out.println("Junit单元测试结束...");
+  }
+  public void testDivideByZero() {
+    Throwable te = null;
+    try {
+      operation.divide(6, 0);
+      Assert.fail("测试失败"); //断言失败
+    } catch (Exception e) {
+      e.printStackTrace();
+      te = e;
     }
-
-
-
-
+    Assert.assertEquals(Exception.class, te.getClass());
+    Assert.assertEquals("除数不能为 0 ", te.getMessage());
+  }
+}
+````
 
 #### 4.2 JUnit 4.X
 
@@ -203,89 +196,84 @@ JUnit有它自己的JUnit扩展生态圈，多数Java的开发环境都已经集
 （2）JUnit 4.X 版本，引用了注解的方式进行单元测试；
 （3）JUnit 4.X 版本我们常用的注解包括：
 
-@Before 注解：与JUnit 3.X 中的 setUp() 方法功能一样，在每个测试方法之前执行，多用于初始化；
+@Before注解：与JUnit 3.X 中的 setUp() 方法功能一样，在每个测试方法之前执行，多用于初始化；
 
-@After 注解：与 JUnit 3.X 中的 tearDown() 方法功能一样，在每个测试方法之后执行，多用于释放资源；
+@After注解：与 JUnit 3.X 中的 tearDown() 方法功能一样，在每个测试方法之后执行，多用于释放资源；
 
-@Test(timeout = xxx) 注解：设置当前测试方法在一定时间内运行完，否则返回错误；
+@Test(timeout = xxx)注解：设置当前测试方法在一定时间内运行完，否则返回错误；
 
-@Test(expected = Exception.class) 注解：设置被测试的方法是否有异常抛出。抛出异常类型为：Exception.class；
+@Test(expected = Exception.class)注解：设置被测试的方法是否有异常抛出。抛出异常类型为：Exception.class；
 
 此外，我们可以通过阅读上面的第二部分“2 注解”了解更多的注解。
 
-
-
-
-    /
-    * 用 JUnit 4.X 进行测试
-    */
-    import static org.junit.Assert.*;
-    import org.junit.After;
-    import org.junit.AfterClass;
-    import org.junit.Before;
-    import org.junit.BeforeClass;
-    import org.junit.Test;
-    public class TestOperation {
-      private Operation operation;
-      @BeforeClass
-      public static void globalInit() { // 在所有方法执行之前执行
-        System.out.println("@BeforeClass标注的方法，在所有方法执行之前执行...");
-      }
-      @AfterClass
-      public static void globalDestory() { // 在所有方法执行之后执行
-        System.out.println("@AfterClass标注的方法，在所有方法执行之后执行...");
-      }
-      @Before
-      public void setUp() { // 在每个测试方法之前执行
-        System.out.println("@Before标注的方法，在每个测试方法之前执行...");
-        operation = new Operation();
-      }
-      @After
-      public void tearDown() { // 在每个测试方法之后执行
-        System.out.println("@After标注的方法，在每个测试方法之后执行...");
-      }
-      @Test(timeout=600)
-      public void testAdd() { // 设置限定测试方法的运行时间 如果超出则返回错误
-        System.out.println("测试 add 方法...");
-        int result = operation.add(2, 3);
-        assertEquals(5, result);
-      }
-      @Test
-      public void testSubtract() {
-        System.out.println("测试 subtract 方法...");
-        int result = operation.subtract(1, 2);
-        assertEquals(-1, result);
-      }
-      @Test
-      public void testMultiply() {
-        System.out.println("测试 multiply 方法...");
-        int result = operation.multiply(2, 3);
-        assertEquals(6, result);
-      }
-      @Test
-      public void testDivide() {
-        System.out.println("测试 divide 方法...");
-        int result = 0;
-        try {
-          result = operation.divide(6, 2);
-        } catch (Exception e) {
-          fail();
-        }
-        assertEquals(3, result);
-      }
-      @Test(expected = Exception.class)
-      public void testDivideAgain() throws Exception {
-        System.out.println("测试 divide 方法，除数为 0 的情况...");
-        operation.divide(6, 0);
-        fail("test Error");
-      }
-      public static void main(String[] args) {
-      }
+````
+/
+* 用 JUnit 4.X 进行测试
+*/
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+public class TestOperation {
+  private Operation operation;
+  @BeforeClass
+  public static void globalInit() { // 在所有方法执行之前执行
+    System.out.println("@BeforeClass标注的方法，在所有方法执行之前执行...");
+  }
+  @AfterClass
+  public static void globalDestory() { // 在所有方法执行之后执行
+    System.out.println("@AfterClass标注的方法，在所有方法执行之后执行...");
+  }
+  @Before
+  public void setUp() { // 在每个测试方法之前执行
+    System.out.println("@Before标注的方法，在每个测试方法之前执行...");
+    operation = new Operation();
+  }
+  @After
+  public void tearDown() { // 在每个测试方法之后执行
+    System.out.println("@After标注的方法，在每个测试方法之后执行...");
+  }
+  @Test(timeout=600)
+  public void testAdd() { // 设置限定测试方法的运行时间 如果超出则返回错误
+    System.out.println("测试 add 方法...");
+    int result = operation.add(2, 3);
+    assertEquals(5, result);
+  }
+  @Test
+  public void testSubtract() {
+    System.out.println("测试 subtract 方法...");
+    int result = operation.subtract(1, 2);
+    assertEquals(-1, result);
+  }
+  @Test
+  public void testMultiply() {
+    System.out.println("测试 multiply 方法...");
+    int result = operation.multiply(2, 3);
+    assertEquals(6, result);
+  }
+  @Test
+  public void testDivide() {
+    System.out.println("测试 divide 方法...");
+    int result = 0;
+    try {
+      result = operation.divide(6, 2);
+    } catch (Exception e) {
+      fail();
     }
-
-
-
-
+    assertEquals(3, result);
+  }
+  @Test(expected = Exception.class)
+  public void testDivideAgain() throws Exception {
+    System.out.println("测试 divide 方法，除数为 0 的情况...");
+    operation.divide(6, 0);
+    fail("test Error");
+  }
+  public static void main(String[] args) {
+  }
+}
+````
 #### 4.3 特别提醒
 
 通过以上两个例子，我们已经可以大致知道 JUnit 3.X 和 JUnit 4.X 两个版本的区别啦！
@@ -298,72 +286,72 @@ JUnit有它自己的JUnit扩展生态圈，多数Java的开发环境都已经集
 
 此外，在上面的两个示例中，我们只给出了测试类，但是在这之前，还应该有一个被测试类，也就是我们真正要实现功能的类。现在，作者将给出上面示例中被测试的类，即 Operation 类：
 
-
-    /
-    * 定义了加减乘除的法则
-    */
-    public class Operation {
-      public static void main(String[] args) {
-        System.out.println("a + b = " + add(1,2));
-        System.out.println("a - b = " + subtract(1,2));
-        System.out.println("a * b = " + multiply(1,2));
-        System.out.println("a / b = " + divide(4,2));
-        System.out.println("a / b = " + divide(1,0));
-      }
-      public static int add(int a, int b) {
-        return a + b;
-      }
-      public static int subtract(int a, int b) {
-        return a - b;
-      }
-      public static int multiply(int a, int b) {
-        return a * b;
-      }
-      public static int divide(int a, int b) {
-        return a / b;
-      }
-    }
-
+````
+/
+* 定义了加减乘除的法则
+*/
+public class Operation {
+  public static void main(String[] args) {
+    System.out.println("a + b = " + add(1,2));
+    System.out.println("a - b = " + subtract(1,2));
+    System.out.println("a * b = " + multiply(1,2));
+    System.out.println("a / b = " + divide(4,2));
+    System.out.println("a / b = " + divide(1,0));
+  }
+  public static int add(int a, int b) {
+    return a + b;
+  }
+  public static int subtract(int a, int b) {
+    return a - b;
+  }
+  public static int multiply(int a, int b) {
+    return a * b;
+  }
+  public static int divide(int a, int b) {
+    return a / b;
+  }
+}
+````
 
 
 ### 5 测试示例
 
 #### 5.1 示例一：简单的 JUnit 3.X 测试
 
-
-    import junit.framework.Test;
-    import junit.framework.TestCase;
-    import junit.framework.TestSuite;
-    import java.util.ArrayList;
-    import java.util.Collection;
-    /
-     * 1、创建一个测试类，继承TestCase类
-     */
-    public class SimpleTestDemo extends TestCase {
-      public SimpleTestDemo(String name) {
-        super(name);
-      }
-      /
-       * 2、写一个测试方法，断言期望的结果
-       */
-      public void testEmptyCollection(){
-        Collection collection = new ArrayList();
-        assertTrue(collection.isEmpty());
-      }
-      /
-       * 3、写一个suite()方法，它会使用反射动态的创建一个包含所有的testXxxx方法的测试套件
-       */
-      public static Test suit(){
-        return new TestSuite(SimpleTestDemo.class);
-      }
-      /
-       * 4、写一个main()方法，以文本运行器的方式方便的运行测试
-       */
-      public static void main(String[] args) {
-        junit.textui.TestRunner.run(suit());
-      }
-    }
-
+````
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import java.util.ArrayList;
+import java.util.Collection;
+/
+ * 1、创建一个测试类，继承TestCase类
+ */
+public class SimpleTestDemo extends TestCase {
+  public SimpleTestDemo(String name) {
+    super(name);
+  }
+  /
+   * 2、写一个测试方法，断言期望的结果
+   */
+  public void testEmptyCollection(){
+    Collection collection = new ArrayList();
+    assertTrue(collection.isEmpty());
+  }
+  /
+   * 3、写一个suite()方法，它会使用反射动态的创建一个包含所有的testXxxx方法的测试套件
+   */
+  public static Test suit(){
+    return new TestSuite(SimpleTestDemo.class);
+  }
+  /
+   * 4、写一个main()方法，以文本运行器的方式方便的运行测试
+   */
+  public static void main(String[] args) {
+    junit.textui.TestRunner.run(suit());
+  }
+}
+````
 
 
 ### 6 个人建议
@@ -386,7 +374,7 @@ JUnit有它自己的JUnit扩展生态圈，多数Java的开发环境都已经集
 12\. 使用文档生成器做测试文档。
 
 ## 8 大单元测试框架
-![](http://img.mp.itc.cn/upload/20170601/4310fd169d4d464db44fa73f25a241c3.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/4310fd169d4d464db44fa73f25a241c3.jpg)
 
 1.Arquillian
 
@@ -394,7 +382,7 @@ Arquillian是一个基于JVM的高度可扩展的测试平台，允许开发人
 
 Arquillian集成了熟悉的测试框架，如JUnit 4、TestNG 5，并允许使用现有的IDE启动测试。并且由于其模块化设计，它能够运行Ant和Maven测试插件。Arquillian目的是简化项目集成测试和功能测试的编写，让它们能像单元测试一样简单。
 
-![](http://img.mp.itc.cn/upload/20170601/8c78fe84d7fa46b9b6dd9fc8ab001e00.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/8c78fe84d7fa46b9b6dd9fc8ab001e00.jpg)
 
 2.JTEST
 
@@ -402,81 +390,48 @@ JTest也被称为“Parasoft JTest”，是Parasoft公司生产的自动化Java
 
 还可以进行结对的代码审查流程自动化和运行时错误检测，例如：条件，异常，资源和内存泄漏，安全攻击漏洞等。
 
-![](http://img.mp.itc.cn/upload/20170601/582197f6e97549bd894380f2b7320cc9.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/582197f6e97549bd894380f2b7320cc9.jpg)
 
 3.The Grinder
 
 “The Grinder”是一个Java负载测试框架。并且通过使用大量负载注射器来为分布式测试提供便利。Grinder可以对具有Java API的任何内容加载测试。这包括HTTP Web服务器，SOAP、REST Web服务、应用程序服务器，包括自定义协议。测试脚本用强大的Jython和Clojure语言编写。Grinder的GUI控制台允许对多个负载注射器进行监控和控制，并自动管理客户端连接和Cookie，SSL，代理感知和连接限制。您可以在这里找到关于磨床功能的更多深入信息。
 
-![](http://img.mp.itc.cn/upload/20170601/2d5c47277d254ad783c08b5f03a42372_th.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2d5c47277d254ad783c08b5f03a42372_th.jpg)
 
 4.TestNG
 
-![](http://img.mp.itc.cn/upload/20170601/0e1f6408b31d4665b4cc75b47750d58d.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/0e1f6408b31d4665b4cc75b47750d58d.jpg)
 
 TestNG受JUnit和NUnit的启发，是为Java编程语言而设计的测试框架。TestNG主要设计用于覆盖更广泛的测试类别，如单元，功能，端到端，集成等。它还引入了一些新功能，使其更强大，更易于使用，如：注解，运行在大线程池中进行各种策略测试，多线程安全验证代码测试，灵活的测试配置，数据驱动的参数测试支持等等。
 
 TestNG有各种工具和插件（如Eclipse，IDEA，Maven等）支持。
 
-![](http://img.mp.itc.cn/upload/20170601/21bc4cc5fd924b16b29be4880f9cfeab_th.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/21bc4cc5fd924b16b29be4880f9cfeab_th.jpg)
 
 5.JUnit
 
 JUnit是为Java编程语言设计的单元测试框架。JUnit在测试驱动开发框架的开发中发挥了重要作用。它是单元测试框架之一，统称为由SUnit起源的xUnit。
 
-![](http://img.mp.itc.cn/upload/20170601/9a6d602756f94c1ea8682fc811d679ef.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/9a6d602756f94c1ea8682fc811d679ef.jpg)
 
 6.JWalk
 
 JWalk被设计为用于Java编程语言的单元测试工具包。它被设计为支持称为“Lazy系统单元测试”的测试范例。
 
-![](http://img.mp.itc.cn/upload/20170601/5d6b9c4de39c43df9eabc2fc5eecca5e_th.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/5d6b9c4de39c43df9eabc2fc5eecca5e_th.jpg)
 
 JWalkTester工具对任何由程序员提供的编译的Java类执行任何测试。它能够通过静态和动态分析以及来自程序员的提示来测试懒惰Lazy规范的一致性。
 
-![](http://img.mp.itc.cn/upload/20170601/34c2bae3fea44fd9a2ec54c7447207d5.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/34c2bae3fea44fd9a2ec54c7447207d5.jpg)
 
 7.Mockito
 
 Mockito被设计为用于Java的开源测试框架，MIT许可证。Mockito允许程序员为了测试驱动开发（TDD）或行为驱动开发（BDD）而在自动化单元测试中创建和测试双对象（Mock对象）。
 
-![](http://img.mp.itc.cn/upload/20170601/cdef7a64440c499a865249fcbc91e38e.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/cdef7a64440c499a865249fcbc91e38e.jpg)
 
 8 Powermock
 
 PowerMock是用于对源代码进行单元测试的Java框架，它可以作为其他模拟框架的扩展，比如原型Mockito或EasyMock，但具有更强大的功能。PowerMock利用自定义的类加载器和字节码操纵器来实现静态方法，构造函数，最终类和方法以及私有方法等的模拟。它主要是为了扩展现有的API，使用少量的方法和注解来实现额外的功能。
 
-## 微信公众号
-
-### 个人公众号：程序员黄小斜
-
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注微信公众号【程序员黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
-
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的微信公众号【Java技术江湖】
-
-这是一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-
-**Java工程师必备学习资源:** 
-关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
-
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
 
-​                     
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21416\357\274\232\346\236\201\347\256\200\351\205\215\347\275\256\347\232\204SpringBoot.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\346\236\201\347\256\200\351\205\215\347\275\256\347\232\204SpringBoot.md"
similarity index 53%
rename from "docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21416\357\274\232\346\236\201\347\256\200\351\205\215\347\275\256\347\232\204SpringBoot.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\346\236\201\347\256\200\351\205\215\347\275\256\347\232\204SpringBoot.md"
index a5cbc34..e98f6e8 100644
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21416\357\274\232\346\236\201\347\256\200\351\205\215\347\275\256\347\232\204SpringBoot.md"
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\346\236\201\347\256\200\351\205\215\347\275\256\347\232\204SpringBoot.md"
@@ -1,27 +1,23 @@
-# Table of Contents
-
-  * [Spring Boot 概述](#spring-boot-概述)
-      * [什么是 Spring Boot](#什么是-spring-boot)
-      * [使用 Spring Boot 有什么好处](#使用-spring-boot-有什么好处)
-  * [Spring Boot 快速搭建](#spring-boot-快速搭建)
-      * [第一步：新建项目](#第一步：新建项目)
-      * [第二步：HelloController](#第二步：hellocontroller)
-      * [第三步：利用 IDEA 启动 Spring Boot](#第三步：利用-idea-启动-spring-boot)
-  * [解析 Spring Boot 项目](#解析-spring-boot-项目)
-      * [解析 pom.xml 文件](#解析-pomxml-文件)
-      * [应用入口类](#应用入口类)
-      * [Spring Boot 的配置文件](#spring-boot-的配置文件)
-      * [Spring Boot 热部署](#spring-boot-热部署)
-  * [Spring Boot 使用](#spring-boot-使用)
-      * [Spring Boot 支持 JSP](#spring-boot-支持-jsp)
-      * [集成 MyBatis](#集成-mybatis)
-  * [springMVC和springboot的区别](#springmvc和springboot的区别)
-  * [微信公众号](#微信公众号)
-    * [个人公众号：程序员黄小斜](#个人公众号：程序员黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
-
-
-本文转载自互联网，侵删
+# 目录
+* [Spring Boot 概述](#spring-boot-概述)
+    * [什么是 Spring Boot](#什么是-spring-boot)
+    * [使用 Spring Boot 有什么好处](#使用-spring-boot-有什么好处)
+* [Spring Boot 快速搭建](#spring-boot-快速搭建)
+    * [第一步：新建项目](#第一步：新建项目)
+    * [第二步：HelloController](#第二步：hellocontroller)
+    * [第三步：利用 IDEA 启动 Spring Boot](#第三步：利用-idea-启动-spring-boot)
+* [解析 Spring Boot 项目](#解析-spring-boot-项目)
+    * [解析 pom.xml 文件](#解析-pomxml-文件)
+    * [应用入口类](#应用入口类)
+    * [Spring Boot 的配置文件](#spring-boot-的配置文件)
+    * [Spring Boot 热部署](#spring-boot-热部署)
+* [Spring Boot 使用](#spring-boot-使用)
+    * [Spring Boot 支持 JSP](#spring-boot-支持-jsp)
+    * [集成 MyBatis](#集成-mybatis)
+* [springMVC和springboot的区别](#springmvc和springboot的区别)
+
+
+本文转载自互联网，侵删  
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
 
@@ -39,10 +35,10 @@
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
 **文末赠送8000G的Java架构师学习资料，需要的朋友可以到文末了解领取方式，资料包括Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源）**
-<!-- more -->
+<!-- more -->  
 
 
-![](https://upload-images.jianshu.io/upload_images/7896890-9323041dd0ce883e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-9323041dd0ce883e.png)
 
 ## Spring Boot 概述
 
@@ -69,7 +65,7 @@
 
 *   划重点：简单、快速、方便地搭建项目；对主流开发框架的无配置集成；极大提高了开发、部署效率。
 
-* * *
+* * *  
 
 ## Spring Boot 快速搭建
 
@@ -77,23 +73,23 @@
 
 选择 Spring Initializr ，然后选择默认的 url 点击【Next】：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-3e2c9c5742c10c86.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-3e2c9c5742c10c86.png)
 
 然后修改一下项目的信息：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-28dbe478ff25a3a0.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-28dbe478ff25a3a0.png)
 
 勾选上 Web 模板：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-532868b7e6760e03.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-532868b7e6760e03.png)
 
 选择好项目的位置，点击【Finish】：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-931cc2fb5c8964e9.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-931cc2fb5c8964e9.png)
 
 如果是第一次配置 Spring Boot 的话可能需要等待一会儿 IDEA 下载相应的 依赖包，默认创建好的项目结构如下：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-9ac7acc56d5a32f0.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-9ac7acc56d5a32f0.png)
 
 项目结构还是看上去挺清爽的，少了很多配置文件，我们来了解一下默认生成的有什么：
 
@@ -106,49 +102,42 @@
 
 在【cn.wmyskxz.springboot】包下新建一个【HelloController】：
 
-```
-package cn.wmyskxz.springboot;
-
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-/**
- * 测试控制器
- *
- * @author: @我没有三颗心脏
- * @create: 2018-05-08-下午 16:46
- */
-@RestController
-public class HelloController {
-
-    @RequestMapping("/hello")
-    public String hello() {
-        return "Hello Spring Boot!";
-    }
-}
-```
-
-*   **@RestController 注解：** 该注解是 @Controller 和 @ResponseBody 注解的合体版
+```  
+package cn.wmyskxz.springboot;  
+  
+import org.springframework.web.bind.annotation.RequestMapping;  
+import org.springframework.web.bind.annotation.RestController;  
+  
+/**  
+ * 测试控制器  
+ * * @author: @我没有三颗心脏  
+ * @create: 2018-05-08-下午 16:46 */@RestController  
+public class HelloController {  
+  
+    @RequestMapping("/hello")    public String hello() {        return "Hello Spring Boot!";    }}  
+```  
+
+*   **@RestController 注解：**该注解是 @Controller 和 @ResponseBody 注解的合体版
 
 #### 第三步：利用 IDEA 启动 Spring Boot
 
 我们回到 SpringbootApplication 这个类中，然后右键点击运行：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-bf1aa6ed5c0db7b4.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-bf1aa6ed5c0db7b4.png)
 
 *   **注意**：我们之所以在上面的项目中没有手动的去配置 Tomcat 服务器，是因为 Spring Boot 内置了 Tomcat
 
 等待一会儿就会看到下方的成功运行的提示信息：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-63e43dc6a277de3e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-63e43dc6a277de3e.png)
 
 可以看到我们的 Tomcat 运行在 8080 端口，我们来访问 “`/hello`” 地址试一下：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-6111e1913c5bf6d6.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-6111e1913c5bf6d6.png)
 
 可以看到页面成功显示出我们返回的信息。
 
-* * *
+* * *  
 
 ## 解析 Spring Boot 项目
 
@@ -158,67 +147,25 @@ public class HelloController {
 
 让我们来看看默认生成的 pom.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>cn.wmyskxz</groupId>
-    springboot
-    <version>0.0.1-SNAPSHOT</version>
-    <packaging>jar</packaging>
-
-    <name>springboot</name>
-    <description>Demo project for Spring Boot</description>
-
-    <parent>
-        <groupId>org.springframework.boot</groupId>
-        spring-boot-starter-parent
-        <version>2.0.1.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>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            spring-boot-starter-web
-        </dependency>
-
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            spring-boot-starter-test
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.springframework.boot</groupId>
-                spring-boot-maven-plugin
-            </plugin>
-        </plugins>
-    </build>
-</project>
-```
-
-我们可以看到一个比较陌生一些的标签 `<parent>` ，这个标签是在配置 Spring Boot 的父级依赖：
-
-```
-<parent>
-    <groupId>org.springframework.boot</groupId>
-    spring-boot-starter-parent
-    <version>2.0.1.RELEASE</version>
-    <relativePath/> <!-- lookup parent from repository -->
-</parent>
-```
+```  
+<?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>cn.wmyskxz</groupId>    springboot    <version>0.0.1-SNAPSHOT</version>    <packaging>jar</packaging>  
+    <name>springboot</name>    <description>Demo project for Spring Boot</description>  
+    <parent>        <groupId>org.springframework.boot</groupId>        spring-boot-starter-parent        <version>2.0.1.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>        <dependency>            <groupId>org.springframework.boot</groupId>            spring-boot-starter-web        </dependency>  
+        <dependency>            <groupId>org.springframework.boot</groupId>            spring-boot-starter-test            <scope>test</scope>        </dependency>    </dependencies>  
+    <build>        <plugins>            <plugin>                <groupId>org.springframework.boot</groupId>                spring-boot-maven-plugin            </plugin>        </plugins>    </build></project>  
+```  
+
+我们可以看到一个比较陌生一些的标签`<parent>`，这个标签是在配置 Spring Boot 的父级依赖：
+
+```  
+<parent>  
+    <groupId>org.springframework.boot</groupId>    spring-boot-starter-parent    <version>2.0.1.RELEASE</version>    <relativePath/> <!-- lookup parent from repository --></parent>  
+```  
 
 有了这个，当前的项目才是 Spring Boot 项目，spring-boot-starter-parent 是一个特殊的 starter ，它用来提供相关的 Maven 默认依赖，**使用它之后，常用的包依赖就可以省去 version 标签。**
 
@@ -226,12 +173,12 @@ public class HelloController {
 
 #### 应用入口类
 
-Spring Boot 项目通常有一个名为 *Application 的入口类，入口类里有一个 main 方法， **这个 main 方法其实就是一个标准的 Javay 应用的入口方法。**
+Spring Boot 项目通常有一个名为 *Application 的入口类，入口类里有一个 main 方法，**这个 main 方法其实就是一个标准的 Javay 应用的入口方法。**
 
-**@SpringBootApplication** 是 Spring Boot 的核心注解，它是一个组合注解，该注解组合了：**@Configuration、@EnableAutoConfiguration、@ComponentScan；** 若不是用 @SpringBootApplication 注解也可以使用这三个注解代替。
+**@SpringBootApplication**是 Spring Boot 的核心注解，它是一个组合注解，该注解组合了：**@Configuration、@EnableAutoConfiguration、@ComponentScan；**若不是用 @SpringBootApplication 注解也可以使用这三个注解代替。
 
 *   其中，**@EnableAutoConfiguration 让 Spring Boot 根据类路径中的 jar 包依赖为当前项目进行自动配置**，例如，添加了 spring-boot-starter-web 依赖，会自动添加 Tomcat 和 Spring MVC 的依赖，那么 Spring Boot 会对 Tomcat 和 Spring MVC 进行自动配置。
-*   **Spring Boot 还会自动扫描 @SpringBootApplication 所在类的同级包以及下级包里的 Bean** ，所以入口类建议就配置在 grounpID + arctifactID 组合的包名下（这里为 cn.wmyskxz.springboot 包）
+*   **Spring Boot 还会自动扫描 @SpringBootApplication 所在类的同级包以及下级包里的 Bean**，所以入口类建议就配置在 grounpID + arctifactID 组合的包名下（这里为 cn.wmyskxz.springboot 包）
 
 #### Spring Boot 的配置文件
 
@@ -243,7 +190,7 @@ Spring Boot 的全局配置文件的作用是对一些默认配置的配置值
 
 > *   简单实例一下
 
-![](https://upload-images.jianshu.io/upload_images/7896890-bcd65f7469b06608.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-bcd65f7469b06608.png)
 
 我们同样的将 Tomcat 默认端口设置为 8080 ，并将默认的访问路径从 “`/`” 修改为 “`/hello`” 时，使用 properties 文件和 yml 文件的区别如上图。
 
@@ -253,27 +200,27 @@ Spring Boot 的全局配置文件的作用是对一些默认配置的配置值
 
 我们直接把 .properties 后缀的文件删掉，使用 .yml 文件来进行简单的配置，然后使用 @Value 来获取配置属性：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-0e808a82254d6a4b.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-0e808a82254d6a4b.png)
 
 重启 Spring Boot ，输入地址：localhost:8080/hello 能看到正确的结果：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-c85216e8ea7910f0.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-c85216e8ea7910f0.png)
 
-*   **注意：** 我们并没有在 yml 文件中注明属性的类型，而是在使用的时候定义的。
+*   **注意：**我们并没有在 yml 文件中注明属性的类型，而是在使用的时候定义的。
 
 你也可以在配置文件中使用当前配置：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-37e91abbc4550982.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-37e91abbc4550982.png)
 
 仍然可以得到正确的结果：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-eabc3cd39b44fd0d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-eabc3cd39b44fd0d.png)
 
-*   **问题：** 这样写配置文件繁琐而且可能会造成类的臃肿，因为有许许多多的 @Value 注解。
+*   **问题：**这样写配置文件繁琐而且可能会造成类的臃肿，因为有许许多多的 @Value 注解。
 
 > *   封装配置信息
 
-![](https://upload-images.jianshu.io/upload_images/7896890-2599817d8f2f50d2.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-2599817d8f2f50d2.png)
 
 我们可以把配置信息封装成一个类，首先在我们的 name 和 age 前加一个 student 前缀，然后新建一个 StudentProperties 的类用来封装这些信息，并用上两个注解：
 
@@ -282,7 +229,7 @@ Spring Boot 的全局配置文件的作用是对一些默认配置的配置值
 
 这样我们就可以在控制器中使用，重启得到正确信息：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-84dc1215d01f3fa9.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-84dc1215d01f3fa9.png)
 
 #### Spring Boot 热部署
 
@@ -292,21 +239,18 @@ Spring Boot 的全局配置文件的作用是对一些默认配置的配置值
 
 我们往 pom.xml 中添加一个依赖就可以了：
 
-```
-<dependency>
-    <groupId>org.springframework.boot</groupId>
-    spring-boot-devtools
-    <optional>true</optional> <!-- 这个需要为 true 热部署才有效 -->
-</dependency>
-```
+```  
+<dependency>  
+    <groupId>org.springframework.boot</groupId>    spring-boot-devtools    <optional>true</optional> <!-- 这个需要为 true 热部署才有效 --></dependency>  
+```  
 
 重新启动 Spring Boot ，然后修改任意代码，就能观察到控制台的自动重启现象：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-cec869956c3cf158.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-cec869956c3cf158.png)
 
 > 关于如何在 IDEA 中配置热部署：[传送门](https://blog.csdn.net/xusheng_Mr/article/details/78771746)
 
-* * *
+* * *  
 
 ## Spring Boot 使用
 
@@ -318,183 +262,138 @@ Spring Boot 的默认视图支持是 Thymeleaf 模板引擎，但是这个我们
 
 > *   第一步：修改 pom.xml 增加对 JSP 文件的支持
 
-```
-<!-- servlet依赖. -->
-<dependency>
-    <groupId>javax.servlet</groupId>
-    javax.servlet-api
-    <scope>provided</scope>
-</dependency>
-<dependency>
-    <groupId>javax.servlet</groupId>
-    jstl
-</dependency>
-
-<!-- tomcat的支持.-->
-<dependency>
-    <groupId>org.apache.tomcat.embed</groupId>
-    tomcat-embed-jasper
-    <scope>provided</scope>
-</dependency>
-```
+```  
+<!-- servlet依赖. -->  
+<dependency>  
+    <groupId>javax.servlet</groupId>    javax.servlet-api    <scope>provided</scope></dependency>  
+<dependency>  
+    <groupId>javax.servlet</groupId>    jstl</dependency>  
+  
+<!-- tomcat的支持.-->  
+<dependency>  
+    <groupId>org.apache.tomcat.embed</groupId>    tomcat-embed-jasper    <scope>provided</scope></dependency>  
+```  
 
 > *   第二步：配置试图重定向 JSP 文件的位置
 
 修改 application.yml 文件，将我们的 JSP 文件重定向到 /WEB-INF/views/ 目录下：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-7c17f7e10cfb2629.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-7c17f7e10cfb2629.png)
 
 > *   第三步：修改 HelloController
 
 修改 @RestController 注解为 @Controller ，然后将 hello 方法修改为：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-2dc2c39cd962edc1.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-2dc2c39cd962edc1.png)
 
 > *   第四步：新建 hello.jsp 文件
 
 在【src/main】目录下依次创建 webapp、WEB-INF、views 目录，并创建一个 hello.jsp 文件：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-a180556d7ead9605.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-a180556d7ead9605.png)
 
 > *   第五步：刷新网页
 
 因为我们部署了热部署功能，所以只需要等待控制台重启信息完成之后再刷新网页就可以看到正确效果了：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-cfd20f747ffca978.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-cfd20f747ffca978.png)
 
 *   关于 404，使用 spring-boot:run 运行项目可以解决：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-27c1bf46487ba5eb.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-27c1bf46487ba5eb.png)
 
 #### 集成 MyBatis
 
 > *   第一步：修改 pom.xml 增加对 MySql和 MyBatis 的支持
 
-```
-
-<!-- mybatis -->
-<dependency>
-    <groupId>org.mybatis.spring.boot</groupId>
-    mybatis-spring-boot-starter
-    <version>1.1.1</version>
-</dependency>
-<!-- mysql -->
-<dependency>
-    <groupId>mysql</groupId>
-    mysql-connector-java
-    <version>5.1.21</version>
-</dependency>
-```
+```  
+  
+<!-- mybatis -->  
+<dependency>  
+    <groupId>org.mybatis.spring.boot</groupId>    mybatis-spring-boot-starter    <version>1.1.1</version></dependency>  
+<!-- mysql -->  
+<dependency>  
+    <groupId>mysql</groupId>    mysql-connector-java    <version>5.1.21</version></dependency>  
+```  
 
 > *   第二步：新增数据库链接参数
 
 这里我们就直接使用之前创建好的 student 表了吧：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-1eda563cfdfbae65.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-1eda563cfdfbae65.png)
 
 > *   第三步：创建 Student 实体类和 StudentMapper 映射类
 
 在【cn.wmyskxz.springboot】下新建一个【pojo】包，然后在其下创建一个 Student 类：
 
-```
-public class Student {
-
-    private Integer id;
-    private Integer student_id;
-    private String name;
-    private Integer age;
-    private String sex;
-    private Date birthday;
-
-    /* getter and setter */
-}
-```
+```  
+public class Student {  
+  
+    private Integer id;    private Integer student_id;    private String name;    private Integer age;    private String sex;    private Date birthday;  
+    /* getter and setter */}  
+```  
 
 在【cn.wmyskxz.springboot】下新建一个【mapper】包，然后在其下创建一个 StudentMapper 映射类：
 
-```
-package cn.wmyskxz.springboot.mapper;
-
-import cn.wmyskxz.springboot.pojo.Student;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Select;
-
-import java.util.List;
-
-@Mapper
-public interface StudentMapper {
-
-    @Select("SELECT * FROM student")
-    List<Student> findAll();
-}
-```
+```  
+package cn.wmyskxz.springboot.mapper;  
+  
+import cn.wmyskxz.springboot.pojo.Student;  
+import org.apache.ibatis.annotations.Mapper;  
+import org.apache.ibatis.annotations.Select;  
+  
+import java.util.List;  
+  
+@Mapper  
+public interface StudentMapper {  
+  
+    @Select("SELECT * FROM student")    List<Student> findAll();}  
+```  
 
 > *   第四步：编写 StudentController
 
 在【cn.wmyskxz.springboot】下新建一个【controller】包，然后在其下创建一个 StudentController ：
 
-```
-package cn.wmyskxz.springboot.controller;
-
-import cn.wmyskxz.springboot.mapper.StudentMapper;
-import cn.wmyskxz.springboot.pojo.Student;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Controller;
-import org.springframework.ui.Model;
-import org.springframework.web.bind.annotation.RequestMapping;
-
-import java.util.List;
-
-/**
- * Student 控制器
- *
- * @author: @我没有三颗心脏
- * @create: 2018-05-08-下午 20:25
- */
-@Controller
-public class StudentController {
-
-    @Autowired
-    StudentMapper studentMapper;
-
-    @RequestMapping("/listStudent")
-    public String listStudent(Model model) {
-        List<Student> students = studentMapper.findAll();
-        model.addAttribute("students", students);
-        return "listStudent";
-    }
-}
-```
+```  
+package cn.wmyskxz.springboot.controller;  
+  
+import cn.wmyskxz.springboot.mapper.StudentMapper;  
+import cn.wmyskxz.springboot.pojo.Student;  
+import org.springframework.beans.factory.annotation.Autowired;  
+import org.springframework.stereotype.Controller;  
+import org.springframework.ui.Model;  
+import org.springframework.web.bind.annotation.RequestMapping;  
+  
+import java.util.List;  
+  
+/**  
+ * Student 控制器  
+ * * @author: @我没有三颗心脏  
+ * @create: 2018-05-08-下午 20:25 */@Controller  
+public class StudentController {  
+  
+    @Autowired    StudentMapper studentMapper;  
+    @RequestMapping("/listStudent")    public String listStudent(Model model) {        List<Student> students = studentMapper.findAll();        model.addAttribute("students", students);        return "listStudent";    }}  
+```  
 
 > 第五步：编写 listStudent.jsp 文件
 
 我们简化一下 JSP 的文件，仅显示两个字段的数据：
 
-```
-<%@ page language="java" contentType="text/html; charset=UTF-8"
-         pageEncoding="UTF-8"%>
-
-<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
-
-<table align='center' border='1' cellspacing='0'>
-    <tr>
-        <td>id</td>
-        <td>name</td>
-    </tr>
-    <c:forEach items="${students}" var="s" varStatus="st">
-        <tr>
-            <td>${s.id}</td>
-            <td>${s.name}</td>
-        </tr>
-    </c:forEach>
-</table>
-```
+```  
+<%@ page language="java" contentType="text/html; charset=UTF-8"  
+         pageEncoding="UTF-8"%>  
+<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>  
+  
+<table align='center' border='1' cellspacing='0'>  
+    <tr>        <td>id</td>        <td>name</td>    </tr>    <c:forEach items="${students}" var="s" varStatus="st">        <tr>            <td>${s.id}</td>            <td>${s.name}</td>        </tr>    </c:forEach></table>  
+```  
 
 > *   第六步：重启服务器运行
 
 因为往 pom.xml 中新增加了依赖的包，所以自动重启服务器没有作用，我们需要手动重启一次，然后在地址输入：localhost:8080/listStudent 查看效果：
 
-![](https://upload-images.jianshu.io/upload_images/7896890-5fd3c075d07b5840.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-5fd3c075d07b5840.png)
 
 > 以上。
 
@@ -528,39 +427,4 @@ Spring 是一个“引擎”；
 
 Spring MVC 是基于Spring的一个 MVC 框架 ；
 
-Spring Boot 是基于Spring4的条件注册的一套快速开发整合包。
-
-## 微信公众号
-
-### 个人公众号：程序员黄小斜
-
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注微信公众号【程序员黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
-
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的微信公众号【Java技术江湖】
-
-这是一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-
-**Java工程师必备学习资源:** 
-关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
-
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-​                     
+Spring Boot 是基于Spring4的条件注册的一套快速开发整合包。
\ No newline at end of file
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2148\357\274\232\346\265\205\346\236\220Tomcat9\350\257\267\346\261\202\345\244\204\347\220\206\346\265\201\347\250\213\344\270\216\345\220\257\345\212\250\351\203\250\347\275\262\350\277\207\347\250\213.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\346\265\205\346\236\220Tomcat\350\257\267\346\261\202\345\244\204\347\220\206\346\265\201\347\250\213\344\270\216\345\220\257\345\212\250\351\203\250\347\275\262\350\277\207\347\250\213.md"
similarity index 72%
rename from "docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2148\357\274\232\346\265\205\346\236\220Tomcat9\350\257\267\346\261\202\345\244\204\347\220\206\346\265\201\347\250\213\344\270\216\345\220\257\345\212\250\351\203\250\347\275\262\350\277\207\347\250\213.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\346\265\205\346\236\220Tomcat\350\257\267\346\261\202\345\244\204\347\220\206\346\265\201\347\250\213\344\270\216\345\220\257\345\212\250\351\203\250\347\275\262\350\277\207\347\250\213.md"
index c656802..8fe356b 100644
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2148\357\274\232\346\265\205\346\236\220Tomcat9\350\257\267\346\261\202\345\244\204\347\220\206\346\265\201\347\250\213\344\270\216\345\220\257\345\212\250\351\203\250\347\275\262\350\277\207\347\250\213.md"
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\346\265\205\346\236\220Tomcat\350\257\267\346\261\202\345\244\204\347\220\206\346\265\201\347\250\213\344\270\216\345\220\257\345\212\250\351\203\250\347\275\262\350\277\207\347\250\213.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [Overview](#overview)
   * [Connector Init and Start](#connector-init-and-start)
   * [Request Process](#request-process)
@@ -8,9 +7,6 @@
     * [Worker](#worker)
     * [Container](#container)
   * [Reference](#reference)
-  * [微信公众号](#微信公众号)
-    * [个人公众号：程序员黄小斜](#个人公众号：程序员黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
 
 
 
@@ -46,7 +42,7 @@ Tomcat-9.0.0.M22 是 Tomcat 目前最新的版本，但尚未发布，它实现
 
 ## Overview
 
-![](https://img-blog.csdnimg.cn/20190808094540456.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FsYmVuWGll,size_16,color_FFFFFF,t_70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405154006.png)
 
 Connector 启动以后会启动一组线程用于不同阶段的请求处理过程。
 
@@ -60,7 +56,7 @@ Acceptor、Poller、worker 所在的 ThreadPoolExecutor 都维护在 NioEndpoint
 
 ## Connector Init and Start
 
-![](https://img-blog.csdnimg.cn/20190808094650927.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FsYmVuWGll,size_16,color_FFFFFF,t_70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405154024.png)
 
 1.  initServerSocket()，通过 ServerSocketChannel.open() 打开一个 ServerSocket，默认绑定到 8080 端口，默认的连接等待队列长度是 100， 当超过 100 个时会拒绝服务。我们可以通过配置 conf/server.xml 中 Connector 的 acceptCount 属性对其进行定制。
 
@@ -74,7 +70,7 @@ Acceptor、Poller、worker 所在的 ThreadPoolExecutor 都维护在 NioEndpoint
 
 ### Acceptor
 
-![](https://img-blog.csdnimg.cn/20190808094725483.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FsYmVuWGll,size_16,color_FFFFFF,t_70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405154041.png)
 
 1.  Acceptor 在启动后会阻塞在 ServerSocketChannel.accept(); 方法处，当有新连接到达时，该方法返回一个 SocketChannel。
 
@@ -84,8 +80,7 @@ Acceptor、Poller、worker 所在的 ThreadPoolExecutor 都维护在 NioEndpoint
 
 ### Poller
 
-![](https://img-blog.csdnimg.cn/20190808094749113.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FsYmVuWGll,size_16,color_FFFFFF,t_70)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405154054.png)
 1.  selector.select(1000)。当 Poller 启动后因为 selector 中并没有已注册的 Channel，所以当执行到该方法时只能阻塞。所有的 Poller 共用一个 Selector，其实现类是 sun.nio.ch.EPollSelectorImpl
 
 2.  events() 方法会将通过 addEvent() 方法添加到事件队列中的 Socket 注册到 EPollSelectorImpl，当 Socket 可读时，Poller 才对其进行处理
@@ -114,7 +109,7 @@ Acceptor、Poller、worker 所在的 ThreadPoolExecutor 都维护在 NioEndpoint
 
 ### Container
 
-![](https://img-blog.csdnimg.cn/20190808094835789.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FsYmVuWGll,size_16,color_FFFFFF,t_70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405154120.png)
 
 *   需要注意的是，基本上每一个容器的 StandardPipeline 上都会有多个已注册的 Valve，我们只关注每个容器的 Basic Valve。其他 Valve 都是在 Basic Valve 前执行。
 
@@ -156,37 +151,6 @@ Acceptor、Poller、worker 所在的 ThreadPoolExecutor 都维护在 NioEndpoint
 
 
 
-## 微信公众号
-
-### 个人公众号：程序员黄小斜
-
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注微信公众号【程序员黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
-
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的微信公众号【Java技术江湖】
-
-这是一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-
-**Java工程师必备学习资源:** 
-关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
-
 
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
 
-​                     
+                     
diff --git "a/docs/java-web/\346\267\261\345\205\245JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21415\357\274\232\346\267\261\345\205\245\346\265\205\345\207\272Mybatis\345\237\272\346\234\254\345\216\237\347\220\206.md" "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\346\267\261\345\205\245\346\265\205\345\207\272Mybatis\345\237\272\346\234\254\345\216\237\347\220\206.md"
similarity index 59%
rename from "docs/java-web/\346\267\261\345\205\245JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21415\357\274\232\346\267\261\345\205\245\346\265\205\345\207\272Mybatis\345\237\272\346\234\254\345\216\237\347\220\206.md"
rename to "docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\346\267\261\345\205\245\346\265\205\345\207\272Mybatis\345\237\272\346\234\254\345\216\237\347\220\206.md"
index 6e98136..7556dc4 100644
--- "a/docs/java-web/\346\267\261\345\205\245JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21415\357\274\232\346\267\261\345\205\245\346\265\205\345\207\272Mybatis\345\237\272\346\234\254\345\216\237\347\220\206.md"
+++ "b/docs/JavaWeb/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\214\357\274\232\346\267\261\345\205\245\346\265\205\345\207\272Mybatis\345\237\272\346\234\254\345\216\237\347\220\206.md"
@@ -1,24 +1,21 @@
-# Table of Contents
-
-  * [引言](#引言)
-  * [工作原理原型图](#工作原理原型图)
-  * [工作原理解析](#工作原理解析)
-  * [mybatis层次图：](#mybatis层次图：)
-    * [[MyBatis框架及原理分析](https://www.cnblogs.com/adolfmc/p/8997281.html)](#[mybatis框架及原理分析]httpswwwcnblogscomadolfmcp8997281html)
-  * [MyBatis的配置](#mybatis的配置)
-  * [MyBatis的主要成员](#mybatis的主要成员)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [个人公众号：程序员黄小斜](#个人公众号：程序员黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
-
+# 目录
+* [引言](#引言)
+* [工作原理原型图](#工作原理原型图)
+* [工作原理解析](#工作原理解析)
+* [mybatis层次图：](#mybatis层次图：)
+    * [MyBatis框架及原理分析](#MyBatis框架及原理分析)
+* [MyBatis的配置](#mybatis的配置)
+* [MyBatis的主要成员](#mybatis的主要成员)
+* [参考文章](#参考文章)
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 文章首发于我的个人博客：
+
 > www.how2playlife.com
 
 本文是微信公众号【Java技术江湖】的《走进JavaWeb技术世界》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
@@ -31,6 +28,7 @@
 <!-- more -->
 
 ## 引言
+
 在mybatis的基础知识中我们已经可以对mybatis的工作方式窥斑见豹（参考：《MyBatis————基础知识》）。
 
 但是，为什么还要要学习mybatis的工作原理？因为，随着mybatis框架的不断发展，如今已经越来越趋于自动化，从代码生成，到基本使用，我们甚至不需要动手写一句SQL就可以完成一个简单应用的全部CRUD操作。
@@ -40,11 +38,13 @@
 万变的外表终将迷惑人们的双眼，只要抓住核心我们永远不会迷茫！
 
 ## 工作原理原型图
+
 用最直观的图，来征服你的心！
 
-![image](https://img-blog.csdn.net/20180624002302854?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ3NDUwNjk=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405165221.png)
 
 ## 工作原理解析
+
 mybatis应用程序通过SqlSessionFactoryBuilder从mybatis-config.xml配置文件（也可以用Java文件配置的方式，需要添加@Configuration）中构建出SqlSessionFactory（SqlSessionFactory是线程安全的）；
 
 然后，SqlSessionFactory的实例直接开启一个SqlSession，再通过SqlSession实例获得Mapper对象并运行Mapper映射的SQL语句，完成对数据库的CRUD和事务提交，之后关闭SqlSession。
@@ -66,11 +66,10 @@ d、JDBC执行sql。
 e、借助MappedStatement中的结果映射关系，将返回结果转化成HashMap、JavaBean等存储结构并返回。
 
 ## mybatis层次图：
-![image](https://img-blog.csdn.net/20180625095624918?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ3NDUwNjk=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
-
-### [MyBatis框架及原理分析](https://www.cnblogs.com/adolfmc/p/8997281.html)
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405165208.png)
 
+### MyBatis框架及原理分析
 
 MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架，其主要就完成2件事情：
 
@@ -83,7 +82,7 @@ MyBatis的主要设计目的就是让我们对执行SQL语句时对输入输出
 
 MyBatis框架和其他绝大部分框架一样，需要一个配置文件，其配置文件大致如下：
 
-
+````
     <configuration>
         <settings>
             <setting name="cacheEnabled" value="true"/>
@@ -111,32 +110,30 @@ MyBatis框架和其他绝大部分框架一样，需要一个配置文件，其
             <mapper resource="userMapper.xml"/>
         </mappers>
     </configuration>
+````
 
 
 
-
-以上配置中，最重要的是数据库参数的配置，比如用户名密码等，如果配置了数据表对应的mapper文件，则需要将其加入到<mappers>节点下。 
+以上配置中，最重要的是数据库参数的配置，比如用户名密码等，如果配置了数据表对应的mapper文件，则需要将其加入到<mappers>节点下。
 
 ## MyBatis的主要成员
 
-*   Configuration        MyBatis所有的配置信息都保存在Configuration对象之中，配置文件中的大部分配置都会存储到该类中
-*   SqlSession            作为MyBatis工作的主要顶层API，表示和数据库交互时的会话，完成必要数据库增删改查功能
-*   Executor               MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护
+*   Configuration    MyBatis所有的配置信息都保存在Configuration对象之中，配置文件中的大部分配置都会存储到该类中
+*   SqlSession      作为MyBatis工作的主要顶层API，表示和数据库交互时的会话，完成必要数据库增删改查功能
+*   Executor        MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护
 *   StatementHandler 封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数等
-*   ParameterHandler  负责对用户传递的参数转换成JDBC Statement 所对应的数据类型
-*   ResultSetHandler   负责将JDBC返回的ResultSet结果集对象转换成List类型的集合
-*   TypeHandler          负责java数据类型和jdbc数据类型(也可以说是数据表列类型)之间的映射和转换
-*   MappedStatement  MappedStatement维护一条<select|update|delete|insert>节点的封装
-*   SqlSource              负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回
-*   BoundSql              表示动态生成的SQL语句以及相应的参数信息
+*   ParameterHandler 负责对用户传递的参数转换成JDBC Statement 所对应的数据类型
+*   ResultSetHandler  负责将JDBC返回的ResultSet结果集对象转换成List类型的集合
+*   TypeHandler     负责java数据类型和jdbc数据类型(也可以说是数据表列类型)之间的映射和转换
+*   MappedStatement MappedStatement维护一条<select|update|delete|insert>节点的封装
+*   SqlSource       负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回
+*   BoundSql       表示动态生成的SQL语句以及相应的参数信息
 
 以上主要成员在一次数据库操作中基本都会涉及，在SQL操作中重点需要关注的是SQL参数什么时候被设置和结果集怎么转换为JavaBean对象的，这两个过程正好对应StatementHandler和ResultSetHandler类中的处理逻辑。
 
 ![](http://img.blog.csdn.net/20141028140852531?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvbHVhbmxvdWlz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
 
-<sub>(图片来自[《深入理解mybatis原理》 MyBatis的架构设计以及实例分析](http://blog.csdn.net/luanlouis/article/details/40422941))</sub>
-
-
+(图片来自[《深入理解mybatis原理》 MyBatis的架构设计以及实例分析](http://blog.csdn.net/luanlouis/article/details/40422941))
 
 
 ## 参考文章
@@ -147,37 +144,7 @@ https://blog.csdn.net/u014745069/article/details/80788127
 https://blog.csdn.net/u014297148/article/details/78696096
 https://blog.csdn.net/weixin_43184769/article/details/91126687
 
-## 微信公众号
-
-### 个人公众号：程序员黄小斜
-
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注微信公众号【程序员黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
-
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的微信公众号【Java技术江湖】
-
-这是一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-
-**Java工程师必备学习资源:** 
-关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
 
 
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
+                     
 
-​                     
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/SpringAOP\347\232\204\346\246\202\345\277\265\344\270\216\344\275\234\347\224\250.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/SpringAOP\347\232\204\346\246\202\345\277\265\344\270\216\344\275\234\347\224\250.md"
new file mode 100644
index 0000000..26e828a
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/SpringAOP\347\232\204\346\246\202\345\277\265\344\270\216\344\275\234\347\224\250.md"
@@ -0,0 +1,621 @@
+# Spring ��ܵ� AOP
+
+## Spring ��ܵ� AOP
+
+Spring ��ܵ�һ���ؼ������**��������ı��**(AOP)��ܡ���������ı����Ҫ�ѳ����߼��ֽ�ɲ�ͬ�IJ��ֳ�Ϊ��ν�Ĺ�ע�㡣��һ��Ӧ�ó���Ķ����Ĺ��ܱ���Ϊ**���й�ע��**����Щ���й�ע���ڸ����϶�����Ӧ�ó����ҵ���߼��������������������и��ָ����ĺܺõ���������ӣ�����־��¼����ơ�����ʽ���񡢰�ȫ�Ժͻ���ȡ�
+
+�� OOP �У��ؼ���Ԫģ������࣬���� AOP �е�Ԫģ��������档����ע��������Ӧ�ó�������໥����ϣ�AOP ���԰������������Ӱ��Ķ����жԺ��й�ע����AOP ���DZ�����ԵĴ������ Perl��.NET��Java �����������ԡ�
+
+Spring AOP ģ���ṩ������������һ��Ӧ�ó������磬��ִ��һ������ʱ��������ڷ���ִ��֮ǰ��֮�����Ӷ���Ĺ��ܡ�
+
+## AOP ����
+
+�����ǿ�ʼʹ�� AOP ����֮ǰ����������Ϥһ�� AOP ����������Щ���ﲢ���ض��� Spring�������� AOP �йصġ�
+
+| �� | ���� |
+| --- | --- |
+| Aspect | һ��ģ�����һ���ṩ��������� APIs�����磬һ����־ģ��Ϊ�˼�¼��־���� AOP ������á�Ӧ�ó������ӵ�����������ķ��棬��ȡ�������� |
+| Join point | �����Ӧ�ó�����������һ���㣬������ڲ�� AOP ���档��Ҳ��˵��������ʵ�ʵ�Ӧ�ó����У�����һ��������ʹ�� Spring AOP ��ܡ� |
+| Advice | ����ʵ���ж�֮ǰ��֮��ִ�еķ����������ڳ���ִ���ڼ�ͨ�� Spring AOP ���ʵ�ʱ����õĴ��롣 |
+| Pointcut | ����һ��һ���������ӵ㣬֪ͨӦ�ñ�ִ�С������ʹ�ñ���ʽ��ģʽָ��������������ǽ��� AOP �������п����ġ� |
+| Introduction | ���������������·��������Ե����е����С� |
+| Target object | ��һ�����߶��������֪ͨ�Ķ������������Զ��һ������������Ҳ��Ϊ��֪ͨ���� |
+| Weaving | Weaving �ѷ������ӵ�������Ӧ�ó������ͻ��߶����ϣ�������һ����֪ͨ�Ķ�����Щ�����ڱ���ʱ�������ʱ������ʱ��ɡ� |
+
+## ֪ͨ������
+
+Spring �������ʹ�������ᵽ������֪ͨ������
+
+| ֪ͨ | ���� |
+| --- | --- |
+| ǰ��֪ͨ | ��һ������ִ��֮ǰ��ִ��֪ͨ�� |
+| ����֪ͨ | ��һ������ִ��֮�󣬲�����������ִ��֪ͨ�� |
+| ���غ�֪ͨ | ��һ������ִ��֮��ֻ���ڷ����ɹ����ʱ������ִ��֪ͨ�� |
+| �׳��쳣��֪ͨ | ��һ������ִ��֮��ֻ���ڷ����˳��׳��쳣ʱ������ִ��֪ͨ�� |
+| ����֪ͨ | �ڽ��鷽������֮ǰ��֮��ִ��֪ͨ�� |
+
+## ʵ���Զ��巽��
+
+Spring ֧�� **@AspectJ annotation style** �ķ�����**����ģʽ**�ķ�����ʵ���Զ��巽�档�����ַ����Ѿ������������ӽڽ�������ϸ���͡�
+
+| ���� | ���� |
+| --- | --- |
+| [XML Schema based](https://www.w3cschool.cn/wkspring/omps1mm6.html) | ������ʹ�ó������Լ��������õ� XML ��ʵ�ֵġ� |
+| [@AspectJ based](https://www.w3cschool.cn/wkspring/k4q21mm8.html) | @AspectJ ����һ����������ķ����Ϊ���� Java 5 ע�͵ij��� Java ��ע�͡� |
+
+
+
+## Spring �л��� AOP �� XML�ܹ�
+
+Ϊ���ڱ��ڵ�������ʹ�� aop �����ռ��ǩ������Ҫ���� spring-aop �ܹ�������������
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+    xmlns:aop="http://www.springframework.org/schema/aop"
+    xsi:schemaLocation="http://www.springframework.org/schema/beans
+    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
+    http://www.springframework.org/schema/aop 
+    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
+
+   <!-- bean definition & AOP specific configuration -->
+
+</beans>
+
+```
+
+�㻹��Ҫ�����Ӧ�ó���� CLASSPATH ��ʹ������ AspectJ ���ļ�����Щ���ļ���һ�� AspectJ װ�õ� ��lib�� Ŀ¼���ǿ��õģ������������ Internet ���������ǡ�(ע��aspectjweaver.jar �Ѱ���������)
+
+*   aspectjrt.jar
+
+*   aspectjweaver.jar
+
+*   aspectj.jar
+
+*   aopalliance.jar
+
+## ������һ�� aspect
+
+һ�� **aspect** ��ʹ�� Ԫ�������ģ�֧�ֵ� bean ��ʹ�� **ref** �������õģ�������ʾ��
+
+```
+
+   
+   ...
+   
+
+<bean id="aBean" class="...">
+...
+</bean>
+```
+
+�����aBean�� �������ú�����ע�룬����ǰ����½����㿴���������� Spring bean һ����
+
+## ����һ�������
+
+һ��**�����**������ȷ��ʹ�ò�ͬ����ִ�еĸ���Ȥ�����ӵ㣨�����������ڴ����������õ� XML �ܹ�ʱ������㽫�ᰴ��������ʾ���壺
+
+```
+
+   
+   
+   ...
+   
+
+<bean id="aBean" class="...">
+...
+</bean>
+```
+
+�����ʾ��������һ����Ϊ ��businessService�� ������㣬������㽫�� com.tutorialspoint ���µ� Student ���е� getName() ������ƥ�䣺
+
+```
+
+   
+   
+   ...
+   
+
+<bean id="aBean" class="...">
+...
+</bean>
+```
+
+## ��������
+
+���������ʹ��Ԫ�����������������͵�֪ͨ�����£�
+
+```
+
+   
+      
+      <!-- a before advice definition -->
+      
+      <!-- an after advice definition -->
+      
+      <!-- an after-returning advice definition -->
+      <!--The doRequiredTask method must have parameter named retVal -->
+      
+      <!-- an after-throwing advice definition -->
+      <!--The doRequiredTask method must have parameter named ex -->
+      
+      <!-- an around advice definition -->
+      
+   ...
+   
+
+<bean id="aBean" class="...">
+...
+</bean>
+```
+
+����ԶԲ�ͬ�Ľ���ʹ����ͬ�� **doRequiredTask** ���߲�ͬ�ķ�������Щ����������Ϊ aspect ģ���һ���������塣
+
+## ���� AOP �� XML �ܹ���ʾ��
+
+Ϊ�����������ᵽ�Ļ��� AOP �� XML �ܹ��ĸ�������DZ�дһ��ʾ��������ʵ�ּ������顣Ϊ�������ǵ�ʾ����ʹ�ü������飬������ʹ Eclipse IDE ���ڹ���״̬��Ȼ�������²��贴��һ�� Spring Ӧ�ó���
+
+| ���� | ���� |
+| --- | --- |
+| 1 | ����һ����Ϊ _SpringExample_ ����Ŀ����������������Ŀ�� **src** �ļ����´���һ����Ϊ _com.tutorialspoint_ �İ��� |
+| 2 | ʹ�� _Add External JARs_ ѡ����������� Spring ���ļ��������� _Spring Hello World Example_ �½��н��͵������� |
+| 3 | ����Ŀ������ Spring AOP ָ���Ŀ��ļ� **aspectjrt.jar�� aspectjweaver.jar** �� **aspectj.jar**�� |
+| 4 | �� _com.tutorialspoint_ ���´��� Java �� **Logging**�� _Student_ �� _MainApp_�� |
+| 5 | �� **src** �ļ����´��� Beans �����ļ� _Beans.xml_�� |
+| 6 | ���һ���Ǵ������� Java �ļ��� Bean �����ļ������ݣ����Ұ����½��͵���������Ӧ�ó��� |
+
+������ **Logging.java** �ļ������ݡ���ʵ������ aspect ģ���һ��ʾ�������������ڸ�������õķ�����
+
+```
+package com.tutorialspoint;
+public class Logging {
+   /** 
+    * This is the method which I would like to execute
+    * before a selected method execution.
+    */
+   public void beforeAdvice(){
+      System.out.println("Going to setup student profile.");
+   }
+   /** 
+    * This is the method which I would like to execute
+    * after a selected method execution.
+    */
+   public void afterAdvice(){
+      System.out.println("Student profile has been setup.");
+   }
+   /** 
+    * This is the method which I would like to execute
+    * when any method returns.
+    */
+   public void afterReturningAdvice(Object retVal){
+      System.out.println("Returning:" + retVal.toString() );
+   }
+   /**
+    * This is the method which I would like to execute
+    * if there is an exception raised.
+    */
+   public void AfterThrowingAdvice(IllegalArgumentException ex){
+      System.out.println("There has been an exception: " + ex.toString());   
+   }  
+}
+```
+
+������ **Student.java** �ļ������ݣ�
+
+```
+package com.tutorialspoint;
+public class Student {
+   private Integer age;
+   private String name;
+   public void setAge(Integer age) {
+      this.age = age;
+   }
+   public Integer getAge() {
+      System.out.println("Age : " + age );
+      return age;
+   }
+   public void setName(String name) {
+      this.name = name;
+   }
+   public String getName() {
+      System.out.println("Name : " + name );
+      return name;
+   }  
+   public void printThrowException(){
+       System.out.println("Exception raised");
+       throw new IllegalArgumentException();
+   }
+}
+```
+
+������ **MainApp.java** �ļ������ݣ�
+
+```
+package com.tutorialspoint;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+public class MainApp {
+   public static void main(String[] args) {
+      ApplicationContext context = 
+             new ClassPathXmlApplicationContext("Beans.xml");
+      Student student = (Student) context.getBean("student");
+      student.getName();
+      student.getAge();      
+      student.printThrowException();
+   }
+}
+```
+
+�����������ļ� **Beans.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" 
+    xmlns:aop="http://www.springframework.org/schema/aop"
+    xsi:schemaLocation="http://www.springframework.org/schema/beans
+    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
+    http://www.springframework.org/schema/aop 
+    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
+
+   
+      
+         
+         
+         
+         
+         
+      
+   
+
+   <!-- Definition for student bean -->
+   <bean id="student" class="com.tutorialspoint.Student">
+      <property name="name"  value="Zara" />
+      <property name="age"  value="11"/>      
+   </bean>
+
+   <!-- Definition for logging aspect -->
+   <bean id="logging" class="com.tutorialspoint.Logging"/> 
+
+</beans>
+
+```
+
+һ�����Ѿ���ɵĴ�����Դ�ļ��� bean �����ļ�������������һ��Ӧ�ó���������Ӧ�ó���һ�ж������Ļ����⽫�����������Ϣ��
+
+```
+Going to setup student profile.
+Name : Zara
+Student profile has been setup.
+Returning:Zara
+Going to setup student profile.
+Age : 11
+Student profile has been setup.
+Returning:11
+Going to setup student profile.
+Exception raised
+Student profile has been setup.
+There has been an exception: java.lang.IllegalArgumentException
+.....
+other exception content
+```
+
+������������һ�����涨����� com.tutorialspoint �� ѡ�����з����� �������Ǽ���һ�£�����Ҫ��һ������ķ���֮ǰ����֮��ִ����Ľ��飬�����ͨ���滻ʹ����ʵ��ͷ������Ƶ�����㶨���е��Ǻţ�*�������������������������ִ�С�
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+    xmlns:aop="http://www.springframework.org/schema/aop"
+    xsi:schemaLocation="http://www.springframework.org/schema/beans
+    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
+    http://www.springframework.org/schema/aop 
+    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
+
+   
+   
+      
+      
+      
+   
+   
+
+   <!-- Definition for student bean -->
+   <bean id="student" class="com.tutorialspoint.Student">
+      <property name="name"  value="Zara" />
+      <property name="age"  value="11"/>      
+   </bean>
+
+   <!-- Definition for logging aspect -->
+   <bean id="logging" class="com.tutorialspoint.Logging"/> 
+
+</beans>
+
+```
+
+�������Ҫִ��ͨ����Щ����֮���ʾ��Ӧ�ó����⽫�����������Ϣ��
+
+```
+Going to setup student profile.
+Name : Zara
+Student profile has been setup.
+Age : 11
+Exception raised
+.....
+other exception content
+```
+
+
+
+## Spring ��� AOP �� @AspectJ
+
+@AspectJ ��Ϊͨ�� Java 5 ע��ע�͵���ͨ�� Java �࣬��ָ�������� aspects ��һ�ַ��ͨ������Ļ��ڼܹ��� XML �����ļ��а�������Ԫ�أ�@AspectJ ֧���ǿ��õġ�
+
+```
+
+```
+
+�㻹��Ҫ�����Ӧ�ó���� CLASSPATH ��ʹ������ AspectJ ���ļ�����Щ���ļ���һ�� AspectJ װ�õ� ��lib�� Ŀ¼���ǿ��õģ����û�У�������� Internet ���������ǡ�
+
+*   aspectjrt.jar
+
+*   aspectjweaver.jar
+
+*   aspectj.jar
+
+*   aopalliance.jar
+
+## ������һ�� aspect
+
+Aspects ��������κ������� bean һ�����������ǽ����� @AspectJ ע��֮�⣬����������һ�������з������ֶΣ�������ʾ��
+
+```
+package org.xyz;
+import org.aspectj.lang.annotation.Aspect;
+@Aspect
+public class AspectModule {
+}
+```
+
+���ǽ��� XML �а������½������ã��ͺ������κ� bean һ����
+
+```
+<bean id="myAspect" class="org.xyz.AspectModule">
+   <!-- configure properties of aspect here as normal -->
+</bean>
+
+```
+
+## ����һ�������
+
+һ��**�����**������ȷ��ʹ�ò�ͬ����ִ�еĸ���Ȥ�����ӵ㣨�����������ڴ����������õ� XML �ܹ�ʱ���������������������֣�
+
+*   һ����������ʽ���������Ǹ���Ȥ���ĸ�������������ִ�С�
+
+*   һ��������ǩ����һ�����ƺ����������IJ��������������������Dz���ɵģ�����ʵ������Ӧ���ǿյġ�
+
+�����ʾ���ж�����һ����Ϊ ��businessService�� ������㣬������㽫�� com.xyz.myapp.service ���µ����п��õ�ÿһ��������ƥ�䣺
+
+```
+import org.aspectj.lang.annotation.Pointcut;
+@Pointcut("execution(* com.xyz.myapp.service.*.*(..))") // expression 
+private void businessService() {}  // signature
+```
+
+�����ʾ���ж�����һ����Ϊ ��getname�� ������㣬������㽫�� com.tutorialspoint ���µ� Student ���е� getName() ������ƥ�䣺
+
+```
+import org.aspectj.lang.annotation.Pointcut;
+@Pointcut("execution(* com.tutorialspoint.Student.getName(..))") 
+private void getname() {}
+```
+
+## ��������
+
+�����ʹ�� @{ADVICE-NAME} ע��������������е�����һ����������ʾ����������Ѿ�������һ��������ǩ���� businessService()��
+
+```
+@Before("businessService()")
+public void doBeforeTask(){
+ ...
+}
+@After("businessService()")
+public void doAfterTask(){
+ ...
+}
+@AfterReturning(pointcut = "businessService()", returning="retVal")
+public void doAfterReturnningTask(Object retVal){
+  // you can intercept retVal here.
+  ...
+}
+@AfterThrowing(pointcut = "businessService()", throwing="ex")
+public void doAfterThrowingTask(Exception ex){
+  // you can intercept thrown exception here.
+  ...
+}
+@Around("businessService()")
+public void doAroundTask(){
+ ...
+}
+```
+
+�����Ϊ����һ�����鶨�����������������������ڽ���֮ǰ��������������һ��ʾ����
+
+```
+@Before("execution(* com.xyz.myapp.service.*.*(..))")
+public doBeforeTask(){
+ ...
+}
+```
+
+## ���� AOP �� @AspectJ ʾ��
+
+Ϊ�����������ᵽ�Ĺ��ڻ��� AOP �� @AspectJ �ĸ�������DZ�дһ��ʾ��������ʵ�ּ������顣Ϊ�������ǵ�ʾ����ʹ�ü������飬������ʹ Eclipse IDE ���ڹ���״̬��Ȼ�������²��贴��һ�� Spring Ӧ�ó���
+
+| ���� | ���� |
+| --- | --- |
+| 1 | ����һ����Ϊ _SpringExample_ ����Ŀ����������������Ŀ�� **src** �ļ����´���һ����Ϊ _com.tutorialspoint_ �İ��� |
+| 2 | ʹ�� _Add External JARs_ ѡ����������� Spring ���ļ��������� _Spring Hello World Example_ �½��н��͵������� |
+| 3 | ����Ŀ������ Spring AOP ָ���Ŀ��ļ� **aspectjrt.jar�� aspectjweaver.jar** �� **aspectj.jar**�� |
+| 4 | �� _com.tutorialspoint_ ���´��� Java �� **Logging**�� _Student_ �� _MainApp_�� |
+| 5 | �� **src** �ļ����´��� Beans �����ļ� _Beans.xml_�� |
+| 6 | ���һ���Ǵ������� Java �ļ��� Bean �����ļ������ݣ����Ұ����½��͵���������Ӧ�ó��� |
+
+������ **Logging.java** �ļ������ݡ���ʵ������ aspect ģ���һ��ʾ�������������ڸ�������õķ�����
+
+```
+package com.tutorialspoint;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.annotation.After;
+import org.aspectj.lang.annotation.AfterThrowing;
+import org.aspectj.lang.annotation.AfterReturning;
+import org.aspectj.lang.annotation.Around;
+@Aspect
+public class Logging {
+   /** Following is the definition for a pointcut to select
+    *  all the methods available. So advice will be called
+    *  for all the methods.
+    */
+   @Pointcut("execution(* com.tutorialspoint.*.*(..))")
+   private void selectAll(){}
+   /** 
+    * This is the method which I would like to execute
+    * before a selected method execution.
+    */
+   @Before("selectAll()")
+   public void beforeAdvice(){
+      System.out.println("Going to setup student profile.");
+   }
+   /** 
+    * This is the method which I would like to execute
+    * after a selected method execution.
+    */
+   @After("selectAll()")
+   public void afterAdvice(){
+      System.out.println("Student profile has been setup.");
+   }
+   /** 
+    * This is the method which I would like to execute
+    * when any method returns.
+    */
+   @AfterReturning(pointcut = "selectAll()", returning="retVal")
+   public void afterReturningAdvice(Object retVal){
+      System.out.println("Returning:" + retVal.toString() );
+   }
+   /**
+    * This is the method which I would like to execute
+    * if there is an exception raised by any method.
+    */
+   @AfterThrowing(pointcut = "selectAll()", throwing = "ex")
+   public void AfterThrowingAdvice(IllegalArgumentException ex){
+      System.out.println("There has been an exception: " + ex.toString());   
+   }  
+}
+```
+
+������ **Student.java** �ļ������ݣ�
+
+```
+package com.tutorialspoint;
+public class Student {
+   private Integer age;
+   private String name;
+   public void setAge(Integer age) {
+      this.age = age;
+   }
+   public Integer getAge() {
+      System.out.println("Age : " + age );
+      return age;
+   }
+   public void setName(String name) {
+      this.name = name;
+   }
+   public String getName() {
+      System.out.println("Name : " + name );
+      return name;
+   }
+   public void printThrowException(){
+      System.out.println("Exception raised");
+      throw new IllegalArgumentException();
+   }
+}
+```
+
+������ **MainApp.java** �ļ������ݣ�
+
+```
+package com.tutorialspoint;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+public class MainApp {
+   public static void main(String[] args) {
+      ApplicationContext context = 
+             new ClassPathXmlApplicationContext("Beans.xml");
+      Student student = (Student) context.getBean("student");
+      student.getName();
+      student.getAge();     
+      student.printThrowException();
+   }
+}
+```
+
+�����������ļ� **Beans.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" 
+    xmlns:aop="http://www.springframework.org/schema/aop"
+    xsi:schemaLocation="http://www.springframework.org/schema/beans
+    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
+    http://www.springframework.org/schema/aop 
+    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
+
+    
+
+   <!-- Definition for student bean -->
+   <bean id="student" class="com.tutorialspoint.Student">
+      <property name="name"  value="Zara" />
+      <property name="age"  value="11"/>      
+   </bean>
+
+   <!-- Definition for logging aspect -->
+   <bean id="logging" class="com.tutorialspoint.Logging"/> 
+
+</beans>
+
+```
+
+һ�����Ѿ���ɵĴ�����Դ�ļ��� bean �����ļ�������������һ��Ӧ�ó���������Ӧ�ó���һ�ж������Ļ����⽫�����������Ϣ��
+
+```
+Going to setup student profile.
+Name : Zara
+Student profile has been setup.
+Returning:Zara
+Going to setup student profile.
+Age : 11
+Student profile has been setup.
+Returning:11
+Going to setup student profile.
+Exception raised
+Student profile has been setup.
+There has been an exception: java.lang.IllegalArgumentException
+.....
+other exception content
+```
+
+
+
+
+
+# �����
+https://www.w3cschool.cn/wkspring
+https://www.runoob.com/w3cnote/basic-knowledge-summary-of-spring.html
+http://codepub.cn/2015/06/21/Basic-knowledge-summary-of-Spring
+https://dunwu.github.io/spring-tutorial
+https://mszlu.com/java/spring
+http://c.biancheng.net/spring/aop-module.html
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/SpringBean\347\232\204\345\256\232\344\271\211\344\270\216\347\256\241\347\220\206\357\274\210\346\240\270\345\277\203\357\274\211.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/SpringBean\347\232\204\345\256\232\344\271\211\344\270\216\347\256\241\347\220\206\357\274\210\346\240\270\345\277\203\357\274\211.md"
new file mode 100644
index 0000000..c4de431
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/SpringBean\347\232\204\345\256\232\344\271\211\344\270\216\347\256\241\347\220\206\357\274\210\346\240\270\345\277\203\357\274\211.md"
@@ -0,0 +1,183 @@
+### ����ע��
+
+Spring��ܵĺ��Ĺ�����������
+
+*   Spring������Ϊ�����󹤳������𴴽����������е�Java������ЩJava���󱻳�ΪBean��
+*   Spring��������������Bean֮���������ϵ��Springʹ��һ�ֱ���Ϊ"����ע��"�ķ�ʽ������Bean֮���������ϵ��
+
+ʹ������ע�룬��������ΪBeanע����ͨ������ֵ��������ע������Bean�����á�����ע����һ������Ľ��ʽ���������Bean�������ļ���֯��һ�𣬶�������Ӳ����ķ�ʽ�����һ��
+
+#### ��������ע��
+
+Rod Johnson�ǵ�һ���߶������������ļ�������Javaʵ����Э����ϵ���ˣ��������ַ�ʽ����һ�����֣����Ʒ�ת��Inverse of Control��IoC��������Martine FowlerΪ���ַ�ʽ������һ�����ƣ�����ע�루Dependency Injection������˲���������ע�룬���ǿ��Ʒ�ת���京����ȫ��ͬ����ij��Java���󣨵����ߣ���Ҫ������һ��Java���󣨱��������󣩵ķ���ʱ���ڴ�ͳģʽ��ͨ��������������
+
+1.  ԭʼ����: ������**����**��������������Ȼ���ٵ��ñ���������ķ�����
+2.  �򵥹���ģʽ: ���������ҵ�����������Ĺ�����Ȼ��**����**ͨ������ȥ��ȡ��������������ٵ��ñ���������ķ�����
+
+ע�������**����**���֣����Ȼ�ᵼ�µ������뱻��������ʵ�����Ӳ������ϣ��dz���������Ŀ������ά����ʹ��Spring���֮�󣬵���������**����**��ȡ���������󣬵�����ֻҪ**����**����Spring����Ϊ�����ߵij�Ա������ֵ���ɣ��ɴ˿ɼ���ʹ��Spring�󣬵����߻�ȡ����������ķ�ʽ��ԭ����������ȡ������˱������ܡ�������Rod Johnson��֮Ϊ���Ʒ�ת��
+
+�����Spring�����ĽǶ�������Spring�������𽫱���������ֵ�������ߵij�Ա���������൱��Ϊ������ע����������ʵ�������Martine Fowler��֮Ϊ����ע�롣
+
+#### ��ֵע��
+
+��ֵע����ָIoC����ͨ����Ա������setter������ע�뱻������������ע�뷽ʽ�򵥡�ֱ�ۣ������Spring������ע�������ʹ�á�
+
+#### ����ע��
+
+���ù�����������������ϵ�ķ�ʽ������Ϊ����ע�롣ͨ����˵����������Spring�ڵײ��Է��䷽ʽִ�д�ָ�������Ĺ���������ִ�д������Ĺ�����ʱ���Ϳ����ù����������Գ�Ա����ִ�г�ʼ����������ǹ���ע��ı��ʡ�
+
+#### ����ע�뷽ʽ�ĶԱ�
+
+��ֵע���������ŵ㣺
+
+*   �봫ͳ��JavaBean��д�������ƣ����򿪷���Ա���������⡢���ܡ�ͨ��setter�����趨������ϵ�Եø���ֱ�ۡ���Ȼ��
+*   ���ڸ��ӵ�������ϵ��������ù���ע�룬�ᵼ�¹���������ӷ�ף������Ķ���Spring�ڴ���Beanʵ��ʱ����Ҫͬʱʵ������������ȫ��ʵ����������������½�����ʹ����ֵע�룬���ܱ�����Щ���⡣
+*   ������ijЩ��Ա������ѡ������£�������Ĺ��������ӱ��ء�
+
+����ע���������£�
+
+*   ����ע������ڹ������о���������ϵ��ע��˳����������������ע�롣
+*   ����������ϵ����仯��Bean������ע������ô�����Ϊû��setter���������е�������ϵȫ���ڹ��������趨�����뵣�ĺ����Ĵ����������ϵ�����ƻ���
+*   ������ϵֻ���ڹ��������趨����ֻ������Ĵ����߲��ܸı������������ϵ��������ĵ����߶��ԣ�����ڲ���������ϵ��ȫ͸���������ϸ��ھ۵�ԭ��
+
+**_ע�⣺_**
+���������ֵע��Ϊ��������ע��Ϊ����ע����ԡ�����������ϵ����仯��ע�룬�������ù���ע�룻������������ϵ��ע�룬���Dz�����ֵע�롣
+
+### Spring�����е�Bean
+
+���ڿ�������˵��������ʹ��Spring�����Ҫ���������£��ٿ���Bean��������Bean������Spring�����˵����Ҫ���ľ��Ǹ��������ļ�������Beanʵ����������Beanʵ���ķ������"����ע��"�����������νIoC�ı��ʡ�
+
+#### ������Bean��������
+
+��ͨ��Spring��������һ��Beanʵ��ʱ�������������Beanʵ����ʵ������������ΪBeanָ���ض���������Spring֧����������������
+
+1.  singleton: ����ģʽ��������Spring IoC�����У�singleton�������Bean��ֻ����һ��ʵ����
+2.  prototype: ÿ��ͨ��������getBean()������ȡprototype�������Beanʱ����������һ���µ�Beanʵ����
+3.  request: ����һ��HTTP����request�������Bean��ֻ����һ��ʵ��������ζ�ţ���ͬһ��HTTP�����ڣ�����ÿ�������Bean���õ�������ͬһ��ʵ����ֻ����WebӦ����ʹ��Springʱ�����������������Ч��
+4.  session���������� bean �Ķ�������Ϊ HTTP �Ự�� ֻ��web-aware Spring ApplicationContext������������Ч��
+5.  global session: ÿ��ȫ�ֵ�HTTP Session��Ӧһ��Beanʵ�����ڵ��͵�����£�����ʹ��portlet context��ʱ����Ч��ͬ��ֻ��WebӦ������Ч��
+
+�����ָ��Bean��������SpringĬ��ʹ��singleton������prototype�������Bean�Ĵ��������ٴ��۱Ƚϴ󡣶�singleton�������Beanʵ��һ�������ɹ����Ϳ����ظ�ʹ�á���ˣ�Ӧ�þ������⽫Bean���ó�prototype������
+
+### ʹ���Զ�װ��ע�������Bean
+
+Spring���Զ�װ��Bean��Bean֮���������ϵ��������ʹ��ref��ʽָ������Bean��������Spring�������XML�����ļ����ݣ�����ij�ֹ���Ϊ������Beanע�뱻������Bean��
+Spring�Զ�װ���ͨ��`<beans/>`Ԫ�ص�`default-autowire`����ָ���������Զ������ļ������е�Bean�����ã�Ҳ��ͨ����`<bean/>`Ԫ�ص�`autowire`����ָ����������ֻ�Ը�Bean�����á�
+
+`autowire`��`default-autowire`���Խ�������ֵ��
+
+*   `no`: ��ʹ���Զ�װ�䡣Bean��������ͨ��refԪ�ض��塣����Ĭ�����ã��ڽϴ�IJ��𻷾��в������ı�������ã���ʽ���ú������ܹ��õ���������������ϵ��
+*   `byName`: ����setter�����������Զ�װ�䡣Spring��������������ȫ��Bean���ҳ���id��setter������ȥ��setǰ׺����Сд����ĸ��ͬ����Bean�����ע�롣���û���ҵ�ƥ���Beanʵ������Spring��������κ�ע�롣
+*   `byType`: ����setter�������β��������Զ�װ�䡣Spring�������������е�ȫ��Bean�����������һ��Bean������setter�������β�����ƥ�䣬���Զ�ע�����Bean������ҵ����������Bean�����׳�һ���쳣�����û���ҵ�������Bean����ʲô�����ᷢ����setter�������ᱻ���á�
+*   `constructor`: ��byType���ƣ������������Զ�ƥ�乹�����IJ����������������ǡ���ҵ�һ���빹������������ƥ���Bean������׳�һ���쳣��
+*   `autodetect`: Spring��������Bean�ڲ��ṹ�����о���ʹ��constructor��byType���ԡ�����ҵ�һ��Ĭ�ϵĹ��캯������ô�ͻ�Ӧ��byType���ԡ�
+
+**��һ��Bean��ʹ���Զ�װ����������ʹ��ref��ʽָ������ʱ������ʽָ�������������Զ�װ�����������ڴ��͵�Ӧ�ã�������ʹ���Զ�װ�䡣��Ȼʹ���Զ�װ��ɼ��������ļ��Ĺ����������������������ϵ�������Ժ�͸���ԡ�������ϵ��װ��������Դ�ļ������������������ͣ�����Bean��Bean֮�����Ͻ��͵������Σ������ڸ߲�ν��**
+
+ <!--ͨ�����ÿ��Խ�Bean�ų����Զ�װ��֮��-->  <bean  id=""  autowire-candidate="false"/>  <!--����֮�⣬��������beansԪ����ָ����֧��ģʽ�ַ���������������abc��β��Bean�����ų����Զ�װ��֮��-->  <beans  default-autowire-candidates="*abc"/> 
+
+## ����Bean��3�ַ�ʽ
+
+### ʹ�ù���������Beanʵ��
+
+ʹ�ù�����������Beanʵ����������������������ù���ע�룬Spring�ײ�����Bean����޲���������������ʵ�������Ҫ���Bean���ṩ�޲����Ĺ�������
+
+����Ĭ�ϵĹ���������Beanʵ����Spring��Beanʵ������������ִ��Ĭ�ϳ�ʼ���������еĻ������͵�ֵ��ʼ��Ϊ0��false�����е��������͵�ֵ��ʼ��Ϊnull��
+
+### ʹ�þ�̬������������Bean
+
+ʹ�þ�̬������������Beanʵ��ʱ��class����Ҳ����ָ��������ʱclass���Բ�����ָ��Beanʵ����ʵ���࣬���Ǿ�̬�����࣬Springͨ��������֪�����ĸ�������������Beanʵ����
+
+����֮�⣬����Ҫʹ��factory-method������ָ����̬����������Spring�����þ�̬������������һ��Beanʵ����һ�������ָ��Beanʵ����Spring����Ĵ��������������ͨ��������Beanʵ����ȫһ���������̬����������Ҫ��������ʹ��`<constructor-arg.../>`Ԫ��ָ����̬���������IJ�����
+
+### ����ʵ��������������Bean
+
+ʵ�����������뾲̬��������ֻ��һ����ͬ�����þ�̬��������ֻ��ʹ�ù����༴�ɣ�������ʵ��������������Ҫ����ʵ����ʹ��ʵ����������ʱ������Beanʵ����`<bean.../>`Ԫ������class���ԣ�����ʵ����������ʹ��`factory-bean`ָ������ʵ����
+����ʵ��������������Bean��`<bean.../>`Ԫ��ʱ��Ҫָ�������������ԣ�
+
+*   factory-bean: �����Ե�ֵΪ����Bean��id��
+*   factory-method: ������ָ��ʵ�������Ĺ���������
+
+������ʵ����������ʱ��Ҫ�����������ʹ��`<constructor-arg.../>`Ԫ��ȷ������ֵ��
+
+## Э��������ͬ����Bean
+
+��singleton�������Bean������prototype�������Beanʱ���������ͬ��������ԭ������Ϊ��Spring������ʼ��ʱ��������Ԥ��ʼ�����������е�`singleton Bean`������`singleton Bean`������`prototype Bean`�����Spring�ڳ�ʼ��`singleton Bean`֮ǰ�����ȴ���`prototypeBean`����Ȼ��Ŵ���`singleton Bean`�������ｫ`prototype Bean`ע��`singleton Bean`��
+�����ͬ���ķ��������֣�
+
+*   ��������ע��: singleton�������Beanÿ����Ҫprototype�������Beanʱ�����������������µ�Beanʵ�������ɱ�֤ÿ��ע���`prototype Bean`ʵ���������µ�ʵ����
+*   ���÷���ע��: ����ע��ͨ��ʹ��lookup����ע�룬ʹ��lookup����ע�������Spring������д������Bean�ij������巽�������ز�������������Bean�Ľ���������ҵ�Beanͨ����һ��`non-singleton Bean`��Springͨ��ʹ��JDK��̬������cglib���޸Ŀͻ��˵Ķ������룬�Ӷ�ʵ������Ҫ��
+
+������õڶ��ַ�����ʹ�÷���ע�롣Ϊ��ʹ��lookup����ע�룬������Ҫ����������
+
+1.  ��������Bean��ʵ���ඨ��Ϊ�����࣬������һ�����󷽷�����ȡ��������Bean��
+2.  ��`<bean.../>`Ԫ��������`<lookup-method.../>`��Ԫ����SpringΪ������Bean��ʵ����ʵ��ָ���ij��󷽷���
+
+**_ע�⣺_**
+
+> Spring���������ʱ��̬��ǿ�ķ�ʽ��ʵ��`<lookup-method.../>`Ԫ����ָ���ij��󷽷������Ŀ�������ʵ�ֹ��ӿڣ�Spring�����JDK��̬������ʵ�ָó����࣬��Ϊ֮ʵ�ֳ��󷽷������Ŀ�������û��ʵ�ֹ��ӿڣ�Spring�����cglibʵ�ָó����࣬��Ϊ֮ʵ�ֳ��󷽷���Spring4.0��spring-core-xxx.jar�����Ѿ�������cglib��⡣
+
+## ���ֺ�����
+
+Spring�ṩ�����ֳ��õĺ�������
+
+*   Bean������: ���ֺ��������������Bean���к�������Bean���ж����ǿ��
+*   ����������: ���ֺ��������IoC�������к�����������ǿ�������ܡ�
+
+### Bean������
+
+Bean��������һ�������Bean�����������Bean���������ṩ������������������id���ԣ�����Ҫ����������е�����Beanִ�к���������Ϊ�����е�Ŀ��Bean���ɴ����ȣ�����Bean��ΪBean��������Bean����������Beanʵ�������ɹ�֮�󣬶�Beanʵ�����н�һ������ǿ������Bean����������ʵ��`BeanPostProcessor`�ӿڣ�ͬʱ����ʵ�ָýӿڵ�����������
+
+1.  `Object postProcessBeforeInitialization(Object bean, String name) throws BeansException`: �÷����ĵ�һ��������ϵͳ�������к�����Beanʵ�����ڶ��������Ǹ�Bean������id
+2.  `Object postProcessAfterinitialization(Object bean, String name) throws BeansException`: �÷����ĵ�һ��������ϵͳ�������к�����Beanʵ�����ڶ��������Ǹ�Bean������id
+
+������һ��ע����Bean��������Bean�������ͻ��Զ���������������ÿ��Bean����ʱ�Զ�������Bean���������������Ļص�ʱ������ͼ��
+
+![bean-post-process](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/e8970a58f831cd7613b680ef0541e7c7.jpg)
+
+ע��һ�㣬���ʹ��`BeanFactory`��ΪSpring������������ֶ�ע��Bean����������������ȡBean������ʵ����Ȼ���ֶ�ע�ᡣ
+
+BeanPostProcessor bp =  (BeanPostProcessor)beanFactory.getBean("bp"); beanFactory.addBeanPostProcessor(bp);  Person p =  (Person)beanFactory.getBean("person");
+
+### ����������
+
+Bean�����������������е�����Beanʵ����������������������������������������������ʵ��`BeanFactoryPostProcessor`�ӿڣ���ʵ�ָýӿڵ�һ������`postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)`ʵ�ָ÷����ķ�������Ƕ�Spring�������еĴ��������ִ������Զ�Spring���������Զ�����չ����ȻҲ���Զ�Spring�����������κδ�����
+
+������`BeanPostProcessor`��`ApplicationContext`���Զ���⵽�����е������������������Զ�ע������������������ʹ��`BeanFactory`��ΪSpring������������ֶ����ø�����������������`BeanFactory`������
+
+## Spring��"������"֧��
+
+### ����Bean��
+
+Spring�ṩ���¼���Annotation����עSpring Bean��
+
+*   `@Component`: ��עһ����ͨ��Spring Bean��
+*   `@Controller`: ��עһ�������������
+*   `@Service`: ��עһ��ҵ���߼������
+*   `@Repository`: ��עһ��DAO�����
+
+��Spring�����ļ������������ã�ָ���Զ�ɨ��İ���
+
+<context:component-scan  base-package="edu.shu.spring.domain"/>
+
+### ʹ��@Resource��������
+
+`@Resource`λ��`javax.annotation`���£�������JavaEE�淶��һ��`Annotation`��Springֱ�ӽ���˸�`Annotation`��ͨ��ʹ�ø�`Annotation`ΪĿ��Beanָ��Э����Bean��ʹ��`@Resource`��`<property.../>`Ԫ�ص�ref��������ͬ��Ч����
+`@Resource`������������setter������Ҳ����ֱ������ʵ�����������ʹ��`@Resource`����ʵ������������Ӽ򵥣���ʱSpring����ֱ��ʹ��JavaEE�淶��Fieldע�룬��ʱ��setter���������Բ�Ҫ��
+
+### ʹ��@PostConstruct��@PreDestroy��������������Ϊ
+
+`@PostConstruct`��`@PreDestroy`ͬ��λ��javax.annotation���£�Ҳ������JavaEE�淶������Annotation��Springֱ�ӽ�������ǣ����ڶ���Spring������Bean������������Ϊ�����Ƕ��������η����������κ����ԡ�����ǰ�����εķ���ʱBean�ij�ʼ�����������������εķ���ʱBean����֮ǰ�ķ�����
+
+### Spring4.0��ǿ���Զ�װ��;�ȷװ��
+
+Spring�ṩ��`@Autowired`ע����ָ���Զ�װ�䣬`@Autowired`��������setter��������ͨ������ʵ�������͹������ȡ���ʹ��`@Autowired`��עsetter����ʱ��Ĭ�ϲ���byType�Զ�װ����ԡ������ֲ����£������Զ�װ�����͵ĺ�ѡBeanʵ�������ж�������ʱ��Ϳ��������쳣��Ϊ��ʵ�־�ȷ���Զ�װ�䣬Spring�ṩ��`@Qualifier`ע�⣬ͨ��ʹ��`@Qualifier`����������Bean��id��ִ���Զ�װ�䡣
+
+# �����
+
+https://www.w3cschool.cn/wkspring
+https://www.runoob.com/w3cnote/basic-knowledge-summary-of-spring.html
+http://codepub.cn/2015/06/21/Basic-knowledge-summary-of-Spring
+https://dunwu.github.io/spring-tutorial
+https://mszlu.com/java/spring
+http://c.biancheng.net/spring/aop-module.html
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\345\257\271\344\272\216\346\225\260\346\215\256\345\272\223\347\232\204\350\256\277\351\227\256.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\345\257\271\344\272\216\346\225\260\346\215\256\345\272\223\347\232\204\350\256\277\351\227\256.md"
new file mode 100644
index 0000000..69bfc96
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\345\257\271\344\272\216\346\225\260\346\215\256\345\272\223\347\232\204\350\256\277\351\227\256.md"
@@ -0,0 +1,1183 @@
+
+## ��������Դ
+
+### Spring ��������Դ
+
+Spring ��������Դ�ж��ַ�ʽ������һһ�о٣�
+
+#### [#](https://dunwu.github.io/spring-tutorial/pages/1b774c/#%E4%BD%BF%E7%94%A8-jndi-%E6%95%B0%E6%8D%AE%E6%BA%90)ʹ�� JNDI ����Դ
+
+��� Spring Ӧ�ò�����֧�� JNDI �� WEB �������ϣ��� WebSphere��JBoss��Tomcat �ȣ����Ϳ���ʹ�� JNDI ��ȡ����Դ��
+
+
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns:jee="http://www.springframework.org/schema/jee"
+  xsi:schemaLocation="http://www.springframework.org/schema/beans
+            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
+http://www.springframework.org/schema/jee
+http://www.springframework.org/schema/jee/spring-jee-3.2.xsd">
+
+  <!-- 1.ʹ��bean����jndi����Դ -->
+  <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
+    <property name="jndiName" value="java:comp/env/jdbc/orclight" />
+  </bean>
+
+  <!-- 2.ʹ��jee��ǩ����jndi����Դ����1�ȼۣ�������Ҫ���������ռ� -->
+  <jee:jndi-lookup id="dataSource" jndi-name=" java:comp/env/jdbc/orclight" />
+</beans>
+
+```
+
+
+
+#### [#](https://dunwu.github.io/spring-tutorial/pages/1b774c/#%E4%BD%BF%E7%94%A8%E6%95%B0%E6%8D%AE%E5%BA%93%E8%BF%9E%E6%8E%A5%E6%B1%A0)ʹ�����ݿ����ӳ�
+
+Spring ������û���ṩ���ݿ����ӳص�ʵ�֣���Ҫ����ѡ����ʵ����ݿ����ӳء�������һ��ʹ�� [Druid (opens new window)](https://github.com/alibaba/druid)��Ϊ���ݿ����ӳص�ʾ����
+
+
+
+```
+<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
+        init-method="init" destroy-method="close">
+    <property name="driverClassName" value="${jdbc.driver}"/>
+    <property name="url" value="${jdbc.url}"/>
+    <property name="username" value="${jdbc.username}"/>
+    <property name="password" value="${jdbc.password}"/>
+
+    <!-- ���ó�ʼ����С����С����� -->
+    <property name="initialSize" value="1"/>
+    <property name="minIdle" value="1"/>
+    <property name="maxActive" value="10"/>
+
+    <!-- ���û�ȡ���ӵȴ���ʱ��ʱ�� -->
+    <property name="maxWait" value="10000"/>
+
+    <!-- ���ü����òŽ���һ�μ�⣬�����Ҫ�رյĿ������ӣ���λ�Ǻ��� -->
+    <property name="timeBetweenEvictionRunsMillis" value="60000"/>
+
+    <!-- ����һ�������ڳ�����С�����ʱ�䣬��λ�Ǻ��� -->
+    <property name="minEvictableIdleTimeMillis" value="300000"/>
+
+    <property name="testWhileIdle" value="true"/>
+
+    <!-- ���ｨ������ΪTRUE����ֹȡ�������Ӳ����� -->
+    <property name="testOnBorrow" value="true"/>
+    <property name="testOnReturn" value="false"/>
+
+    <!-- ��PSCache������ָ��ÿ��������PSCache�Ĵ�С -->
+    <property name="poolPreparedStatements" value="true"/>
+    <property name="maxPoolPreparedStatementPerConnectionSize"
+              value="20"/>
+
+    <!-- ���������ύ��ʽ��Ĭ�Ͼ���TRUE�����Բ������� -->
+
+    <property name="defaultAutoCommit" value="true"/>
+
+    <!-- ��֤������Ч����SQL����ͬ���������ò�ͬ -->
+    <property name="validationQuery" value="select 1 "/>
+    <property name="filters" value="stat"/>
+  </bean>
+
+```
+
+
+
+#### [#](https://dunwu.github.io/spring-tutorial/pages/1b774c/#%E5%9F%BA%E4%BA%8E-jdbc-%E9%A9%B1%E5%8A%A8%E7%9A%84%E6%95%B0%E6%8D%AE%E6%BA%90)���� JDBC ����������Դ
+
+
+
+```
+<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
+  <property name="driverClassName" value="${jdbc.driver}"/>
+  <property name="url" value="${jdbc.url}"/>
+  <property name="username" value="${jdbc.username}"/>
+  <property name="password" value="${jdbc.password}"/>
+</bean>
+```
+
+
+#### ʹ��JDBC
+
+������: 2022/11/16 20:10 / �Ķ�: 946668
+
+* * *
+
+
+
+������ǰ�����[JDBC���](https://www.liaoxuefeng.com/wiki/1252599548343744/1255943820274272)ʱ�Ѿ�������Java����ʹ��JDBC�ӿڷ��ʹ�ϵ���ݿ��ʱ����Ҫ���¼�����
+
+*   ����ȫ��`DataSource`ʵ������ʾ���ݿ����ӳأ�
+*   ����Ҫ��д���ݿ�ķ����ڲ��������²���������ݿ⣺
+    *   ��ȫ��`DataSource`ʵ����ȡ`Connection`ʵ����
+    *   ͨ��`Connection`ʵ������`PreparedStatement`ʵ����
+    *   ִ��SQL��䣬����Dz�ѯ����ͨ��`ResultSet`��ȡ�������������޸ģ�����`int`�����
+
+��ȷ��дJDBC����Ĺؼ���ʹ��`try ... finally`�ͷ���Դ���漰������Ĵ�����Ҫ��ȷ�ύ��ع�����
+
+��Springʹ��JDBC����������ͨ��IoC��������������һ��`DataSource`ʵ����Ȼ��Spring�ṩ��һ��`JdbcTemplate`�����Է���������Dz���JDBC����ˣ�ͨ������£����ǻ�ʵ����һ��`JdbcTemplate`������˼�壬�������Ҫʹ����[Templateģʽ](https://www.liaoxuefeng.com/wiki/1252599548343744/1281319636041762)��
+
+��дʾ��������߲��Դ���ʱ������ǿ���Ƽ�ʹ��[HSQLDB](http://hsqldb.org/)������ݿ⣬����һ����Java��д�Ĺ�ϵ���ݿ⣬�������ڴ�ģʽ�����ļ�ģʽ���У�����ֻ��һ��jar�����dz��ʺ���ʾ������߲��Դ��롣
+
+������ʵ�ʹ���Ϊ�����ȴ���Maven����`spring-data-jdbc`��Ȼ����������������
+
+*   org.springframework:spring-context:6.0.0
+*   org.springframework:spring-jdbc:6.0.0
+*   jakarta.annotation:jakarta.annotation-api:2.1.1
+*   com.zaxxer:HikariCP:5.0.1
+*   org.hsqldb:hsqldb:2.7.1
+
+��`AppConfig`�У�������Ҫ�������¼��������Bean��
+
+```
+@Configuration
+@ComponentScan
+@PropertySource("jdbc.properties")
+public class AppConfig {
+
+    @Value("${jdbc.url}")
+    String jdbcUrl;
+
+    @Value("${jdbc.username}")
+    String jdbcUsername;
+
+    @Value("${jdbc.password}")
+    String jdbcPassword;
+
+    @Bean
+    DataSource createDataSource() {
+        HikariConfig config = new HikariConfig();
+        config.setJdbcUrl(jdbcUrl);
+        config.setUsername(jdbcUsername);
+        config.setPassword(jdbcPassword);
+        config.addDataSourceProperty("autoCommit", "true");
+        config.addDataSourceProperty("connectionTimeout", "5");
+        config.addDataSourceProperty("idleTimeout", "60");
+        return new HikariDataSource(config);
+    }
+
+    @Bean
+    JdbcTemplate createJdbcTemplate(@Autowired DataSource dataSource) {
+        return new JdbcTemplate(dataSource);
+    }
+}
+
+```
+
+������������
+
+1.  ͨ��`@PropertySource("jdbc.properties")`��ȡ���ݿ������ļ���
+2.  ͨ��`@Value("${jdbc.url}")`ע�������ļ���������ã�
+3.  ����һ��DataSourceʵ��������ʵ��������`HikariDataSource`������ʱ��Ҫ�õ�ע������ã�
+4.  ����һ��JdbcTemplateʵ��������Ҫע��`DataSource`������ͨ�������������ע��ġ�
+
+������HSQLDBдһ�������ļ�`jdbc.properties`��
+
+```
+# ���ݿ��ļ���Ϊtestdb:
+jdbc.url=jdbc:hsqldb:file:testdb
+
+# HsqldbĬ�ϵ��û�����sa�������ǿ��ַ���:
+jdbc.username=sa
+jdbc.password=
+
+```
+
+����ͨ��HSQLDB�Դ��Ĺ�������ʼ�����ݿ������������дһ��Bean����Spring��������ʱ�Զ�����һ��`users`����
+
+```
+@Component
+public class DatabaseInitializer {
+    @Autowired
+    JdbcTemplate jdbcTemplate;
+
+    @PostConstruct
+    public void init() {
+        jdbcTemplate.update("CREATE TABLE IF NOT EXISTS users (" //
+                + "id BIGINT IDENTITY NOT NULL PRIMARY KEY, " //
+                + "email VARCHAR(100) NOT NULL, " //
+                + "password VARCHAR(100) NOT NULL, " //
+                + "name VARCHAR(100) NOT NULL, " //
+                + "UNIQUE (email))");
+    }
+}
+
+```
+
+���ڣ�����׼������������ϡ�����ֻ��Ҫ����Ҫ�������ݿ��Bean�У�ע��`JdbcTemplate`���ɣ�
+
+```
+@Component
+public class UserService {
+    @Autowired
+    JdbcTemplate jdbcTemplate;
+    ...
+}
+
+```
+
+### JdbcTemplate�÷�
+
+Spring�ṩ��`JdbcTemplate`����Templateģʽ���ṩ��һϵ���Իص�Ϊ�ص�Ĺ��߷�����Ŀ���DZ��ⷱ����`try...catch`��䡣
+
+�����Ծ����ʾ����˵��JdbcTemplate���÷���
+
+�������ǿ�`T execute(ConnectionCallback<T> action)`���������ṩ��Jdbc��`Connection`������ʹ�ã�
+
+```
+public User getUserById(long id) {
+    // ע�⴫�����ConnectionCallback:
+    return jdbcTemplate.execute((Connection conn) -> {
+        // ����ֱ��ʹ��connʵ������Ҫ�ͷ������ص�������JdbcTemplate�Զ��ͷ�:
+        // ���ڲ��ֶ�������PreparedStatement��ResultSet������try(...)�ͷ�:
+        try (var ps = conn.prepareStatement("SELECT * FROM users WHERE id = ?")) {
+            ps.setObject(1, id);
+            try (var rs = ps.executeQuery()) {
+                if (rs.next()) {
+                    return new User( // new User object:
+                            rs.getLong("id"), // id
+                            rs.getString("email"), // email
+                            rs.getString("password"), // password
+                            rs.getString("name")); // name
+                }
+                throw new RuntimeException("user not found by id.");
+            }
+        }
+    });
+}
+
+```
+
+Ҳ����˵�������ص�����������ȡConnection��Ȼ�����κλ���Connection�IJ�����
+
+�����ٿ�`T execute(String sql, PreparedStatementCallback<T> action)`���÷���
+
+```
+public User getUserByName(String name) {
+    // ��Ҫ����SQL��䣬�Լ�PreparedStatementCallback:
+    return jdbcTemplate.execute("SELECT * FROM users WHERE name = ?", (PreparedStatement ps) -> {
+        // PreparedStatementʵ���Ѿ���JdbcTemplate���������ڻص����Զ��ͷ�:
+        ps.setObject(1, name);
+        try (var rs = ps.executeQuery()) {
+            if (rs.next()) {
+                return new User( // new User object:
+                        rs.getLong("id"), // id
+                        rs.getString("email"), // email
+                        rs.getString("password"), // password
+                        rs.getString("name")); // name
+            }
+            throw new RuntimeException("user not found by id.");
+        }
+    });
+}
+
+```
+
+������ǿ�`T queryForObject(String sql, RowMapper<T> rowMapper, Object... args)`������
+
+```
+public User getUserByEmail(String email) {
+    // ����SQL��������RowMapperʵ��:
+    return jdbcTemplate.queryForObject("SELECT * FROM users WHERE email = ?",
+            (ResultSet rs, int rowNum) -> {
+                // ��ResultSet�ĵ�ǰ��ӳ��Ϊһ��JavaBean:
+                return new User( // new User object:
+                        rs.getLong("id"), // id
+                        rs.getString("email"), // email
+                        rs.getString("password"), // password
+                        rs.getString("name")); // name
+            },
+            email);
+}
+
+```
+
+��`queryForObject()`�����У�����SQL�Լ�SQL������`JdbcTemplate`���Զ�����`PreparedStatement`���Զ�ִ�в�ѯ������`ResultSet`�������ṩ��`RowMapper`��Ҫ����������ǰ�`ResultSet`�ĵ�ǰ��ӳ���һ��JavaBean�����ء����������У�ʹ��`Connection`��`PreparedStatement`��`ResultSet`������Ҫ�����ֶ�������
+
+`RowMapper`��һ������JavaBean��ʵ���������Է����κ�Java�������磬ʹ��`SELECT COUNT(*)`��ѯʱ�����Է���`Long`��
+
+```
+public long getUsers() {
+    return jdbcTemplate.queryForObject("SELECT COUNT(*) FROM users", (ResultSet rs, int rowNum) -> {
+        // SELECT COUNT(*)��ѯֻ��һ�У�ȡ��һ������:
+        return rs.getLong(1);
+    });
+}
+
+```
+
+��������������ض��м�¼��������һ�У�������`query()`������
+
+```
+public List<User> getUsers(int pageIndex) {
+    int limit = 100;
+    int offset = limit * (pageIndex - 1);
+    return jdbcTemplate.query("SELECT * FROM users LIMIT ? OFFSET ?",
+            new BeanPropertyRowMapper<>(User.class),
+            limit, offset);
+}
+
+```
+
+����`query()`��������IJ�����Ȼ��SQL��SQL�����Լ�`RowMapper`ʵ������������ֱ��ʹ��Spring�ṩ��`BeanPropertyRowMapper`��������ݿ���Ľṹǡ�ú�JavaBean����������һ�£���ô`BeanPropertyRowMapper`�Ϳ���ֱ�Ӱ�һ�м�¼������ת��ΪJavaBean��
+
+�������ִ�еIJ��Dz�ѯ�����Dz��롢���º�ɾ����������ô��Ҫʹ��`update()`������
+
+```
+public void updateUser(User user) {
+    // ����SQL��SQL���������ظ��µ�����:
+    if (1 != jdbcTemplate.update("UPDATE users SET name = ? WHERE id = ?", user.getName(), user.getId())) {
+        throw new RuntimeException("User not found by id");
+    }
+}
+
+```
+
+ֻ��һ��`INSERT`�����Ƚ����⣬�Ǿ������ijһ���������У�����������������ͨ����������Ҫ��ȡ����������ֵ��`JdbcTemplate`�ṩ��һ��`KeyHolder`������һ������
+
+```
+public User register(String email, String password, String name) {
+    // ����һ��KeyHolder:
+    KeyHolder holder = new GeneratedKeyHolder();
+    if (1 != jdbcTemplate.update(
+        // ����1:PreparedStatementCreator
+        (conn) -> {
+            // ����PreparedStatementʱ������ָ��RETURN_GENERATED_KEYS:
+            var ps = conn.prepareStatement("INSERT INTO users(email, password, name) VALUES(?, ?, ?)",
+                    Statement.RETURN_GENERATED_KEYS);
+            ps.setObject(1, email);
+            ps.setObject(2, password);
+            ps.setObject(3, name);
+            return ps;
+        },
+        // ����2:KeyHolder
+        holder)
+    ) {
+        throw new RuntimeException("Insert failed.");
+    }
+    // ��KeyHolder�л�ȡ���ص�����ֵ:
+    return new User(holder.getKey().longValue(), email, password, name);
+}
+
+```
+
+`JdbcTemplate`�����������ط������������Dz�һһ���ܡ���Ҫǿ�����ǣ�`JdbcTemplate`ֻ�Ƕ�JDBC������һ���򵥷�װ������Ŀ���Ǿ��������ֶ���д`try(resource) {...}`�Ĵ��룬���ڲ�ѯ����Ҫͨ��`RowMapper`ʵ����JDBC�������Java�����ת����
+
+�����ܽ�һ��`JdbcTemplate`���÷����Ǿ��ǣ�
+
+*   ��Լ򵥲�ѯ����ѡ`query()`��`queryForObject()`����Ϊֻ���ṩSQL��䡢������`RowMapper`��
+*   ��Ը��²�������ѡ`update()`����Ϊֻ���ṩSQL���Ͳ�����
+*   �κθ��ӵIJ���������Ҳ����ͨ��`execute(ConnectionCallback)`ʵ�֣���Ϊ�õ�`Connection`�Ϳ������κ�JDBC������
+
+ʵ��������ʹ��������Ȼ�Ǹ��ֲ�ѯ���������Ʊ��ṹ��ʱ���ܹ���JavaBean������һһ��Ӧ����ôֱ��ʹ��`BeanPropertyRowMapper`�ͺܷ��㡣������ṹ��JavaBean��һ����ô�죿�Ǿ���Ҫ��΢��дһ�²�ѯ��ʹ������Ľṹ��JavaBean����һ�¡�
+
+���磬����������`office_address`����JavaBean������`workAddress`������Ҫָ����������д��ѯ���£�
+
+```
+SELECT id, email, office_address AS workAddress, name FROM users WHERE email = ?
+```
+
+ʹ��`JdbcTemplate`��ʱ�������õ����ķ�������`List<T> query(String, RowMapper, Object...)`�����`RowMapper`�����þ��ǰ�`ResultSet`��һ�м�¼ӳ��ΪJava Bean��
+
+���ְѹ�ϵ���ݿ�ı���¼ӳ��ΪJava����Ĺ��̾���ORM��Object-Relational Mapping��ORM�ȿ��԰Ѽ�¼ת����Java����Ҳ���԰�Java����ת��Ϊ�м�¼��
+
+ʹ��`JdbcTemplate`���`RowMapper`���Կ�������ԭʼ��ORM�����Ҫʵ�ָ��Զ�����ORM������ѡ������ORM��ܣ�����[Hibernate](https://hibernate.org/)��
+
+���������������Spring���Hibernate��
+
+Hibernate��ΪORM��ܣ����������`JdbcTemplate`����Hibernate��Ȼ��ҪJDBC���������ԣ�������Ҫ����JDBC���������ӳأ��Լ�Hibernate��������Maven�У����Ǽ������������
+
+*   org.springframework:spring-context:6.0.0
+*   org.springframework:spring-orm:6.0.0
+*   jakarta.annotation:jakarta.annotation-api:2.1.1
+*   jakarta.persistence:jakarta.persistence-api:3.1.0
+*   org.hibernate:hibernate-core:6.1.4.Final
+*   com.zaxxer:HikariCP:5.0.1
+*   org.hsqldb:hsqldb:2.7.1
+
+��`AppConfig`�У�������Ȼ��Ҫ����`DataSource`������JDBC�����ļ����Լ���������ʽ����
+
+```
+@Configuration
+@ComponentScan
+@EnableTransactionManagement
+@PropertySource("jdbc.properties")
+public class AppConfig {
+    @Bean
+    DataSource createDataSource() {
+        ...
+    }
+}
+
+```
+
+Ϊ������Hibernate��������Ҫ����һ��`LocalSessionFactoryBean`��
+
+```
+public class AppConfig {
+    @Bean
+    LocalSessionFactoryBean createSessionFactory(@Autowired DataSource dataSource) {
+        var props = new Properties();
+        props.setProperty("hibernate.hbm2ddl.auto", "update"); // ����������Ҫʹ��
+        props.setProperty("hibernate.dialect", "org.hibernate.dialect.HSQLDialect");
+        props.setProperty("hibernate.show_sql", "true");
+        var sessionFactoryBean = new LocalSessionFactoryBean();
+        sessionFactoryBean.setDataSource(dataSource);
+        // ɨ��ָ����package��ȡ����entity class:
+        sessionFactoryBean.setPackagesToScan("com.itranswarp.learnjava.entity");
+        sessionFactoryBean.setHibernateProperties(props);
+        return sessionFactoryBean;
+    }
+}
+
+```
+
+ע��������[����Bean](https://www.liaoxuefeng.com/wiki/1252599548343744/1308043627200545)�н�����`FactoryBean`��`LocalSessionFactoryBean`��һ��`FactoryBean`���������Զ�����һ��`SessionFactory`����Hibernate�У�`Session`�Ƿ�װ��һ��JDBC `Connection`��ʵ������`SessionFactory`�Ƿ�װ��JDBC `DataSource`��ʵ������`SessionFactory`�������ӳأ�ÿ����Ҫ�������ݿ��ʱ��`SessionFactory`����һ���µ�`Session`���൱�ڴ����ӳػ�ȡ��һ���µ�`Connection`��`SessionFactory`����Hibernate�ṩ������ĵ�һ�����󣬵�`LocalSessionFactoryBean`��Spring�ṩ��Ϊ�������Ƿ��㴴��`SessionFactory`���ࡣ
+
+ע�⵽���洴��`LocalSessionFactoryBean`�Ĵ��룬������`Properties`����Hibernate��ʼ��`SessionFactory`ʱ�õ����������ã����õ�������ο�[Hibernate�ĵ�](https://docs.jboss.org/hibernate/orm/5.4/userguide/html_single/Hibernate_User_Guide.html#configurations)����������ֻ������3�����ã�
+
+*   `hibernate.hbm2ddl.auto=update`����ʾ�Զ��������ݿ�ı��ṹ��ע�ⲻҪ���������������ã�
+*   `hibernate.dialect=org.hibernate.dialect.HSQLDialect`��ָʾHibernateʹ�õ����ݿ���HSQLDB��Hibernateʹ��һ��HQL�IJ�ѯ��䣬����SQL���ƣ��������ڡ����롱��SQLʱ��������趨�����ݿ⡰���ԡ�������������ݿ��Ż���SQL��
+*   `hibernate.show_sql=true`����Hibernate��ӡִ�е�SQL������ڵ��Էdz����ã����ǿ��Է���ؿ���Hibernate���ɵ�SQL����Ƿ�������ǵ�Ԥ�ڡ�
+
+��������`DataSource`��`Properties`֮�⣬ע�⵽`setPackagesToScan()`���Ǵ�����һ��`package`���ƣ���ָʾHibernateɨ����������������Java�࣬�Զ��ҳ���ӳ��Ϊ���ݿ����¼��JavaBean���������ǻ���ϸ������α�д����HibernateҪ���JavaBean��
+
+�����ţ����ǻ���Ҫ����`HibernateTransactionManager`��
+
+```
+public class AppConfig {
+    @Bean
+    PlatformTransactionManager createTxManager(@Autowired SessionFactory sessionFactory) {
+        return new HibernateTransactionManager(sessionFactory);
+    }
+}
+
+```
+
+`HibernateTransactionManager`�����Hibernateʹ������ʽ����������ġ�����Ϊֹ�����е����ö�������ϣ�������������ν����ݿ���ṹӳ��ΪJava����
+
+�������µ����ݿ����
+
+```
+CREATE TABLE user
+    id BIGINT NOT NULL AUTO_INCREMENT,
+    email VARCHAR(100) NOT NULL,
+    password VARCHAR(100) NOT NULL,
+    name VARCHAR(100) NOT NULL,
+    createdAt BIGINT NOT NULL,
+    PRIMARY KEY (`id`),
+    UNIQUE KEY `email` (`email`)
+);
+
+```
+
+���У�`id`������������`email`��`password`��`name`��`VARCHAR`���ͣ�`email`��Ψһ������ȷ��Ψһ�ԣ�`createdAt`�洢�������͵�ʱ�������JavaBean��ʾ���£�
+
+```
+public class User {
+    private Long id;
+    private String email;
+    private String password;
+    private String name;
+    private Long createdAt;
+
+    // getters and setters
+    ...
+}
+
+```
+
+����ӳ���ϵʮ���׶�����������Ҫ����һЩע��������Hibernate��ΰ�`User`��ӳ�䵽����¼��
+
+```
+@Entity
+public class User {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(nullable = false, updatable = false)
+    public Long getId() { ... }
+
+    @Column(nullable = false, unique = true, length = 100)
+    public String getEmail() { ... }
+
+    @Column(nullable = false, length = 100)
+    public String getPassword() { ... }
+
+    @Column(nullable = false, length = 100)
+    public String getName() { ... }
+
+    @Column(nullable = false, updatable = false)
+    public Long getCreatedAt() { ... }
+}
+
+```
+
+���һ��JavaBean������ӳ�䣬���Ǿͱ��һ��`@Entity`��Ĭ������£�ӳ��ı�����`user`�����ʵ�ʵı�����ͬ������ʵ�ʱ�����`users`������׷��һ��`@Table(name="users")`��ʾ��
+
+```
+@Entity
+@Table(name="users)
+public class User {
+    ...
+}
+
+```
+
+ÿ�����Ե����ݿ��е�ӳ����`@Column()`��ʶ��`nullable`ָʾ���Ƿ�����Ϊ`NULL`��`updatable`ָʾ�����Ƿ�����������`UPDATE`��䣬`length`ָʾ`String`���͵��еij��ȣ����û��ָ����Ĭ����`255`����
+
+��������������Ҫ��`@Id`��ʶ������������׷��һ��`@GeneratedValue`���Ա�Hibernate�ܶ�ȡ������������ֵ��
+
+ϸ�ĵ�ͯЬ���ܻ�ע�⵽������`id`��������Ͳ���`long`������`Long`��������ΪHibernate�����⵽����Ϊ`null`���Ͳ�����`INSERT`�����ָ��������ֵ�����Ƿ��������ݿ����ɵ�����ֵ������Hibernate��Ϊ���ǵij���ָ����������ֵ������`INSERT`�����ֱ���г���`long`���ֶ����Ǿ���Ĭ��ֵ`0`����ˣ�ÿ�β��������ֵ����0�����³���һ����������붼��ʧ�ܡ�
+
+`createdAt`��Ȼ�����ͣ������Dz�û��ʹ��`long`������`Long`��������Ϊʹ�û������ͻᵼ��findByExample��ѯ���������������������ֻ���μǣ���Ϊӳ��ʹ�õ�JavaBean���������Զ�ʹ�ð�װ���Ͷ����ǻ������͡�
+
+ʹ��Hibernateʱ����Ҫʹ�û������͵����ԣ�����ʹ�ð�װ���ͣ���Long��Integer��
+
+���Ƶģ������ٶ���һ��`Book`�ࣺ
+
+```
+@Entity
+public class Book {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(nullable = false, updatable = false)
+    public Long getId() { ... }
+
+    @Column(nullable = false, length = 100)
+    public String getTitle() { ... }
+
+    @Column(nullable = false, updatable = false)
+    public Long getCreatedAt() { ... }
+}
+
+```
+
+�����ϸ�۲�`User`��`Book`���ᷢ�����Ƕ����`id`��`createdAt`������һ���ģ��������ݿ���ṹ������кܳ���������ÿ������ͨ�����ǻ�ͳһʹ��һ���������ɻ��ƣ�������`createdAt`��ʾ����ʱ�䣬`updatedAt`��ʾ�޸�ʱ���ͨ���ֶΡ�
+
+������`User`��`Book`���ظ�������Щͨ���ֶΣ����ǿ��԰������ᵽһ���������У�
+
+```
+@MappedSuperclass
+public abstract class AbstractEntity {
+
+    private Long id;
+    private Long createdAt;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(nullable = false, updatable = false)
+    public Long getId() { ... }
+
+    @Column(nullable = false, updatable = false)
+    public Long getCreatedAt() { ... }
+
+    @Transient
+    public ZonedDateTime getCreatedDateTime() {
+        return Instant.ofEpochMilli(this.createdAt).atZone(ZoneId.systemDefault());
+    }
+
+    @PrePersist
+    public void preInsert() {
+        setCreatedAt(System.currentTimeMillis());
+    }
+}
+
+```
+
+����`AbstractEntity`��˵������Ҫ��עһ��`@MappedSuperclass`��ʾ�����ڼ̳С����⣬ע�⵽���Ƕ�����һ��`@Transient`������������һ�������⡱�����ԡ���Ϊ`getCreatedDateTime()`�Ǽ���ó������ԣ������Ǵ����ݿ��������ֵ����˱���Ҫ��ע`@Transient`������Hibernate�᳢�Դ����ݿ��ȡ��Ϊ`createdDateTime`��������ڵ��ֶδӶ�������
+
+��ע�⵽`@PrePersist`��ʶ�ķ���������ʾ�����ǽ�һ��JavaBean�־û������ݿ�֮ǰ����ִ��INSERT��䣩��Hibernate����ִ�и÷������������ǾͿ����Զ����ú�`createdAt`���ԡ�
+
+����`AbstractEntity`�����ǾͿ��Դ����`User`��`Book`��
+
+```
+@Entity
+public class User extends AbstractEntity {
+
+    @Column(nullable = false, unique = true, length = 100)
+    public String getEmail() { ... }
+
+    @Column(nullable = false, length = 100)
+    public String getPassword() { ... }
+
+    @Column(nullable = false, length = 100)
+    public String getName() { ... }
+}
+
+```
+
+ע�⵽ʹ�õ�����ע�������`jakarta.persistence`������JPA�淶��һ���֡���������ֻ����ʹ��ע��ķ�ʽ����Hibernateӳ���ϵ�����ٽ��ܴ�ͳ�ıȽϷ�����XML���á�ͨ��Spring����Hibernateʱ��Ҳ������Ҫ`hibernate.cfg.xml`�����ļ�����һ�仰�ܽ᣺
+
+ʹ��Spring����Hibernate�����JPAע�⣬�����κζ����XML���á�
+
+����`User`��`Book`����������ORM��Java Bean������ͨ����֮ΪEntity Bean��
+
+������������������`user`��������ɾ�IJ顣��Ϊʹ����Hibernate����ˣ�����Ҫ���ģ�ʵ�����Ƕ�`User`���JavaBean���С���ɾ�IJ顱�����DZ�дһ��`UserService`��ע��`SessionFactory`��
+
+```
+@Component
+@Transactional
+public class UserService {
+    @Autowired
+    SessionFactory sessionFactory;
+}
+
+```
+
+### Insert����
+
+Ҫ�־û�һ��`User`ʵ��������ֻ�����`persist()`��������`register()`����Ϊ�����������£�
+
+```
+public User register(String email, String password, String name) {
+    // ����һ��User����:
+    User user = new User();
+    // ���úø�������:
+    user.setEmail(email);
+    user.setPassword(password);
+    user.setName(name);
+    // ��Ҫ����id����Ϊʹ������������
+    // ���浽���ݿ�:
+    sessionFactory.getCurrentSession().persist(user);
+    // �����Ѿ��Զ������id:
+    System.out.println(user.getId());
+    return user;
+}
+
+```
+
+### Delete����
+
+ɾ��һ��`User`�൱�ڴӱ���ɾ����Ӧ�ļ�¼��ע��Hibernate������`id`��ɾ����¼����ˣ�Ҫ��ȷ����`User`��`id`���Բ�������ɾ����¼��
+
+```
+public boolean deleteUser(Long id) {
+    User user = sessionFactory.getCurrentSession().byId(User.class).load(id);
+    if (user != null) {
+        sessionFactory.getCurrentSession().remove(user);
+        return true;
+    }
+    return false;
+}
+
+```
+
+ͨ������ɾ����¼ʱ��һ���������÷����ȸ����������ظü�¼����ɾ����ע�⵽����¼������ʱ��`load()`����`null`��
+
+### Update����
+
+���¼�¼�൱���ȸ���`User`��ָ�����ԣ�Ȼ�����`merge()`������
+
+```
+public void updateUser(Long id, String name) {
+    User user = sessionFactory.getCurrentSession().byId(User.class).load(id);
+    user.setName(name);
+    sessionFactory.getCurrentSession().merge(user);
+}
+
+```
+
+ǰ�������ڶ���`User`ʱ�����е����Ա�ע��`@Column(updatable=false)`��Hibernate�ڸ��¼�¼ʱ����ֻ���`@Column(updatable=true)`�����Լ��뵽`UPDATE`����У����������ṩһ�����İ�ȫ�ԣ��������С���޸���`User`��`email`��`createdAt`�����ԣ�ִ��`update()`ʱ��������¶�Ӧ�����ݿ��С���Ҳ�����μǣ����������Hibernate�ṩ�ģ�����ƹ�Hibernateֱ��ͨ��JDBCִ��`UPDATE`�����Ȼ���Ը������ݿ�������е�ֵ��
+
+������DZ�д�Ĵ󲿷ַ������Ǹ��ָ����IJ�ѯ������`id`��ѯ���ǿ���ֱ�ӵ���`load()`�����Ҫʹ��������ѯ�����磬����������ִ�����²�ѯ��
+
+```
+SELECT * FROM user WHERE email = ? AND password = ?
+
+```
+
+��������������ʹ��ʲô��ѯ��
+
+### ʹ��HQL��ѯ
+
+һ�ֳ��õIJ�ѯ��ֱ�ӱ�дHibernate���õ�HQL��ѯ��
+
+```
+List<User> list = sessionFactory.getCurrentSession()
+        .createQuery("from User u where u.email = ?1 and u.password = ?2", User.class)
+        .setParameter(1, email).setParameter(2, password)
+        .list();
+
+```
+
+��SQL��ȣ�HQLʹ������������������Hibernate�Զ�ת��Ϊʵ�ʵı�������������ϸ��HQL�﷨���Բο�[Hibernate�ĵ�](https://docs.jboss.org/hibernate/orm/6.1/userguide/html_single/Hibernate_User_Guide.html#query-language)��
+
+���˿���ֱ�Ӵ���HQL�ַ����⣬Hibernate������ʹ��һ��`NamedQuery`��������ѯ������֣�Ȼ�󱣴���ע���С�ʹ��`NamedQuery`ʱ������Ҫ����`User`���ע��
+
+```
+@NamedQueries(
+    @NamedQuery(
+        // ��ѯ����:
+        name = "login",
+        // ��ѯ���:
+        query = "SELECT u FROM User u WHERE u.email = :e AND u.password = :pwd"
+    )
+)
+@Entity
+public class User extends AbstractEntity {
+    ...
+}
+
+```
+
+ע�⵽�����`NamedQuery`��`jakarta.persistence.NamedQuery`������ֱ�Ӵ���HQL�е㲻ͬ���ǣ�ռλ��ʹ��`:e`��`:pwd`��
+
+ʹ��`NamedQuery`ֻ��Ҫ�����ѯ���Ͳ�����
+
+```
+public User login(String email, String password) {
+    List<User> list = sessionFactory.getCurrentSession()
+        .createNamedQuery("login", User.class) // ����NamedQuery
+        .setParameter("e", email) // ��e����
+        .setParameter("pwd", password) // ��pwd����
+        .list();
+    return list.isEmpty() ? null : list.get(0);
+}
+
+```
+
+ֱ��дHQL��ʹ��`NamedQuery`�������ӡ�ǰ�߿����ڴ�����ֱ�۵ؿ�����ѯ��䣬���߿�����`User`��ͳһ����������ز�ѯ��
+
+��һ�����ǽ�����Spring�м���Hibernate��Hibernate�ǵ�һ�����㷺ʹ�õ�ORM��ܣ����Ǻܶ�С��黹��˵��JPA��Java Persistence API��������ɶ��
+
+������JPA֮ǰ������Ҫע�⵽JavaEE����1999��ͷ����ˣ�������Servlet��JMS������׼��������ƽ̨��ͬ��Java�������ڷdz������ڱ�׼���У����Ҹ�����������������ѽӿڶ��ˣ�Ȼ�󣬸��ԻؼҸɻ�ȥʵ�ֽӿڣ��������û��Ϳ����ڲ�ͬ�ij����ṩ�IJ�Ʒ����ѡ�񣬻����������л�����Ϊ�û���д�����ʱ��ֻ��Ҫ���ýӿڣ�������Ҫ���þ���ĵײ�ʵ�֣�����JDBC����
+
+JPA����JavaEE��һ��ORM��׼������ʵ����ʵ��Hibernateûɶ�������𣬵����û����ʹ��JPA����ô���õľ���`jakarta.persistence`�������׼������������`org.hibernate`�����ĵ�����������ΪJPAֻ�ǽӿڣ����ԣ�����Ҫѡ��һ��ʵ�ֲ�Ʒ����JDBC�ӿں�MySQL����һ��������
+
+����ʹ��JPAʱҲ��ȫ����ѡ��Hibernate��Ϊ�ײ�ʵ�֣���Ҳ����ѡ��������JPA�ṩ��������[EclipseLink](https://www.eclipse.org/eclipselink/)��Spring������JPA�ļ��ɣ���֧��ѡ��Hibernate��EclipseLink��Ϊʵ�֡�����������Ȼ��������Hibernate��ΪJPAʵ��Ϊ���ӣ���ʾJPA�Ļ����÷���
+
+��ʹ��Hibernateһ��������ֻ��Ҫ��������������
+
+*   org.springframework:spring-context:6.0.0
+*   org.springframework:spring-orm:6.0.0
+*   jakarta.annotation:jakarta.annotation-api:2.1.1
+*   jakarta.persistence:jakarta.persistence-api:3.1.0
+*   org.hibernate:hibernate-core:6.1.4.Final
+*   com.zaxxer:HikariCP:5.0.1
+*   org.hsqldb:hsqldb:2.7.1
+
+ʵ�������������������������һ�ڼ���Hibernate�����������ȫһ������ΪHibernate���ṩ�����Լ��Ľӿڣ�Ҳ�ṩ��JPA�ӿڣ�������JPA�ӿھ��൱��ͨ��JPA����Hibernate��
+
+Ȼ����`AppConfig`����������ʽ�������������`DataSource`��
+
+```
+@Configuration
+@ComponentScan
+@EnableTransactionManagement
+@PropertySource("jdbc.properties")
+public class AppConfig {
+    @Bean
+    DataSource createDataSource() { ... }
+}
+
+```
+
+ʹ��Hibernateʱ��������Ҫ����һ��`LocalSessionFactoryBean`�����������Զ�����һ��`SessionFactory`��ʹ��JPAҲ�����Ƶģ�����Ҳ����һ��`LocalContainerEntityManagerFactoryBean`�����������Զ�����һ��`EntityManagerFactory`��
+
+```
+@Bean
+public LocalContainerEntityManagerFactoryBean createEntityManagerFactory(@Autowired DataSource dataSource) {
+    var emFactory = new LocalContainerEntityManagerFactoryBean();
+    // ע��DataSource:
+    emFactory.setDataSource(dataSource);
+    // ɨ��ָ����package��ȡ����entity class:
+    emFactory.setPackagesToScan(AbstractEntity.class.getPackageName());
+    // ʹ��Hibernate��ΪJPAʵ��:
+    emFactory.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
+    // ����������:
+    var props = new Properties();
+    props.setProperty("hibernate.hbm2ddl.auto", "update"); // ����������Ҫʹ��
+    props.setProperty("hibernate.dialect", "org.hibernate.dialect.HSQLDialect");
+    props.setProperty("hibernate.show_sql", "true");
+    emFactory.setJpaProperties(props);
+    return emFactory;
+}
+
+```
+
+�۲��������룬������Ҫע��`DataSource`���趨�Զ�ɨ���`package`�⣬����Ҫָ��JPA���ṩ�̣�����ʹ��Spring�ṩ��һ��`HibernateJpaVendorAdapter`��������Hibernate�Լ���Ҫ�����ã���`Properties`����ʽע�롣
+
+������ǻ���Ҫʵ����һ��`JpaTransactionManager`����ʵ������ʽ����
+
+```
+@Bean
+PlatformTransactionManager createTxManager(@Autowired EntityManagerFactory entityManagerFactory) {
+    return new JpaTransactionManager(entityManagerFactory);
+}
+
+```
+
+���������Ǿ������JPA��ȫ����ʼ����������ЩͯЬ���ܴ�����������֪JPA��Ҫ`persistence.xml`�����ļ����Լ����ӵ�`orm.xml`�ļ����������Ǹ���ظ��ߴ�ң�ʹ��Spring+Hibernate��ΪJPAʵ�֣������κ������ļ���
+
+����Entity Bean�����ú���һ����ȫ��ͬ��ȫ������Annotation��ע����������ֻ����ľ����ҵ�������ͨ��JPA�ӿڲ������ݿ⡣
+
+������`UserService`Ϊ�������˱�ע`@Component`��`@Transactional`�⣬������Ҫע��һ��`EntityManager`�����Dz�Ҫʹ��`Autowired`������`@PersistenceContext`��
+
+```
+@Component
+@Transactional
+public class UserService {
+    @PersistenceContext
+    EntityManager em;
+}
+
+```
+
+���ǻع�һ��JDBC��Hibernate��JPA�ṩ�Ľӿڣ�ʵ���ϣ����ǵĹ�ϵ���£�
+
+| JDBC | Hibernate | JPA |
+| --- | --- | --- |
+| DataSource | SessionFactory | EntityManagerFactory |
+| Connection | Session | EntityManager |
+
+`SessionFactory`��`EntityManagerFactory`�൱��`DataSource`��`Session`��`EntityManager`�൱��`Connection`��ÿ����Ҫ�������ݿ��ʱ����Ҫ��ȡ�µ�`Session`��`EntityManager`��������ٹرա�
+
+���ǣ�ע�⵽`UserService`ע��IJ���`EntityManagerFactory`������`EntityManager`�����ұ�ע��`@PersistenceContext`���ѵ�ʹ��JPA�����������̲߳���ͬһ��`EntityManager`��
+
+ʵ��������ע��IJ�����������`EntityManager`������һ��`EntityManager`�Ĵ����࣬�൱�ڣ�
+
+```
+public class EntityManagerProxy implements EntityManager {
+    private EntityManagerFactory emf;
+}
+
+```
+
+Spring������ע��`@PersistenceContext`��`EntityManager`���Զ�ע��������ô������ڱ�Ҫ��ʱ���Զ���`EntityManager`�����仰˵�����߳����õ�`EntityManager`��Ȼ��ͬһ�������࣬���ô������ڲ���Բ�ͬ�̻߳ᴴ����ͬ��`EntityManager`ʵ����
+
+���ܽ�һ�£���ע��`@PersistenceContext`��`EntityManager`���Ա����̰߳�ȫ�ع�����
+
+��ˣ���`UserService`��ÿ��ҵ�񷽷��ֱ��ʹ��`EntityManager`�ͺܷ��㡣��������ѯΪ����
+
+```
+public User getUserById(long id) {
+    User user = this.em.find(User.class, id);
+    if (user == null) {
+        throw new RuntimeException("User not found by id: " + id);
+    }
+    return user;
+}
+
+```
+
+��HQL��ѯ���ƣ�JPAʹ��JPQL��ѯ�������﷨��HQL������ࣺ
+
+```
+public User fetchUserByEmail(String email) {
+    // JPQL��ѯ:
+    TypedQuery<User> query = em.createQuery("SELECT u FROM User u WHERE u.email = :e", User.class);
+    query.setParameter("e", email);
+    List<User> list = query.getResultList();
+    if (list.isEmpty()) {
+        return null;
+    }
+    return list.get(0);
+}
+
+```
+
+ͬ���ģ�JPAҲ֧��`NamedQuery`�����ȸ���ѯ������֣��ٰ����ִ�����ѯ��
+
+```
+public User login(String email, String password) {
+    TypedQuery<User> query = em.createNamedQuery("login", User.class);
+    query.setParameter("e", email);
+    query.setParameter("pwd", password);
+    List<User> list = query.getResultList();
+    return list.isEmpty() ? null : list.get(0);
+}
+
+```
+
+`NamedQuery`ͨ��ע���ע��`User`���ϣ����Ķ������һ�ڵ�`User`��һ����
+
+```
+@NamedQueries(
+    @NamedQuery(
+        name = "login",
+        query = "SELECT u FROM User u WHERE u.email=:e AND u.password=:pwd"
+    )
+)
+@Entity
+public class User {
+    ...
+}
+
+```
+
+�����ݿ������ɾ�ĵIJ��������Էֱ�ʹ��`persist()`��`remove()`��`merge()`������������ΪEntity Bean������ʹ�÷dz��򵥣����ﲻ�ٶ�����
+
+#### ����MyBatis
+
+������: 2022/11/16 21:07 / �Ķ�: 601258
+
+* * *
+
+
+
+ʹ��Hibernate��JPA�������ݿ�ʱ������ORM�ɵ���Ҫ�������ǰ�ResultSet��ÿһ�б��Java Bean�����߰�Java Bean�Զ�ת����INSERT��UPDATE���IJ����У��Ӷ�ʵ��ORM��
+
+��ORM���֮����֪����ΰ�������ӳ�䵽Java Bean������Ϊ������Java Bean�������ϸ����㹻��ע����ΪԪ���ݣ�ORM��ܻ�ȡJava Bean��ע��󣬾�֪����ν���˫��ӳ�䡣
+
+��ô��ORM�������θ���Java Bean���޸ģ��Ա���`update()`�����и��±�Ҫ�����ԣ�
+
+����ʹ��[Proxyģʽ](https://www.liaoxuefeng.com/wiki/1252599548343744/1281319432618017)����ORM��ܶ�ȡ��Userʵ��ʵ���ϲ�����User�࣬���Ǵ����࣬������̳���User�࣬�����ÿ��setter�������˸�д��
+
+```
+public class UserProxy extends User {
+    boolean _isNameChanged;
+
+    public void setName(String name) {
+        super.setName(name);
+        _isNameChanged = true;
+    }
+}
+
+```
+
+��������������Ը��ٵ�ÿ�����Եı仯��
+
+���һ�Զ����һ��ϵʱ�����������ֱ��ͨ��getter������ѯ���ݿ⣺
+
+```
+public class UserProxy extends User {
+    Session _session;
+    boolean _isNameChanged;
+
+    public void setName(String name) {
+        super.setName(name);
+        _isNameChanged = true;
+    }
+
+    /**
+     * ��ȡUser���������Address����:
+     */
+    public Address getAddress() {
+        Query q = _session.createQuery("from Address where userId = :userId");
+        q.setParameter("userId", this.getId());
+        List<Address> list = query.list();
+        return list.isEmpty() ? null : list(0);
+    }
+}
+
+```
+
+Ϊ��ʵ�������IJ�ѯ��UserProxy���뱣��Hibernate�ĵ�ǰSession�����ǣ��������ύ��Session�Զ��رգ���ʱ�ٻ�ȡ`getAddress()`���޷��������ݿ⣬���߻�ȡ�IJ�������һ�µ����ݡ���ˣ�ORM�������������Attached/Detached״̬����ʾ��ǰ��Java Bean��������Session�ķ�Χ�ڣ�����������Session�����һ�������롱���󡣺ܶ��ѧ���޷���ȷ����״̬�仯������߽磬�ͻ���ɴ�����`PersistentObjectException`�쳣��������ʽ״̬ʹ����ͨJava Bean���������ڱ�ø��ӡ�
+
+���⣬Hibernate��JPAΪ��ʵ�ּ��ݶ������ݿ⣬��ʹ��HQL��JPQL��ѯ������һ��ת��������ض����ݿ��SQL���������������������޷��л����ݿ⣬����һ���Զ�ת���������������ܿ����⣬��SQL������Ż��������鷳��
+
+���ORM���ͨ���ṩ�˻��棬���һ���Ϊһ������Ͷ������档һ��������ָ��һ��Session��Χ�ڵĻ��棬�������龰�Ǹ���������ѯʱ�����β�ѯ���Է���ͬһʵ����
+
+```
+User user1 = session.load(User.class, 123);
+User user2 = session.load(User.class, 123);
+
+```
+
+����������ָ��Session�Ļ��棬һ��Ĭ�Ϲرգ���Ҫ�ֶ����á��������漫������������ݵIJ�һ���ԣ�ԭ������SQL�dz��������ᵼ������ĸ��¡����磺
+
+```
+// �߳�1��ȡ:
+User user1 = session1.load(User.class, 123);
+...
+// һ��ʱ����߳�2��ȡ:
+User user2 = session2.load(User.class, 123);
+
+```
+
+������������Ч��ʱ�������̶߳�ȡ��Userʵ����һ���ģ����ǣ����ݿ��Ӧ���м�¼��ȫ���ܱ��޸ģ����磺
+
+```
+-- �����û�����100����:
+UPDATE users SET bonus = bonus + 100 WHERE createdAt <= ?
+
+```
+
+ORM�޷��ж�`id=123`���û��Ƿ��ܸ�`UPDATE`���Ӱ�졣���ǵ����ݿ�ͨ����֧�ֶ��Ӧ�ó��򣬴�UPDATE����������������ִ�У�ORM��ܾ͸���֪���ˡ�
+
+���ǰ�����ORM��ܳ�֮Ϊȫ�Զ�ORM��ܡ�
+
+�Ա�Spring�ṩ��JdbcTemplate������ORM�����ȣ���Ҫ�м�����
+
+1.  ��ѯ����Ҫ�ֶ��ṩMapperʵ���Ա��ResultSet��ÿһ�б�ΪJava����
+2.  ��ɾ�IJ�������IJ����б�����Ҫ�ֶ����룬����Userʵ����Ϊ[user.id, user.name, user.email]�������б����Ƚ��鷳��
+
+����JdbcTemplate��������������ȷ���ԣ���ÿ�ζ�ȡ����һ�������ݿ���������ǻ��棬��ִ�е�SQL����ȫȷ���ģ�ȱ����Ǵ���ȽϷ���������`INSERT INTO users VALUES (?,?,?)`���Ǹ��ӡ�
+
+���ԣ�����ȫ�Զ�ORM��Hibernate����дȫ����JdbcTemplate֮�䣬����һ�ְ��Զ���ORM����ֻ�����ResultSet�Զ�ӳ�䵽Java Bean�������Զ����Java Bean�������������Լ�д��SQL��[MyBatis](https://mybatis.org/)��������һ�ְ��Զ���ORM��ܡ�
+
+���������������Spring���MyBatis��
+
+���ȣ�����Ҫ����MyBatis��������Σ�����Spring��û����Hibernate�������ö�MyBatis�ļ��ɣ����ԣ�������Ҫ������MyBatis�ٷ��Լ�������һ����Spring���ɵĿ⣺
+
+*   org.mybatis:mybatis:3.5.11
+*   org.mybatis:mybatis-spring:3.0.0
+
+��ǰ��һ�����ȴ���`DataSource`�DZز����ٵģ�
+
+```
+@Configuration
+@ComponentScan
+@EnableTransactionManagement
+@PropertySource("jdbc.properties")
+public class AppConfig {
+    @Bean
+    DataSource createDataSource() { ... }
+}
+
+```
+
+�ٻع�һ��Hibernate��JPA��`SessionFactory`��`EntityManagerFactory`��MyBatis��֮��Ӧ����`SqlSessionFactory`��`SqlSession`��
+
+| JDBC | Hibernate | JPA | MyBatis |
+| --- | --- | --- | --- |
+| DataSource | SessionFactory | EntityManagerFactory | SqlSessionFactory |
+| Connection | Session | EntityManager | SqlSession |
+
+�ɼ���ORM�������·�������Ƶġ�ʹ��MyBatis�ĺ��ľ��Ǵ���`SqlSessionFactory`������������Ҫ��������`SqlSessionFactoryBean`��
+
+```
+@Bean
+SqlSessionFactoryBean createSqlSessionFactoryBean(@Autowired DataSource dataSource) {
+    var sqlSessionFactoryBean = new SqlSessionFactoryBean();
+    sqlSessionFactoryBean.setDataSource(dataSource);
+    return sqlSessionFactoryBean;
+}
+
+```
+
+��ΪMyBatis����ֱ��ʹ��Spring����������ʽ������ˣ����������������ʹ��JDBC��һ���ģ�
+
+```
+@Bean
+PlatformTransactionManager createTxManager(@Autowired DataSource dataSource) {
+    return new DataSourceTransactionManager(dataSource);
+}
+
+```
+
+��Hibernate��ͬ���ǣ�MyBatisʹ��Mapper��ʵ��ӳ�䣬����Mapper�����ǽӿڡ�������`User`��Ϊ������`User`���`users`��֮��ӳ���`UserMapper`��д���£�
+
+```
+public interface UserMapper {
+	@Select("SELECT * FROM users WHERE id = #{id}")
+	User getById(@Param("id") long id);
+}
+
+```
+
+ע�⣺�����Mapper����`JdbcTemplate`��`RowMapper`�ĸ�����Ƕ������`users`���Ľӿڷ������������Ƕ�����һ��`User getById(long)`��������ѯ����������Ҫ����ӿڷ�����������Ҫ��ȷд����ѯ��SQL��������ע��`@Select`��ǡ�SQL�����κβ��������뷽�����������ƶ�Ӧ�����磬��������id������ͨ��ע��`@Param()`���Ϊ`id`����SQL����ｫ���滻��ռλ������`#{id}`��
+
+����ж����������ôÿ������������ֱ����SQL��д����Ӧ��ռλ�����ɣ�
+
+```
+@Select("SELECT * FROM users LIMIT #{offset}, #{maxResults}")
+List<User> getAll(@Param("offset") int offset, @Param("maxResults") int maxResults);
+
+```
+
+ע�⣺MyBatisִ�в�ѯ�󣬽����ݷ����ķ��������Զ���ResultSet��ÿһ��ת��ΪUserʵ����ת������Ȼ�ǰ���������������Ӧ�������������������ͬ����򵥵ķ�ʽ�DZ�дSELECT���ı�����
+
+```
+-- ������created_time����������createdAt:
+SELECT id, name, email, created_time AS createdAt FROM users
+
+```
+
+ִ��INSERT������΢�鷳�㣬��Ϊ����ϣ������Userʵ������ˣ�����ķ����ӿ���`@Insert`ע�����£�
+
+```
+@Insert("INSERT INTO users (email, password, name, createdAt) VALUES (#{user.email}, #{user.password}, #{user.name}, #{user.createdAt})")
+void insert(@Param("user") User user);
+
+```
+
+������������IJ���������`user`������������User�࣬��SQL�����õ�ʱ����`#{obj.property}`�ķ�ʽдռλ������Hibernate������ȫ�Զ���ORM��ȣ�MyBatis����д��������INSERT��䡣
+
+���`users`����`id`��������������ô��������SQL�в�����`id`����ϣ����ȡ��������������Ҫ�ټ�һ��`@Options`ע�⣺
+
+```
+@Options(useGeneratedKeys = true, keyProperty = "id", keyColumn = "id")
+@Insert("INSERT INTO users (email, password, name, createdAt) VALUES (#{user.email}, #{user.password}, #{user.name}, #{user.createdAt})")
+void insert(@Param("user") User user);
+
+```
+
+`keyProperty`��`keyColumn`�ֱ�ָ��JavaBean�����Ժ����ݿ������������
+
+ִ��`UPDATE`��`DELETE`�����ԱȽϼ򵥣����Ƕ��巽�����£�
+
+```
+@Update("UPDATE users SET name = #{user.name}, createdAt = #{user.createdAt} WHERE id = #{user.id}")
+void update(@Param("user") User user);
+
+@Delete("DELETE FROM users WHERE id = #{id}")
+void deleteById(@Param("id") long id);
+
+```
+
+����`UserMapper`�ӿڣ�����Ҫ��Ӧ��ʵ�����������ִ����Щ���ݿ�����ķ�������Ȼ�����Լ�дʵ���࣬�����dz��˱�д`UserMapper`�ӿ��⣬����`BookMapper`��`BonusMapper`����һ��һ��д̫�鷳����ˣ�MyBatis�ṩ��һ��`MapperFactoryBean`���Զ���������Mapper��ʵ���ࡣ������һ���򵥵�ע������������
+
+```
+@MapperScan("com.itranswarp.learnjava.mapper")
+...����ע��...
+public class AppConfig {
+    ...
+}
+
+```
+
+����`@MapperScan`���Ϳ�����MyBatis�Զ�ɨ��ָ����������Mapper������ʵ���ࡣ��������ҵ���߼��У����ǿ���ֱ��ע�룺
+
+```
+@Component
+@Transactional
+public class UserService {
+    // ע��UserMapper:
+    @Autowired
+    UserMapper userMapper;
+
+    public User getUserById(long id) {
+        // ����Mapper����:
+        User user = userMapper.getById(id);
+        if (user == null) {
+            throw new RuntimeException("User not found by id.");
+        }
+        return user;
+    }
+}
+
+```
+
+�ɼ���ҵ���߼���Ҫ����ͨ��`XxxMapper`��������ݿⷽ�����������ݿ⡣
+
+### XML����
+
+������Spring�м���MyBatis�ķ�ʽ������ֻ��Ҫ�õ�ע�⣬��û���κ�XML�����ļ���MyBatisҲ����ʹ��XML����ӳ���ϵ��SQL��䣬���磬����`User`ʱ��������ֵ���춯̬SQL��
+
+```
+<update id="updateUser">
+  UPDATE users SET
+  <set>
+    <if test="user.name != null"> name = #{user.name} </if>
+    <if test="user.hobby != null"> hobby = #{user.hobby} </if>
+    <if test="user.summary != null"> summary = #{user.summary} </if>
+  </set>
+  WHERE id = #{user.id}
+</update>
+
+```
+
+��дXML���õ��ŵ��ǿ�����װ����̬SQL�����Ұ�����SQL����������һ��ȱ������������̫���������÷���ʱ�����鿴SQL����Ҫ��λ��XML�����С��������Dz�����XML�����÷�ʽ����Ҫ�˽��ͯЬ�������Ķ�[�ٷ��ĵ�](https://mybatis.org/mybatis-3/zh/configuration.html)��
+
+ʹ��MyBatis��������������SQL����Ҫȫ����д���ŵ���ִ�е�SQL���������Լ�д��SQL����SQL�����Ż��dz��򵥣�Ҳ���Ա�д���⸴�ӵ�SQL������ʹ�����ݿ���ض��﷨�����л����ݿ���ܾͲ�̫���ס�����Ϣ�Ǵ󲿷���Ŀ��û���л����ݿ��������ȫ�������ij�����ݿ��д�������Ż���SQL��
+
+# �����
+https://www.w3cschool.cn/wkspring
+https://www.runoob.com/w3cnote/basic-knowledge-summary-of-spring.html
+http://codepub.cn/2015/06/21/Basic-knowledge-summary-of-Spring
+https://dunwu.github.io/spring-tutorial
+https://mszlu.com/java/spring
+http://c.biancheng.net/spring/aop-module.html
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\345\257\271\344\272\216\346\240\241\351\252\214\345\212\237\350\203\275\347\232\204\346\224\257\346\214\201.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\345\257\271\344\272\216\346\240\241\351\252\214\345\212\237\350\203\275\347\232\204\346\224\257\346\214\201.md"
new file mode 100644
index 0000000..de8dba7
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\345\257\271\344\272\216\346\240\241\351\252\214\345\212\237\350\203\275\347\232\204\346\224\257\346\214\201.md"
@@ -0,0 +1,713 @@
+# Spring ��
+
+Java API �淶(`JSR303`)������`Bean`У��ı�׼`validation-api`����û���ṩʵ�֡�`hibernate validation`�Ƕ�����淶��ʵ�֣���������У��ע����`@Email`��`@Length`�ȡ�`Spring Validation`�Ƕ�`hibernate validation`�Ķ��η�װ������֧��`spring mvc`�����Զ�У�顣
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8)��������
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#%E5%BC%95%E5%85%A5%E4%BE%9D%E8%B5%96)��������
+
+��� spring-boot �汾С�� 2.3.x��spring-boot-starter-web ���Զ����� hibernate-validator ��������� spring-boot �汾���� 2.3.x������Ҫ�ֶ�����������
+
+
+
+```
+<dependency>
+  <groupId>org.hibernate.validator</groupId>
+  hibernate-validator-parent
+  <version>6.2.5.Final</version>
+</dependency>
+
+```
+
+
+
+���� web ������˵��Ϊ��ֹ�Ƿ�������ҵ�����Ӱ�죬�� Controller ��һ��Ҫ������У��ģ��󲿷�����£����������Ϊ����������ʽ��
+
+*   POST��PUT ����ʹ�� requestBody ���ݲ�����
+*   GET ����ʹ�� requestParam/PathVariable ���ݲ�����
+
+ʵ���ϣ������� requestBody ����У�黹�Ƿ��������У�飬���ն��ǵ��� Hibernate Validator ִ��У�飬Spring Validation ֻ������һ���װ��
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#%E6%A0%A1%E9%AA%8C%E7%A4%BA%E4%BE%8B)У��ʾ��
+
+��1����ʵ���ϱ��У��ע��
+
+
+
+```
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class User implements Serializable {
+
+    @NotNull
+    private Long id;
+
+    @NotBlank
+    @Size(min = 2, max = 10)
+    private String name;
+
+    @Min(value = 1)
+    @Max(value = 100)
+    private Integer age;
+
+}
+
+```
+
+
+
+��2���ڷ�������������У��ע��
+
+
+
+```
+@Slf4j
+@Validated
+@RestController
+@RequestMapping("validate1")
+public class ValidatorController {
+
+    /**
+     * {@link RequestBody} ������
+     */
+    @PostMapping(value = "save")
+    public DataResult<Boolean> save(@Valid @RequestBody User entity) {
+        log.info("����һ����¼��{}", JSONUtil.toJsonStr(entity));
+        return DataResult.ok(true);
+    }
+
+    /**
+     * {@link RequestParam} ������
+     */
+    @GetMapping(value = "queryByName")
+    public DataResult<User> queryByName(
+        @RequestParam("username")
+        @NotBlank
+        @Size(min = 2, max = 10)
+        String name
+    ) {
+        User user = new User(1L, name, 18);
+        return DataResult.ok(user);
+    }
+
+    /**
+     * {@link PathVariable} ������
+     */
+    @GetMapping(value = "detail/{id}")
+    public DataResult<User> detail(@PathVariable("id") @Min(1L) Long id) {
+        User user = new User(id, "����", 18);
+        return DataResult.ok(user);
+    }
+
+}
+
+```
+
+
+
+��3������������������У���������׳� `ConstraintViolationException` �� `MethodArgumentNotValidException` �쳣��
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#%E7%BB%9F%E4%B8%80%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86)ͳһ�쳣����
+
+��ʵ����Ŀ�����У�ͨ������ͳһ�쳣����������һ�����Ѻõ���ʾ��
+
+
+
+```
+@Slf4j
+@ControllerAdvice
+public class GlobalExceptionHandler {
+
+    /**
+     * �������в���֪���쳣
+     */
+    @ResponseBody
+    @ResponseStatus(HttpStatus.OK)
+    @ExceptionHandler(Throwable.class)
+    public Result handleException(Throwable e) {
+        log.error("δ֪�쳣", e);
+        return new Result(ResultStatus.HTTP_SERVER_ERROR.getCode(), e.getMessage());
+    }
+
+    /**
+     * ͳһ�����������У���쳣(��ͨ����)
+     *
+     * @param e ConstraintViolationException
+     * @return {@link DataResult}
+     */
+    @ResponseBody
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    @ExceptionHandler({ ConstraintViolationException.class })
+    public Result handleConstraintViolationException(final ConstraintViolationException e) {
+        log.error("ConstraintViolationException", e);
+        List<String> errors = new ArrayList<>();
+        for (ConstraintViolation<?> violation : e.getConstraintViolations()) {
+            Path path = violation.getPropertyPath();
+            List<String> pathArr = StrUtil.split(path.toString(), ',');
+            errors.add(pathArr.get(0) + " " + violation.getMessage());
+        }
+        return new Result(ResultStatus.REQUEST_ERROR.getCode(), CollectionUtil.join(errors, ","));
+    }
+
+    /**
+     * ��������У���쳣
+     *
+     * @param e MethodArgumentNotValidException
+     * @return {@link DataResult}
+     */
+    @ResponseBody
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    @ExceptionHandler({ MethodArgumentNotValidException.class })
+    private Result handleMethodArgumentNotValidException(final MethodArgumentNotValidException e) {
+        log.error("MethodArgumentNotValidException", e);
+        List<String> errors = new ArrayList<>();
+        for (ObjectError error : e.getBindingResult().getAllErrors()) {
+            errors.add(((FieldError) error).getField() + " " + error.getDefaultMessage());
+        }
+        return new Result(ResultStatus.REQUEST_ERROR.getCode(), CollectionUtil.join(errors, ","));
+    }
+
+}
+
+```
+
+
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#%E8%BF%9B%E9%98%B6%E4%BD%BF%E7%94%A8)����ʹ��
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#%E5%88%86%E7%BB%84%E6%A0%A1%E9%AA%8C)������
+
+��ʵ����Ŀ�У����ܶ��������Ҫʹ��ͬһ�� DTO �������ղ���������ͬ������У�����ܿ����Dz�һ���ġ����ʱ�򣬼򵥵��� DTO ����ֶ��ϼ�Լ��ע���޷����������⡣��ˣ�spring-validation ֧���˷���У��Ĺ��ܣ�ר����������������⡣
+
+��1���������
+
+
+
+```
+@Target({ ElementType.FIELD, ElementType.PARAMETER })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AddCheck { }
+
+@Target({ ElementType.FIELD, ElementType.PARAMETER })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface EditCheck { }
+
+```
+
+
+
+��2����ʵ���ϱ��У��ע��
+
+
+
+```
+@Data
+public class User2 {
+
+    @NotNull(groups = EditCheck.class)
+    private Long id;
+
+    @NotNull(groups = { AddCheck.class, EditCheck.class })
+    @Size(min = 2, max = 10, groups = { AddCheck.class, EditCheck.class })
+    private String name;
+
+    @IsMobile(message = "������Ч�ֻ���", groups = { AddCheck.class, EditCheck.class })
+    private String mobile;
+
+}
+
+```
+
+
+
+��3���ڷ����ϸ��ݲ�ͬ��������У�����
+
+
+
+```
+@Slf4j
+@Validated
+@RestController
+@RequestMapping("validate2")
+public class ValidatorController2 {
+
+    /**
+     * {@link RequestBody} ������
+     */
+    @PostMapping(value = "add")
+    public DataResult<Boolean> add(@Validated(AddCheck.class) @RequestBody User2 entity) {
+        log.info("����һ����¼��{}", JSONUtil.toJsonStr(entity));
+        return DataResult.ok(true);
+    }
+
+    /**
+     * {@link RequestBody} ������
+     */
+    @PostMapping(value = "edit")
+    public DataResult<Boolean> edit(@Validated(EditCheck.class) @RequestBody User2 entity) {
+        log.info("�༭һ����¼��{}", JSONUtil.toJsonStr(entity));
+        return DataResult.ok(true);
+    }
+
+}
+
+```
+
+
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#%E5%B5%8C%E5%A5%97%E6%A0%A1%E9%AA%8C)Ƕ��У��
+
+ǰ���ʾ���У�DTO ��������ֶζ��ǻ����������ͺ� String ���͡�����ʵ�ʳ����У��п���ij���ֶ�Ҳ��һ��������������ȣ�����ʹ��Ƕ��У�顣 post ���磬���汣�� User ��Ϣ��ʱ��ͬʱ������ Job ��Ϣ����Ҫע����ǣ���ʱ DTO ��Ķ�Ӧ�ֶα�����@Valid ע�⡣
+
+
+
+```
+@Data
+public class UserDTO {
+
+    @Min(value = 10000000000000000L, groups = Update.class)
+    private Long userId;
+
+    @NotNull(groups = {Save.class, Update.class})
+    @Length(min = 2, max = 10, groups = {Save.class, Update.class})
+    private String userName;
+
+    @NotNull(groups = {Save.class, Update.class})
+    @Length(min = 6, max = 20, groups = {Save.class, Update.class})
+    private String account;
+
+    @NotNull(groups = {Save.class, Update.class})
+    @Length(min = 6, max = 20, groups = {Save.class, Update.class})
+    private String password;
+
+    @NotNull(groups = {Save.class, Update.class})
+    @Valid
+    private Job job;
+
+    @Data
+    public static class Job {
+
+        @Min(value = 1, groups = Update.class)
+        private Long jobId;
+
+        @NotNull(groups = {Save.class, Update.class})
+        @Length(min = 2, max = 10, groups = {Save.class, Update.class})
+        private String jobName;
+
+        @NotNull(groups = {Save.class, Update.class})
+        @Length(min = 2, max = 10, groups = {Save.class, Update.class})
+        private String position;
+    }
+
+    /**
+     * �����ʱ��У�����
+     */
+    public interface Save {
+    }
+
+    /**
+     * ���µ�ʱ��У�����
+     */
+    public interface Update {
+    }
+}
+���ƴ���
+
+```
+
+
+
+Ƕ��У����Խ�Ϸ���У��һ��ʹ�á����о���Ƕ�׼���У���Լ��������ÿһ�����У�飬����`List<Job>`�ֶλ����� list �����ÿһ�� Job ���󶼽���У��
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#%E8%87%AA%E5%AE%9A%E4%B9%89%E6%A0%A1%E9%AA%8C%E6%B3%A8%E8%A7%A3)�Զ���У��ע��
+
+��1���Զ���У��ע�� `@IsMobile`
+
+
+
+```
+@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
+@Retention(RUNTIME)
+@Constraint(validatedBy = MobileValidator.class)
+public @interface IsMobile {
+
+    String message();
+
+    Class<?>[] groups() default {};
+
+    Class<? extends Payload>[] payload() default {};
+
+}
+
+```
+
+
+
+��2��ʵ�� `ConstraintValidator` �ӿڣ���д `@IsMobile` У��ע��Ľ�����
+
+
+
+```
+import cn.hutool.core.util.StrUtil;
+import io.github.dunwu.spring.core.validation.annotation.IsMobile;
+import io.github.dunwu.tool.util.ValidatorUtil;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+public class MobileValidator implements ConstraintValidator<IsMobile, String> {
+
+    @Override
+    public void initialize(IsMobile isMobile) { }
+
+    @Override
+    public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) {
+        if (StrUtil.isBlank(s)) {
+            return false;
+        } else {
+            return ValidatorUtil.isMobile(s);
+        }
+    }
+
+}
+
+```
+
+
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#%E8%87%AA%E5%AE%9A%E4%B9%89%E6%A0%A1%E9%AA%8C)�Զ���У��
+
+����ͨ��ʵ�� `org.springframework.validation.Validator` �ӿ����Զ���У�顣
+
+������Ҫ��
+
+*   ʵ�� `supports` ����
+*   ʵ�� `validate` ����
+    *   ͨ�� `Errors` �����ռ�����
+        *   `ObjectError`������Bean������
+        *   `FieldError`������Bean�����ԣ�Property������
+    *   ͨ�� `ObjectError` �� `FieldError` ���� `MessageSource` ʵ�ֻ�ȡ���յĴ����İ�
+
+
+
+```
+package io.github.dunwu.spring.core.validation;
+
+import io.github.dunwu.spring.core.validation.annotation.Valid;
+import io.github.dunwu.spring.core.validation.config.CustomValidatorConfig;
+import io.github.dunwu.spring.core.validation.entity.Person;
+import org.springframework.stereotype.Component;
+import org.springframework.validation.Errors;
+import org.springframework.validation.ValidationUtils;
+import org.springframework.validation.Validator;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@Component
+public class CustomValidator implements Validator {
+
+    private final CustomValidatorConfig validatorConfig;
+
+    public CustomValidator(CustomValidatorConfig validatorConfig) {
+        this.validatorConfig = validatorConfig;
+    }
+
+    /**
+     * ��У����ֻ��� Person �������У��
+     */
+    @Override
+    public boolean supports(Class<?> clazz) {
+        return Person.class.equals(clazz);
+    }
+
+    @Override
+    public void validate(Object target, Errors errors) {
+        ValidationUtils.rejectIfEmpty(errors, "name", "name.empty");
+
+        List<Field> fields = getFields(target.getClass());
+        for (Field field : fields) {
+            Annotation[] annotations = field.getAnnotations();
+            for (Annotation annotation : annotations) {
+                if (annotation.annotationType().getAnnotation(Valid.class) != null) {
+                    try {
+                        ValidatorRule validatorRule = validatorConfig.findRule(annotation);
+                        if (validatorRule != null) {
+                            validatorRule.valid(annotation, target, field, errors);
+                        }
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+
+    private List<Field> getFields(Class<?> clazz) {
+        // ����Field����
+        List<Field> fields = new ArrayList<>();
+        // ���class���Ͳ�Ϊ��
+        while (clazz != null) {
+            // �������Ե���������
+            Collections.addAll(fields, clazz.getDeclaredFields());
+            clazz = clazz.getSuperclass();
+        }
+        return fields;
+    }
+
+}
+
+```
+
+
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#%E5%BF%AB%E9%80%9F%E5%A4%B1%E8%B4%A5-fail-fast)����ʧ��(Fail Fast)
+
+Spring Validation Ĭ�ϻ�У���������ֶΣ�Ȼ����׳��쳣������ͨ��һЩ�򵥵����ã����� Fali Fast ģʽ��һ��У��ʧ�ܾ��������ء�
+
+
+
+```
+@Bean
+public Validator validator() {
+    ValidatorFactory validatorFactory = Validation.byProvider(HibernateValidator.class)
+            .configure()
+            // ����ʧ��ģʽ
+            .failFast(true)
+            .buildValidatorFactory();
+    return validatorFactory.getValidator();
+}
+
+```
+
+
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#spring-%E6%A0%A1%E9%AA%8C%E5%8E%9F%E7%90%86)Spring У��ԭ��
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#spring-%E6%A0%A1%E9%AA%8C%E4%BD%BF%E7%94%A8%E5%9C%BA%E6%99%AF)Spring У��ʹ�ó���
+
+*   Spring ����У�飨Validator��
+*   Spring ���ݰ󶨣�DataBinder��
+*   Spring Web �����󶨣�WebDataBinder��
+*   Spring WebMVC/WebFlux ��������������
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#validator-%E6%8E%A5%E5%8F%A3%E8%AE%BE%E8%AE%A1)Validator �ӿ����
+
+*   �ӿ�ְ��
+    *   Spring �ڲ�У�����ӿڣ�ͨ����̵ķ�ʽУ��Ŀ�����
+*   ���ķ���
+    *   `supports(Class)`��У��Ŀ�����ܷ�У��
+    *   `validate(Object,Errors)`��У��Ŀ����󣬲���У��ʧ�ܵ���������� Errors ����
+*   �������
+    *   �����ռ�����`org.springframework.validation.Errors`
+    *   Validator �����ࣺ`org.springframework.validation.ValidationUtils`
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#errors-%E6%8E%A5%E5%8F%A3%E8%AE%BE%E8%AE%A1)Errors �ӿ����
+
+*   �ӿ�ְ��
+    *   ���ݰ󶨺�У������ռ��ӿڣ��� Java Bean ����������ǿ������
+*   ���ķ���
+    *   `reject` ���������أ����ռ������İ�
+    *   `rejectValue` ���������أ����ռ������ֶ��еĴ����İ�
+*   �������
+    *   Java Bean ����������`org.springframework.validation.ObjectError`
+    *   Java Bean ���Դ���������`org.springframework.validation.FieldError`
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#errors-%E6%96%87%E6%A1%88%E6%9D%A5%E6%BA%90)Errors �İ���Դ
+
+Errors �İ����ɲ���
+
+*   ѡ�� Errors ʵ�֣��磺`org.springframework.validation.BeanPropertyBindingResult`��
+*   ���� reject �� rejectValue ����
+*   ��ȡ Errors ������ ObjectError �� FieldError
+*   �� ObjectError �� FieldError �е� code �� args������ MessageSource ʵ�֣��磺`ResourceBundleMessageSource`��
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#spring-web-%E6%A0%A1%E9%AA%8C%E5%8E%9F%E7%90%86)spring web У��ԭ��
+
+#### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#requestbody-%E5%8F%82%E6%95%B0%E6%A0%A1%E9%AA%8C%E5%AE%9E%E7%8E%B0%E5%8E%9F%E7%90%86)RequestBody ����У��ʵ��ԭ��
+
+�� spring-mvc �У�`RequestResponseBodyMethodProcessor` �����ڽ��� `@RequestBody` ��ע�IJ����Լ�����`@ResponseBody` ��ע�����ķ���ֵ�ġ����У�ִ�в���У����߼��϶����ڽ��������ķ��� `resolveArgument()` �У�
+
+
+
+```
+@Override
+public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
+    NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
+
+    parameter = parameter.nestedIfOptional();
+    Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
+    String name = Conventions.getVariableNameForParameter(parameter);
+
+    if (binderFactory != null) {
+        WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
+        if (arg != null) {
+            // ���Խ��в���У��
+            validateIfApplicable(binder, parameter);
+            if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
+                // �������У��������׳� MethodArgumentNotValidException
+                throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
+            }
+        }
+        if (mavContainer != null) {
+            mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
+        }
+    }
+
+    return adaptArgumentIfNecessary(arg, parameter);
+}
+
+```
+
+
+
+���Կ�����resolveArgument()������ validateIfApplicable()���в���У�顣
+
+
+
+```
+protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter) {
+    // ��ȡ����ע�⣬�� @RequestBody��@Valid��@Validated
+    Annotation[] annotations = parameter.getParameterAnnotations();
+    for (Annotation ann : annotations) {
+        // �ȳ��Ի�ȡ @Validated ע��
+        Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class);
+        // �����ע�� @Validated��ֱ�ӿ�ʼУ�顣
+        // ���û�У���ô�жϲ���ǰ�Ƿ��� Valid ��ͷ��ע�⡣
+        if (validatedAnn != null || ann.annotationType().getSimpleName().startsWith("Valid")) {
+            Object hints = (validatedAnn != null ? validatedAnn.value() : AnnotationUtils.getValue(ann));
+            Object[] validationHints = (hints instanceof Object[] ? (Object[]) hints : new Object[] {hints});
+            // ִ��У��
+            binder.validate(validationHints);
+            break;
+        }
+    }
+}
+
+```
+
+
+
+���ϴ��룬�ͽ����� Spring Ϊʲô��ͬʱ֧�� `@Validated`��`@Valid` ����ע�⡣
+
+����������һ�� WebDataBinder.validate() ��ʵ�֣�
+
+
+
+```
+@Override
+public void validate(Object target, Errors errors, Object... validationHints) {
+    if (this.targetValidator != null) {
+        processConstraintViolations(
+            // �˴����� Hibernate Validator ִ��������У��
+            this.targetValidator.validate(target, asValidationGroups(validationHints)), errors);
+    }
+}
+
+```
+
+
+
+ͨ��������룬���Կ��� Spring У��ʵ�����ǻ��� Hibernate Validator �ķ�װ��
+
+#### [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#%E6%96%B9%E6%B3%95%E7%BA%A7%E5%88%AB%E7%9A%84%E5%8F%82%E6%95%B0%E6%A0%A1%E9%AA%8C%E5%AE%9E%E7%8E%B0%E5%8E%9F%E7%90%86)��������IJ���У��ʵ��ԭ��
+
+Spring ֧�ָ��ݷ���ȥ�������ء�У�飬ԭ��������Ӧ���� AOP ������������˵����ͨ�� `MethodValidationPostProcessor` ��̬ע�� AOP ���棬Ȼ��ʹ�� `MethodValidationInterceptor` ���е㷽��֯����ǿ��
+
+
+
+```
+public class MethodValidationPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessorimplements InitializingBean {
+    @Override
+    public void afterPropertiesSet() {
+        // Ϊ���� @Validated ��ע�� Bean ��������
+        Pointcut pointcut = new AnnotationMatchingPointcut(this.validatedAnnotationType, true);
+        // ���� Advisor ������ǿ
+        this.advisor = new DefaultPointcutAdvisor(pointcut, createMethodValidationAdvice(this.validator));
+    }
+
+    // ���� Advice�����ʾ���һ������������
+    protected Advice createMethodValidationAdvice(@Nullable Validator validator) {
+        return (validator != null ? new MethodValidationInterceptor(validator) : new MethodValidationInterceptor());
+    }
+}
+
+```
+
+
+
+���ſ�һ�� `MethodValidationInterceptor`��
+
+
+
+```
+public class MethodValidationInterceptor implements MethodInterceptor {
+    @Override
+    public Object invoke(MethodInvocation invocation) throws Throwable {
+        // ������ǿ�ķ�����ֱ������
+        if (isFactoryBeanMetadataMethod(invocation.getMethod())) {
+            return invocation.proceed();
+        }
+        // ��ȡ������Ϣ
+        Class<?>[] groups = determineValidationGroups(invocation);
+        ExecutableValidator execVal = this.validator.forExecutables();
+        Method methodToValidate = invocation.getMethod();
+        Set<ConstraintViolation<Object>> result;
+        try {
+            // �������У�飬���ջ���ί�и� Hibernate Validator ��У��
+            result = execVal.validateParameters(
+                invocation.getThis(), methodToValidate, invocation.getArguments(), groups);
+        }
+        catch (IllegalArgumentException ex) {
+            ...
+        }
+        // ���쳣ֱ���׳�
+        if (!result.isEmpty()) {
+            throw new ConstraintViolationException(result);
+        }
+        // �����ķ�������
+        Object returnValue = invocation.proceed();
+        // �Է���ֵ��У�飬���ջ���ί�и�Hibernate Validator��У��
+        result = execVal.validateReturnValue(invocation.getThis(), methodToValidate, returnValue, groups);
+        // ���쳣ֱ���׳�
+        if (!result.isEmpty()) {
+            throw new ConstraintViolationException(result);
+        }
+        return returnValue;
+    }
+}
+
+```
+
+
+
+ʵ���ϣ������� requestBody ����У�黹�Ƿ��������У�飬���ն��ǵ��� Hibernate Validator ִ��У�飬Spring Validation ֻ������һ���װ��
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#%E9%97%AE%E9%A2%98)����
+
+**Spring ����ЩУ��������**��
+
+*   ��������`org.springframework.validation.Validator`
+*   �����ռ�����`org.springframework.validation.Errors`
+*   Java Bean ����������`org.springframework.validation.ObjectError`
+*   Java Bean ���Դ���������`org.springframework.validation.FieldError`
+*   Bean Validation ���䣺`org.springframework.validation.beanvalidation.LocalValidatorFactoryBean`
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/fe6aad/#%E5%8F%82%E8%80%83%E8%B5%84%E6%96%99)�����
+
+*   [Spring �ٷ��ĵ�֮ Core Technologies(opens new window)](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans)
+*   [��С���署 Spring ���ı��˼�롷(opens new window)](https://time.geekbang.org/course/intro/265)
+*   https://juejin.cn/post/6856541106626363399
+
+
+# �����
+https://www.w3cschool.cn/wkspring
+https://www.runoob.com/w3cnote/basic-knowledge-summary-of-spring.html
+http://codepub.cn/2015/06/21/Basic-knowledge-summary-of-Spring
+https://dunwu.github.io/spring-tutorial
+https://mszlu.com/java/spring
+http://c.biancheng.net/spring/aop-module.html
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\347\232\204Environment\347\216\257\345\242\203\345\217\230\351\207\217.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\347\232\204Environment\347\216\257\345\242\203\345\217\230\351\207\217.md"
new file mode 100644
index 0000000..99987fa
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\347\232\204Environment\347\216\257\345\242\203\345\217\230\351\207\217.md"
@@ -0,0 +1,849 @@
+
+
+
+
+��������ڰ����������ø��ٵĴ��롢�����д��������ϵͳ�� Spring Boot ��Ȼ��Ϊ Java Ӧ�ÿ�������ʵ��׼���� Spring Boot �ṩ���ڶ������У�**�Զ�����**�����Ƕ���������������������һ�����ԣ�Spring Boot ������һ����Ϊ������Ա�Զ����������ɿ��伴�á��߱�ijһ���ܵ� Bean�����������£��Զ����õ� Bean �պ��������ҵ����󣬵���ijЩ����£����ò������ظ������ǣ����ʱ��ֻ��Ҫ��������������͵� Bean ���ɣ���Ϊ��������Զ����õ� Bean ������`@ConditionalOnMissingBean`ע�����Ρ����˵��ǣ����ֻ����΢��һЩϸ�ڣ�����ĸĶ˿ں� (server.port) ������Դ URL (spring.datasource.url) ����ѹ��û��Ҫ��������`ServerProperties`��`DataSourceProperties`���� Bean �������Զ����õ� Bean�� Spring Boot Ϊ�Զ����õ� Bean �ṩ��1000�������΢�������ԣ�����Ҫ��������ʱ��ֻ��Ҫ�ڻ��������������в����������ļ� (application.properties/application.yml) �н���ָ�����ɣ������ Spring Boot ��`Externalized Configuration` (�����⻯) ���ԡ�
+
+��Ȼ���ⲿ����Դ���������ڻ��������������в����������ļ������֣�����Ȥ�Ķ��߿��������Ķ� Spring Boot �ٷ��ĵ����� Spring �У�`BeanFactory`������ Bean �����Ľ�ɫ����`Environment`ͬ����λΪһ�����������ⲿ����Դ�е����Զ��ᱻ���ӵ� _Environment_ �С�**��΢�����������Ľ��죬�ⲿ����Դ����������_Disconf_��_Apollo_ �� _Nacos_ �ȷֲ�ʽ�������ģ����� Spring �ĵ��̣�����Ҫ�������ף������������ж�ȡ����������Ȼ�ᱻ׷�ӵ� _Environment_ ��**��
+
+����֮����д��ƪ���£�����`jasypt`�������������һ�νӴ�������2018�꣬��ʱ�ͺܺ�������������������ʵ�ֶ��������Լӽ��ܵģ�����������Ҫ��ʵ����ôһ��������������Ҫ��Ϥ Bean ���������ڡ�IoC ������չ�� (IoC Container Extension Points) �� Spring Boot ���������̵�֪ʶ������Ҫ���� _Environment_��
+
+> jasypt ����ʮ�ּ򵥡�����ͨ��`jasypt-maven-plugin`��һ maven ���Ϊ��������ֵ�������ģ�Ȼ����`ENC(����)`�滻��������ֵ���ɡ����£�
+>
+> ```
+> jasypt.encryptor.password=crimson_typhoon
+> 
+> spring.datasource.url=jdbc:mysql://HOST:PORT/db_sql_boy?characterEncoding=UTF-8
+> spring.datasource.hikari.driver-class-name=com.mysql.cj.jdbc.Driver
+> spring.datasource.hikari.username=root
+> spring.datasource.hikari.password=ENC(qS8+DEIlHxvhPHgn1VaW3oHkn2twrmwNOHewWLIfquAXiCDBrKwvIhDoqalKyhIF)
+> ���ƴ���
+> ```
+
+## 1 ��ʶ Environmnent
+
+��ʵ�ʹ����У������� _Environment_ �򽻵��Ļ��Ტ���ࣻ���ҵ�� Bean ȷʵ��Ҫ��ȡ�ⲿ����Դ�е�ijһ����ֵ�������ֶ��� _Environment_ ע�뵽��ҵ�� Bean �У�Ҳ����ֱ��ʵ��`EnvironmentAware`�ӿڣ��õ� _Environment_ ���͵� Bean ʵ��֮�����ͨ��`getProperty()`��ȡ��������ֵ��_Environment_ �ӿ�����������ʾ��
+
+```
+public interface Environment extends PropertyResolver {
+    String[] getActiveProfiles();
+    String[] getDefaultProfiles();
+    boolean acceptsProfiles(Profiles profiles);
+}
+
+public interface PropertyResolver {
+    boolean containsProperty(String key);
+    String getProperty(String key);
+    String getProperty(String key, String defaultValue);
+    <T> T getProperty(String key, Class<T> targetType);
+    <T> T getProperty(String key, Class<T> targetType, T defaultValue);
+    String resolvePlaceholders(String text);
+}
+���ƴ���
+```
+
+**��Ҳ�Ҫ�� _Environment_ �� _getProperty()_ �������󵼣��ⲿ����Դ�е����Բ������Ե�������Ϊά�ȱ����ӵ� _Environment_ �еģ�������`PropertySource`Ϊά��**��_PropertySource_ �Ƕ�����Դ���ƺ͸�����Դ��һ�����Եij���`MapPropertySource`��һ����򵥵�ʵ�֣���ͨ�� _Map<String, Object>_ ��������ص����ԡ�_PropertySource_ �������£�
+
+```
+public abstract class PropertySource<T> {
+    protected final String name;
+    protected final T source;
+
+    public PropertySource(String name, T source) {
+        this.name = name;
+        this.source = source;
+    }
+
+    public String getName() { return this.name; }
+    public T getSource() { return this.source; }
+    public abstract Object getProperty(String name);
+}
+���ƴ���
+```
+
+������ _PropertySource_ ����������_PropertySource_ �����Ǿ߱�������������ȡ����ֵ��һ�����ġ�
+
+####  ****getProperty()�ڲ�ִ���߼�****
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/QQ%E6%88%AA%E5%9B%BE20230416193319.jpg)
+
+һ�㣬_Environment_ ʵ�����л����һ��`PropertyResolver`���͵ij�Ա�������������� _PropertyResolver_ ����ִ�� _getProperty()_ �߼���_PropertyResolver_ ʵ�������ֻ����������Ա�������ֱ��ǣ�`ConversionService`��`PropertySources`�����ȣ�_PropertyResolver_ ���� `PropertySources` �е� _PropertySource_����ȡԭ������ֵ��Ȼ��ί�� _ConversionService_ ��ԭ������ֵ������������ת�� (����б�Ҫ�Ļ�)��**��Ȼ PropertySource �����Ǿ߱�������������ȡ����ֵ��һ�����ģ������߱�ռλ������������ת���������������м�����߱������������� PropertyResolver�� ��Ҳӡ֤��һ�����ӣ��ڼ������ѧ�У�û��ʲô���������м��һ�������˵ģ�����У��Ǿ��ټ�һ��**��
+
+####  ****PropertySource�ڲ������߼�****
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/QQ%E6%88%AA%E5%9B%BE20230416193319.jpg)
+
+_Environment_ ʵ�����г��˳���`PropertyResolver`���͵ij�Ա�����⣬����һ��`MutablePropertySources`���͵ij�Ա�������������ṩֱ�Ӳ����� _MutablePropertySources_ �ķ���������ֻ��ͨ��`getPropertySources()`������ȡ _MutablePropertySources_ ʵ����Ȼ����� _MutablePropertySources_ �е�`addFirst()`��`addLast()`��`replace()`�ȷ���ȥ���� _PropertySource_��_MutablePropertySources_ �� _PropertySources_ Ψһһ��ʵ���࣬����ͼ��ʾ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416193420.png)
+
+�ܵ���˵��_Environment_ �Ƕ� _PropertySource_ �� _Profile_ �Ķ�������������� _Profile_ �ĸ����Ӧ�ó�����Ҫ���𵽲�ͬ�����л���ʱ��һЩ������ͨ����������ͬ�����磬����Դ URL �ڿ��������Ͳ��Ի����ͻ᲻һ����Spring ��3.1�汾��ʼ֧�ֻ��� _Profile_ �����������á�
+
+**Profile in Spring 3.1**
+
+�� Spring ����3.1�汾ʱ��Spring Boot ��δ����������˵��ʱ�� _Profile_ ���Ի�����Щ**覴�**�ģ���覲���褡���Ҫ�����ڣ����ͬһ���͵� Bean������������Ρ�һ��������������С覴ã�
+
+```
+@Configuration(proxyBeanMethods = false)
+public class DataSourceConfig {
+    @Bean
+    @Profile("dev")
+    public DataSource devDataSource () {
+        return DataSourceBuilder.create()
+                .driverClassName("com.mysql.jdbc.Driver")
+                .url("jdbc:mysql://DEV_HOST:PORT/db_sql_boy?characterEncoding=UTF-8")
+                .username("dev")
+                .password("dev")
+                .build();
+    }
+
+    @Bean
+    @Profile("test")
+    public DataSource testDataSource () {
+        return DataSourceBuilder.create()
+                .driverClassName("com.mysql.jdbc.Driver")
+                .url("jdbc:mysql://TEST_HOST:PORT/db_sql_boy?characterEncoding=UTF-8")
+                .username("test")
+                .password("test")
+                .build();
+    }
+}
+���ƴ���
+```
+
+**Profile in Spring Boot**
+
+Spring Boot ������`@Profile`ע������ӵ����������ˡ��ٷ��������п϶�Ҳ��ʶ�� _Profile in Spring 3.1_ ������覴ã������� Spring Boot �ĵ�һ�汾 _(1.0.0.RELEASE)_ �о��Ȳ�������֧��Ϊ _application.properties_ �� _application.yml_ ������������� _Profile_ �ˡ�������ζ��һ�����������������ţ�
+
+```
+@Configuration(proxyBeanMethods = false)
+public class DataSourceConfig {
+    @Bean
+    public DataSource devDataSource (DataSourceProperties dataSourceProperties) {
+        return DataSourceBuilder.create()
+                .driverClassName(dataSourceProperties.getDriverClassName())
+                .url(dataSourceProperties.getUrl())
+                .username(dataSourceProperties.getUsername())
+                .password(dataSourceProperties.getPassword())
+                .build();
+    }
+}
+���ƴ���
+```
+
+_application-dev.properties_ �������£�
+
+```
+spring.datasource.url=jdbc:mysql://DEV_HOST:PORT/db_sql_boy?characterEncoding=UTF-8
+spring.datasource.hikari.driver-class-name=com.mysql.jdbc.Driver
+spring.datasource.hikari.password=dev
+spring.datasource.hikari.username=dev
+���ƴ���
+```
+
+_application-test.properties_ �������£�
+
+```
+spring.datasource.url=jdbc:mysql://TEST_HOST:PORT/db_sql_boy?characterEncoding=UTF-8
+spring.datasource.hikari.driver-class-name=com.mysql.jdbc.Driver
+spring.datasource.hikari.password=test
+spring.datasource.hikari.username=test
+���ƴ���
+```
+
+��ԭ�� Spring 3.1 �� Spring Boot �У�����ͨ��`spring.profiles.active`��Ϊ _Environment_ ָ������� _Profile_������_Environment_ ��Ĭ�ϼ���� _Profile_ ����Ϊ`default`��д����������Ժ�������һ�����⣺һ�㣬`@Profile` ע����Ҫ�� _@Configuration_ ע��� _@Bean_ ע�����ʹ�ã���� _spring.profiles.active_ ��ֵΪ _dev_ ʱ����ô��Щ�� _@Configuration_ �� _@Bean_ ע���� (��û��`@Profile`ע�����Ӱ��) �� Bean ���ᱻ����Ϊ����`BeanDefinition`ʵ���𣿴��ǻ�ġ�`ConfigurationClassPostProcessor`���� _@Configuration_ ���������Ϊ _BeanDefinition_���ڴ˹����л�ִ��`ConditionEvaluator`��`shouldSkip()`��������Ҫ�������£�
+
+```
+public class ConditionEvaluator {
+    public boolean shouldSkip(AnnotatedTypeMetadata metadata, ConfigurationCondition.ConfigurationPhase phase) {
+        if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
+            return false;
+        }
+
+        if (phase == null) {
+            if (metadata instanceof AnnotationMetadata &&
+                    ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
+                return shouldSkip(metadata, ConfigurationCondition.ConfigurationPhase.PARSE_CONFIGURATION);
+            }
+            return shouldSkip(metadata, ConfigurationCondition.ConfigurationPhase.REGISTER_BEAN);
+        }
+
+        List<Condition> conditions = new ArrayList<>();
+        for (String[] conditionClasses : getConditionClasses(metadata)) {
+            for (String conditionClass : conditionClasses) {
+                Condition condition = getCondition(conditionClass, this.context.getClassLoader());
+                conditions.add(condition);
+            }
+        }
+
+        AnnotationAwareOrderComparator.sort(conditions);
+
+        for (Condition condition : conditions) {
+            ConfigurationCondition.ConfigurationPhase requiredPhase = null;
+            if (condition instanceof ConfigurationCondition) {
+                requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
+            }
+            if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
+���ƴ���
+```
+
+`shouldSkip()`������һ�� _if_ �����Ǵ𰸣�`@Profile`ע����`@Conditional(ProfileCondition.class)`���Σ������һ��������ͷ��û��`Condition`����Ӱ��ֱ�ӷ���`false`�ˣ��Ǿ��Dz����������������˼ඣ�
+
+_Environment_ �е���Щ _PropertySource_ ������ɶ�ð�����Ȼ��Ϊ����� _Bean_ ඣ��ϻ�����˵����ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416193443.png)
+
+> ������ǰ������ visio �� processOn ��ͼ����һ������ draw.io��û�뵽������㣬ǿ�Ұ���һ����
+
+## 2 Environmnent ��ʼ������
+
+������Ҫ���� Spring Boot �������������� _Environmnt_ �о���ע������Щ _PropertySource_���������λ��`SpringApplication`�е�`run(String... args)`���������£�
+
+```
+public class SpringApplication {
+    public ConfigurableApplicationContext run(String... args) {
+        StopWatch stopWatch = new StopWatch();
+        stopWatch.start();
+        DefaultBootstrapContext bootstrapContext = createBootstrapContext();
+        ConfigurableApplicationContext context = null;
+        configureHeadlessProperty();
+        SpringApplicationRunListeners listeners = getRunListeners(args);
+        listeners.starting(bootstrapContext, this.mainApplicationClass);
+        try {
+            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
+            ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
+            configureIgnoreBeanInfo(environment);
+            Banner printedBanner = printBanner(environment);
+            context = createApplicationContext();
+            context.setApplicationStartup(this.applicationStartup);
+            prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
+            refreshContext(context);
+            afterRefresh(context, applicationArguments);
+            stopWatch.stop();
+            if (this.logStartupInfo) {
+                new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
+            }
+            listeners.started(context);
+            callRunners(context, applicationArguments);
+        } catch (Throwable ex) {
+            handleRunFailure(context, ex, listeners);
+            throw new IllegalStateException(ex);
+        }
+
+        try {
+            listeners.running(context);
+        } catch (Throwable ex) {
+            handleRunFailure(context, ex, null);
+            throw new IllegalStateException(ex);
+        }
+        return context;
+    }
+}
+���ƴ���
+```
+
+�������Կ�����_Environmnt_ �ij�ʼ������`refreshContext(context)`֮ǰ��ɵģ����Ǻ������ʵġ�_run()_ �����ܸ��ӣ����뱾���������ϵ��߼�ֻ��**һ**����
+
+```
+prepareEnvironment(listeners, bootstrapContext, applicationArguments);
+���ƴ���
+```
+
+����ֱ���������������߼���
+
+### 2.1 prepareEnvironment()
+
+��Ȼ���������ݶ���`prepareEnvironment()`�����ڣ������С����һ������
+
+```
+public class SpringApplication {
+    private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
+                                                       DefaultBootstrapContext bootstrapContext,
+                                                       ApplicationArguments applicationArguments) {
+        // 2.1.1
+        ConfigurableEnvironment environment = getOrCreateEnvironment();
+        // 2.1.2
+        configureEnvironment(environment, applicationArguments.getSourceArgs());
+        // 2.1.3
+        ConfigurationPropertySources.attach(environment);
+        // 2.1.4
+        listeners.environmentPrepared(bootstrapContext, environment);
+        DefaultPropertiesPropertySource.moveToEnd(environment);
+        bindToSpringApplication(environment);
+        ConfigurationPropertySources.attach(environment);
+        return environment;
+    }
+}
+���ƴ���
+```
+
+#### 2.1.1 getOrCreateEnvironment()
+
+`getOrCreateEnvironment()`��Ҫ���𹹽� _Environment_ ʵ���������ǰӦ���ǻ���`ͬ������I/O`ģ�͵ģ��� _Environment_ ѡ��`ApplicationServletEnvironment`���෴�أ������ǰӦ���ǻ���`�첽������I/O`ģ�͵ģ��� _Environment_ ѡ��`ApplicationReactiveWebEnvironment`�����ǹ����л������ǻ��� Spring MVC ����Ӧ�ã�Spring MVC ��һ�����`Servlet API`֮�ϡ�����ͬ������ I/O ģ�͵����� Java Web ������ܣ����� I/O ģ����ζ��һ�� HTTP �����Ӧһ���̣߳���ÿһ�� HTTP �������ڸ����߳�����������ɴ����ġ�_ApplicationServletEnvironment_ �̳й�ϵ����ͼ��ʾ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416193515.png)
+
+����ͼ���Կ��� _ApplicationServletEnvironment_ �����൱�Ӵ���ִ�� _ApplicationServletEnvironment_ ���췽����ʱ���Ȼ�ᴥ���������๹�췽���е��߼���**����Ϊ**��
+
+```
+public abstract class AbstractEnvironment implements ConfigurableEnvironment {
+    public AbstractEnvironment() {
+        this(new MutablePropertySources());
+    }
+
+    protected AbstractEnvironment(MutablePropertySources propertySources) {
+        this.propertySources = propertySources;
+        // createPropertyResolver(propertySources)
+        // |___ ConfigurationPropertySources.createPropertyResolver(propertySources)
+        //      |___ new ConfigurationPropertySourcesPropertyResolver(propertySources)
+        this.propertyResolver = createPropertyResolver(propertySources);
+        customizePropertySources(propertySources);
+    }
+}
+���ƴ���
+```
+
+```
+public class StandardServletEnvironment extends StandardEnvironment implements ConfigurableWebEnvironment {
+    @Override
+    protected void customizePropertySources(MutablePropertySources propertySources) {
+        propertySources.addLast(new StubPropertySource("servletConfigInitParams"));
+        propertySources.addLast(new StubPropertySource("servletContextInitParams"));
+        super.customizePropertySources(propertySources);
+    }
+}
+���ƴ���
+```
+
+```
+public class StandardEnvironment extends AbstractEnvironment {
+    @Override
+    protected void customizePropertySources(MutablePropertySources propertySources) {
+        propertySources.addLast(
+                new PropertiesPropertySource("systemProperties", (Map) System.getProperties()));
+        propertySources.addLast(
+                new SystemEnvironmentPropertySource("systemEnvironment", (Map) System.getenv()));
+    }
+}
+���ƴ���
+```
+
+���� _ApplicationServletEnvironment_ ���췽����ִ�У���ʱ�� _Environment_ �� _MutablePropertySources_ ���͵ij�Ա����`propertySources`���Ѿ�����**��**�� _PropertySource_ �ˣ����������ǣ�`servletConfigInitParams`��`servletContextInitParams`��`systemProperties`��`systemEnvironment`�����⣬ҲҪ��ס _ApplicationServletEnvironment_ �е�������Ҫ��Ա��������`MutablePropertySources`��`ConfigurationPropertySourcesPropertyResolver`��
+
+#### 2.1.2 configureEnvironment()
+
+`configureEnvironment()`�����е��߼�Ҳ�ܼ򵥹������ȣ�Ϊ _Environment_ �е� _PropertySourcesPropertyResolver_ �趨 _ConversionService_��Ȼ���� _Environment_ �е� _MutablePropertySources_ ׷��һ������Ϊ`commandLineArgs`�� _PropertySource_ ʵ����ע��ʹ�õ���`addFirst()`����Ŷ������ζ���������Ϊ`commandLineArgs`�� _PropertySource_ ���ȼ�����ߵġ���Ҫ�߼����£�
+
+```
+public class SpringApplication {
+    protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
+        if (this.addConversionService) {
+            environment.getPropertyResolver().setConversionService(new ApplicationConversionService());
+        }
+        if (this.addCommandLineProperties && args.length > 0) {
+            MutablePropertySources sources = environment.getPropertySources();
+            sources.addFirst(new SimpleCommandLinePropertySource(args));
+        }
+    }
+}
+���ƴ���
+```
+
+����`SimpleCommandLinePropertySource`��
+
+```
+public class SimpleCommandLinePropertySource extends CommandLinePropertySource<CommandLineArgs> {
+    public SimpleCommandLinePropertySource(String... args) {
+        // �丸�๹�췽��Ϊ��super("commandLineArgs", source)
+        super(new SimpleCommandLineArgsParser().parse(args));
+    }
+}
+���ƴ���
+```
+
+�����в������DZȽϳ��õģ��������������� Spring Boot Ӧ��ʱ���������������в�����`java -jar app.jar --server.port=8088`��
+
+#### 2.1.3 ConfigurationPropertySources.attach()
+
+`attach()`������Ҫ������ _Environment_ �� _MutablePropertySources_ ��ͷ��λ�ò����һ������Ϊ`configurationProperties`�� _PropertySource_ ʵ������Ҫ�߼����£�
+
+```
+public final class ConfigurationPropertySources {
+    public static void attach(org.springframework.core.env.Environment environment) {
+        MutablePropertySources sources = ((ConfigurableEnvironment) environment).getPropertySources();
+        PropertySource<?> attached = getAttached(sources);
+        if (attached != null && attached.getSource() != sources) {
+            sources.remove(ATTACHED_PROPERTY_SOURCE_NAME);
+            attached = null;
+        }
+        if (attached == null) {
+            sources.addFirst(new ConfigurationPropertySourcesPropertySource("configurationProperties", new SpringConfigurationPropertySources(sources)));
+        }
+    }
+
+    static PropertySource<?> getAttached(MutablePropertySources sources) {
+        return (sources != null) ? sources.get("configurationProperties") : null;
+    }
+}
+���ƴ���
+```
+
+���߶�������������˺þã�ѹ��û�����������Ϊ`configurationProperties`�� _PropertySource_ ������ɶ�á���󣬻����ڹٷ��ĵ��й���`Relaxed Binding` (���ɰ�) �������в³���Щ���ߡ�����ͨ������������Ƚ�ֱ�ӡ����ȣ��� _application.properties_ ��׷��һ�������`a.b.my-first-key=hello spring environment`��Ȼ��ͨ�� _Environment_ ȡ������������ֵ�����£�
+
+```
+@SpringBootApplication
+public class DemoApplication {
+    public static void main(String[] args) {
+        ConfigurableApplicationContext configurableApplicationContext = SpringApplication.run(DemoApplication.class, args);
+        ConfigurableWebEnvironment environment = (ConfigurableWebEnvironment)
+                configurableApplicationContext.getBean(Environment.class);
+        System.out.println(environment.getProperty("a.b.my-first-key"));
+    }
+}
+���ƴ���
+```
+
+����Ӧ�ú󣬿���̨��ӡ���� _hello spring environment_ ����������Ԥ��������ġ��ɵ�����ͨ��`environment.getProperty("a.b.myfirstkey")`����`environment.getProperty("a.b.my-firstkey")`��Ȼ�ܹ���ȡ������������ݡ�`a.b.myfirstkey`��`a.b.my-firstkey`�����������ļ��е��������ƣ�ֻ�����ƶ��ѣ����ȷ��**����**��������������Ȥ�Ķ��߿������� DEBUG �������е�ԭ����
+
+#### 2.1.4 listeners.environmentPrepared()
+
+�úڰ壬��λ���У����Ҫ���� ��`environmentPrepared()`������㲥һ��`ApplicationEnvironmentPreparedEvent`�¼���������`EnvironmentPostProcessorApplicationListener`��Ӧ���¼�����Ӧ���ǵ��͵�**�۲���ģʽ**����Ҫ�������£�
+
+```
+public class SpringApplicationRunListeners {
+    private final List<SpringApplicationRunListener> listeners;
+
+    void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
+        doWithListeners("spring.boot.application.environment-prepared",
+                (listener) -> listener.environmentPrepared(bootstrapContext, environment));
+    }
+
+    private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction) {
+        StartupStep step = this.applicationStartup.start(stepName);
+        this.listeners.forEach(listenerAction);
+        step.end();
+    }
+}
+
+public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {
+    @Override
+    public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
+                                    ConfigurableEnvironment environment) {
+        this.initialMulticaster.multicastEvent(
+                new ApplicationEnvironmentPreparedEvent(bootstrapContext, this.application, this.args, environment));
+    }
+}
+
+public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
+    @Override
+    public void multicastEvent(ApplicationEvent event) {
+        multicastEvent(event, resolveDefaultEventType(event));
+    }
+
+    @Override
+    public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
+        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
+        Executor executor = getTaskExecutor();
+        for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
+            if (executor != null) {
+                executor.execute(() -> invokeListener(listener, event));
+            } else {
+                invokeListener(listener, event);
+            }
+        }
+    }
+}
+���ƴ���
+```
+
+��������һ��`EnvironmentPostProcessorApplicationListener`��®ɽ����Ŀ��
+
+```
+public class EnvironmentPostProcessorApplicationListener implements SmartApplicationListener, Ordered {
+    @Override
+    public void onApplicationEvent(ApplicationEvent event) {
+        if (event instanceof ApplicationEnvironmentPreparedEvent) {
+            onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
+        }
+        if (event instanceof ApplicationPreparedEvent) {
+            onApplicationPreparedEvent();
+        }
+        if (event instanceof ApplicationFailedEvent) {
+            onApplicationFailedEvent();
+        }
+    }
+    private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
+        ConfigurableEnvironment environment = event.getEnvironment();
+        SpringApplication application = event.getSpringApplication();
+        for (EnvironmentPostProcessor postProcessor : getEnvironmentPostProcessors(application.getResourceLoader(), event.getBootstrapContext())) {
+            postProcessor.postProcessEnvironment(environment, application);
+        }
+    }
+}
+���ƴ���
+```
+
+`EnvironmentPostProcessor`�� Spring Boot Ϊ _Environment_ �����������չ�㡣�������ùٷ��ĵ��бȽϾ�����һ�仰��_Allows for customization of the application's Environment prior to the application context being refreshed_��_EnvironmentPostProcessor_ ��һ�������Խӿڣ��������£�
+
+```
+public interface EnvironmentPostProcessor {
+    void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application);
+}
+���ƴ���
+```
+
+������ _EnvironmentPostProcessorApplicationListener_ �¼������߼��У�`getEnvironmentPostProcessors`������س����е� _EnvironmentPostProcessor_ ����һ���ڲ������߼���
+
+```
+public interface EnvironmentPostProcessorsFactory {
+    static EnvironmentPostProcessorsFactory fromSpringFactories(ClassLoader classLoader) {
+        return new ReflectionEnvironmentPostProcessorsFactory(
+                classLoader, 
+                SpringFactoriesLoader.loadFactoryNames(EnvironmentPostProcessor.class, classLoader)
+        );
+    }
+}
+���ƴ���
+```
+
+��������`SpringFactoriesLoader`һ̽������
+
+```
+public final class SpringFactoriesLoader {
+
+    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
+
+    public static List<String> loadFactoryNames(Class<?> factoryType, ClassLoader classLoader) {
+        ClassLoader classLoaderToUse = classLoader;
+        if (classLoaderToUse == null) {
+            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
+        }
+        String factoryTypeName = factoryType.getName();
+        return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
+    }
+
+    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
+        Map<String, List<String>> result = cache.get(classLoader);
+        if (result != null) {
+            return result;
+        }
+
+        result = new HashMap<>();
+        try {
+            Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
+            while (urls.hasMoreElements()) {
+                URL url = urls.nextElement();
+                UrlResource resource = new UrlResource(url);
+                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
+                for (Map.Entry<?, ?> entry : properties.entrySet()) {
+                    String factoryTypeName = ((String) entry.getKey()).trim();
+                    String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
+                    for (String factoryImplementationName : factoryImplementationNames) {
+                        result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
+                                .add(factoryImplementationName.trim());
+                    }
+                }
+            }
+            result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
+                    .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
+            cache.put(classLoader, result);
+        } catch (IOException ex) {
+            throw new IllegalArgumentException("Unable to load factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
+        }
+        return result;
+    }
+}
+���ƴ���
+```
+
+> **Spring SPI**
+>
+> > _SpringFactoriesLoader_ ��һ���߼����� Spring �е�`SPI`���ƣ�ֱ�׵�˵�����Ǵ�`classpath`�µ�`META-INF/spring.factories` �ļ��м��� _EnvironmentPostProcessor_ ��������������ͽ��Լ�ʵ�ֵ� _EnvironmentPostProcessor_ �ŵ����ļ��о����ˡ���ʵ��`JDK`�е�`SPI`���ƺ����ƹ���
+
+�ڵ�ǰ�汾��Spring Boot ������7�� _EnvironmentPostProcessor_ ʵ���ࡣ�������������Ƚϵ��͵ķ����¡�
+
+**RandomValuePropertySourceEnvironmentPostProcessor**
+
+`RandomValuePropertySourceEnvironmentPostProcessor`�� _Environment_ ��׷����һ������Ϊ`random`�� _PropertySource_����`RandomValuePropertySource`���������£�
+
+```
+public class RandomValuePropertySourceEnvironmentPostProcessor implements EnvironmentPostProcessor, Ordered {
+    public static final int ORDER = Ordered.HIGHEST_PRECEDENCE + 1;
+    private final Log logger;
+
+    public RandomValuePropertySourceEnvironmentPostProcessor(Log logger) {
+        this.logger = logger;
+    }
+
+    @Override
+    public int getOrder() {
+        return ORDER;
+    }
+
+    @Override
+    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
+        RandomValuePropertySource.addToEnvironment(environment, this.logger);
+    }
+}
+���ƴ���
+```
+
+��ô��� _RandomValuePropertySource_ ��ɶ�����أ���Ҫ����������������������磺`environment.getProperty("random.int(5,10)")`���Ի�ȡһ�����������`random.int`Ϊ���������Ի�ȡһ�� _int_ ���͵����������`random.long`Ϊ���������Ի�ȡһ�� _long_ ���͵����������`random.int(5,10)`Ϊ���������Ի�ȡһ�� _[5, 10}_ ������ _int_ ���͵�������������淨�������̽����
+
+_SystemEnvironmentPropertySourceEnvironmentPostProcessor_
+
+��ǰ��_Environment_ ���Ѿ�����һ������Ϊ`systemEnvironment`�� _PropertySource_����`SystemEnvironmentPropertySource`��`SystemEnvironmentPropertySourceEnvironmentPostProcessor`���ڽ��� _SystemEnvironmentPropertySource_ �滻Ϊ`OriginAwareSystemEnvironmentPropertySource`��զ�е㡰�ѿ��ӷ�ƨ�����һ�١��ĸо��أ�������
+
+```
+public class SystemEnvironmentPropertySourceEnvironmentPostProcessor implements EnvironmentPostProcessor, Ordered {
+    public static final int DEFAULT_ORDER = SpringApplicationJsonEnvironmentPostProcessor.DEFAULT_ORDER - 1;
+    private int order = DEFAULT_ORDER;
+
+    @Override
+    public int getOrder() {
+        return this.order;
+    }
+
+    @Override
+    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
+        String sourceName = "systemEnvironment";
+        PropertySource<?> propertySource = environment.getPropertySources().get(sourceName);
+        if (propertySource != null) {
+            replacePropertySource(environment, sourceName, propertySource, application.getEnvironmentPrefix());
+        }
+    }
+    private void replacePropertySource(ConfigurableEnvironment environment, String sourceName,
+                                       PropertySource<?> propertySource, String environmentPrefix) {
+        Map<String, Object> originalSource = (Map<String, Object>) propertySource.getSource();
+        SystemEnvironmentPropertySource source = new OriginAwareSystemEnvironmentPropertySource(sourceName, originalSource, environmentPrefix);
+        environment.getPropertySources().replace(sourceName, source);
+    }
+}
+���ƴ���
+```
+
+**SpringApplicationJsonEnvironmentPostProcessor**
+
+������ͨ��`java -jar -Dspring.application.json={"name":"duxiaotou"} app.jar`���� Spring Boot Ӧ�õ�ʱ�򣬸����Իᱻ�Զ����ӵ� JVM ϵͳ������ (��ʵ _-Dkey=value_ ������ʽ�����Ծ������)�����Ч��`System.setProperty(key, value)`����������`SPRING_APPLICATION_JSON`��һϵͳ����ʱ����ȻҲ����`System.getenv()`�г��֡�ǰ�������ᵽ��`System.getProperties()`��������`systemProperties`��һ _PropertySource_����`System.getenv()`���������`systemEnvironment`��һ _PropertySource_��`SpringApplicationJsonEnvironmentPostProcessor`�������ڴ������� _PropertySource_ �г�ȡ�� _spring.application.json_ �� _SPRING_APPLICATION_JSON_ �� _JSON_ �������������� _Environment_ ��׷��һ������Ϊ`spring.application.json`�� _PropertySource_����`JsonPropertySource`��
+
+**ConfigDataEnvironmentPostProcessor**
+
+`ConfigDataEnvironmentPostProcessor`����`optional:classpath:/`��`optional:classpath:/config/`��`optional:file:./`��`optional:file:./config/`��`optional:file:./config/*/`��ЩĿ¼�µ� _application.properties_ �����ļ����س����������ָ���� _spring.profiles.active_�Ļ���ͬʱҲ�Ὣ��ЩĿ¼�µ� _application-{profile}.properties_ �����ļ����س��������գ�_ConfigDataEnvironmentPostProcessor_ ������ _Environment_ ��׷������`OriginTrackedMapPropertySource`������ _PropertySource_ λ�� _Environment_ ��β�������� _application-{profile}.properties_ �������� _OriginTrackedMapPropertySource_ ������ _application.properties_ �������� _OriginTrackedMapPropertySource_ ǰ��ģ���һ��ͦ��Ҫ��
+
+## 3 jasypt ����ԭ�����
+
+> `jasypt`�����������`jasypt-spring-boot-starter`�Dz�ͬ����д�ģ�����ֻ��Ϊ jasypt ��������� Spring Boot ��������������ѡ���������������ʵ������������������
+
+_application.properties_ �����ļ��й�������Դ��������һ�����ܺ�����ģ����£�
+
+```
+spring.datasource.hikari.password=ENC(4+t9a5QG8NkNdWVS6UjIX3dj18UtYRMqU6eb3wUKjivOiDHFLZC/RTK7HuWWkUtV)
+���ƴ���
+```
+
+��`HikariDataSource`��������������󣬸� Bean �� _password_ �ֶε�ֵզ�ͱ�Ϊ���ܺ�� _qwe@1234_ ��һ�������أ���Ȼ��Spring Boot Ϊ _Environment_ �ṩ��`EnvironmentPostProcessor`��һ��չ�����ʵ��͵�컻�գ�������û������������ʹ���� Spring �е�һ�� _IoC ��չ��_����`BeanFactoryPostProcessor`����Ҳ����ȫ���Եģ���Ϊ��ִ�е� _BeanFactoryPostProcessor_ �е�`postProcessBeanFactory()`�߼�ʱ��ֻ�����������`BeanDefinition`�ļ��أ�����û��ʵ���� _BeanDefinition_ ��������Ӧ�� Bean��
+
+���濴һ��`EnableEncryptablePropertiesBeanFactoryPostProcessor`�е����ݣ�
+
+```
+public class EnableEncryptablePropertiesBeanFactoryPostProcessor implements BeanFactoryPostProcessor, Ordered {
+
+    private final ConfigurableEnvironment environment;
+    private final EncryptablePropertySourceConverter converter;
+
+    public EnableEncryptablePropertiesBeanFactoryPostProcessor(ConfigurableEnvironment environment, EncryptablePropertySourceConverter converter) {
+        this.environment = environment;
+        this.converter = converter;
+    }
+
+    @Override
+    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
+        MutablePropertySources propSources = environment.getPropertySources();
+        converter.convertPropertySources(propSources);
+    }
+
+    @Override
+    public int getOrder() {
+        return Ordered.LOWEST_PRECEDENCE - 100;
+    }
+}
+���ƴ���
+```
+
+����Դ������� _BeanFactoryPostProcessor_ ����`EncryptablePropertySourceConverter`�� _MutablePropertySources_ ����һ��ת������ôת����ɶ���أ�
+
+���ţ����� _EncryptablePropertySourceConverter_�������������£�
+
+```
+public class EncryptablePropertySourceConverter {
+
+    public void convertPropertySources(MutablePropertySources propSources) {
+        propSources.stream()
+                .filter(ps -> !(ps instanceof EncryptablePropertySource))
+                .map(this::makeEncryptable)
+                .collect(toList())
+                .forEach(ps -> propSources.replace(ps.getName(), ps));
+    }
+
+    public <T> PropertySource<T> makeEncryptable(PropertySource<T> propertySource) {
+        if (propertySource instanceof EncryptablePropertySource 
+                || skipPropertySourceClasses.stream().anyMatch(skipClass -> skipClass.equals(propertySource.getClass()))) {
+            return propertySource;
+        }
+        PropertySource<T> encryptablePropertySource = convertPropertySource(propertySource);
+        return encryptablePropertySource;
+    }
+
+    private <T> PropertySource<T> convertPropertySource(PropertySource<T> propertySource) {
+        PropertySource<T> encryptablePropertySource;
+        if (propertySource instanceof SystemEnvironmentPropertySource) {
+            encryptablePropertySource = (PropertySource<T>) new EncryptableSystemEnvironmentPropertySourceWrapper((SystemEnvironmentPropertySource) propertySource, propertyResolver, propertyFilter);
+        } else if (propertySource instanceof MapPropertySource) {
+            encryptablePropertySource = (PropertySource<T>) new EncryptableMapPropertySourceWrapper((MapPropertySource) propertySource, propertyResolver, propertyFilter);
+        } else if (propertySource instanceof EnumerablePropertySource) {
+            encryptablePropertySource = new EncryptableEnumerablePropertySourceWrapper<>((EnumerablePropertySource) propertySource, propertyResolver, propertyFilter);
+        } else {
+            encryptablePropertySource = new EncryptablePropertySourceWrapper<>(propertySource, propertyResolver, propertyFilter);
+        }
+        return encryptablePropertySource;
+    }
+}
+���ƴ���
+```
+
+��Ȼ���������ԭ�� _PropertySource_ ת��Ϊ��һ��`EncryptablePropertySourceWrapper`��������϶�����ʵ�����Ľ��ܣ�����ģ�
+
+����������`EncryptablePropertySourceWrapper`���������£�
+
+```
+public class EncryptablePropertySourceWrapper<T> extends PropertySource<T> implements EncryptablePropertySource<T> {
+    private final CachingDelegateEncryptablePropertySource<T> encryptableDelegate;
+
+    public EncryptablePropertySourceWrapper(PropertySource<T> delegate, EncryptablePropertyResolver resolver, EncryptablePropertyFilter filter) {
+        super(delegate.getName(), delegate.getSource());
+        encryptableDelegate = new CachingDelegateEncryptablePropertySource<>(delegate, resolver, filter);
+    }
+
+    @Override
+    public Object getProperty(String name) {
+        return encryptableDelegate.getProperty(name);
+    }
+
+    @Override
+    public PropertySource<T> getDelegate() {
+        return encryptableDelegate;
+    }
+}
+���ƴ���
+```
+
+ʧ����û����ɶ�����߼��������� _getProperty_ ��������������������߼�ί�ɸ���`CachingDelegateEncryptablePropertySource`��
+
+û�취��ֻ�ܵ� _CachingDelegateEncryptablePropertySource_ ��һ̽�����ˣ�
+
+```
+public class CachingDelegateEncryptablePropertySource<T> extends PropertySource<T> implements EncryptablePropertySource<T> {
+    private final PropertySource<T> delegate;
+    private final EncryptablePropertyResolver resolver;
+    private final EncryptablePropertyFilter filter;
+    private final Map<String, Object> cache;
+
+    public CachingDelegateEncryptablePropertySource(PropertySource<T> delegate, EncryptablePropertyResolver resolver, EncryptablePropertyFilter filter) {
+        super(delegate.getName(), delegate.getSource());
+        this.delegate = delegate;
+        this.resolver = resolver;
+        this.filter = filter;
+        this.cache = new HashMap<>();
+    }
+
+    @Override
+    public PropertySource<T> getDelegate() {
+        return delegate;
+    }
+
+    @Override
+    public Object getProperty(String name) {
+        if (cache.containsKey(name)) {
+            return cache.get(name);
+        }
+        synchronized (name.intern()) {
+            if (!cache.containsKey(name)) {
+                Object resolved = getProperty(resolver, filter, delegate, name);
+                if (resolved != null) {
+                    cache.put(name, resolved);
+                }
+            }
+            return cache.get(name);
+        }
+    }
+}
+���ƴ���
+```
+
+���ڣ�������`EncryptablePropertySource`�п����˽��ܵ������߼������У�`EncryptablePropertyDetector`����̽����������Ƿ���Ҫ������ܣ���Ҫͨ���жϸ�����ֵ�Ƿ���`ENC()`������
+
+```
+public interface EncryptablePropertySource<T> extends OriginLookup<String> {
+    default Object getProperty(EncryptablePropertyResolver resolver, EncryptablePropertyFilter filter, PropertySource<T> source, String name) {
+        Object value = source.getProperty(name);
+        if (value != null && filter.shouldInclude(source, name) && value instanceof String) {
+            String stringValue = String.valueOf(value);
+            return resolver.resolvePropertyValue(stringValue);
+        }
+        return value;
+    }
+}
+
+public class DefaultPropertyResolver implements EncryptablePropertyResolver {
+
+    private final Environment environment;
+    private StringEncryptor encryptor;
+    private EncryptablePropertyDetector detector;
+
+    @Override
+    public String resolvePropertyValue(String value) {
+        return Optional.ofNullable(value)
+                .map(environment::resolvePlaceholders)
+                .filter(detector::isEncrypted)
+                .map(resolvedValue -> {
+                    try {
+                        String unwrappedProperty = detector.unwrapEncryptedValue(resolvedValue.trim());
+                        String resolvedProperty = environment.resolvePlaceholders(unwrappedProperty);
+                        return encryptor.decrypt(resolvedProperty);
+                    } catch (EncryptionOperationNotPossibleException e) {
+                        throw new DecryptionException("Unable to decrypt property: " + value + " resolved to: " + resolvedValue + ". Decryption of Properties failed,  make sure encryption/decryption " +
+                                "passwords match", e);
+                    }
+                })
+                .orElse(value);
+    }
+}
+���ƴ���
+```
+
+## 4 �ܽ�
+
+�ܽ��Ե����־Ͳ���˵�ˣ�����������˼Ȫӿ����������ˮ300�֡����ϣ����Ҽ�ס�ڵ�ǰ Spring Boot �汾�У���`ApplicationServletEnvironment`���� _Environment_�������ս�ί��`ConfigurationPropertySourcesPropertyResolver`ȥ��ȡ����ֵ��
+
+
+
+���ߣ�����Գ��Сͷ
+���ӣ�https://juejin.cn/post/7098299623759937543
+��Դ��ϡ�����
+����Ȩ���������С���ҵת������ϵ���߻����Ȩ������ҵת����ע��������
+
+# �����
+
+https://www.w3cschool.cn/wkspring
+https://www.runoob.com/w3cnote/basic-knowledge-summary-of-spring.html
+http://codepub.cn/2015/06/21/Basic-knowledge-summary-of-Spring
+https://dunwu.github.io/spring-tutorial
+https://mszlu.com/java/spring
+http://c.biancheng.net/spring/aop-module.html
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\347\232\204\344\272\213\344\273\266\345\244\204\347\220\206\346\234\272\345\210\266.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\347\232\204\344\272\213\344\273\266\345\244\204\347\220\206\346\234\272\345\210\266.md"
new file mode 100644
index 0000000..98c55c3
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\347\232\204\344\272\213\344\273\266\345\244\204\347\220\206\346\234\272\345\210\266.md"
@@ -0,0 +1,270 @@
+
+
+
+
+# Spring �е��¼�����
+
+
+
+2022-05-16 15:29 ����
+
+
+
+
+
+
+
+
+
+## Spring �е��¼�����
+
+���Ѿ��������������½��� Spring �ĺ����� **ApplicationContext**����������� beans �������������ڡ������� beans ʱ��ApplicationContext ����ijЩ���͵��¼������磬������������ʱ��ContextStartedEvent ��������������ֹͣʱ��ContextStoppedEvent ������
+
+ͨ�� ApplicationEvent ��� ApplicationListener �ӿ����ṩ�� ApplicationContext �д����¼������һ�� bean ʵ�� ApplicationListener����ôÿ�� ApplicationEvent �������� ApplicationContext �ϣ��Ǹ� bean �ᱻ֪ͨ��
+
+Spring �ṩ�����µı�׼�¼���
+
+| ��� | Spring �����¼� & ���� |
+| --- | --- |
+| 1 | **ContextRefreshedEvent**ApplicationContext ����ʼ����ˢ��ʱ�����¼�����������Ҳ������ ConfigurableApplicationContext �ӿ���ʹ�� refresh() ������������ |
+| 2 | **ContextStartedEvent**��ʹ�� ConfigurableApplicationContext �ӿ��е� start() �������� ApplicationContext ʱ�����¼�������������Ե���������ݿ⣬����������ڽ��ܵ�����¼��������κ�ֹͣ��Ӧ�ó��� |
+| 3 | **ContextStoppedEvent**��ʹ�� ConfigurableApplicationContext �ӿ��е� stop() ����ֹͣ ApplicationContext ʱ����������¼���������ڽ��ܵ�����¼�������Ҫ�������Ĺ����� |
+| 4 | **ContextClosedEvent**��ʹ�� ConfigurableApplicationContext �ӿ��е� close() �����ر� ApplicationContext ʱ�����¼���������һ���ѹرյ������ĵ�����������ĩ�ˣ������ܱ�ˢ�»������� |
+| 5 | **RequestHandledEvent**����һ�� web-specific �¼����������� bean HTTP �����Ѿ������� |
+
+���� Spring ���¼������ǵ��̵߳ģ��������һ���¼���������ֱ�����ҳ������еĽ����ߵõ��ĸ���Ϣ���ý��̱������������̽������������ˣ�����¼�������ʹ�ã������Ӧ�ó���ʱӦע�⡣
+
+## �����������¼�
+
+Ϊ�˼����������¼���һ�� bean Ӧ��ʵ��ֻ��һ������ **onApplicationEvent()** �� ApplicationListener �ӿڡ���ˣ�����дһ�������������¼�����δ����ģ��Լ���ο����ô�����ִ�л���ijЩ�¼����������
+
+��������ǡ����λ��ʹ�� Eclipse IDE��Ȼ��������IJ���������һ�� Spring Ӧ�ó���
+
+| ���� | ���� |
+| --- | --- |
+| 1 | ����һ������Ϊ SpringExample ����Ŀ�������ڴ�����Ŀ�� **src** �ļ����д���һ���� com.tutorialspoint�� |
+| 2 | ʹ�� Add External JARs ѡ���������� Spring �⣬���ͼ� Spring Hello World Example �½ڡ� |
+| 3 | �� com.tutorialspoint ����� Java �� HelloWorld��CStartEventHandler��CStopEventHandler �� MainApp�� |
+| 4 | �� **src** �ļ����д��� Bean �������ļ� Beans.xml�� |
+| 5 | ���һ���Ǵ��������� Java �ļ��� Bean �����ļ������ݣ�������Ӧ�ó��򣬽���������ʾ�� |
+
+������ **HelloWorld.java** �ļ������ݣ�
+
+```
+package com.tutorialspoint;
+public class HelloWorld {
+   private String message;
+   public void setMessage(String message){
+      this.message  = message;
+   }
+   public void getMessage(){
+      System.out.println("Your Message : " + message);
+   }
+}
+```
+
+������ **CStartEventHandler.java** �ļ������ݣ�
+
+```
+package com.tutorialspoint;
+import org.springframework.context.ApplicationListener;
+import org.springframework.context.event.ContextStartedEvent;
+public class CStartEventHandler 
+   implements ApplicationListener<ContextStartedEvent>{
+   public void onApplicationEvent(ContextStartedEvent event) {
+      System.out.println("ContextStartedEvent Received");
+   }
+}
+```
+
+������ **CStopEventHandler.java** �ļ������ݣ�
+
+```
+package com.tutorialspoint;
+import org.springframework.context.ApplicationListener;
+import org.springframework.context.event.ContextStoppedEvent;
+public class CStopEventHandler 
+   implements ApplicationListener<ContextStoppedEvent>{
+   public void onApplicationEvent(ContextStoppedEvent event) {
+      System.out.println("ContextStoppedEvent Received");
+   }
+}
+```
+
+������ **MainApp.java** �ļ������ݣ�
+
+```
+package com.tutorialspoint;
+
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+public class MainApp {
+   public static void main(String[] args) {
+      ConfigurableApplicationContext context = 
+      new ClassPathXmlApplicationContext("Beans.xml");
+
+      // Let us raise a start event.
+      context.start();
+
+      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
+
+      obj.getMessage();
+
+      // Let us raise a stop event.
+      context.stop();
+   }
+}
+```
+
+�����������ļ� **Beans.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-3.0.xsd">
+
+   <bean id="helloWorld" class="com.tutorialspoint.HelloWorld">
+      <property name="message" value="Hello World!"/>
+   </bean>
+
+   <bean id="cStartEventHandler" 
+         class="com.tutorialspoint.CStartEventHandler"/>
+
+   <bean id="cStopEventHandler" 
+         class="com.tutorialspoint.CStopEventHandler"/>
+
+</beans>
+```
+
+һ��������˴���Դ�� bean �������ļ������ǾͿ������и�Ӧ�ó���������Ӧ�ó���һ�ж������������������Ϣ��
+
+```
+ContextStartedEvent Received
+Your Message : Hello World!
+ContextStoppedEvent Received
+```
+
+
+
+
+
+
+
+## Spring �е��Զ����¼�
+
+��д�ͷ����Լ����Զ����¼������ಽ�衣��������һ�¸�����˵������д�������ʹ����Զ��� Spring �¼���
+
+| ���� | ���� |
+| --- | --- |
+| 1 | ����һ������Ϊ SpringExample ����Ŀ�������ڴ�����Ŀ�� **src** �ļ����д���һ���� com.tutorialspoint�� |
+| 2 | ʹ�� Add External JARs ѡ���������� Spring �⣬���ͼ� Spring Hello World Example �½ڡ� |
+| 3 | ͨ����չ **ApplicationEvent**,����һ���¼��� CustomEvent���������붨��һ��Ĭ�ϵĹ��캯������Ӧ�ô� ApplicationEvent ���м̳еĹ��캯���� |
+| 4 | һ�������¼��࣬����Դ��κ����з��������ٶ� EventClassPublisher ʵ���� ApplicationEventPublisherAware���㻹��Ҫ�� XML �����ļ��������������Ϊһ�� bean��֮������������ʶ�� bean ��Ϊ�¼������ߣ�����Ϊ��ʵ���� ApplicationEventPublisherAware �ӿڡ� |
+| 5 | �������¼�������һ�����б��������ٶ� EventClassHandler ʵ���� ApplicationListener �ӿڣ�����ʵ�����Զ����¼��� onApplicationEvent ������ |
+| 6 | �� **src** �ļ����д��� bean �������ļ� Beans.xml �� MainApp �࣬��������Ϊһ�� Spring Ӧ�ó��������С� |
+| 7 | ���һ���Ǵ��������� Java �ļ��� Bean �����ļ������ݣ�������Ӧ�ó��򣬽���������ʾ�� |
+
+����� **CustomEvent.java** �ļ������ݣ�
+
+```
+package com.tutorialspoint;
+import org.springframework.context.ApplicationEvent;
+public class CustomEvent extends ApplicationEvent{ 
+   public CustomEvent(Object source) {
+      super(source);
+   }
+   public String toString(){
+      return "My Custom Event";
+   }
+}
+
+```
+
+������ **CustomEventPublisher.java** �ļ������ݣ�
+
+```
+package com.tutorialspoint;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.context.ApplicationEventPublisherAware;
+public class CustomEventPublisher 
+   implements ApplicationEventPublisherAware {
+   private ApplicationEventPublisher publisher;
+   public void setApplicationEventPublisher
+              (ApplicationEventPublisher publisher){
+      this.publisher = publisher;
+   }
+   public void publish() {
+      CustomEvent ce = new CustomEvent(this);
+      publisher.publishEvent(ce);
+   }
+}
+```
+
+������ **CustomEventHandler.java** �ļ������ݣ�
+
+```
+package com.tutorialspoint;
+import org.springframework.context.ApplicationListener;
+public class CustomEventHandler 
+   implements ApplicationListener<CustomEvent>{
+   public void onApplicationEvent(CustomEvent event) {
+      System.out.println(event.toString());
+   }
+}
+```
+
+������ **MainApp.java** �ļ������ݣ�
+
+```
+package com.tutorialspoint;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+public class MainApp {
+   public static void main(String[] args) {
+      ConfigurableApplicationContext context = 
+      new ClassPathXmlApplicationContext("Beans.xml");    
+      CustomEventPublisher cvp = 
+      (CustomEventPublisher) context.getBean("customEventPublisher");
+      cvp.publish();  
+      cvp.publish();
+   }
+}
+```
+
+�����������ļ� **Beans.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-3.0.xsd">
+
+   <bean id="customEventHandler" 
+      class="com.tutorialspoint.CustomEventHandler"/>
+
+   <bean id="customEventPublisher" 
+      class="com.tutorialspoint.CustomEventPublisher"/>
+
+</beans>
+```
+
+һ��������˴���Դ�� bean �������ļ������ǾͿ������и�Ӧ�ó���������Ӧ�ó���һ�ж������������������Ϣ��
+
+```
+My Custom Event
+My Custom Event
+```
+
+# �����
+https://www.w3cschool.cn/wkspring
+https://www.runoob.com/w3cnote/basic-knowledge-summary-of-spring.html
+http://codepub.cn/2015/06/21/Basic-knowledge-summary-of-Spring
+https://dunwu.github.io/spring-tutorial
+https://mszlu.com/java/spring
+http://c.biancheng.net/spring/aop-module.html
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\347\232\204\350\265\204\346\272\220\347\256\241\347\220\206.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\347\232\204\350\265\204\346\272\220\347\256\241\347\220\206.md"
new file mode 100644
index 0000000..09874af
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\347\232\204\350\265\204\346\272\220\347\256\241\347\220\206.md"
@@ -0,0 +1,309 @@
+## Resource �ӿ�
+
+��Ա�׼ URL ���ʻ��ƣ�Spring �� `org.springframework.core.io.Resource` �ӿڳ����˶Եײ���Դ�ķ��ʽӿڣ��ṩ��һ�׸��õķ��ʷ�ʽ��
+
+
+
+```
+public interface Resource extends InputStreamSource {
+
+    boolean exists();
+
+    boolean isReadable();
+
+    boolean isOpen();
+
+    boolean isFile();
+
+    URL getURL() throws IOException;
+
+    URI getURI() throws IOException;
+
+    File getFile() throws IOException;
+
+    ReadableByteChannel readableChannel() throws IOException;
+
+    long contentLength() throws IOException;
+
+    long lastModified() throws IOException;
+
+    Resource createRelative(String relativePath) throws IOException;
+
+    String getFilename();
+
+    String getDescription();
+}
+
+```
+
+
+
+���� `Resource` �ӿڵĶ�����ʾ������չ�� `InputStreamSource` �ӿڡ�`Resource` ����ĵķ������£�
+
+*   `getInputStream()` - ��λ���Ҵ򿪵�ǰ��Դ�����ص�ǰ��Դ�� `InputStream`��ÿ�ε��ö��᷵��һ���µ� `InputStream`����������Ҫ����ر�����
+*   `exists()` - �жϵ�ǰ��Դ�Ƿ���Ĵ��ڡ�
+*   `isOpen()` - �жϵ�ǰ��Դ�Ƿ���һ���Ѵ򿪵� `InputStream`�����Ϊ true���� `InputStream` ���ܱ���ζ�ȡ������ֻ��ȡһ��Ȼ��ر��Ա�����Դй©�������г�����Դʵ�ַ��� false��`InputStreamResource` ���⡣
+*   `getDescription()` - ���ص�ǰ��Դ����������������Դ����ʱ����Դ�����������ڴ�����Ϣ�������һ����˵����Դ��������һ����ȫ�޶����ļ����ƣ������ǵ�ǰ��Դ����ʵ URL��
+
+���� Spring ��Դ�ӿڣ�
+
+| ���� | �ӿ� |
+| --- | --- |
+| ������ | `org.springframework.core.io.InputStreamSource` |
+| ֻ����Դ | `org.springframework.core.io.Resource` |
+| ��д��Դ | `org.springframework.core.io.WritableResource` |
+| ������Դ | `org.springframework.core.io.support.EncodedResource` |
+| ��������Դ | `org.springframework.core.io.ContextResource` |
+
+
+
+![](https://raw.githubusercontent.com/dunwu/images/dev/snap/20221223155859.png)
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/a1549f/#%E5%86%85%E7%BD%AE%E7%9A%84-resource-%E5%AE%9E%E7%8E%B0)���õ� Resource ʵ��
+
+Spring �����������õ� Resource ʵ�֣�
+
+| ��Դ��Դ | ǰ׺ | ˵�� |
+| --- | --- | --- |
+| [`UrlResource`(opens new window)](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-urlresource) | `file:`��`https:`��`ftp:` �� | `UrlResource` ��װ��һ�� `java.net.URL` ����**���ڷ��ʿ�ͨ�� URL ���ʵ��κζ���**�������ļ���HTTPS Ŀ�ꡢFTP Ŀ��ȡ����� URL ������ͨ����׼�����ַ�����ʽ��ʾ����˿���ʹ���ʵ��ı�׼��ǰ׺��ָʾһ�� URL ��������һ�� URL ���͵����� �������`file`�����ڷ����ļ�ϵͳ·����`https`������ͨ�� HTTPS Э�������Դ��`ftp`������ͨ�� FTP ������Դ�ȵȡ� |
+| [`ClassPathResource`(opens new window)](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-classpathresource) | `classpath:` | `ClassPathResource` **����·���ϼ�����Դ**����ʹ���߳������ļ����������������������ָ���� class �����е�����һ����������Դ�� |
+| [`FileSystemResource`(opens new window)](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-filesystemresource) | `file:` | `FileSystemResource` **�� `java.io.File` ����Դʵ��**������֧�� `java.nio.file.Path` ��Ӧ�� Spring �ı�׼���ַ���·������ת����`FileSystemResource` ֧�ֽ���Ϊ�ļ��� URL�� |
+| [`PathResource`(opens new window)](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-pathresource) | �� | `PathResource` �� `java.nio.file.Path` ����Դʵ�֡� |
+| [`ServletContextResource`(opens new window)](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-servletcontextresource) | �� | `ServletContextResource` **�� `ServletContext` ����Դʵ��**������ʾ��Ӧ Web Ӧ�ó����Ŀ¼�е����·���� |
+| [`InputStreamResource`(opens new window)](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-inputstreamresource) | �� | `InputStreamResource` **��ָ�� `InputStream` ����Դʵ��**��ע�⣺����� `InputStream` �ѱ��򿪣��򲻿��Զ�ζ�ȡ������ |
+| [`ByteArrayResource`(opens new window)](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-bytearrayresource) | �� | `ByteArrayResource` ��ָ���Ķ������������Դʵ�֡�����Ϊ�������ֽ����鴴��һ�� `ByteArrayInputStream`�� |
+
+
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/a1549f/#resourceloader-%E6%8E%A5%E5%8F%A3)ResourceLoader �ӿ�
+
+`ResourceLoader` �ӿ����ڼ��� `Resource` �����䶨�����£�
+
+
+
+```
+public interface ResourceLoader {
+
+    Resource getResource(String location);
+
+    ClassLoader getClassLoader();
+}
+
+```
+
+
+
+Spring ����Ҫ�� ResourceLoader ʵ�֣�
+
+![](https://raw.githubusercontent.com/dunwu/images/dev/snap/20221223164745.png)
+
+Spring �У����е� `ApplicationContext` ��ʵ���� `ResourceLoader` �ӿڡ���ˣ����� `ApplicationContext` ������ͨ�� `getResource()` ������ȡ `Resource` ʵ����
+
+��ʾ����
+
+
+
+```
+// ���û��ָ����Դǰ׺��Spring �᳢�Է��غ��ʵ���Դ
+Resource template = ctx.getResource("some/resource/path/myTemplate.txt");
+// ���ָ�� classpath: ǰ׺��Spring ��ǿ��ʹ�� ClassPathResource
+Resource template = ctx.getResource("classpath:some/resource/path/myTemplate.txt");
+// ���ָ�� file:��http �� URL ǰ׺��Spring ��ǿ��ʹ�� UrlResource
+Resource template = ctx.getResource("file:///some/resource/path/myTemplate.txt");
+Resource template = ctx.getResource("http://myhost.com/resource/path/myTemplate.txt");
+
+```
+
+
+
+�±��о��� Spring ���ݸ���λ��·��������Դ�IJ��ԣ�
+
+| ǰ׺ | ���� | ˵�� |
+| --- | --- | --- |
+| `classpath:` | `classpath:com/myapp/config.xml` | ����·������ |
+| `file:` | `file:///data/config.xml` | �� URL ��ʽ���ļ�ϵͳ���� |
+| `http:` | `http://myserver/logo.png` | �� URL ��ʽ���� |
+| �� | `/data/config.xml` | �ɵײ�� ApplicationContext ʵ�־��� |
+
+
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/a1549f/#resourcepatternresolver-%E6%8E%A5%E5%8F%A3)ResourcePatternResolver �ӿ�
+
+`ResourcePatternResolver` �ӿ��� `ResourceLoader` �ӿڵ���չ�����������Ƕ�����ԣ�����λ��ģʽ���� `Resource` ����
+
+
+
+```
+public interface ResourcePatternResolver extends ResourceLoader {
+
+    String CLASSPATH_ALL_URL_PREFIX = "classpath*:";
+
+    Resource[] getResources(String locationPattern) throws IOException;
+}
+
+```
+
+
+
+`PathMatchingResourcePatternResolver` ��һ��������ʵ�֣������� `ApplicationContext` ֮��ʹ�ã�Ҳ���Ա� `ResourceArrayPropertyEditor` ������� `Resource[]` bean ���ԡ�`PathMatchingResourcePatternResolver` �ܹ���ָ������Դλ��·������Ϊһ������ƥ��� `Resource` ����
+
+> ע�⣺�κα�׼ `ApplicationContext` �е�Ĭ�� `ResourceLoader` ʵ������ `PathMatchingResourcePatternResolver` ��һ��ʵ������ʵ���� `ResourcePatternResolver` �ӿڡ�
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/a1549f/#resourceloaderaware-%E6%8E%A5%E5%8F%A3)ResourceLoaderAware �ӿ�
+
+`ResourceLoaderAware` �ӿ���һ������Ļص��ӿڣ���������ṩ `ResourceLoader` ���õĶ���`ResourceLoaderAware` �ӿڶ������£�
+
+
+
+```
+public interface ResourceLoaderAware {
+    void setResourceLoader(ResourceLoader resourceLoader);
+}
+
+```
+
+
+
+��һ����ʵ�� `ResourceLoaderAware` ������Ӧ�ó����������У���Ϊ Spring ������ bean��ʱ�����ᱻӦ�ó���������ʶ��Ϊ `ResourceLoaderAware`��Ȼ��Ӧ�ó��������Ļ���� `setResourceLoader(ResourceLoader)`����������Ϊ�����ṩ�����ס��Spring �е�����Ӧ�ó��������Ķ�ʵ�� `ResourceLoader` �ӿڣ���
+
+���� `ApplicationContext` ��һ�� `ResourceLoader`���� bean ������ʵ�� `ApplicationContextAware` �ӿڲ�ֱ��ʹ���ṩ��Ӧ�ó�����������������Դ�� ���ǣ�һ����˵�������ֻ��Ҫ��Щ�����ʹ��ר�ŵ� `ResourceLoader` �ӿڡ� �ô��뽫����ϵ���Դ���ؽӿڣ����Ա���Ϊʵ�ó���ӿڣ���������ϵ����� Spring `ApplicationContext` �ӿڡ�
+
+��Ӧ�ó����У�������ʹ�� `ResourceLoader` ���Զ�װ����Ϊʵ�� `ResourceLoaderAware` �ӿڵ������������ͳ�Ĺ��캯���� `byType` �Զ�װ��ģʽ�ܹ��ֱ�Ϊ���캯�������� setter ���������ṩ `ResourceLoader`�� Ϊ�˻�ø��������ԣ������Զ�װ���ֶκͶ�������������������뿼��ʹ�û���ע����Զ�װ�书�ܡ� ����������£�`ResourceLoader` ���Զ����ӵ���Ҫ `ResourceLoader` ���͵��ֶΡ����캯�������򷽷������У�ֻҪ����ֶΡ����캯���򷽷����� `@Autowired` ע�⼴�ɡ�
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/a1549f/#%E8%B5%84%E6%BA%90%E4%BE%9D%E8%B5%96)��Դ����
+
+��� bean ����Ҫͨ��ij�ֶ�̬������ȷ�����ṩ��Դ·������ô bean ����ʹ�� `ResourceLoader` �� `ResourcePatternResolver` �ӿ���������Դ�� ���磬���Ǽ���ij��ģ�壬����������ض���Դȡ�����û��Ľ�ɫ�� �����Դ�Ǿ�̬�ģ���ȫ���� `ResourceLoader` �ӿڣ��� `ResourcePatternResolver` �ӿڣ���ʹ�ã��� bean ��������Ҫ�� `Resource` ���ԣ�������������ע��������������ġ�
+
+ʹע����Щ���Ա�ü򵥵�ԭ��������Ӧ�ó��������Ķ�ע�Ტʹ��һ������� JavaBeans `PropertyEditor`�������Խ� `String` ·��ת��Ϊ `Resource` ���� ���磬����� MyBean ����һ�� `Resource` ���͵�ģ�����ԡ�
+
+��ʾ����
+
+
+
+```
+<bean id="myBean" class="example.MyBean">
+    <property name="template" value="some/resource/path/myTemplate.txt"/>
+</bean>
+
+```
+
+
+
+��ע�⣬���������õ�ģ����Դ·��û��ǰ׺����ΪӦ�ó��������ı��������� `ResourceLoader`����Դ������������Ҫͨ�� `ClassPathResource`��`FileSystemResource` �� ServletContextResource ���أ�����ȡ���������ĵ�ȷ�����͡�
+
+�����Ҫǿ��ʹ���ض�����Դ���ͣ������ʹ��ǰ׺�� ��������ʾ����ʾ���ǿ��ʹ�� `ClassPathResource` �� `UrlResource`���������ڷ����ļ�ϵͳ�ļ�����
+
+
+
+```
+<property name="template" value="classpath:some/resource/path/myTemplate.txt">
+<property name="template" value="file:///some/resource/path/myTemplate.txt"/>
+
+```
+
+
+
+����ͨ�� `@Value` ע�������Դ�ļ� `myTemplate.txt`��ʾ�����£�
+
+
+
+```
+@Component
+public class MyBean {
+
+    private final Resource template;
+
+    public MyBean(@Value("${template.path}") Resource template) {
+        this.template = template;
+    }
+
+    // ...
+}
+
+```
+
+
+
+Spring �� `PropertyEditor` �������Դ�ļ���·���ַ��������� `Resource` ���󣬲�����ע�뵽 MyBean �Ĺ��췽����
+
+�����Ҫ���ض����Դ�ļ�������ʹ�� `classpath*:` ǰ׺�����磺`classpath*:/config/templates/*.txt`��
+
+
+
+```
+@Component
+public class MyBean {
+
+    private final Resource[] templates;
+
+    public MyBean(@Value("${templates.path}") Resource[] templates) {
+        this.templates = templates;
+    }
+
+    // ...
+}
+
+```
+
+
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/a1549f/#%E5%BA%94%E7%94%A8%E4%B8%8A%E4%B8%8B%E6%96%87%E5%92%8C%E8%B5%84%E6%BA%90%E8%B7%AF%E5%BE%84)Ӧ�������ĺ���Դ·��
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/a1549f/#%E6%9E%84%E9%80%A0%E5%BA%94%E7%94%A8%E4%B8%8A%E4%B8%8B%E6%96%87)����Ӧ��������
+
+Ӧ�������Ĺ��캯��������ض���Ӧ�����������ͣ�ͨ�����ַ������ַ���������Ϊ��Դ��λ��·�������繹�������Ķ���� XML �ļ���
+
+��ʾ����
+
+
+
+```
+ApplicationContext ctx = new ClassPathXmlApplicationContext("conf/appContext.xml");
+ApplicationContext ctx = new FileSystemXmlApplicationContext("conf/appContext.xml");
+ApplicationContext ctx = new FileSystemXmlApplicationContext("classpath:conf/appContext.xml");
+ApplicationContext ctx = new ClassPathXmlApplicationContext(
+                new String[] {"services.xml", "daos.xml"}, MessengerService.class);
+
+```
+
+
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/a1549f/#%E4%BD%BF%E7%94%A8%E9%80%9A%E9%85%8D%E7%AC%A6%E6%9E%84%E9%80%A0%E5%BA%94%E7%94%A8%E4%B8%8A%E4%B8%8B%E6%96%87)ʹ��ͨ�������Ӧ��������
+
+ApplicationContext ���������е���Դ·�������ǵ�һ��·������һ��һ��ӳ�䵽Ŀ����Դ����Ҳ������ͨ�����ʽ�����ɰ��� classpath*��Ҳ������ǰ׺�� ant �����������ʽ��ʹ�� spring �� PathMatcher ��ƥ�䣩��
+
+ʾ����
+
+
+
+```
+ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath*:conf/appContext.xml");
+
+```
+
+
+
+ʹ�� `classpath*` ��ʾ��·��������ƥ���ļ����Ƶ���Դ���ᱻ��ȡ(�����Ͼ��ǵ����� ClassLoader.getResources(��) �����������Ž���ȡ������Դ��װ�����յ�Ӧ�������ġ�
+
+��λ��·�������ಿ�֣�`classpath*:` ǰ׺������ PathMatcher ���ʹ�ã��磺`classpath*:META-INF/*-beans.xml`��
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/a1549f/#%E9%97%AE%E9%A2%98)����
+
+Spring ������Դ������Щ�������ͣ�
+
+*   XML ��Դ
+*   Properties ��Դ
+*   YAML ��Դ
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/a1549f/#%E5%8F%82%E8%80%83%E8%B5%84%E6%96%99)�����
+
+*   [Spring �ٷ��ĵ�֮ Core Technologies(opens new window)](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans)
+*   [��С���署 Spring ���ı��˼�롷](https://time.geekbang.org/course/intro/265)
+
+# �����
+https://www.w3cschool.cn/wkspring
+https://www.runoob.com/w3cnote/basic-knowledge-summary-of-spring.html
+http://codepub.cn/2015/06/21/Basic-knowledge-summary-of-Spring
+https://dunwu.github.io/spring-tutorial
+https://mszlu.com/java/spring
+http://c.biancheng.net/spring/aop-module.html
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\347\232\204\351\205\215\347\275\256\345\205\203\346\225\260\346\215\256\357\274\210\347\256\241\347\220\206\351\205\215\347\275\256\347\232\204\345\237\272\346\234\254\346\225\260\346\215\256\357\274\211.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\347\232\204\351\205\215\347\275\256\345\205\203\346\225\260\346\215\256\357\274\210\347\256\241\347\220\206\351\205\215\347\275\256\347\232\204\345\237\272\346\234\254\346\225\260\346\215\256\357\274\211.md"
new file mode 100644
index 0000000..4515cad
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\270\255\347\232\204\351\205\215\347\275\256\345\205\203\346\225\260\346\215\256\357\274\210\347\256\241\347\220\206\351\205\215\347\275\256\347\232\204\345\237\272\346\234\254\346\225\260\346\215\256\357\274\211.md"
@@ -0,0 +1,298 @@
+
+
+# Spring ����Ԫ����
+
+
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#spring-%E9%85%8D%E7%BD%AE%E5%85%83%E4%BF%A1%E6%81%AF)Spring ����Ԫ��Ϣ
+
+*   Spring Bean ����Ԫ��Ϣ - BeanDefinition
+*   Spring Bean ����Ԫ��Ϣ - PropertyValues
+*   Spring ��������Ԫ��Ϣ
+*   Spring �ⲿ������Ԫ��Ϣ - PropertySource
+*   Spring Profile Ԫ��Ϣ - @Profile
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#spring-bean-%E9%85%8D%E7%BD%AE%E5%85%83%E4%BF%A1%E6%81%AF)Spring Bean ����Ԫ��Ϣ
+
+Bean ����Ԫ��Ϣ - BeanDefinition
+
+*   GenericBeanDefinition��ͨ���� BeanDefinition
+*   RootBeanDefinition���� Parent �� BeanDefinition ���ߺϲ��� BeanDefinition
+*   AnnotatedBeanDefinition��ע���ע�� BeanDefinition
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#spring-bean-%E5%B1%9E%E6%80%A7%E5%85%83%E4%BF%A1%E6%81%AF)Spring Bean ����Ԫ��Ϣ
+
+*   Bean ����Ԫ��Ϣ - PropertyValues
+    *   ���޸�ʵ�� - MutablePropertyValues
+    *   Ԫ�س�Ա - PropertyValue
+*   Bean ���������Ĵ洢 - AttributeAccessor
+*   Bean Ԫ��ϢԪ�� - BeanMetadataElement
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#spring-%E5%AE%B9%E5%99%A8%E9%85%8D%E7%BD%AE%E5%85%83%E4%BF%A1%E6%81%AF)Spring ��������Ԫ��Ϣ
+
+Spring XML ����Ԫ��Ϣ - beans Ԫ�����
+
+| beans Ԫ������ | Ĭ��ֵ | ʹ�ó��� |
+| --- | --- | --- |
+| profile | null�����գ� | Spring Profiles ����ֵ |
+| default-lazy-init | default | �� outter beans ��default-lazy-init�� ���Դ���ʱ���̳и�ֵ������Ϊ��false�� |
+| default-merge | default | �� outter beans ��default-merge�� ���Դ���ʱ���̳и�ֵ������Ϊ��false�� |
+| default-autowire | default | �� outter beans ��default-autowire�� ���Դ���ʱ���̳и�ֵ������Ϊ��no�� |
+| default-autowire-candidates | null�����գ� | Ĭ�� Spring Beans ���� pattern |
+| default-init-method | null�����գ� | Ĭ�� Spring Beans �Զ����ʼ������ |
+| default-destroy-method | null�����գ� | Ĭ�� Spring Beans �Զ������ٷ��� |
+
+Spring XML ����Ԫ��Ϣ - Ӧ�����������
+
+| XML Ԫ�� | ʹ�ó��� |
+| --- | --- |
+| `<context:annotation-config />` | ���� Spring ע������ |
+| `<context:component-scan />` | Spring @Component �Լ��Զ���ע��ɨ�� |
+| `<context:load-time-weaver />` | ���� Spring LoadTimeWeaver |
+| `<context:mbean-export />` | ��¶ Spring Beans ��Ϊ JMX Beans |
+| `<context:mbean-server />` | ����ǰƽ̨��Ϊ MBeanServer |
+| `<context:property-placeholder />` | �����ⲿ��������Դ��Ϊ Spring ������ |
+| `<context:property-override />` | �����ⲿ��������Դ���� Spring �� |
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#%E5%9F%BA%E4%BA%8E-xml-%E6%96%87%E4%BB%B6%E8%A3%85%E8%BD%BD-spring-bean-%E9%85%8D%E7%BD%AE%E5%85%83%E4%BF%A1%E6%81%AF)���� XML �ļ�װ�� Spring Bean ����Ԫ��Ϣ
+
+�ײ�ʵ�� - XmlBeanDefinitionReader
+
+| XML Ԫ�� | ʹ�ó��� |
+| --- | --- |
+| `<beans:beans />` | �� XML ��Դ�µĶ�� Spring Beans ���� |
+| `<beans:bean />` | ���� Spring Bean ���壨BeanDefinition������ |
+| `<beans:alias />` | Ϊ Spring Bean ���壨BeanDefinition��ӳ����� |
+| `<beans:import />` | �����ⲿ Spring XML ������Դ |
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#%E5%9F%BA%E4%BA%8E-properties-%E6%96%87%E4%BB%B6%E8%A3%85%E8%BD%BD-spring-bean-%E9%85%8D%E7%BD%AE%E5%85%83%E4%BF%A1%E6%81%AF)���� Properties �ļ�װ�� Spring Bean ����Ԫ��Ϣ
+
+�ײ�ʵ�� - PropertiesBeanDefinitionReader
+
+| Properties ������ | ʹ�ó��� |
+| --- | --- |
+| `class` | Bean ��ȫ���޶��� |
+| `abstract` | �Ƿ�Ϊ����� BeanDefinition |
+| `parent` | ָ�� parent BeanDefinition ���� |
+| `lazy-init` | �Ƿ�Ϊ�ӳٳ�ʼ�� |
+| `ref` | �������� Bean ������ |
+| `scope` | ���� Bean �� scope ���� |
+| ${n} | n ��ʾ�� n+1 ������������ |
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#%E5%9F%BA%E4%BA%8E-java-%E6%B3%A8%E8%A7%A3%E8%A3%85%E8%BD%BD-spring-bean-%E9%85%8D%E7%BD%AE%E5%85%83%E4%BF%A1%E6%81%AF)���� Java ע��װ�� Spring Bean ����Ԫ��Ϣ
+
+Spring ģʽע��
+
+| Spring ע�� | ����˵�� | ��ʼ�汾 |
+| --- | --- | --- |
+| `@Repository` | ���ݲִ�ģʽע�� | 2.0 |
+| `@Component` | ͨ�����ģʽע�� | 2.5 |
+| `@Service` | ����ģʽע�� | 2.5 |
+| `@Controller` | Web ������ģʽע�� | 2.5 |
+| `@Configuration` | ������ģʽע�� | 3.0 |
+
+Spring Bean ����ע��
+
+| Spring ע�� | ����˵�� | ��ʼ�汾 |
+| --- | --- | --- |
+| `@Bean` | �滻 XML Ԫ�� `<bean>` | 3.0 |
+| `@DependsOn` | ��� XML ���� `<bean depends-on="..."/>` | 3.0 |
+| `@Lazy` | ��� XML ���� `<bean lazy-init="true | falses" />` | 3.0 |
+| `@Primary` | �滻 XML Ԫ�� `<bean primary="true | false" />` | 3.0 |
+| `@Role` | �滻 XML Ԫ�� `<bean role="..." />` | 3.1 |
+| `@Lookup` | ��� XML ���� `<bean lookup-method="...">` | 4.1 |
+
+Spring Bean ����ע��ע��
+
+| Spring ע�� | ����˵�� | ��ʼ�汾 |
+| --- | --- | --- |
+| `@Autowired` | Bean ����ע�룬֧�ֶ����������ҷ�ʽ | 2.5 |
+| `@Qualifier` | ϸ���ȵ� @Autowired �������� | 2.5 |
+
+ 
+
+| Java ע�� | ����˵�� | ��ʼ�汾 |
+| --- | --- | --- |
+| @Resource | ������ @Autowired | 2.5 |
+| @Inject | ������ @Autowired | 2.5 |
+
+Spring Bean ����װ��ע��
+
+| Spring ע�� | ����˵�� | ��ʼ�汾 |
+| --- | --- | --- |
+| @Profile | ���û�����װ�� | 3.1 |
+| @Conditional | �������װ�� | 4.0 |
+
+Spring Bean �������ڻص�ע��
+
+| Spring ע�� | ����˵�� | ��ʼ�汾 |
+| --- | --- | --- |
+| @PostConstruct | �滻 XML Ԫ�� <bean init-method="..."></bean>�� InitializingBean | 2.5 |
+| @PreDestroy | �滻 XML Ԫ�� <bean destroy-method="..."></bean>�� DisposableBean | 2.5 |
+
+Spring BeanDefinition ������ע��
+
+| Spring ע�� | ����˵�� | ��ʼ�汾 |
+| --- | --- | --- |
+| XML ��Դ | XmlBeanDefinitionReader | 1.0 |
+| Properties ��Դ | PropertiesBeanDefinitionReader | 1.0 |
+| Java ע�� | AnnotatedBeanDefinitionReader | 3.0 |
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#spring-bean-%E9%85%8D%E7%BD%AE%E5%85%83%E4%BF%A1%E6%81%AF%E5%BA%95%E5%B1%82%E5%AE%9E%E7%8E%B0)Spring Bean ����Ԫ��Ϣ�ײ�ʵ��
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#spring-xml-%E8%B5%84%E6%BA%90-beandefinition-%E8%A7%A3%E6%9E%90%E4%B8%8E%E6%B3%A8%E5%86%8C)Spring XML ��Դ BeanDefinition ������ע��
+
+���� API - XmlBeanDefinitionReader
+
+*   ��Դ - Resource
+*   �ײ� - BeanDefinitionDocumentReader
+    *   XML ���� - Java DOM Level 3 API
+    *   BeanDefinition ���� - BeanDefinitionParserDelegate
+    *   BeanDefinition ע�� - BeanDefinitionRegistry
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#spring-properties-%E8%B5%84%E6%BA%90-beandefinition-%E8%A7%A3%E6%9E%90%E4%B8%8E%E6%B3%A8%E5%86%8C)Spring Properties ��Դ BeanDefinition ������ע��
+
+���� API - PropertiesBeanDefinitionReader
+
+*   ��Դ
+    *   �ֽ��� - Resource
+    *   �ַ��� - EncodedResouce
+*   �ײ�
+    *   �洢 - java.util.Properties
+    *   BeanDefinition ���� - API �ڲ�ʵ��
+    *   BeanDefinition ע�� - BeanDefinitionRegistry
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#spring-java-%E6%B3%A8%E5%86%8C-beandefinition-%E8%A7%A3%E6%9E%90%E4%B8%8E%E6%B3%A8%E5%86%8C)Spring Java ע�� BeanDefinition ������ע��
+
+���� API - AnnotatedBeanDefinitionReader
+
+*   ��Դ
+    *   ����� - java.lang.Class
+*   �ײ�
+    *   �������� - ConditionEvaluator
+    *   Bean ������ - ScopeMetadataResolver
+    *   BeanDefinition ���� - �ڲ� API ʵ��
+    *   BeanDefinition ���� - AnnotationConfigUtils.processCommonDefinitionAnnotations
+    *   BeanDefinition ע�� - BeanDefinitionRegistry
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#%E5%9F%BA%E4%BA%8E-xml-%E6%96%87%E4%BB%B6%E8%A3%85%E8%BD%BD-spring-ioc-%E5%AE%B9%E5%99%A8%E9%85%8D%E7%BD%AE%E5%85%83%E4%BF%A1%E6%81%AF)���� XML �ļ�װ�� Spring IoC ��������Ԫ��Ϣ
+
+Spring IoC ������� XML ����
+
+| �����ռ� | ����ģ�� | Schema ��Դ URL |
+| --- | --- | --- |
+| beans | spring-beans | https://www.springframework.org/schema/beans/spring-beans.xsd |
+| context | spring-context | https://www.springframework.org/schema/context/spring-context.xsd |
+| aop | spring-aop | https://www.springframework.org/schema/aop/spring-aop.xsd |
+| tx | spring-tx | https://www.springframework.org/schema/tx/spring-tx.xsd |
+| util | spring-beans | beans https://www.springframework.org/schema/util/spring-util.xsd |
+| tool | spring-beans | https://www.springframework.org/schema/tool/spring-tool.xsd |
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#%E5%9F%BA%E4%BA%8E-java-%E6%B3%A8%E8%A7%A3%E8%A3%85%E8%BD%BD-spring-ioc-%E5%AE%B9%E5%99%A8%E9%85%8D%E7%BD%AE%E5%85%83%E4%BF%A1%E6%81%AF)���� Java ע��װ�� Spring IoC ��������Ԫ��Ϣ
+
+Spring IoC ����װ��ע��
+
+| Spring ע�� | ����˵�� | ��ʼ�汾 |
+| --- | --- | --- |
+| @ImportResource | �滻 XML Ԫ�� `<import>` | 3.0 |
+| @Import | ���� Configuration Class | 3.0 |
+| @ComponentScan | ɨ��ָ�� package �±�ע Spring ģʽע����� | 3.1 |
+
+Spring IoC ��������ע��
+
+| Spring ע�� | ����˵�� | ��ʼ�汾 |
+| --- | --- | --- |
+| @PropertySource | �������Գ��� PropertySource ע�� | 3.1 |
+| @PropertySources | @PropertySource ����ע�� | 4.0 |
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#%E5%9F%BA%E4%BA%8E-extensible-xml-authoring-%E6%89%A9%E5%B1%95-springxml-%E5%85%83%E7%B4%A0)���� Extensible XML authoring ��չ SpringXML Ԫ��
+
+Spring XML ��չ
+
+*   ��д XML Schema �ļ������� XML �ṹ
+*   �Զ��� NamespaceHandler ʵ�֣������ռ��
+*   �Զ��� BeanDefinitionParser ʵ�֣�XML Ԫ���� BeanDefinition ����
+*   ע�� XML ��չ�������ռ��� XML Schema ӳ��
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#extensible-xml-authoring-%E6%89%A9%E5%B1%95%E5%8E%9F%E7%90%86)Extensible XML authoring ��չԭ��
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#%E8%A7%A6%E5%8F%91%E6%97%B6%E6%9C%BA)����ʱ��
+
+*   AbstractApplicationContext#obtainFreshBeanFactory
+    *   AbstractRefreshableApplicationContext#refreshBeanFactory
+        *   AbstractXmlApplicationContext#loadBeanDefinitions
+            *   ...
+                *   XmlBeanDefinitionReader#doLoadBeanDefinitions
+                    *   ...
+                        *   BeanDefinitionParserDelegate#parseCustomElement
+
+### [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#%E6%A0%B8%E5%BF%83%E6%B5%81%E7%A8%8B)��������
+
+BeanDefinitionParserDelegate#parseCustomElement(org.w3c.dom.Element, BeanDefinition)
+
+*   ��ȡ namespace
+*   ͨ�� namespace ���� NamespaceHandler
+*   ���� ParserContext
+*   ����Ԫ�أ���ȡ BeanDefinintion
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#%E5%9F%BA%E4%BA%8E-properties-%E6%96%87%E4%BB%B6%E8%A3%85%E8%BD%BD%E5%A4%96%E9%83%A8%E5%8C%96%E9%85%8D%E7%BD%AE)���� Properties �ļ�װ���ⲿ������
+
+ע������
+
+*   @org.springframework.context.annotation.PropertySource
+*   @org.springframework.context.annotation.PropertySources
+
+API ���
+
+*   org.springframework.core.env.PropertySource
+*   org.springframework.core.env.PropertySources
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#%E5%9F%BA%E4%BA%8E-yaml-%E6%96%87%E4%BB%B6%E8%A3%85%E8%BD%BD%E5%A4%96%E9%83%A8%E5%8C%96%E9%85%8D%E7%BD%AE)���� YAML �ļ�װ���ⲿ������
+
+API ���
+
+*   org.springframework.beans.factory.config.YamlProcessor
+    *   org.springframework.beans.factory.config.YamlMapFactoryBean
+    *   org.springframework.beans.factory.config.YamlPropertiesFactoryBean
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#%E9%97%AE%E9%A2%98)����
+
+**Spring �Ƚ� XML Schema ��������Щ**��
+
+| �����ռ� | ����ģ�� | Schema ��Դ URL |
+| --- | --- | --- |
+| beans | spring-beans | https://www.springframework.org/schema/beans/spring-beans.xsd |
+| context | spring-context | https://www.springframework.org/schema/context/spring-context.xsd |
+| aop | spring-aop | https://www.springframework.org/schema/aop/spring-aop.xsd |
+| tx | spring-tx | https://www.springframework.org/schema/tx/spring-tx.xsd |
+| util | spring-beans | beans https://www.springframework.org/schema/util/spring-util.xsd |
+| tool | spring-beans | https://www.springframework.org/schema/tool/spring-tool.xsd |
+
+**Spring ����Ԫ��Ϣ��������Щ**��
+
+*   Bean ����Ԫ��Ϣ��ͨ��ý�飨�� XML��Proeprties �ȣ������� BeanDefinition
+*   IoC ��������Ԫ��Ϣ��ͨ��ý�飨�� XML��Proeprties �ȣ������� IoC ������Ϊ������ע��������AOP ��
+*   �ⲿ�����ã�ͨ����Դ������ Proeprties��YAML �ȣ������� PropertySource
+*   Spring Profile��ͨ���ⲿ�����ã��ṩ������֧����
+
+**Extensible XML authoring ��ȱ��**��
+
+*   �߸��Ӷȣ�������Ա��Ҫ��Ϥ XML Schema��spring.handlers��spring.schemas �Լ� Spring API
+*   Ƕ��Ԫ��֧�ֽ�����ͨ����Ҫʹ�÷����ݹ������Ƕ�׽����ķ�ʽ����Ƕ�ף��ӣ�Ԫ��
+*   XML �������ܽϲSpring XML ���� DOM Level 3 API ʵ�֣��� API �������⣬Ȼ�����ܽϲ�
+*   XML �����ֲ�Բ������������ܺͱ����Ե� XML ��ܣ��� JAXB
+
+## [#](https://dunwu.github.io/spring-tutorial/pages/55f315/#%E5%8F%82%E8%80%83%E8%B5%84%E6%96%99)�����
+
+*   [Spring �ٷ��ĵ�֮ Core Technologies(opens new window)](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans)
+*   [��С���署 Spring ���ı��˼�롷(opens new window)](https://time.geekbang.org/course/intro/265)
+
+
+
+# �����
+https://www.w3cschool.cn/wkspring
+https://www.runoob.com/w3cnote/basic-knowledge-summary-of-spring.html
+http://codepub.cn/2015/06/21/Basic-knowledge-summary-of-Spring
+https://dunwu.github.io/spring-tutorial
+https://mszlu.com/java/spring
+http://c.biancheng.net/spring/aop-module.html
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\272\213\345\212\241\345\237\272\346\234\254\347\224\250\346\263\225.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\272\213\345\212\241\345\237\272\346\234\254\347\224\250\346\263\225.md"
new file mode 100644
index 0000000..c247c82
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\344\272\213\345\212\241\345\237\272\346\234\254\347\224\250\346\263\225.md"
@@ -0,0 +1,292 @@
+# Spring������Ľӿ�
+
+[Spring](http://www.voidme.com/spring) ����������ǻ��� AOP ʵ�ֵģ��� AOP ���Է���Ϊ��λ�ġ�Spring ���������Էֱ�Ϊ������Ϊ�����뼶��ֻ���ͳ�ʱ���ԣ���Щ�����ṩ������Ӧ�õķ������������ԡ�
+
+�� [Java](http://www.voidme.com/java) EE �����������õķֲ�ģʽ�У�Spring ��������λ��ҵ���߼��㣬���ṩ���������Ľ��������
+
+�� Spring ��ѹ���� libs Ŀ¼�У�����һ������Ϊ spring-tx-3.2.13.RELEASE.jar ���ļ������ļ��� Spring �ṩ��������������� JAR �������а�������������������Ľӿڣ�PlatformTransactionManager��TransactionDefinition �� TransactionStatus��
+
+���� JAR ���ĺ�׺�� jar �ij� zip ����ʽ�󣬽�ѹѹ�����������ѹ�ļ����е� \org\springframework\transaction Ŀ¼�󣬸�Ŀ¼�е��ļ���ͼ 1 ��ʾ��
+
+![����������Ľӿ�](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/760_a12_405.png)  
+ͼ 1  ����������Ľӿ�
+
+��ͼ 1 �У���������ע�������ļ����DZ��ڽ�Ҫ����ĺ��Ľӿڡ����������Ľӿڵ����ü����ṩ�ķ������¡�
+
+#### 1\. PlatformTransactionManager
+
+PlatformTransactionManager �ӿ��� Spring �ṩ��ƽ̨��������������ڹ������񡣸ýӿ����ṩ��������������������������¡�
+
+*   TransactionStatus getTransaction��TransactionDefinition definition�������ڻ�ȡ����״̬��Ϣ��
+*   void commit��TransactionStatus status���������ύ����
+*   void rollback��TransactionStatus status�������ڻع�����
+
+����Ŀ�У�Spring �� xml �����õ�������ϸ��Ϣ��װ������ TransactionDefinition �У�Ȼ��ͨ������������� getTransaction() ������������״̬��TransactionStatus�����������������һ���IJ�����
+
+#### 2\. TransactionDefinition
+
+TransactionDefinition �ӿ��������壨�������Ķ������ṩ�����������Ϣ��ȡ�ķ��������а�������������������¡�
+
+*   String getName()����ȡ����������ơ�
+*   int getIsolationLevel()����ȡ����ĸ��뼶��
+*   int getPropagationBehavior()����ȡ����Ĵ�����Ϊ��
+*   int getTimeout()����ȡ����ij�ʱʱ�䡣
+*   boolean isReadOnly()����ȡ�����Ƿ�ֻ����
+
+��������������������У�����Ĵ�����Ϊ��ָ��ͬһ�������У���ͬ����ǰ����ʹ�õ����񡣴�����Ϊ��������� 1 ��ʾ��
+
+| �������� | ֵ | ��  �� |  
+| --- | --- | --- |  
+| PROPAGATION_REQUIRED | required | ֧�ֵ�ǰ������� A �����Ѿ��������У��� B ����ֱ��ʹ�á����򽫴��������� |  
+| PROPAGATION_SUPPORTS | supports | ֧�ֵ�ǰ������� A �����Ѿ��������У��� B ����ֱ��ʹ�á������Է�����״ִ̬�� |  
+| PROPAGATION_MANDATORY | mandatory | ֧�ֵ�ǰ������� A ����û���������׳��쳣 |  
+| PROPAGATION_REQUIRES_NEW | requires_new | �������µ�������� A �����Ѿ��������У��� A ������� |  
+| PROPAGATION_NOT_SUPPORTED | not_supported | ��֧�ֵ�ǰ���������Է�����״ִ̬�С���� A �����Ѿ��������У�������� |  
+| PROPAGATION_NEVER | never | ��֧�ֵ�ǰ������� A �����������У����׳��쳣 |  
+| PROPAGATION.NESTED | nested | Ƕ�����񣬵ײ㽫ʹ�� Savepoint �γ�Ƕ������ |  
+
+��������������У�������Ϊ���Կ����Ƿ���Ҫ���������Լ���δ�������
+
+ͨ������£����ݵIJ�ѯ����ı�ԭ���ݣ����Բ���Ҫ����������������������ݵ����ӡ��޸ĺ�ɾ���Ȳ������������������������û��ָ������Ĵ�����Ϊ���� Spring3 Ĭ�ϵĴ�����Ϊ�� required��
+
+#### 3\. TransactionStatus
+
+TransactionStatus �ӿ��������״̬����������ijһʱ����������״̬��Ϣ�����а�������������������� 2 ��ʾ��
+
+<caption>�� 2  ����IJ���</caption>  
+| ���� | ˵�� |  
+| --- | --- |  
+| void flush() | ˢ������ |  
+| boolean hasSavepoint() | ��ȡ�Ƿ���ڱ���� |  
+| boolean isCompleted() | ��ȡ�����Ƿ���� |  
+| boolean isNewTransaction() | ��ȡ�Ƿ��������� |  
+| boolean isRollbackOnly() | ��ȡ�Ƿ�ع� |  
+| void setRollbackOnly() | ��������ع� |  
+
+# Spring����ʽ�������������XML��ʽʵ�֣�
+
+[Spring](http://www.voidme.com/spring) ��������������ַ�ʽ��һ���Ǵ�ͳ�ı��ʽ�����������ͨ����д����ʵ�ֵ������������һ���ǻ��� AOP ����ʵ�ֵ�����ʽ���������������ʵ�ʿ����У����ʽ�����������ʹ�ã���������ֻ�� Spring ������ʽ�������������ϸ���⡣
+
+Spring ����ʽ��������ڵײ������ AOP �������������ŵ���������ͨ����̵ķ�ʽ��������ֻ��Ҫ�������ļ��н�����صĹ����������Ϳ��Խ��������Ӧ�õ�ҵ���߼��С�
+
+Spring ʵ������ʽ���������Ҫ�����ַ�ʽ��
+
+*   ���� XML ��ʽ������ʽ���������
+*   ͨ�� Annotation ע�ⷽʽ�����������
+
+����ͨ������ת�˵İ����������ʹ�� XML �ķ�ʽʵ�� Spring ������ʽ��������
+
+#### 1\. ������Ŀ
+
+�� MyEclipse �д���һ����Ϊ springDemo03 �� Web ��Ŀ���� Spring ֧�ֺ������� JAR �����Ƶ� Web ��Ŀ�� lib Ŀ¼�У������ӵ���·���¡������ӵ� JAR ����ͼ 1 ��ʾ��
+
+![��Ҫ�����JAR��](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/761_732_fcf.png)  
+ͼ 1  ��Ҫ�����JAR��
+
+��ͼ 1 �п��Կ������������ӵ����� spring-tx-3.2.13.RELEASE.jar��������������Լ� [MySQL](http://www.voidme.com/mysql) ������JDBC �� C3P0 �� JAR ����
+
+#### 2\. �������ݿ⡢���Լ���������
+
+�� MySQL �д���һ����Ϊ spring �����ݿ⣬Ȼ���ڸ����ݿ��д���һ�� account ����������в����������ݣ��� SQL ִ�����������ʾ��
+
+CREATE DATABASE spring;  
+USE spring;  
+CREATE TABLE account (  
+id INT (11) PRIMARY KEY AUTO_INCREMENT,  
+username VARCHAR(20) NOT NULL,  
+money INT DEFAULT NULL  
+);  
+INSERT INTO account VALUES (1,'zhangsan',1000);  
+INSERT INTO account VALUES (2,'lisi',1000);
+
+ִ�к�� account ���е�������ͼ 2 ��ʾ��
+
+![ִ�н��](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/762_276_8a5.PNG)  
+ͼ 2  ִ�н��
+
+#### 3\. ���� c3p0-db.properties
+
+����Ŀ�� src �´���һ����Ϊ c3p0-db.properties �������ļ�������ʹ�� C3P0 ����Դ����Ҫ�ڸ��ļ��������������ã�
+````  
+jdbc.driverClass = com.mysql.jdbc.Driver  
+jdbc.jdbcUrl = jdbc:mysql://localhost:3306/spring  
+jdbc.user = root  
+jdbc.password = root  
+````  
+#### 4\. ʵ�� DAO
+
+#### 1������ AccountDao �ӿ�
+
+����Ŀ�� src Ŀ¼�´���һ����Ϊ com.mengma.dao �İ����ڸð��´���һ���ӿ� AccountDao�����ڽӿ��д��������տ�ķ�����������ʾ��
+````  
+package com.mengma.dao;  
+public interface AccountDao {  
+    // ���  
+    public void out(String outUser, int money);  
+    // �տ�  
+    public void in(String inUser, int money);} ````  
+���������У������� out() �� in() �����������ֱ����ڱ�ʾ�����տ  
+  
+#### 2������DAO��ӿ�ʵ����  
+  
+����Ŀ�� src Ŀ¼�´���һ����Ϊ com.mengma.dao.impl �İ����ڸð��´���ʵ���� AccountDaoImpl��������ʾ��  
+````  
+package com.mengma.dao.impl;
+
+import org.springframework.jdbc.core.JdbcTemplate;  
+import com.mengma.dao.AccountDao;
+
+public class AccountDaoImpl implements AccountDao {  
+private JdbcTemplate jdbcTemplate;  
+public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {        this.jdbcTemplate = jdbcTemplate;    }  
+// ����ʵ�ַ���  
+public void out(String outUser, int money) {        this.jdbcTemplate.update("update account set money =money-?"                + "where username =?", money, outUser);    }  
+// �տ��ʵ�ַ���  
+public void in(String inUser, int money) {        this.jdbcTemplate.update("update account set money =money+?"                + "where username =?", money, inUser);    }} ````  
+���������У�ʹ�� JdbcTemplate ��� update() ����ʵ���˸��²�����
+
+#### 5\. ʵ�� Service
+
+#### 1������ Service ��ӿ�
+
+����Ŀ�� src Ŀ¼�´���һ����Ϊ com.mengma.service �İ����ڸð��´����ӿ� AccountService��������ʾ��
+````  
+package com.mengma.service;  
+  
+public interface AccountService {  
+    // ת��  
+    public void transfer(String outUser, String inUser, int money);} ````  
+#### 2������ Service ��ӿ�ʵ����  
+  
+����Ŀ�� src Ŀ¼�´���һ����Ϊ com.mengma.service.impl �İ����ڸð��´���ʵ���� AccountServiceImpl��������ʾ��  
+````  
+package com.mengma.service.impl;
+
+import com.mengma.dao.AccountDao;
+
+public class AccountServiceImpl {  
+private AccountDao accountDao;  
+public void setAccountDao(AccountDao accountDao) {        this.accountDao = accountDao;    }  
+public void transfer(String outUser, String inUser, int money) {        this.accountDao.out(outUser, money);        this.accountDao.in(inUser, money);    }} ````  
+���������п��Կ���������ʵ���� AccountService �ӿڣ�����ת�˵ķ���������ʵ�֣����ݲ����IJ�ͬ���� DAO ����Ӧ�ķ�����
+
+#### 6\. ���� Spring �����ļ�
+
+����Ŀ�� src Ŀ¼�´��� Spirng �����ļ� applicationContext.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"    xmlns:context="http://www.springframework.org/schema/context"    xmlns:tx="http://www.springframework.org/schema/tx"    xmlns:aop="http://www.springframework.org/schema/aop"    xsi:schemaLocation="http://www.springframework.org/schema/beans            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd            http://www.springframework.org/schema/context  
+            http://www.springframework.org/schema/context/spring-context.xsd            http://www.springframework.org/schema/tx            http://www.springframework.org/schema/tx/spring-tx-2.5.xsd            http://www.springframework.org/schema/aop            http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">    <!-- ����properties�ļ� -->    <context:property-placeholder location="classpath:c3p0-db.properties" />    <!-- ��������Դ����ȡproperties�ļ���Ϣ -->    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">        <property name="driverClass" value="${jdbc.driverClass}" />        <property name="jdbcUrl" value="${jdbc.jdbcUrl}" />        <property name="user" value="${jdbc.user}" />        <property name="password" value="${jdbc.password}" />    </bean>    <!-- ����jdbcģ�� -->    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">        <property name="dataSource" ref="dataSource" />    </bean>    <!-- ����dao -->  
+    <bean id="accountDao" class="com.mengma.dao.impl.AccountDaoImpl">        <property name="jdbcTemplate" ref="jdbcTemplate" />    </bean>    <!-- ����service -->  
+    <bean id="accountService" class="com.mengma.service.impl.AccountServiceImpl">        <property name="accountDao" ref="accountDao" />    </bean>    <!-- ���������������������Դ -->    <bean id="txManager"        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">        <property name="dataSource" ref="dataSource" />    </bean>    <!-- ��д֪ͨ�������������ǿ��֪ͨ������Ҫ��д�����;���ִ�������ϸ�� -->    <tx:advice id="txAdvice" transaction-manager="txManager">        <tx:attributes>            <!-- ������㷽�������������飬name��ʾ�������ƣ�*��ʾ���ⷽ�����ƣ�propagation�������ô�����Ϊ��read-only��ʾ���뼶���Ƿ�ֻ�� -->            <tx:method name="find*" propagation="SUPPORTS"                rollback-for="Exception" />            <tx:method name="*" propagation="REQUIRED" isolation="DEFAULT"                read-only="false" />        </tx:attributes>    </tx:advice>    <!-- aop��д����Spring�Զ���Ŀ�����ɴ�������Ҫʹ��AspectJ�ı���ʽ -->    <aop:config>        <!-- ����� -->        <aop:pointcut expression="execution(* com.mengma.service.*.*(..))"            id="txPointCut" />        <!-- ���棺���������֪ͨ���� -->        <aop:advisor pointcut-ref="txPointCut" advice-ref="txAdvice" />    </aop:config></beans> ````  
+���������У������� <beans> ��ǵĵ� 6��13 �� 14 �д���ֱ������� AOP ����������ռ��������� 42��50 �д���ʹ�� <tx:advice> �����������֪ͨ���ݡ�  
+  
+�� 52��58 �д���ʹ��  ��Ƕ������棬���е� 54 �д���Ӧ���� AspectJ ����ʽ������ com.mengma.service ��������������з�����Ӧ��������򣬵� 57 �д���ʹ��  ��ǽ������������֪ͨ���ϣ����� AOP ������ʽ����������ɡ�  
+  
+#### 7\. ����������  
+  
+����Ŀ�� src Ŀ¼�´��� com.mengma.test �İ����ڸð��´��������� AccountTest��������ʾ��  
+````  
+package com.mengma.test;  
+import org.junit.Test;  
+import org.springframework.context.ApplicationContext;  
+import org.springframework.context.support.ClassPathXmlApplicationContext;  
+import com.mengma.service.AccountService;  
+public class AccountTest {  
+@Test    public void test() {        // ���Spring������������  
+String xmlPath = "applicationContext.xml";        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(                xmlPath);        AccountService accountService = (AccountService) applicationContext                .getBean("accountService");        accountService.transfer("zhangsan", "lisi", 100);    }} ````  
+����������ģ��������ת��ҵ�񣬴� zhangsan ���˻��� lisi ���˻���ת�� 100 Ԫ��ʹ�� JUnit �������� test() ���������гɹ��󣬲�ѯ account ������ͼ 3 ��ʾ��
+
+��ͼ 3 �IJ�ѯ����п��Կ�����zhangsan �ɹ��� lisi ת�� 100 Ԫ��
+
+![��ѯ���](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/763_9ae_de5.PNG)  
+ͼ 3  ��ѯ���
+
+����ͨ���޸İ���ģ��ת��ʧ�ܵ�������ڵ� transfer() ����������һ�д��롰int i=1/0����ģ��ϵͳ�ϵ��������������������ʾ��
+````  
+ public void transfer(String outUser, String inUser, int money) {    this.accountDao.out(outUser, money);    //ģ��ϵ�  
+    int i = 1/0;    this.accountDao.in(inUser, money);
+ } 
+````  
+    
+���²������� test() ������JUnit ����̨�������Ϣ��ͼ 4 ��ʾ��  
+  
+![����̨������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/764_7a3_f52.png)  
+ͼ 4  ����̨������  
+  
+��ͼ 4 �п��Կ�������ִ�в��Է���ʱ�������˳��� 0 ���쳣��Ϣ����ʱ�ٴβ�ѯ account �������ѯ�����ͼ 5 ��ʾ��  
+  
+��ͼ 5 �IJ�ѯ����п��Կ��������е����ݲ�û�з����仯�����ڳ�����ִ�й������׳����쳣���������������ύ������ת��ʧ�ܡ��ɴ˿�֪��Spring �����������Ч�ˡ�  
+  
+![��ѯ���](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/763_9ae_de5.PNG)  
+ͼ 5  ��ѯ���  
+  
+# Spring����ʽ�������������Annotationע�ⷽʽʵ�֣�  
+  
+�� [Spring](http://www.voidme.com/spring) �У�����ʹ�û��� XML �ķ�ʽ����ʵ������ʽ����������⣬������ͨ�� Annotation ע��ķ�ʽʵ������ʽ���������  
+  
+ʹ�� Annotation �ķ�ʽ�dz��򵥣�ֻ��Ҫ����Ŀ���������£��������¡�  
+  
+#### 1���� Spring ������ע������������������ʾ��  
+````  
+<tx:annotation-driven transaction-manager="txManager"/>
+````  
+#### 2������Ҫʹ�������ҵ������߷���������ע�� @Transactional�������� @Transactional �IJ��������� @Transactional �IJ�����ͼ 1 ��ʾ��  
+  
+![@Transactional�����б�](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/765_7af_ff7.png)  
+ͼ 1  @Transactional�����б�  
+  
+����ͨ���޸ġ� [Spring����XMLʵ���������](http://www.voidme.com/spring/spring-transaction-management-by-xml)���̳�������ת�˵İ����������ʹ�� Annotation ע��ķ�ʽʵ�� Spring ����ʽ���������  
+  
+#### 1\. ע������  
+  
+�޸� Spring �����ļ� applicationContext.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"    xmlns:context="http://www.springframework.org/schema/context"    xmlns:tx="http://www.springframework.org/schema/tx"    xmlns:aop="http://www.springframework.org/schema/aop"    xsi:schemaLocation="http://www.springframework.org/schema/beans            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd            http://www.springframework.org/schema/context  
+http://www.springframework.org/schema/context/spring-context.xsd            http://www.springframework.org/schema/tx            http://www.springframework.org/schema/tx/spring-tx-2.5.xsd            http://www.springframework.org/schema/aop            http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">    <!-- ����properties�ļ� -->    <context:property-placeholder location="classpath:c3p0-db.properties" />    <!-- ��������Դ����ȡproperties�ļ���Ϣ -->    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">        <property name="driverClass" value="${jdbc.driverClass}" />        <property name="jdbcUrl" value="${jdbc.jdbcUrl}" />        <property name="user" value="${jdbc.user}" />        <property name="password" value="${jdbc.password}" />    </bean>    <!-- ����jdbcģ�� -->    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">        <property name="dataSource" ref="dataSource" />    </bean>    <!-- ����dao -->  
+<bean id="accountDao" class="com.mengma.dao.impl.AccountDaoImpl">        <property name="jdbcTemplate" ref="jdbcTemplate" />    </bean>    <!-- ����service -->  
+<bean id="accountService" class="com.mengma.service.impl.AccountServiceImpl">        <property name="accountDao" ref="accountDao" />    </bean>    <!-- ���������������������Դ -->    <bean id="txManager"        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">        <property name="dataSource" ref="dataSource" />    </bean>    <!-- ע������������� -->    <tx:annotation-driven transaction-manager="txManager"/></beans> ````  
+````
+���������п��Կ�������ԭ���������ļ���ȣ�����ֻ�޸���������������֣������Ӳ�ע���������������������
+
+��Ҫע����ǣ���ѧϰ AOP ע�ⷽʽ����ʱ����Ҫ�������ļ��п���ע�⴦������ָ��ɨ����Щ���µ�ע�⣬����û�п���ע�⴦��������Ϊ�ڵ� 33��35 ���ֶ������� AccountServiceImpl���� @Transactional ע��������ڸ����У����Ի�ֱ����Ч��
+
+#### 2\. ���� @Transactional ע��
+
+�޸� AccountServiceImpl�����ļ������� @Transactional ע�⼰���������Ӻ�������ʾ��
+````  
+package com.mengma.service.impl;  
+  
+import org.springframework.transaction.annotation.Isolation;  
+import org.springframework.transaction.annotation.Propagation;  
+import org.springframework.transaction.annotation.Transactional;  
+  
+import com.mengma.dao.AccountDao;  
+  
+@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, readOnly = false)  
+public class AccountServiceImpl {  
+    private AccountDao accountDao;  
+    public void setAccountDao(AccountDao accountDao) {        this.accountDao = accountDao;    }  
+    public void transfer(String outUser, String inUser, int money) {        this.accountDao.out(outUser, money);        // ģ��ϵ�  
+        int i = 1 / 0;        this.accountDao.in(inUser, money);    
+}}
+````
+
+��Ҫע����ǣ���ʹ�� @Transactional ע��ʱ������֮���á��������зָ���  
+  
+ʹ�� JUnit �����ٴ����� test() ����ʱ������̨ͬ���������ͼ 2 ��ʾ���쳣��Ϣ����˵��ʹ�û��� Annotation ע��ķ�ʽͬ��ʵ���� Spring ������ʽ������������ע�͵�ģ��ϵ�Ĵ�����в��ԣ���ת�˲�������������ɡ�  
+  
+![����](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/764_7a3_f52.png)  
+ͼ 2  ���н��  
+  
+# �����  
+https://www.w3cschool.cn/wkspring  
+https://www.runoob.com/w3cnote/basic-knowledge-summary-of-spring.html  
+http://codepub.cn/2015/06/21/Basic-knowledge-summary-of-Spring  
+https://dunwu.github.io/spring-tutorial  
+https://mszlu.com/java/spring  
+http://c.biancheng.net/spring/aop-module.html
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\345\220\210\351\233\206.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\345\220\210\351\233\206.md"
new file mode 100644
index 0000000..931264e
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\345\220\210\351\233\206.md"
@@ -0,0 +1,22 @@
+# Spring
+
+
+# SpringԴ�����
+
+# SpringMVC
+
+# SpringMVC Դ�����
+
+# SpringBoot
+## springboot��ǰ������
+## springboot�Ļ���ʹ��
+## springboot�ij���ע��
+## springboot������
+## springboot�Ļ���ԭ��
+## springbootԴ�����
+
+# SpringBoot Դ�����
+
+# SpringCloud 
+# SpringCloud Դ�����
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\345\256\271\345\231\250\344\270\216IOC.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\345\256\271\345\231\250\344\270\216IOC.md"
new file mode 100644
index 0000000..35623db
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\345\256\271\345\231\250\344\270\216IOC.md"
@@ -0,0 +1,157 @@
+IoC �� Inversion of Control �ļ�д����Ϊ�����Ʒ�ת����������һ�ż���������һ�����˼�룬��һ����Ҫ����������̷����ܹ�ָ�����������Ƴ�����ϡ��������ij���
+
+Spring ͨ�� IoC �������������� Java �����ʵ�����ͳ�ʼ�������ƶ��������֮���������ϵ�����ǽ��� IoC ���������� Java �����Ϊ Spring Bean������ʹ�ùؼ��� new ������ Java ����û���κ�����
+
+IoC ������ Spring ���������Ҫ�ĺ������֮һ�����ᴩ�� Spring �ӵ������ɳ����������̡�
+
+## ���Ʒ�ת��IoC��
+
+�ڴ�ͳ�� Java Ӧ���У�һ������Ҫ������һ�����е����Ի򷽷���ͨ���������������ͨ�� new Object() �ķ�ʽ�����ߵĶ��󴴽�������Ȼ�����ʵ�����Ի򷽷��ĵ��á�Ϊ�˷�����������������ǿ��Խ�ǰ�߳�Ϊ�������ߡ��������߳�Ϊ���������ߡ���Ҳ����˵�������������ű������߶��󴴽��Ŀ���Ȩ��
+
+���� Spring Ӧ���У�Java ���󴴽��Ŀ���Ȩ�������� IoC ��������ģ�����²������¡�
+
+������Աͨ�� XML �����ļ���ע�⡢Java ������ȷ�ʽ���� Java ������ж��壬������ XML �����ļ���ʹ�� <bean> ��ǩ���� Java ����ʹ�� @Component ע��ȡ� 
+Spring ����ʱ��IoC �������Զ����ݶ����壬����Щ���󴴽���������������Щ�� IoC ���������������Ķ��󱻳�Ϊ Spring Bean�� 
+��������Ҫʹ��ij�� Bean ʱ������ֱ�Ӵ� IoC �����л�ȡ������ͨ�� ApplicationContext �� getBean() ��������������Ҫ�ֶ�ͨ�����루���� new Obejct() �ķ�ʽ��������
+
+IoC ���������ı䲻�Ǵ������ģ����Ǵ�˼������Ϸ����ˡ����ӻ�λ���ĸı䡣ԭ����������������һ��������Ҫʹ��ʲô��Դ�ͻ������������Լ����������� Spring Ӧ���У�IoC ��������������Ȩ�������������˱�����һ���������ĵȴ� IoC ��������������Ҫ�Ķ���Bean����
+
+���������ְ����淢���˿���Ȩ�ķ�ת����ԭ��������ͨ������ʵ�ֵĶ���Ĵ�������ת�� IoC ��������æʵ�֣�������ǽ�������̳�Ϊ Spring �ġ����Ʒ�ת����
+
+## ����ע�루DI��
+
+���˽��� IoC ֮�����ǻ���Ҫ�˽�����һ���dz���Ҫ�ĸ������ע�롣
+
+����ע�루Denpendency Injection����дΪ DI���� Martin Fowler �� 2004 ���ڶԡ����Ʒ�ת�����н���ʱ����ġ�Martin Fowler ��Ϊ�����Ʒ�ת��һ�ʺܻ�ɬ���޷����˺�ֱ�ӵ����⡰���������ﷴת�ˡ������������ʹ�á�����ע�롱�����桰���Ʒ�ת����
+
+����������У�����Ͷ���֮���Ǵ���һ�ֽ������������Ĺ�ϵ������˵��������ϵ������һ����������Ҫ�õ�����һ�����󣬼������д���һ�����ԣ�������������һ����Ķ���
+
+���磬��һ����Ϊ B �� Java �࣬���Ĵ������¡�
+
+
+
+
+
+ 
+
+public class  B { 
+String  bid; 
+A  a; 
+}
+
+ 
+
+
+
+
+
+�Ӵ�����Կ�����B �д���һ�� A ���͵Ķ������� a����ʱ���ǾͿ���˵ B �Ķ��������ڶ��� a��������ע����Ǿ��ǻ������֡�������ϵ���������ġ�
+
+����֪�������Ʒ�ת����˼������� Spring �������Ĵ������ڶ��󴴽������У�Spring ���Զ�����������ϵ�����������Ķ���ע�뵽��ǰ�����У��������ν�ġ�����ע�롱��
+
+����ע�뱾������ [Spring Bean ����ע��](http://c.biancheng.net/spring/attr-injection.html)��һ�֣�ֻ�������������һ���������Զ��ѡ�
+
+## IoC �Ĺ���ԭ��
+
+�� Java �������������У�ϵͳ�еĸ�������֮�䡢����ģ��֮�䡢����ϵͳ��Ӳ��ϵͳ֮�䣬�����ٶ�����һ������Ϲ�ϵ��
+
+��һ��ϵͳ����϶ȹ��ߣ���ô�ͻ��������ά�������⣬����ȫû����ϵĴ��뼸���޷�����κι������������ڼ������еĹ��ܶ���Ҫ����֮���໥Э�����໥����������ɡ���������ڳ������ʱ�������е�˼��һ�㶼���ڲ�Ӱ��ϵͳ���ܵ�ǰ���£�����޶ȵĽ�����϶ȡ�
+
+IoC �ײ�ͨ������ģʽ��Java �ķ�����ơ�XML �����ȼ��������������϶Ƚ��͵�����޶ȣ�����Ҫ�������¡�
+
+�������ļ������� Bean.xml���У��Ը��������Լ�����֮���������ϵ�������ã�
+���ǿ��԰� IoC ��������һ����������������IJ�Ʒ���� Spring Bean��
+��������ʱ����ز�������Щ�����ļ����õ�����Ļ�����Ϣ�Լ�����֮���������ϵ��
+IoC ���� Java �ķ�����ƣ���������������Ӧ�Ķ��󣨼� Spring Bean����������������ϵ���������ע�뵽�������Ķ����С�
+
+���ڶ���Ļ�����Ϣ������֮���������ϵ�����������ļ��ж���ģ���û���ڴ����н�����ϣ���˼�ʹ�������ı䣬����Ҳֻ��Ҫ�������ļ��н����޸ļ��ɣ�������� Java ��������޸ģ������ Spring IoC ʵ�ֽ����ԭ����
+
+## IoC ����������ʵ��
+
+IoC ˼����� IoC ����ʵ�ֵģ�IoC �����ײ���ʵ����һ�� Bean ������Spring ���Ϊ�����ṩ�����ֲ�ͬ���� IoC ���������Ƿֱ��� BeanFactory �� ApplicationContext��
+
+### BeanFactory
+
+BeanFactory �� IoC �����Ļ���ʵ�֣�Ҳ�� Spring �ṩ����򵥵� IoC ���������ṩ�� IoC ����������Ĺ��ܣ��� org.springframework.beans.factory.BeanFactory �ӿڶ��塣
+
+BeanFactory ���������أ�lazy-load�����ƣ������ڼ��������ļ�ʱ���������̴��� Java ����ֻ�г����л�ȡ��ʹ�ã�����Զ���ʱ�Żᴴ����
+
+#### ʾ�� 1
+
+��������ͨ��һ��ʵ����ʾ������ʾ�� BeanFactory ��ʹ�á�
+
+1\. �� HelloSpring ��Ŀ�У��� MainApp �Ĵ����޸�Ϊʹ�� BeanFactory ��ȡ HelloWorld �Ķ��󣬾���������¡�
+
+
+
+
+
+ 
+
+public static void main(String[] args) {
+BeanFactory  context = new ClassPathXmlApplicationContext("Beans.xml");
+HelloWorld  obj = context.getBean("helloWorld", HelloWorld.class);
+obj.getMessage();
+}
+
+ 
+
+
+
+
+
+2. ���� MainApp.java������̨������¡�
+
+ message : Hello World! 
+
+> ע�⣺BeanFactory �� Spring �ڲ�ʹ�ýӿڣ�ͨ������²��ṩ��������Աʹ�á�
+
+### ApplicationContext
+
+ApplicationContext �� BeanFactory �ӿڵ��ӽӿڣ��Ƕ� BeanFactory ����չ��ApplicationContext �� BeanFactory �Ļ�����������������ҵ���Ĺ��ܣ����� AOP�����������̣������ʻ�������֧�ֵȡ�
+
+ApplicationContext �ӿ����������õ�ʵ���࣬�������±���
+
+| ʵ���� | ���� | ʾ������ |
+| --- | --- | --- |
+| ClassPathXmlApplicationContext | ������·�� ClassPath ��ָ���� XML �����ļ�������� ApplicationContext ��ʵ�������� | ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation); |
+| FileSystemXmlApplicationContext | ����ָ�����ļ�ϵͳ·����ָ���� XML �����ļ�������� ApplicationContext ��ʵ�������� | ApplicationContext applicationContext = new FileSystemXmlApplicationContext(String configLocation); |
+
+> ���ϱ���ʾ�������У����� configLocation ����ָ�� Spring �����ļ������ƺ�λ�ã��� Beans.xml��
+
+#### ʾ�� 2
+
+�������Ǿ�ͨ��һ��ʵ��������ʾ ApplicationContext ��ʹ�á�
+
+1. �޸� HelloSpring ��Ŀ MainApp ���� main() �����Ĵ��룬����������¡�
+
+
+
+
+
+ 
+````
+public static void main(String[] args) {
+//ʹ�� FileSystemXmlApplicationContext ����ָ��·���µ������ļ� Bean.xml
+BeanFactory  context = new FileSystemXmlApplicationContext("D:\\eclipe workspace\\spring workspace\\HelloSpring\\src\\Beans.xml");
+HelloWorld  obj = context.getBean("helloWorld", HelloWorld.class);
+obj.getMessage();
+}
+````
+ 
+
+
+
+
+
+2. ���� MainApp.java������̨������¡�
+
+ message : Hello World! 
+
+# �����
+https://www.w3cschool.cn/wkspring
+https://www.runoob.com/w3cnote/basic-knowledge-summary-of-spring.html
+http://codepub.cn/2015/06/21/Basic-knowledge-summary-of-Spring
+https://dunwu.github.io/spring-tutorial
+https://mszlu.com/java/spring
+http://c.biancheng.net/spring/aop-module.html
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\345\270\270\350\247\201\346\263\250\350\247\243.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\345\270\270\350\247\201\346\263\250\350\247\243.md"
new file mode 100644
index 0000000..c5b2238
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\345\270\270\350\247\201\346\263\250\350\247\243.md"
@@ -0,0 +1,724 @@
+# Springע��
+## 1 ����
+
+���Ƕ�֪��Spring����ĵ����Ծ���IOC+AOP��IOC��ԭ������ʵ����һ��Spring������������������Spring Beanʵ��
+DI��Ҳ��������ע�룬��������Ϊ��������Ҫ���ĵĺ��Ļ��⣬���ע��������ע���ĸ���������������Ҫ��ȷ֪���ġ�
+����ǰ������ϰ������xml�����ļ�������һ��bean�������ڣ����Ǹ����ʹ��ע��ʹ��������DI�Ĺ���
+
+
+���ǿ���ʹ�� org.springframework.beans.factory.annotation �� org.springframework.context.annotation ���е�ע�������� Spring DI ����Ĺ��ܡ�
+
+����ͨ������Щ��Ϊ��Spring ����ע�͡������ǽ��ڱ��̳��ж�����лعˡ�
+
+
+## 2 DI���ע��
+
+### 2.1 @Autowired
+
+���ǿ���ʹ�� @Autowired ����� Spring ��Ҫ������ע��������
+���ǿ��Խ���ע���빹�캯����setter ���ֶ�ע��һ��ʹ�á�
+Constructor injection:
+
+**������ע��**
+
+````
+class Car {
+    Engine engine;
+
+    @Autowired
+    Car(Engine engine) {
+        this.engine = engine;
+    }
+}
+````
+
+**Setterע��**
+````
+class Car {
+    Engine engine;
+
+    @Autowired
+    void setEngine(Engine engine) {
+        this.engine = engine;
+    }
+}
+````
+**����ע��**
+````
+class Car {
+    @Autowired
+    Engine engine;
+}
+````
+
+@Autowired ��һ����Ϊ required �IJ���������Ĭ��ֵΪ true��
+
+�����Ҳ������ʵ� bean ������ʱ��������� Spring ����Ϊ�� ��Ϊ true ʱ�����׳��쳣�����������κ����ݡ�
+
+��ע�⣬�������ʹ�ù��캯��ע�룬�����й��캯����������ǿ���Եġ�
+
+�� 4.3 �汾��ʼ�����Dz���Ҫ��ʽ��ʹ�� @Autowired ע�⹹�캯���������������������������캯����
+
+### 2.2 @Bean
+
+@Bean ���ʵ���� Spring bean �Ĺ���������
+
+```
+@Bean
+Engine engine() {
+    return new Engine();
+}
+````
+
+����Ҫ�������͵���ʵ��ʱ��Spring �������Щ������
+
+���ɵ� bean �빤������ͬ���� ����������Բ�ͬ�ķ�ʽ���������ǿ���ʹ�ô�ע�͵����ƻ�ֵ����������ֵ�Dz������Ƶı�������
+
+````
+@Bean("engine")
+Engine getEngine() {
+    return new Engine();
+}
+````
+����һ�ַdz�������bean������ʽ����Ϊ�ܶ��bean����������һ��ʼ���ڴ����ﶨ��õģ���������Ҫ��������ʱ���������а��蹹����
+
+���ǿ������ɵ������Ͷ���Bean������Ҳ���Ը������Զ����bean���ơ�
+
+ע�⣬������@Bean ע�͵ķ�����������@Configuration ���С�
+
+### 2.3 @Qualifier
+
+����ʹ��@Qualifier ��@Autowired ���ṩ������Ҫ�ڲ���ȷ�����ʹ�õ�bean id ��bean ���ơ�
+
+���磬�������� bean ʵ����ͬ�Ľӿڣ�
+````
+class Bike implements Vehicle {}
+
+class Car implements Vehicle {}
+
+````
+
+��� Spring ��Ҫע��һ�� Vehicle bean�������Զ��ƥ�䶨������� ����������£����ǿ���ʹ�� @Qualifier ע����ʽ�ṩ bean �����ơ�
+
+**������ע��**
+````
+@Autowired
+Biker(@Qualifier("bike") Vehicle vehicle) {
+this.vehicle = vehicle;
+}
+````
+
+**Setterע��**
+
+````
+@Autowired
+void setVehicle(@Qualifier("bike") Vehicle vehicle) {
+this.vehicle = vehicle;
+}
+````
+����:
+
+````
+@Autowired
+@Qualifier("bike")
+void setVehicle(Vehicle vehicle) {
+this.vehicle = vehicle;
+````
+**����ע��**
+
+````
+@Autowired
+@Qualifier("bike")
+Vehicle vehicle;
+````
+���ע�����ǿ���ƽ���õIJ��࣬���ǵ�һ���ӿ��ж��ʵ����ʱ�����ͻᾭ�������ó���
+
+### 2.4 @Required
+
+@Required �� setter �����ϱ��������Ҫͨ�� XML ���������
+````
+@Required
+void setColor(String color) {
+this.color = color;
+}
+````
+xml
+````
+<bean class="com.baeldung.annotations.Bike">
+    <property name="color" value="green" />
+</bean>
+````
+���򣬽��׳� BeanInitializationException��
+�dz��ټ����÷���֪��һ�¾�����
+
+### 2.5 @Value
+���ǿ���ʹ�� @Value ������ֵע�� bean�� ���빹�캯����setter ���ֶ�ע����ݡ�
+
+��Ҳ�Ƿdz����õ�һ��ע�⣬��Ϊ���Ǻܶ�ʱ����Ҫ��application.properties�������������ļ�������ȡ��������ֵ��
+
+**������ע��**
+````
+Engine(@Value("8") int cylinderCount) {
+this.cylinderCount = cylinderCount;
+}
+````
+
+**setterע��**
+
+````
+@Autowired
+void setCylinderCount(@Value("8") int cylinderCount) {
+this.cylinderCount = cylinderCount;
+}
+````
+
+����:
+````
+
+@Value("8")
+void setCylinderCount(int cylinderCount) {
+this.cylinderCount = cylinderCount;
+}
+````
+
+**����ע��**
+````
+@Value("8")
+int cylinderCount;
+````
+
+��Ȼ��ע�뾲ֵ̬��û���õġ� ��ˣ����ǿ����� @Value ��ʹ��ռλ���ַ������������ⲿԴ�ж����ֵ�������� .properties �� .yaml �ļ��С�
+````
+
+engine.fuelType=petrol
+````
+
+���ǿ���ͨ�����·�ʽע�� engine.fuelType ��ֵ��
+
+````
+@Value("${engine.fuelType}")
+String fuelType;
+````
+
+������������ʹ�� SpEL ��ʹ��@Value�� ����߼�ʾ�����������ǹ���@Value ���������ҵ���
+
+### 2.6 @DependsOn
+���ǿ���ʹ�ô�ע���� Spring ��ע��� bean ֮ǰ��ʼ������ bean�� ͨ��������Ϊ���Զ��ģ����� bean ֮�����ʽ������ϵ��
+
+����ֻ������������ʽ��ʱ�����Ҫ���ע�⣬����JDBC�������ػ��߾�̬������ʼ����
+
+���ǿ�����ָ������ bean ���Ƶ���������ʹ�� @DependsOn�� ע�͵�ֵ������Ҫһ���������� bean ���Ƶ����飺
+
+````
+@DependsOn("engine")
+class Car implements Vehicle {}
+````
+Alternatively, if we define a bean with the @Bean annotation, the factory method should be annotated with @DependsOn:
+````
+@Bean
+@DependsOn("fuel")
+Engine engine() {
+return new Engine();
+}
+````
+### 2.7 @Lazy
+������������س�ʼ�����ǵ� bean ʱ������ʹ�� @Lazy�� Ĭ������£�Spring ��Ӧ�ó��������ĵ�����/����ʱ���еش������е��� bean��
+
+���ǣ���Щ�����������Ҫ������ʱ���� bean����������Ӧ�ó�������ʱ������
+
+���ע�����Ϊ��������Ƿ�������ȷ��λ�ö�������ͬ�� ���ǿ��԰������ڣ�
+
+һ�� @Bean ע�͵� bean �������������ӳٷ������ã���˴��� bean��
+@Configuration ������а�����@Bean ���������ܵ�Ӱ��
+
+һ�� @Component �࣬������ @Configuration �࣬��� bean �����ӳٳ�ʼ��
+
+@Autowired ���캯����setter ���ֶΣ������ӳټ������������ͨ��������
+
+````
+@Configuration
+@Lazy
+class VehicleFactoryConfig {
+
+    @Bean
+    @Lazy(false)
+    Engine engine() {
+        return new Engine();
+    }
+}
+````
+��ͬ������һ�����õ�ע�⡣
+
+������ά��һ���д���bean����Ŀʱ���ᷢ���кܶ�bean���ܶ��ǰ���ʹ�õģ���һ����Ҫ��������ʼ��ʱ�ͽ��г�ʼ��������԰����ǽ�ʡ�ܶ�ʱ������ܡ�
+
+
+### 2.8 @Lookup
+ͬ����һ���Ƚ����õ���ע��
+
+@Lookup ����� Spring �����ǵ�����ʱ���ط����������͵�ʵ����
+
+�����ϣ�Spring ���������Ǵ�ע�͵ķ�����ʹ�����Ƿ����ķ������ͺͲ�����Ϊ BeanFactory#getBean �IJ�����
+
+@Lookup �����ڣ�
+
+��ԭ�� bean ע�������Լ���bean�������� Provider��
+
+����������ɾ���ӵ��һ��ԭ�� Spring bean����ô���Ǽ����������������������⣺
+
+���ǵĵ��� Spring bean ����η�����Щԭ�� Spring bean��
+
+���ڣ�Provider �϶���һ�ַ�ʽ������ @Lookup ��ijЩ�������ͨ�á�
+
+Ҫע����ǣ�springĬ��ʹ�õĵ���bean�������������Ҫע��ԭ��bean�����Dz���Ҫ�������Ķ��⹤��
+
+���ȣ������Ǵ���һ��ԭ�� bean���Ժ����ǽ���ע�뵽���� bean �У�
+````
+@Component
+@Scope("prototype")
+public class SchoolNotification {
+// ... prototype-scoped state
+}
+````
+ʹ��@Lookup�����ǿ���ͨ������ bean ��ȡ SchoolNotification ��ʵ����
+
+````
+@Component
+public class StudentServices {
+
+    // ... member variables, etc.
+
+    @Lookup
+    public SchoolNotification getNotification() {
+        return null;
+    }
+
+    // ... getters and setters
+}
+````
+Using @Lookup, we can get an instance of SchoolNotification through our singleton bean:
+````
+@Test
+public void whenLookupMethodCalled_thenNewInstanceReturned() {
+// ... initialize context
+StudentServices first = this.context.getBean(StudentServices.class);
+StudentServices second = this.context.getBean(StudentServices.class);
+
+    assertEquals(first, second); 
+    assertNotEquals(first.getNotification(), second.getNotification()); 
+}
+````
+��ע�⣬�� StudentServices �У����ǽ� getNotification ��������Ϊ�����
+
+������Ϊ Spring ͨ������ beanFactory.getBean(StudentNotification.class) �����˸÷�����������ǿ��Խ������ա�
+
+
+### 2.9 @Primary
+��ʱ������Ҫ��������ͬ���͵�bean�� ����Щ����£�ע�뽫���ɹ�����Ϊ Spring ��֪��������Ҫ�ĸ� bean��
+
+�����Ѿ������˴������������ѡ���@Qualifier ������н��ߵ㲢ָ������ bean �����ơ�
+
+Ȼ���������ʱ��������Ҫһ���ض��� bean��������Ҫ���� bean��
+
+���ǿ���ʹ��@Primary ����������������������@Primary �����õ�bean��������unqualified��ע����ϱ�ѡ��
+
+````
+@Component
+@Primary
+class Car implements Vehicle {}
+
+@Component
+class Bike implements Vehicle {}
+
+@Component
+class Driver {
+@Autowired
+Vehicle vehicle;
+}
+
+@Component
+class Biker {
+@Autowired
+@Qualifier("bike")
+Vehicle vehicle;
+}
+````
+��ǰ���ʾ���У���������Ҫ������ ��ˣ��� Driver ���У�Spring ע����һ�� Car bean�� ��Ȼ���� Biker bean �У��ֶ� vehicle ��ֵ����һ�� Bike ������Ϊ����qualified�ġ�
+
+### 2.10 @Scope
+
+����ͨ����Ӧ����˵������bean��scopeĬ�϶��ǵ����ģ���ʵ����spring bean����֧�ֶ��ֶ��������÷�Χ���������Ų�ͬ���������ڡ�
+
+����ʹ��@Scope ������@Component ���@Bean ����ķ�Χ�� �������ǵ�����ԭ�͡����󡢻Ự��globalSession ��һЩ�Զ��巶Χ��
+
+��Ӧ��ö��ֵΪ
+````
+singleton
+prototype
+request
+session
+application
+websocket
+````
+
+����
+````
+@Component
+@Scope("prototype")
+class Engine {}
+````
+���ǿ�������һЩ����������request��session��websocket�����������bean��ͨ��Ӧ���Ǻ�����������صģ������ô洢�û���Ϣ��session֮���bean��
+
+������ôʹ�ã���Ҫ������ľ��峡����ѡ���ˣ������һ���ܴ�Ļ��⣬������Ȳ�չ���ˣ��Ժ�����ڵ�����������������ܡ�
+
+## 3 ����������ע��
+���ǿ���ʹ�ñ�����������ע��������Ӧ�ó��������ġ�
+
+
+### 3.1 @Profile
+
+�������ϣ�� Spring �����ض������ļ����ڻ״̬ʱʹ��@Component ���@Bean ���������ǿ���ʹ��@Profile ������б�ǡ�
+
+���ǿ���ʹ��ע�͵�ֵ�������������ļ������ƣ�
+
+����ͨ�����ע�������ò�ͬ���������á�
+���������������
+
+````
+public interface DatasourceConfig {
+public void setup();
+}
+````
+
+�����ǿ������������ã�
+
+````
+@Component
+@Profile("dev")
+public class DevDatasourceConfig implements DatasourceConfig {
+@Override
+public void setup() {
+System.out.println("Setting up datasource for DEV environment. ");
+}
+}
+````
+�������������������ã�
+
+````
+@Component
+@Profile("production")
+public class ProductionDatasourceConfig implements DatasourceConfig {
+@Override
+public void setup() {
+System.out.println("Setting up datasource for PRODUCTION environment. ");
+}
+}
+````
+��Ȼ����Ҳ����ʹ��xml�����������͵������ļ��������������bean
+
+xml
+````
+<beans profile="local">
+    <bean id="localDatasourceConfig" 
+      class="org.test.profiles.LocalDatasourceConfig" />
+</beans>
+````
+### 3.2 @Import
+
+���ǿ���ʹ���ض��� @Configuration �࣬������ʹ�ô�ע��������ɨ�衣 ���ǿ���Ϊ��Щ���ṩ@Import ��ֵ����
+
+������˵�����Ҫ�õ�@Configurationע���bean����ôspringӦ�ñ���Ҫɨ�赽��Ŀ¼�����ǡ��û�жԸ�·������ɨ�裬��������ֻ����ʹ��·���µĵ��������࣬��ô���ǾͿ���ʹ��@Import����������������ˡ�
+
+���ע�⻹�Ƿdz����õģ���һ�������������
+
+````
+@Import(VehiclePartSupplier.class)
+class VehicleFactoryConfig {}
+
+@Configuration
+class VehiclePartSupplier{
+}
+````
+
+### 3.3 @ImportResource
+
+����˵��������һ�� bean.xml �������ļ�����Ҫ���� beans.xml �ж���� bean���� �����뵽 Spring Boot �����������У�����β����أ�
+
+1.Spring ��ʽ�������ļ� bean.xml �˴����ٸ�ʾ��������˵ xml ��������һ�� helloService��������ʾ
+````
+<?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">
+
+    <!--�� HelloService ��xml�ķ�ʽ,ע�뵽������-->
+    <bean id="helloService" class="com.demo.springboot.service.HelloService"></bean>
+</beans>
+````
+2.ʹ��@ImportResourceע�⣬���� xml ����
+````
+/**
+ * Spring Boot����û��Spring�������ļ��������Լ���д�������ļ���Ҳ�����Զ�ʶ��
+ * �������Spring�������ļ���Ч�����ص�Spring ����������
+ * ʹ��@ImportResourceע�⣬�����ע��һ����������(�˴�������������)
+ */
+@SpringBootApplication
+@ImportResource(locations = {"classpath:beans.xml"})
+public class BootApplication {
+
+    public static void main(String[] args) {
+        // SpringӦ����������         
+        SpringApplication.run(BootApplication.class,args);
+
+    }
+}
+
+````
+### 3.4 @PropertySource
+ͨ�����ע�⣬���ǿ���ΪӦ�ó������ö��������ļ���
+
+@PropertySource ע���ṩ��һ�ַ���������Ի��ƣ����ڽ� PropertySource ���ӵ� Spring �� Environment �У��� @Configuration ��һ��ʹ�á�
+
+�����ʹ�� @Value ȥ���ö�������ԣ����磺@Value("testbean.name")��Ҳ����ָ��Ĭ��ֵ���磺@Value("testbean.name:defaultValue")��
+
+�÷�ʾ��
+
+����һ�������ļ�app.properties
+````
+testbean.name=myTestBean
+````
+���� @Configuration ��ʹ�� @PropertySource �� app.properties ���ø� Environment �� PropertySources ���ϡ�
+````
+@Configuration
+@PropertySource("classpath:/com/myco/app.properties")
+public class AppConfig {
+
+    @Autowired
+    Environment env;
+ 
+    @Bean
+    public TestBean testBean() {
+        TestBean testBean = new TestBean();
+        testBean.setName(env.getProperty("testbean.name"));
+        return testBean;
+    }
+}
+````
+
+ע�⣺ʹ�� @Autowired �� Environment ����ע�뵽�������У�Ȼ���� testBean() ������ʹ�á�
+���������У����� testBean.getName() ���������ء�myTestBean���ַ�����
+
+@PropertySource ������ Java 8 ���ظ�ע�����ԣ�����ζ�����ǿ���������α��һ���ࣺ
+
+````
+@Configuration
+@PropertySource("classpath:/annotations.properties")
+@PropertySource("classpath:/vehicle-factory.properties")
+class VehicleFactoryConfig {}
+````
+
+### 3.5 @PropertySources
+�÷�ͬ�ϣ�ֻ��������һ�����ǿ���ʹ�����ע��ָ�����@PropertySource ���ã�
+````
+@Configuration
+@PropertySources({
+@PropertySource("classpath:/annotations.properties"),
+@PropertySource("classpath:/vehicle-factory.properties")
+})
+class VehicleFactoryConfig {}
+````
+��ע�⣬�� Java 8 ���������ǿ���ͨ�������ظ�ע�͹���ʵ����ͬ�Ĺ��ܡ�
+
+## 4.����
+
+�ڱ����У����ǿ���������� Spring ����ע�͵ĸ����� ���ǿ������������ bean ���Ӻ�Ӧ�������ģ��Լ����Ϊ���ɨ�����ࡣ
+
+spring��ϵ�еij���ע�⻹�кܶ࣬һƪ���²�����ȫ�����ǣ�������©����ӭ���䡣
+
+# Spring Beanע��
+
+## 1 ����
+�ڱ��̳��У����ǽ��������ڶ��岻ͬ���� bean ������� Spring bean ע�͡�
+
+�м��ַ��������� Spring ���������� bean�� ���ȣ����ǿ���ʹ�� XML �����������ǡ� ���ǻ���������������ʹ��@Bean ע�������� bean��
+
+������ǿ���ʹ�� org.springframework.stereotype ���е�ע��֮һ����Ǹ��࣬�������ಿ���������ɨ�衣
+
+## 2 @ComponentScan
+�������Ǿ�����ʹ�õ�һ��ע�⣬�����ǵ�Ӧ���У���ʱ��һ����ɨ�����еİ����ر��ǵ�����Ҫɨ���ⲿjar���е�beanʱ�����dz����á�
+
+�����Լ���SpringBootApplication�ϣ�Ҳ���Լ���@configurationע���ϵ���������
+
+������������ɨ�裬Spring �����Զ�ɨ����е� bean��
+
+@ComponentScan ����ʹ��ע������ɨ����Щ�����ࡣ 
+
+���ǿ���ֱ��ʹ�� basePackages �� value ����֮һָ�����������ƣ�value �� basePackages �ı�����
+
+````
+@Configuration
+@ComponentScan(basePackages = "com.baeldung.annotations")
+class VehicleFactoryConfig {}
+````
+���⣬���ǿ���ʹ�� basePackageClasses ����ָ��������е��ࣺ
+
+````
+@Configuration
+@ComponentScan(basePackageClasses = VehicleFactoryConfig.class)
+class VehicleFactoryConfig {}
+````
+
+�����������������飬������ǿ���Ϊÿ�������ṩ�������
+
+���δָ����������ɨ�跢���ڴ��� @ComponentScan ע�����ͬһ���С�
+
+@ComponentScan ������ Java 8 ���ظ�ע�����ԣ�����ζ�����ǿ���������α��һ���ࣺ
+
+````
+@Configuration
+@ComponentScan(basePackages = "com.baeldung.annotations")
+@ComponentScan(basePackageClasses = VehicleFactoryConfig.class)
+class VehicleFactoryConfig {}
+````
+
+���ߣ����ǿ���ʹ�� @ComponentScans ָ����� @ComponentScan ���ã�
+
+````
+@Configuration
+@ComponentScans({
+@ComponentScan(basePackages = "com.baeldung.annotations"),
+@ComponentScan(basePackageClasses = VehicleFactoryConfig.class)
+})
+````
+````
+class VehicleFactoryConfig {
+}
+````
+ʹ�� XML ����ʱ���������ɨ��ͬ���򵥣�
+
+````
+<context:component-scan base-package="com.baeldung"/>
+````
+
+### 3 @Component
+
+@Component ���༶���ע�⡣ �����ɨ���ڼ䣬Spring Framework ���Զ����ʹ��@Component ע����ࣺ
+````
+@Component
+class CarUtility {
+// ...
+}
+````
+
+Ĭ������£������ bean ʵ��������ͬ��������ĸСд�� ���⣬���ǿ���ʹ�ô�ע�͵Ŀ�ѡֵ����ָ����ͬ�����ơ�
+
+����@Repository��@Service��@Configuration ��@Controller ���Ǵ���@Component ��ע�⣬���ǹ�����ͬ��bean ������Ϊ�� 
+
+Spring ���������ɨ��������Զ�������ǡ�
+
+ͨ����˵�����ǻ���mvcӦ�������ǻ��õ���������ע�⣬�������ڷ�webӦ���и���ؿ���ʹ��@component��ע��bean
+
+### 4 @Repository
+
+DAO or Repository classes usually represent the database access layer in an application, and should be annotated with @Repository:
+````
+@Repository
+class VehicleRepository {
+// ...
+}
+````
+ʹ�ô�ע�͵�һ���ŵ������������Զ��־����쳣ת���� ��ʹ�ó־��Կ�ܣ��� Hibernate��ʱ����ʹ�� @Repository ע�͵������׳��ı����쳣���Զ�ת��Ϊ Spring �� DataAccessExeption �����ࡣ
+
+Ҫ�����쳣ת����������Ҫ���������Լ��� PersistenceExceptionTranslationPostProcessor bean��
+````
+@Bean
+public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
+return new PersistenceExceptionTranslationPostProcessor();
+}
+````
+��ע�⣬�ڴ��������£�Spring ���Զ�ִ���������衣
+
+����ͨ�� XML ���ã�
+````
+<bean class=
+"org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>
+````
+
+### 5 @Service
+Ӧ�ó����ҵ���߼�ͨ��פ���ڷ�����У�������ǽ�ʹ��@Service ע����ָʾһ�������ڸò㣺
+
+````
+@Service
+public class VehicleService {
+// ...    
+}
+````
+### 6 @Controller
+@Controller ��һ���༶���ע�⣬������ Spring Framework �������Ϊ Spring MVC �еĿ�������
+
+spring���@Controller ע���bean���ܶ����飬�����������ǻ���SpringMVC��ص�����������
+
+````
+@Controller
+public class VehicleController {
+// ...
+}
+
+````
+## 7 @Configuration
+
+��������԰�����@Bean ע�͵� bean ���巽����
+````
+@Configuration
+class VehicleFactoryConfig {
+
+    @Bean
+    Engine engine() {
+        return new Engine();
+    }
+
+}
+````
+## 8 AOPע��
+������ʹ�� Spring ������ע��ʱ�������״���һ������㣬������������о����ض������͵���ΪĿ�ꡣ
+
+���磬������������� DAO �㷽����ִ��ʱ�䡣 ���ǽ��������·��棨ʹ�� AspectJ ע�ͣ������� @Repository �����ͣ�
+
+```
+@Aspect
+@Component
+public class PerformanceAspect {
+@Pointcut("within(@org.springframework.stereotype.Repository *)")
+public void repositoryClassMethods() {};
+
+    @Around("repositoryClassMethods()")
+    public Object measureMethodExecutionTime(ProceedingJoinPoint joinPoint) 
+      throws Throwable {
+        long start = System.nanoTime();
+        Object returnValue = joinPoint.proceed();
+        long end = System.nanoTime();
+        String methodName = joinPoint.getSignature().getName();
+        System.out.println(
+          "Execution of " + methodName + " took " + 
+          TimeUnit.NANOSECONDS.toMillis(end - start) + " ms");
+        return returnValue;
+    }
+}
+````
+
+�ڴ�ʾ���У����Ǵ�����һ������㣬�������ƥ��ʹ��@Repository ע�͵����е����з����� Ȼ������ʹ��@Around ֪ͨ����λ�Ǹ�����㣬��ȷ�����ط������õ�ִ��ʱ�䡣
+
+���⣬ʹ�����ַ��������ǿ���Ϊÿ��Ӧ�ó����������־��¼�����ܹ�������ƺ�������Ϊ��
+
+��Ȼ�ˣ�aspectJ�����ע�⻹�ܶ࣬���������������棬δ������Ҳ�ᵥ��д�Ľ��ܡ�
+
+## 9 ����
+
+�ڱ����У����Ǽ���� Spring ������ע�Ͳ����������Ǹ��Դ������������͡�
+
+���ǻ�ѧϰ�����ʹ�����ɨ����������������������ҵ���ע�͵��ࡣ
+
+��������˽�����Щע����ε��¸ɾ����ֲ������Լ�Ӧ�ó����ע��֮��ķ��롣 ���ǻ�ʹ���ø�С����Ϊ���Dz�����Ҫ�ֶ���ʽ���� bean��
+
+# �����
+https://www.baeldung.com/spring-annotations
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\346\246\202\350\277\260.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\346\246\202\350\277\260.md"
new file mode 100644
index 0000000..e9a041f
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/Spring\346\246\202\350\277\260.md"
@@ -0,0 +1,145 @@
+Spring �� Java EE ��������һ���������Ŀ�Դ��ܣ��ɱ���Ϊ��Spring ֮������ Rod Johnson �� 2002 �����������������Ŀ�����Ҫ�� Java ��ҵ��Ӧ�ó���Ŀ����ѶȺ����ڡ�
+
+Spring �Ե�����������������һֱ����󿪷���Ա��Ϊ Java ��ҵ��Ӧ�ó��򿪷�����ѡ��ʱ�����գ�Spring ٲȻ��Ϊ�� Java EE �����ʣ���Ϊ�˹��� Java EE Ӧ�õ���ʵ��׼��
+
+## Spring �ĵ����뷢չ
+
+���ڵ� J2EE��Java EE ƽ̨���Ƴ��� EJB Ϊ���ĵĿ�����ʽ�������ֿ�����ʽ��ʵ�ʵĿ��������д������ֱ׶ˣ�����ʹ�ø��ӡ�����ӷ�ס�����������ǿ���������ڳ�����ֲ�Ѷȴ�ȡ�
+
+Rod Johnson ���� 2004 ������ij����顶Expert One-on-One J2EE Development without EJB���У���� EJB ����ӷ�׵Ľṹ��������һ�ķ����ͷ񶨣����ֱ��Ը��Ӽ��ķ�ʽ�������滻��
+
+���Ȿ���У�Rod Johnson ͨ��һ������ 3 ���д���ĸ�����չʾ������ڲ�ʹ�� EJB ������¹���һ��������������չ�� Java Ӧ�ó�������������У�Rod Johnson ��д�������л����ṹ���룬���а�������������õ� Java �ӿں��࣬���� ApplicationContext��BeanFactory �ȡ���Щ��ĸ���������Ϊ com.interface21������Ϊ�������ṩ�� 21 ���͵�һ���ο���
+
+�Ȿ��Ӱ����Զ������ Rod Johnson �� com.interface21 �Ĵ��뿪Դ����������¿�ܲ�����Ϊ��Spring��������Ϊ��Spring ��һ�ƴ���һ����ɨƽ��ͳ J2EE �ĺ�����
+
+2003 �� 2 �£�Spring 0.9 �汾�������������� Apache 2.0 ��ԴЭ�飻2004 �� 4 �£�Spring 1.0 �汾��ʽ��������ĿǰΪֹ��Spring �Ѿ����뵽�˵� 5 ����汾��Ҳ�������dz�˵�� Spring 5��
+
+## Spring ������͹���
+
+�ڲ�ͬ���ﾳ�У�Spring �������ĺ����Dz�ͬ�ġ��������Ǿͷֱ�ӡ����塱�͡����塱�����Ƕȣ��� Spring ���н��ܡ�
+
+### ����� Spring��Spring ����ջ
+
+�����ϵ� Spring ��ָ�� Spring Framework Ϊ���ĵ� Spring ����ջ��
+
+����ʮ����ķ�չ��Spring �Ѿ�������һ��������Ӧ�ÿ�ܣ������𽥷�չ��Ϊһ���ɶ����ͬ����Ŀ��ģ�飩��ɵij��켼�������� Spring Framework��Spring MVC��SpringBoot��Spring Cloud��Spring Data��Spring Security �ȣ����� Spring Framework ����������Ŀ�Ļ�����
+
+��Щ����Ŀ�����˴���ҵ��Ӧ�ÿ������Ƽ���ȸ���������ݣ��ܹ�����������Ա���������չ�����в��ϲ����ĸ���ʵ�����⣬��������Ա�����˸��õĿ������顣
+
+| ��Ŀ���� | ���� |  
+| --- | --- |  
+| Spring Data | Spring �ṩ�����ݷ���ģ�飬�� JDBC �� ORM �ṩ�˺ܺõ�֧�֡�ͨ������������Ա����ʹ��һ�����ͳһ�ķ�ʽ��������λ�ڲ�ͬ�������ݿ��е����ݡ� |  
+| Spring Batch | һ��ר�������ҵ��ϵͳ�е��ճ��������������������ܣ��ܹ�����������Ա����Ŀ�������׳����Ч��������Ӧ�ó��� |  
+| Spring Security | ǰ��Ϊ Acegi���� Spring �нϳ������ģ��֮һ������һ����Զ��ƻ���������֤�ͷ��ʿ��ƿ�ܡ� |  
+| Spring Mobile | �Ƕ� Spring MVC ����չ���������ƶ��� Web Ӧ�õĿ����� |  
+| Spring Boot | �� Spring �Ŷ��ṩ��ȫ�¿�ܣ���Ϊ Spring �Լ���������һЩ���伴�õ����ã����Լ� Spring Ӧ�õĴ���������̡� |  
+| Spring Cloud | һ����� Spring Boot ʵ�ֵ�΢�����ܡ���������ijһ�ż���������һϵ��΢�������������ܵ����򼯺ϡ����������ϳ���ġ�������֤��΢������������������ͨ�� Spring Boot ��˼������ٷ�װ�����ε����и��ӵ����ú�ʵ��ԭ��������Ϊ������Ա�ṩ��һ�׼��׶����ײ������ά���ķֲ�ʽϵͳ�������߰��� |  
+
+### ����� Spring��Spring Framework
+
+����� Spring ��ָ Spring Framework��ͨ�����ǽ�����Ϊ Spring ��ܡ�
+
+Spring �����һ���ֲ�ġ���������� Java Ӧ�ó����һվʽ������������������� Spring ����ջ�ĺ��ĺͻ�������Ϊ�˽����ҵ��Ӧ�ÿ����ĸ����Զ������ġ�
+
+Spring ���������IJ��֣� IoC �� AOP��
+
+| ���� | ���� |  
+| --- | --- |  
+| IOC | Inverse of Control �ļ�д����Ϊ�����Ʒ�ת����ָ�Ѵ���������̽��� Spring ���й����� |  
+| AOP | Aspect Oriented Programming �ļ�д����Ϊ�����������̡���AOP ������װ�����Ĺ�����Ϊ������Щ��ҵ���޹أ�ȴΪҵ��ģ������ͬ���õ��߼���װ����������ϵͳ���ظ����룬����ģ������϶ȡ����⣬AOP �����һЩϵͳ�����ϵ����⣬������־������Ȩ�޵ȡ� |  
+
+Spring ��һ�ֻ��� Bean �ı�̼���������̵ظı��� Java �������硣Spring ʹ�ü򵥡������� Java Bean �������ǰֻ�� EJB ������ɵĹ�����ʹ�úܶิ�ӵĴ��������źͼ�࣬������ EJB ӷ�ס���Ч�Ŀ���ģʽ������ķ�����Ŀ�ĺ���ά������������չ��
+
+��ʵ�ʿ����У���������Ӧ�ó���ͨ������������ϵ�ܹ����ֱ�Ϊ���ֲ㣨web����ҵ���߼��㣨service�����־ò㣨dao����
+
+Spring ������ Java EE Ӧ�ø���Ľ����������ÿһ�㶼�ṩ�˼���֧�֡�
+
+*   �ڱ��ֲ��ṩ�˶� Spring MVC��Struts2 �ȿ�ܵ����ϣ�
+*   ��ҵ���߼����ṩ�˹�������ͼ�¼��־�Ĺ��ܣ�
+*   �ڳ־ò㻹�������� MyBatis��Hibernate �� JdbcTemplate �ȼ����������ݿ���з��ʡ�
+
+���ֵ������� Spring ��һ��ȫ��Ľ��������������Щ�Ѿ��нϺý������������Spring �������ظ������顣
+
+������Ͽ���Spring ��ܸ����� Java ����Ա���ߵ����ɶȣ���ҵ��ij�������Ҳ�ṩ�����õĽ������������ڿ�Դ�����ܵ��˹㷺�Ļ�ӭ�����ұ��󲿷ֹ�˾��Ϊ Java ��Ŀ��������ѡ��ܡ�
+
+## Spring Framework ���ص�
+
+Spring ��ܾ������¼����ص㡣
+
+### **�������򻯿���**
+
+Spring ����һ���󹤳������Խ����ж���Ĵ�����������ϵ��ά������ Spring ������
+
+### **���㼯�ɸ���������**
+
+Spring ���ų��������Ŀ�Դ��ܣ����ڲ��ṩ�˶Ը��������ܣ��� Struts2��Hibernate��MyBatis �ȣ���ֱ��֧�֡�
+
+### **���� Java EE API ��ʹ���Ѷ�**
+
+Spring �� Java EE �����зdz����õ�һЩ API��JDBC��JavaMail��Զ�̵��õȣ����ṩ�˷�װ��ʹ��Щ API Ӧ�õ��Ѷȴ�󽵵͡�
+
+### **�������IJ���**
+
+Spring ֧�� JUnit4������ͨ��ע�ⷽ��ز��� Spring ����
+
+### **AOP ��̵�֧��**
+
+Spring �ṩ���������̣����Է����ʵ�ֶԳ������Ȩ�����غ����м�صȹ��ܡ�
+
+### **����ʽ�����֧��**
+
+ֻ��Ҫͨ�����þͿ�����ɶ�����Ĺ������������ֶ���̡�
+
+Spring ��ܻ�����������ҵ��Ӧ�ÿ����ĸ������棬�������� 20 �����ͬ��ģ�顣
+
+ spring-aop      spring-context-indexer  spring-instrument  spring-orm    spring-web  
+spring-aspects  spring-context-support  spring-jcl         spring-oxm    spring-webflux  
+spring-beans    spring-core             spring-jdbc        spring-r2dbc  spring-webmvc  
+spring-context  spring-expression       spring-jms         spring-test   spring-websocket  
+spring-messaging   spring-tx     
+
+![Spring��ϵ�ṹͼ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/163550G63-0.png)  
+ͼ1��Spring�ܹ�ͼ
+
+��ͼ�а����� Spring ��ܵ�����ģ�飬��Щģ���������һ����ҵ��Ӧ�ÿ����������ڿ��������п��Ը���������ѡ���Ե�ʹ������Ҫ��ģ�顣����ֱ����Щģ������ý��м򵥽��ܡ�
+
+## 1\. Data Access/Integration�����ݷ��ʣ����ɣ�
+
+���ݷ��ʣ����ɲ���� JDBC��ORM��OXM��JMS �� Transactions ģ�飬����������¡�
+
+*   JDBC ģ�飺�ṩ��һ�� JBDC ������ģ�壬ʹ����Щģ����������ͳ�߳��� JDBC ���뻹�б����������ƣ����������ܵ� Spring ��������ĺô���
+*   ORM ģ�飺�ṩ�����еġ�����-��ϵ��ӳ�����޷켯�ɵ� API������ JPA��JDO��Hibernate �� MyBatis �ȡ����һ�����ʹ�� Spring �����������������������
+*   OXM ģ�飺�ṩ��һ��֧�� Object /XML ӳ��ij����ʵ�֣��� JAXB��Castor��XMLBeans��JiBX �� XStream���� Java ����ӳ��� XML ���ݣ����߽�XML ����ӳ��� Java ����
+*   JMS ģ�飺ָ Java ��Ϣ�����ṩһ�� ����Ϣ�����ߡ���Ϣ�����ߡ�ģ�����ڸ��Ӽ򵥵�ʹ�� JMS��JMS ��������������Ӧ�ó���֮�䣬��ֲ�ʽϵͳ�з�����Ϣ�������첽ͨ�š�
+*   Transactions ����ģ�飺֧�ֱ�̺�����ʽ���������
+
+## 2\. Web ģ��
+
+Spring �� Web ����� Web��Servlet��WebSocket �� Portlet ���������������¡�
+
+*   Web ģ�飺�ṩ�˻����� Web �����������ԣ�������ļ��ϴ����ܡ�ʹ�õ� Servlet �������� IOC ������ʼ���Լ� Web Ӧ�������ġ�
+*   Servlet ģ�飺�ṩ��һ�� Spring MVC Web ���ʵ�֡�Spring MVC ����ṩ�˻���ע���������Դע�롢���򵥵����ݰ󶨡�������֤�ȼ�һ�׷dz����õ� JSP ��ǩ����ȫ�޷��� Spring ��������Э����
+*   WebSocket ģ�飺�ṩ�˼򵥵Ľӿڣ��û�ֻҪʵ����Ӧ�ĽӿھͿ��Կ��ٵĴ WebSocket Server���Ӷ�ʵ��˫��ͨѶ��
+*   Portlet ģ�飺�ṩ���� Portlet ������ʹ�� MVC ʵ�֣����� Web-Servlet ģ��Ĺ��ܡ�
+
+## 3\. Core Container��Spring ���������
+
+Spring �ĺ�������������ģ�齨���Ļ������� Beans ģ�顢Core ����ģ�顢Context ������ģ��� SpEL ����ʽ����ģ����ɣ�û����Щ����������Ҳ�������� AOP��Web ���ϲ�Ĺ��ܡ�����������¡�
+
+*   Beans ģ�飺�ṩ�˿�ܵĻ������֣��������Ʒ�ת������ע�롣
+*   Core ����ģ�飺��װ�� Spring ��ܵĵײ㲿�֣�������Դ���ʡ�����ת����һЩ���ù����ࡣ
+*   Context ������ģ�飺������ Core �� Beans ģ��Ļ���֮�ϣ����� Beans ģ�鹦�ܲ�������Դ�󶨡�������֤�����ʻ���Java EE ֧�֡������������ڡ��¼������ȡ�ApplicationContext �ӿ���������ģ��Ľ��㡣
+*   SpEL ģ�飺�ṩ��ǿ��ı���ʽ����֧�֣�֧�ַ��ʺ��޸�����ֵ���������ã�֧�ַ��ʼ��޸����顢������������������������֧���������߼����㣬֧�ִ� Spring ������ȡ Bean����Ҳ֧���б�ͶӰ��ѡ���һ����б��ۺϵȡ�
+
+## 4\. AOP��Aspects��Instrumentation �� Messaging
+
+�� Core Container ֮���� AOP��Aspects ��ģ�飬����������£�
+
+*   AOP ģ�飺�ṩ������������ʵ�֣��ṩ������־��¼��Ȩ�޿��ơ�����ͳ�Ƶ�ͨ�ù��ܺ�ҵ���߼�����ļ����������ܶ�̬�İ���Щ�������ӵ���Ҫ�Ĵ����У�������˾��ְ������ҵ���߼���ͨ�ù��ܵ���ϡ�
+*   Aspects ģ�飺�ṩ�� AspectJ �ļ��ɣ���һ������ǿ���ҳ�������������̣�AOP����ܡ�
+*   Instrumentation ģ�飺�ṩ���๤�ߵ�֧�ֺ����������ʵ�֣��������ض���Ӧ�÷�������ʹ�á�
+*   messaging ģ�飺Spring 4.0 �Ժ���������Ϣ��Spring-messaging��ģ�飬��ģ���ṩ�˶���Ϣ������ϵ�ṹ��Э���֧�֡�
+
+## 5\. Test ģ��
+
+Test ģ�飺Spring ֧�� Junit �� TestNG ���Կ�ܣ����һ������ṩ��һЩ���� Spring �IJ��Թ��ܣ������ڲ��� Web ���ʱ��ģ�� Http ����Ĺ��ܡ�
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/\347\254\254\344\270\200\344\270\252Spring\345\272\224\347\224\250.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/\347\254\254\344\270\200\344\270\252Spring\345\272\224\347\224\250.md"
new file mode 100644
index 0000000..b40a369
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring/\347\254\254\344\270\200\344\270\252Spring\345\272\224\347\224\250.md"
@@ -0,0 +1,70 @@
+## ��������
+�������ǿ����Ȱ� Spring ���� Jar ���Լ� Commons-loggin ���뵽��Ŀ�У��������������ӣ��������Ҫ�ٵ��� Spring ������ Jar��
+
+````
+org.springframework.core-5.3.13.jar
+org.springframework.beans-5.3.13.jar
+spring-context-5.3.13.jar
+spring-expression-5.3.13.jar
+commons.logging-1.2.jar
+````
+��Ȼ���������Ƽ�ʹ��maven��������
+
+## ���� Java ��
+   �� HelloSpring �д��� net.biancheng.c ����Ȼ����������´��� HelloWorld.java �� MainApp.java �ࡣ
+
+HelloWorld.java ��Ĵ�������
+````
+package net.biancheng.c;
+public class HelloWorld {
+    private String message;
+    public void setMessage(String message) {
+        this.message = message;
+    }
+    public void getMessage() {
+        System.out.println("message : " + message);
+    }
+}
+````
+MainApp.java ��Ĵ�������
+````
+package net.biancheng.c;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+    public class MainApp {
+        public static void main(String[] args) {
+            ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
+            HelloWorld obj = context.getBean("helloWorld",HelloWorld.class);
+            obj.getMessage();
+        }
+    }
+````
+�������ϴ��룬��Ҫע���������㣺
+
+���� ApplicationContext ����ʱʹ���� ClassPathXmlApplicationContext �࣬��������ڼ��� Spring �����ļ��������ͳ�ʼ�����ж���Bean����
+ApplicationContext.getBean() ����������ȡ Bean���÷�������ֵ����Ϊ Object��ͨ��ǿ������ת��Ϊ HelloWorld ��ʵ�����󣬵������е� getMessage() ������
+
+## ���������ļ�
+
+�� src Ŀ¼�£�����һ�� Spring �����ļ� Beans.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-3.0.xsd">
+    <bean id="helloWorld" class="net.biancheng.c.HelloWorld">
+        <property name="message" value="Hello World!" />
+    </bean>
+</beans>
+````
+����Ҳ���Խ��������ļ�����Ϊ������Ч�����ƣ�����Ҫע����ǣ����ļ��������� MainApp.java �ж�ȡ�������ļ�����һ�¡�
+
+Beans.xml ���ڸ���ͬ�� Bean ����Ψһ�� ID��������Ӧ�� Bean ���Ը�ֵ�����磬�����ϴ����У����ǿ����ڲ�Ӱ�������������£��� message ������ֵ��
+## �����
+
+   ���� MainApp.java��Eclipse IDE ����̨����ʾ��Ϣ���¡�
+   message : Hello World!
+
+���ˣ����Ǿͳɹ������˵�һ�� Spring Ӧ�ó���
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\344\270\255\347\232\204\344\273\273\345\212\241\350\260\203\345\272\246\344\270\216@Async.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\344\270\255\347\232\204\344\273\273\345\212\241\350\260\203\345\272\246\344\270\216@Async.md"
new file mode 100644
index 0000000..c3bce06
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\344\270\255\347\232\204\344\273\273\345\212\241\350\260\203\345\272\246\344\270\216@Async.md"
@@ -0,0 +1,240 @@
+
+
+<header>
+
+# Spring Boot����
+
+�������ݽ���վ�������Ѹ���ѧϰ�ʼǡ��ܽ���о��ղء�����֤��ȷ�ԣ���ʹ�ö������ķ����뱾վ�޹أ�
+
+</header>
+
+
+
+<script>( adsbygoogle = window.adsbygoogle || []).push({});</script>
+
+
+
+������ִ���ض�ʱ��ε�����Ĺ��̡�Spring BootΪ��SpringӦ�ó����ϱ�д���ȳ����ṩ�˺ܺõ�֧�֡�
+
+## Java Cron����ʽ
+
+Java Cron����ʽ��������CronTrigger��ʵ��������`org.quartz.Trigger`�����ࡣ �й�Java cron����ʽ�ĸ�����Ϣ������Ĵ����� -
+
+*   [https://docs.oracle.com/cd/E12058_01/doc/doc.1014/e12030/cron_expressions.html](https://docs.oracle.com/cd/E12058_01/doc/doc.1014/e12030/cron_expressions.html)
+
+`[@EnableScheduling](https://github.com/EnableScheduling "@EnableScheduling")`ע������ΪӦ�ó������õ��ȳ��򡣽�����ע���ӵ���Spring BootӦ�ó������ļ��С�
+
+```
+@SpringBootApplication
+@EnableScheduling
+
+public class DemoApplication {
+   public static void main(String[] args) {
+      SpringApplication.run(DemoApplication.class, args);
+   }
+}
+
+```
+
+`[@Scheduled](https://github.com/Scheduled "@Scheduled")`ע���������ض�ʱ����ڴ������ȳ���
+
+```
+@Scheduled(cron = "0 * 9 * * ?")
+public void cronJobSch() throws Exception {
+}
+
+```
+
+������һ��ʾ�����룬��ʾ�����ÿ������9:00��ʼ��ÿ������9:59����ִ������
+
+```
+package com.yiibai.demo.scheduler;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+@Component
+public class Scheduler {
+   @Scheduled(cron = "0 * 9 * * ?")
+   public void cronJobSch() {
+      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
+      Date now = new Date();
+      String strDate = sdf.format(now);
+      System.out.println("Java cron job expression:: " + strDate);
+   }
+}
+
+```
+
+������Ļ��ͼ��ʾ��Ӧ�ó��������`09:03:23`���������Ҵ���ʱ��ÿ��һ����ִ��һ��cron��ҵ���ȳ�������
+
+![](/uploads/images/2018/10/05/103218_77311.jpg)
+
+## �̶�����
+
+�̶����ʵ��ȳ����������ض�ʱ��ִ�����������ȴ�ǰһ���������ɡ� ֵ���Ժ���Ϊ��λ�� ʾ��������ʾ�ڴ˴� -
+
+```
+@Scheduled(fixedRate = 1000)
+public void fixedRateSch() { 
+}
+
+```
+
+�˴���ʾ��Ӧ�ó�������ʱÿ��ִ�������ʾ������ -
+
+```
+package com.yiibai.demo.scheduler;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+@Component
+public class Scheduler {
+   @Scheduled(fixedRate = 1000)
+   public void fixedRateSch() {
+      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
+
+      Date now = new Date();
+      String strDate = sdf.format(now);
+      System.out.println("Fixed Rate scheduler:: " + strDate);
+   }
+}
+
+```
+
+��ע��������Ļ��ͼ��������ʾ����`09:12:00`������Ӧ�ó���֮��ÿ��һ���̶����ʵ��ȳ���ִ������
+
+![](/uploads/images/2018/10/05/103355_72877.jpg)
+
+## �̶��ӳ�
+
+�̶��ӳٵ��ȳ����������ض�ʱ��ִ������ ��Ӧ�õȴ���һ��������ɡ� ֵӦ�Ժ���Ϊ��λ�� �˴���ʾʾ������ -
+
+```
+@Scheduled(fixedDelay = 1000, initialDelay = 1000)
+public void fixedDelaySch() {
+}
+
+```
+
+���`initialDelay`���ڳ�ʼ�ӳ�ֵ֮���һ��ִ�������ʱ�䡣
+
+��Ӧ�ó����������`3`���ÿ��ִ��һ�������ʾ��������ʾ -
+
+```
+package com.yiibai.demo.scheduler;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+@Component
+public class Scheduler {
+   @Scheduled(fixedDelay = 1000, initialDelay = 3000)
+   public void fixedDelaySch() {
+      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
+      Date now = new Date();
+      String strDate = sdf.format(now);
+      System.out.println("Fixed Delay scheduler:: " + strDate);
+   }
+}
+
+```
+
+ִ����������������ʾ��`09:18:39`��ʼ��Ӧ�ó���ÿ`3`��󣬹̶��ӳټƻ���������(ÿ��ִ��һ��)��
+
+
+
+
+
+//�������Ķ���https://www.yiibai.com/spring-boot/spring_boot_scheduling.html
+
+@EnableAsync ע��
+Ҫʹ�� @Async��������Ҫʹ�� @EnableAsync ע�⿪�� Spring Boot �е��첽���ԡ�
+
+@Configuration
+@EnableAsync
+public class AppConfig {
+}
+����ϸ������˵�������Բο���AsyncConfigurer(opens new window)
+
+#@Async ע��
+#֧�ֵ��÷�
+��1��������޷���ֵ����
+
+�������� @Async ע�����η��������������������첽��ʽ���á����仰˵�������ڵ��ô˷���ʱ���������أ���������ʵ��ִ�з��������ύ�� Spring TaskExecutor �������С�����򵥵�����£������Խ�ע��Ӧ���ڷ��� void �ķ�����������ʾ����ʾ��
+
+@Async
+void doSomething() {
+// this will be executed asynchronously
+}
+��2��������޷���ֵ����
+
+��ʹ�� @Scheduled ע��ע�͵ķ�����ͬ����Щ��������ָ����������Ϊ����������ʱ�ɵ������ԡ���������ʽ���ã������������������ĵ���������á����磬���´����� @Async ע��ĺϷ�Ӧ�ã�
+
+@Async
+void doSomething(String s) {
+// this will be executed asynchronously
+}
+��3��������з���ֵ����
+
+���������첽���÷���ֵ�ķ��������ǣ���Щ������Ҫ���� Future ���͵ķ���ֵ������Ȼ�ṩ���첽ִ�еĺô����Ա�����߿����ڵ��� Future �ϵ� get() ֮ǰִ��������������ʾ����ʾ����ڷ���ֵ�ķ�����ʹ��@Async��
+
+@Async
+Future<String> returnSomething(int i) {
+// this will be executed asynchronously
+}
+#��֧�ֵ��÷�
+@Async �������������ڻص�һ��ʹ�ã����� @PostConstruct��
+
+Ҫ�첽��ʼ�� Spring bean������ʹ�õ����ij�ʼ�� Spring bean��Ȼ����Ŀ���ϵ��� @Async ��ע�͵ķ�����������ʾ����ʾ��
+
+public class SampleBeanImpl implements SampleBean {
+
+    @Async
+    void doSomething() {
+        // ...
+    }
+
+}
+
+public class SampleBeanInitializer {
+
+    private final SampleBean bean;
+
+    public SampleBeanInitializer(SampleBean bean) {
+        this.bean = bean;
+    }
+
+    @PostConstruct
+    public void initialize() {
+        bean.doSomething();
+    }
+
+}
+#��ȷָ��ִ����
+Ĭ������£��ڷ�����ָ�� @Async ʱ��ʹ�õ�ִ�������������첽֧��ʱ���õ�ִ�����������ʹ�� XML �� AsyncConfigurer ʵ�֣�����У�����Ϊ annotation-driven Ԫ�ء����ǣ������Ҫָʾ��ִ�и�������ʱӦʹ��Ĭ��ֵ�����ִ�����������ʹ�� @Async ע��� value ���ԡ�����ʾ����ʾ�����ִ�д˲�����
+
+@Async("otherExecutor")
+void doSomething(String s) {
+// this will be executed asynchronously by "otherExecutor"
+}
+����������£���otherExecutor�������� Spring �������κ� Executor bean �����ƣ�Ҳ���������κ� Executor �������޶��������ƣ����磬ʹ�� <qualifier> Ԫ�ػ� Spring �� @Qualifier ע��ָ���� ����
+
+#���� @Async ���쳣
+�� @Async �����ķ���ֵ����Ϊ Future ��ʱ�������׹����ڷ���ִ���ڼ��׳����쳣����Ϊ�ڵ��� get ���ʱ���׳����쳣�����ǣ����ڷ���ֵ����Ϊ void �͵ķ������쳣���ᱻ�������޷����䡣�������ṩ AsyncUncaughtExceptionHandler �����������쳣������ʾ����ʾ�����ִ�д˲�����
+
+public class MyAsyncUncaughtExceptionHandler implements AsyncUncaughtExceptionHandler {
+
+    @Override
+    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
+        // handle exception
+    }
+}
+Ĭ������£�����¼�쳣��������ʹ�� AsyncConfigurer �� <task��annotation-driven /> XML Ԫ�ض����Զ��� AsyncUncaughtExceptionHandler��
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\344\270\255\347\232\204\346\227\245\345\277\227\347\256\241\347\220\206.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\344\270\255\347\232\204\346\227\245\345\277\227\347\256\241\347\220\206.md"
new file mode 100644
index 0000000..009576d
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\344\270\255\347\232\204\346\227\245\345\277\227\347\256\241\347\220\206.md"
@@ -0,0 +1,806 @@
+## 4\. ��־
+
+
+
+
+
+Spring Boot�������ڲ���־��ʹ�� [Commons Logging](https://commons.apache.org/logging) �����Եײ���־��ʵ�ֱ��ֿ��š� Ϊ [Java Util Logging](https://docs.oracle.com/javase/17/docs/api/java/util/logging/package-summary.html) �� [Log4j2](https://logging.apache.org/log4j/2.x/) �� [Logback](https://logback.qos.ch/) �ṩ��Ĭ�����á� ��ÿһ������£���¼����logger������Ԥ��Ϊʹ�ÿ���̨�����Ҳ����ѡ��������ļ���
+
+
+
+
+
+Ĭ������£������ʹ�� ��Starter������Ĭ��ʹ��Logback�� �ʵ���Logback·��Ҳ�������ڣ���ȷ��ʹ��Java Util Logging��Commons Logging��Log4J��SLF4J�������ⶼ����ȷ������
+
+
+
+
+
+|  | �кܶ�������Java����־��ܡ� ���������б��������ܻ��ң��벻Ҫ���ġ� һ����˵���㲻��Ҫ�ı������־������Spring Boot��Ĭ��ֵ�ͺܺ��á� |
+| --- | --- |
+
+
+
+
+
+|  | ��������Ӧ�ó�����һ��servlet������Ӧ�÷�����ʱ����Java Util Logging APIִ�е���־���ᱻ���͵����Ӧ�ó������־�С� ����Է�ֹ�������������Ѿ���������Ӧ�ó���ִ�е���־���������Ӧ�ó������־�С� |
+| --- | --- |
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.logging.log-format)4.1\. ��־��ʽ
+
+
+
+Spring Boot��Ĭ�ϵ���־�����ʽ��������������ӡ�
+
+
+
+
+
+
+
+ 2023-03-03T21:18:18.827+08:00  INFO 19388 --- [           main] o.s.b.d.f.s.MyApplication                : Starting MyApplication using Java 17 with PID 19388 (/opt/apps/myapp.jar started by myuser in /opt/apps/)
+2023-03-03T21:18:18.834+08:00  INFO 19388 --- [           main] o.s.b.d.f.s.MyApplication                : No active profile set, falling back to 1 default profile: "default"
+2023-03-03T21:18:20.439+08:00  INFO 19388 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
+2023-03-03T21:18:20.461+08:00  INFO 19388 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
+2023-03-03T21:18:20.461+08:00  INFO 19388 --- [           main] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.5]
+2023-03-03T21:18:20.600+08:00  INFO 19388 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
+2023-03-03T21:18:20.602+08:00  INFO 19388 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 1685 ms
+2023-03-03T21:18:21.078+08:00  INFO 19388 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
+2023-03-03T21:18:21.093+08:00  INFO 19388 --- [           main] o.s.b.d.f.s.MyApplication                : Started MyApplication in 2.998 seconds (process running for 3.601) 
+
+
+
+
+
+
+
+�������Ŀ���¡�
+
+
+
+
+
+*   Date��ʱTime����ȷ�����룬��������
+
+*   ��־����: `ERROR`, `WARN`, `INFO`, `DEBUG`, �� `TRACE`.
+
+*   ����ID��
+
+*   һ�� `---` �ָ�����������ʵ����־��Ϣ�Ŀ�ʼ��
+
+*   �߳����ƣ������ڷ������У����ڿ���̨������ܻᱻ�ضϣ���
+
+*   ��¼�����ƣ���ͨ����Դ������ƣ�ͨ������д����
+
+*   ��־��Ϣ��
+
+
+
+
+
+|  | Logbackû�� `FATAL` ���� ����ӳ�䵽 `ERROR`�� |
+| --- | --- |
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.logging.console-output)4.2\. ����̨���
+
+
+
+Ĭ������£���־����� `ERROR`��`WARN` �� `INFO` �������Ϣ������̨�� ��Ҳ����ͨ���� `--debug` ��־�������Ӧ�ó��������� `debug` ģʽ��
+
+
+
+
+
+
+
+```
+$ java -jar myapp.jar --debug
+```
+
+
+
+
+
+
+
+|  | ��Ҳ��������� `application.properties` ��ָ�� `debug=true`�� |
+| --- | --- |
+
+
+
+
+
+��debugģʽ������ʱ��һЩ���ļ�¼����Ƕ��ʽ������Hibernate��Spring Boot��������Ϊ���������Ϣ�� ����debugģʽ������ζ�Ž����Ӧ�ó�������Ϊ�� `DEBUG` �����¼������Ϣ��
+
+
+
+
+
+���⣬�����ͨ��������Ӧ�ó���ʱʹ�� `--trace` ��־������ `application.properties` ��ʹ�� `trace=true` �������� ��trace�� ģʽ�� ���������Զ�һЩ���ļ�¼����Ƕ��ʽ������Hibernate schema���ɺ�����Spring��ϣ����и��ټ�¼��
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.logging.console-output.color-coded)4.2.1\. ��ɫ��������
+
+
+
+�������ն�֧��ANSI���ͻ�ʹ�ò�ɫ����������Ķ��� ����Խ� `spring.output.ansi.enabled` ����Ϊ [֧�ֵ�ֵ](https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/api/org/springframework/boot/ansi/AnsiOutput.Enabled.html)���Ը����Զ���⡣
+
+
+
+
+
+��ɫ������ͨ��ʹ�� `%clr` ת���ؼ��������õġ� ������򵥵���ʽ�У�ת����������־��������������ɫ�����������������ʾ��
+
+
+
+
+
+
+
+```
+%clr(%5p)
+```
+
+
+
+
+
+
+
+�±���������־��������ɫ��ӳ���ϵ��
+
+
+
+<colgroup><col><col></colgroup>
+| ��־���� | ��ɫ |
+| --- | --- |
+| `FATAL` | �� |
+| `ERROR` | �� |
+| `WARN` | �� |
+| `INFO` | �� |
+| `DEBUG` | �� |
+| `TRACE` | �� |
+
+
+
+���⣬��Ҳ����ͨ��Ϊת���ṩһ��ѡ����ָ��Ӧ��ʹ�õ���ɫ����ʽ�� ���磬Ҫʹ�ı�Ϊ��ɫ����ʹ���������á�
+
+
+
+
+
+
+
+```
+%clr(%d{yyyy-MM-dd'T'HH:mm:ss.SSSXXX}){yellow}
+```
+
+
+
+
+
+
+
+֧��������ɫ����ʽ��
+
+
+
+
+
+*   `blue`
+
+*   `cyan`
+
+*   `faint`
+
+*   `green`
+
+*   `magenta`
+
+*   `red`
+
+*   `yellow`
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.logging.file-output)4.3\. ������ļ�
+
+
+
+Ĭ������£�Spring Bootֻ�����̨��¼��־����д��־�ļ��� ��������ڿ���̨���֮��д��־�ļ�������Ҫ���� `logging.file.name` �� `logging.file.path` ���ԣ����磬����� `application.properties` �У���
+
+
+
+
+
+�±���ʾ�� `logging.*` ������α�һ��ʹ�á�
+
+
+
+<caption>Table 5\. Logging properties</caption><colgroup><col><col><col><col></colgroup>
+| `logging.file.name` | `logging.file.path` | Example | Description |
+| --- | --- | --- | --- |
+| _(none)_ | _(none)_ |  | ֻ�ڿ���̨���м�¼�� |
+| ָ���ļ� | _(none)_ | `my.log` | д��ָ������־�ļ��� ���ƿ�����һ��ȷ�е�λ�ã�Ҳ�������뵱ǰĿ¼�����λ�á� |
+| _(none)_ | ָ��Ŀ¼ | `/var/log` | �� `spring.log` д��ָ��Ŀ¼�� ���ƿ�����һ��ȷ�е�λ�ã�Ҳ�������뵱ǰĿ¼�����λ�á� |
+
+
+
+��־�ļ��ڴﵽ10MBʱ�ͻ��ֻ��������̨���һ����Ĭ������»��¼ `ERROR` ��`WARN` ���� `INFO` �������Ϣ��
+
+
+
+
+
+|  | ��־���Զ�����ʵ�ʵ���־������ʩ�� ��ˣ��ض����������ԣ���Logback�� `logback.configurationFile` ������spring Boot������ |
+| --- | --- |
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.logging.file-rotation)4.4\. �ļ��ֻ���������־��
+
+
+
+�����ʹ��Logback������ʹ����� `application.properties` �� `application.yaml` �ļ���΢����־�ֻ����á� ����������������־ϵͳ���㽫��Ҫ�Լ�ֱ�������ֻ����ã����磬�����ʹ��Log4J2����ô���������һ�� `log4j2.xml` �� `log4j2-spring.xml` �ļ�����
+
+
+
+
+
+֧�������ֻ��������ԡ�
+
+
+
+<colgroup><col><col></colgroup>
+| ���� | ˵�� |
+| --- | --- |
+| `logging.logback.rollingpolicy.file-name-pattern` | ���ڴ�����־�鵵���ļ���ģʽ�� |
+| `logging.logback.rollingpolicy.clean-history-on-start` | Ӧ�ó�������ʱ���Ƿ�����־�鵵������ |
+| `logging.logback.rollingpolicy.max-file-size` | ��־�ļ��鵵ǰ�����ߴ磨�ļ����������ﵽ�������ͻ�鵵���� |
+| `logging.logback.rollingpolicy.total-size-cap` | ��־�����ڱ�ɾ��ǰ�����ߴ磨�鵵�ļ����ռ�ô�С�����������С��ᱻɾ������ |
+| `logging.logback.rollingpolicy.max-history` | Ҫ�����Ĺ鵵��־�ļ������������Ĭ��Ϊ7���� |
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.logging.log-levels)4.5\. ��־����
+
+
+
+����֧�ֵ���־ϵͳ������ͨ��ʹ�� `logging.level.<logger-name>=<level>` ��Spring�� `Environment`�����磬�� `application.properties`����������־�������� `level` �� `TRACE`, `DEBUG`, `INFO`, `WARN`, `ERROR`, `FATAL`, �� `OFF` ֮һ�� `root` ��¼����logger���ļ������ͨ�� `logging.level.root` �����á�
+
+
+
+
+
+�����������ʾ�� `application.properties` ��DZ�ڵ���־���á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+logging.level.root=warn
+logging.level.org.springframework.web=debug
+logging.level.org.hibernate=error
+```
+
+
+
+
+
+
+
+Ҳ����ʹ�û���������������־���� ���磬`LOGGING_LEVEL_ORG_SPRINGFRAMEWORK_WEB=DEBUG` ������ `org.springframework.web` Ϊ `DEBUG` ��
+
+
+
+
+
+|  | ��������ֻ�����ڰ�����־�� ���ڿ��ɰ����ǽ���������ת��ΪСд��ĸ�����Բ����������ַ�ʽΪ������������־�� �������ҪΪһ����������־�������ʹ��[`SPRING_APPLICATION_JSON`](https://springdoc.cn/spring-boot/features.html#features.external-config.application-json)������ |
+| --- | --- |
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.logging.log-groups)4.6\. ��־�飨Log Groups��
+
+
+
+�ܹ�����ص���־��¼�����飬�Ա�ͬʱ�����ǽ������ã���ͨ�������á� ���磬����ܾ����ı� _����_ ��Tomcat��صļ�¼���ļ�¼���𣬵��㲻���׼�ס��߼���İ���
+
+
+
+
+
+Ϊ�˰������������⣬Spring Boot��������Spring `Environment` �ж�����־�顣 ���磬�����ͨ���� `application.properties` �м��� ��tomcat�� group ����������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+logging.group.tomcat=org.apache.catalina,org.apache.coyote,org.apache.tomcat
+
+```
+
+
+
+
+
+
+
+һ������ú󣬾Ϳ�����һ�д������ı���������logger�ļ���
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+logging.level.tomcat=trace
+
+```
+
+
+
+
+
+
+
+Spring Boot��������Ԥ�������־�飬���Կ��伴�á�
+
+
+
+<colgroup><col><col></colgroup>
+| ���� | ���е�logger |
+| --- | --- |
+| web | `org.springframework.core.codec`, `org.springframework.http`, `org.springframework.web`, `org.springframework.boot.actuate.endpoint.web`, `org.springframework.boot.web.servlet.ServletContextInitializerBeans` |
+| sql | `org.springframework.jdbc.core`, `org.hibernate.SQL`, `org.jooq.tools.LoggerListener` |
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.logging.shutdown-hook)4.7\. ʹ����־ Shutdown Hook
+
+
+
+Ϊ�������Ӧ�ó�����ֹʱ�ͷ���־��Դ�������ṩ��һ��Shutdown Hook��������JVM�˳�ʱ������־ϵͳ������ �������Ӧ�ó�������war�ļ�����ʽ����ģ��������Shutdown Hook���Զ�ע�ᡣ ������Ӧ�ó����и��ӵ������IJ�νṹ��Shutdown Hook�����޷������������ ������ܣ�����ùػ����ӣ����о��ײ���־ϵͳֱ���ṩ��ѡ� ���磬Logback�ṩ�� [context selectors](https://logback.qos.ch/manual/loggingSeparation.html)������ÿ����¼�������Լ����������б������� �����ʹ�� `logging.register-shutdown-hook` ����������Shutdown Hook�� ��������Ϊ `false` ������ע�ᡣ ���������� `application.properties` �� `application.yaml` �ļ������ø����ԡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+logging.register-shutdown-hook=false
+
+```
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.logging.custom-log-configuration)4.8\. �Զ�����־����
+
+
+
+������־ϵͳ����ͨ����classpath�ϰ����ʵ��Ŀ���������ҿ���ͨ����classpath�ĸ�Ŀ¼�»��� Spring `Environment` ����ָ����λ���ṩһ�����ʵ������ļ�����һ�����ƣ� `logging.config`��
+
+
+
+
+
+������ͨ��ʹ�� `org.springframework.boot.logging.LoggingSystem` ϵͳ���ԣ�ǿ��Spring Bootʹ���ض�����־ϵͳ�� ��ֵӦ���� `LoggingSystem` ʵ�ֵ�ȫ������ ��Ҳ����ͨ��ʹ�� `none` ��ֵ����ȫ����Spring Boot����־���á�
+
+
+
+
+
+|  | S������־���ڴ��� `ApplicationContext` ֮ǰ��ʼ���ģ����Բ����ܴ�Spring `@Configuration` �ļ��е� `@PropertySources` ������־�� �ı���־ϵͳ����ȫͣ������Ψһ������ͨ��System properties�� |
+| --- | --- |
+
+
+
+
+
+���������־ϵͳ������������ļ���
+
+
+
+<colgroup><col><col></colgroup>
+| ��־ϵͳ | �����ļ� |
+| --- | --- |
+| Logback | `logback-spring.xml`, `logback-spring.groovy`, `logback.xml` ���� `logback.groovy` |
+| Log4j2 | `log4j2-spring.xml` ���� `log4j2.xml` |
+| JDK (Java Util Logging) | `logging.properties` |
+
+
+
+|  | �ڿ��ܵ�����£����ǽ�����ʹ�� `-spring` ������������־���ã����磬 `logback-spring.xml` ������ `logback.xml` ���� �����ʹ�ñ�׼����λ�ã�Spring������ȫ������־��ʼ���� |
+| --- | --- |
+
+
+
+
+
+|  | ���� "��ִ�е�jar "������ʱ��Java Util Logging��һЩ��֪����������⣬�ᵼ�����⡣ ������ܵĻ������ǽ������ڴ� "��ִ�е�jar" ������ʱ����ʹ������ |
+| --- | --- |
+
+
+
+
+
+Ϊ�˰������ƣ�����һЩ���Դ�Spring�� `Environment` ת�Ƶ�System properties�����±���ʾ��
+
+
+
+| Spring Environment | System Property | ��ע |
+| --- | --- | --- |
+| `logging.exception-conversion-word` | `LOG_EXCEPTION_CONVERSION_WORD` | ��¼�쳣ʱʹ�õ�ת���ʡ� |
+| `logging.file.name` | `LOG_FILE` | ��������ˣ���������Ĭ�ϵ���־�����С� |
+| `logging.file.path` | `LOG_PATH` | ��������ˣ���������Ĭ�ϵ���־�����С� |
+| `logging.pattern.console` | `CONSOLE_LOG_PATTERN` | �ڿ���̨��stdout��ʹ�õ���־���ģʽ�� |
+| `logging.pattern.dateformat` | `LOG_DATEFORMAT_PATTERN` | date ��ʽ��. |
+| `logging.charset.console` | `CONSOLE_LOG_CHARSET` | ����̨�����־���ַ����롣 |
+| `logging.threshold.console` | `CONSOLE_LOG_THRESHOLD` | ���ڿ���̨��־��¼����־���� |
+| `logging.pattern.file` | `FILE_LOG_PATTERN` | Ҫ���ļ���ʹ�õ���־ģʽ����� `LOG_FILE` �����ã��� |
+| `logging.charset.file` | `FILE_LOG_CHARSET` | �ļ���־���ַ����루��� `LOG_FILE` �����ã��� |
+| `logging.threshold.file` | `FILE_LOG_THRESHOLD` | �����ļ���־��¼����־���� |
+| `logging.pattern.level` | `LOG_LEVEL_PATTERN` | ��Ⱦ��־����ʱʹ�õĸ�ʽ��Ĭ��Ϊ `%5p` ���� |
+| `PID` | `PID` | ��ǰ�Ľ���ID |
+
+
+
+�����ʹ��Logback����������Ҳ�ᱻת�ơ�
+
+
+
+| Spring Environment | System Property | ��ע |
+| --- | --- | --- |
+| `logging.logback.rollingpolicy.file-name-pattern` | `LOGBACK_ROLLINGPOLICY_FILE_NAME_PATTERN` | ������־�ļ�����ģʽ��Ĭ��Ϊ `${LOG_FILE}.%d{yyyy-MM-dd}.%i.gz` ���� |
+| `logging.logback.rollingpolicy.clean-history-on-start` | `LOGBACK_ROLLINGPOLICY_CLEAN_HISTORY_ON_START` | �Ƿ�������ʱ�����鵵��־�ļ��� |
+| `logging.logback.rollingpolicy.max-file-size` | `LOGBACK_ROLLINGPOLICY_MAX_FILE_SIZE` | �����־�ļ���С�� |
+| `logging.logback.rollingpolicy.total-size-cap` | `LOGBACK_ROLLINGPOLICY_TOTAL_SIZE_CAP` | Ҫ��������־���ݵ��ܴ�С�� |
+| `logging.logback.rollingpolicy.max-history` | `LOGBACK_ROLLINGPOLICY_MAX_HISTORY` | Ҫ���������鵵��־�ļ������� |
+
+
+
+����֧�ֵ���־ϵͳ�ڽ����������ļ�ʱ�����Դ� System properties �л�ȡ���ԡ� ���Ӽ� `spring-boot.jar` �е�Ĭ�����á�
+
+
+
+
+
+*   [Logback](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot/src/main/resources/org/springframework/boot/logging/logback/defaults.xml)
+
+*   [Log4j 2](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot/src/main/resources/org/springframework/boot/logging/log4j2/log4j2.xml)
+
+*   [Java Util logging](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot/src/main/resources/org/springframework/boot/logging/java/logging-file.properties)
+
+
+
+
+
+|  | �����������־������ʹ��ռλ������Ӧ��ʹ��[Spring Boot���﷨](https://springdoc.cn/spring-boot/features.html#features.external-config.files.property-placeholders)�����ǵײ��ܵ��﷨�� ֵ��ע����ǣ������ʹ��Logback����Ӧ��ʹ�� `:` ��Ϊ����������Ĭ��ֵ֮��ķָ�����������ʹ�� `:-` �� |
+| --- | --- |
+
+
+
+
+
+|  | �����ͨ��ֻ���� `LOG_LEVEL_PATTERN` ����ʹ��Logback�� `logging.pattern.level` ��������־������MDC��������ʱ���ݡ� ���磬�����ʹ�� `logging.pattern.level=user:%X{user} %5p` ����ôĬ�ϵ���־��ʽ����һ�� "user" ��MDC��Ŀ����������ڵĻ�����������ʾ�� 2019-08-30 12:30:04.031 user:someone INFO 22174 --- [  nio-8080-exec-0] demo.ControllerHandling authenticated request  |
+| --- | --- |
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.logging.logback-extensions)4.9\. Logback ��չ
+
+
+
+Spring Boot����һЩ��Logback����չ�����԰������и߼����á� ���������� `logback-spring.xml` �����ļ���ʹ����Щ��չ��
+
+
+
+
+
+|  | ��Ϊ��׼�� `logback.xml` �����ļ���������أ��㲻��������ʹ����չ�� ����Ҫʹ�� `logback-spring.xml` ���߶���һ�� `logging.config` ���ԡ� |
+| --- | --- |
+
+
+
+
+
+|  | ��չ�������� [Logback������ɨ��](https://logback.qos.ch/manual/configuration.html#autoScan) һ��ʹ�á� �������ͼ���������������ļ������޸Ļᵼ�����������µĴ��󱻼�¼������ |
+| --- | --- |
+
+
+
+
+
+
+
+ ERROR in ch.qos.logback.core.joran.spi.Interpreter@4:71 - no applicable action for [springProperty], current ElementPath is [[configuration][springProperty]]
+ERROR in ch.qos.logback.core.joran.spi.Interpreter@4:71 - no applicable action for [springProfile], current ElementPath is [[configuration][springProfile]] 
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.logging.logback-extensions.profile-specific)4.9.1\. �ض��������ļ�
+
+
+
+`<springProfile>` ��ǩ������Ը��ݻ��Spring�����ļ�ѡ���Եذ������ų����õIJ��֣� ֧���� `<configuration>` Ԫ�ص��κεط��������� ʹ�� `name` ������ָ���������õ������ļ��� `<springProfile>` ��ǩ���԰���һ�������ļ����ƣ����� `staging` ����һ�������ļ�����ʽ�� �����ļ�����ʽ������������ӵ������ļ��߼������� `production & (eu-central | eu-west)` �� �鿴 [Spring ��ܲο�ָ��](https://docs.spring.io/spring-framework/docs/6.0.5/reference/html/core.html#beans-definition-profiles-java) ���˽����ϸ�ڡ� ������б���ʾ���������������ļ���
+
+
+
+
+
+
+
+```
+<springProfile name="staging">
+    <!-- configuration to be enabled when the "staging" profile is active -->
+</springProfile>
+
+<springProfile name="dev | staging">
+    <!-- configuration to be enabled when the "dev" or "staging" profiles are active -->
+</springProfile>
+
+<springProfile name="!production">
+    <!-- configuration to be enabled when the "production" profile is not active -->
+</springProfile>
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.logging.logback-extensions.environment-properties)4.9.2\. ���������ԣ�Environment Properties
+
+
+
+`<springProperty>` ��ǩ���Է��� Spring `Environment` �е����ԣ��Ա���Logback��ʹ�á� ���������Logback�����з��� `application.properties` �ļ��е�ֵ��������������á� �ñ�ǩ�Ĺ�����ʽ��Logback�ı�׼ `<property>` ��ǩ���ơ� Ȼ�����㲻��ֱ��ָ��һ�� `value` ������ָ�����Ե� `source` ������ `Environment` ���� �������Ҫ�� `local` ��Χ����ĵط��洢�����ԣ������ʹ�� `scope` ���ԡ� �������Ҫһ����ֵ��Ĭ��ֵ������һ������û���� `Environment` �����ã��������ʹ�� `defaultValue` ���ԡ� �����������ʾ����ι��������Ա���Logback��ʹ�á�
+
+
+
+
+
+
+
+```
+<springProperty scope="context" name="fluentHost" source="myapp.fluentd.host"
+        defaultValue="localhost"/>
+
+    <remoteHost>${fluentHost}</remoteHost>
+    ...
+
+```
+
+
+
+
+
+
+
+|  | `source` ������kebab���ָ������ `my.property-name` ���� Ȼ�������Կ���ͨ��ʹ�ÿ��ɵĹ������ӵ� `Environment` �С� |
+| --- | --- |
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.logging.log4j2-extensions)4.10\. Log4j2 ��չ
+
+
+
+Spring Boot����һЩ��Log4j2����չ�����԰������и߼����á���������κ� `log4j2-spring.xml` �����ļ���ʹ����Щ��չ��
+
+
+
+
+
+|  | ��Ϊ��׼�� `log4j2.xml` �����ļ���������أ��㲻��������ʹ����չ������Ҫʹ�� `log4j2-spring.xml` ���߶���һ�� ``logging.config`` ���ԡ� |
+| --- | --- |
+
+
+
+
+
+|  | ��Щ��չȡ����Log4J�ṩ�� [Spring Boot֧��](https://logging.apache.org/log4j/2.x/log4j-spring-boot/index.html)�� ��Ӧ��ȷ������Ĺ����в����� `org.apache.logging.log4j:log4j-spring-boot` ģ�顣 |
+| --- | --- |
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.logging.log4j2-extensions.profile-specific)4.10.1\. �ض������ļ�����
+
+
+
+`<SpringProfile>` ��ǩ������Ը��ݻ��Spring�����ļ�ѡ���Եذ������ų����õIJ��֡������ļ����ֱ�֧���� `<Configuration>` Ԫ�ص��κεط���ʹ�� `name` ������ָ���ĸ������ļ��������á� `<SpringProfile>` ��ǩ���԰���һ�������ļ����ƣ����� `staging`����һ�������ļ�����ʽ�� �����ļ�����ʽ������������ӵ������ļ��߼������� `production & (eu-central | eu-west)`���鿴 [Spring��ܲο�ָ��](https://docs.spring.io/spring-framework/docs/6.0.5/reference/html/core.html#beans-definition-profiles-java) ���˽����ϸ�ڡ� ������б���ʾ���������������ļ���
+
+
+
+
+
+
+
+```
+<SpringProfile name="staging">
+    <!-- configuration to be enabled when the "staging" profile is active -->
+</SpringProfile>
+
+<SpringProfile name="dev | staging">
+    <!-- configuration to be enabled when the "dev" or "staging" profiles are active -->
+</SpringProfile>
+
+<SpringProfile name="!production">
+    <!-- configuration to be enabled when the "production" profile is not active -->
+</SpringProfile>
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.logging.log4j2-extensions.environment-properties-lookup)4.10.2\. ������Environment�����Բ���
+
+
+
+���������Log4j2����������Spring `Environment` �е����ԣ������ʹ�� `spring:` ǰ׺ [����](https://logging.apache.org/log4j/2.x/manual/lookups.html)�����������Log4j2�����з��� `application.properties` �ļ��е�ֵ��������������á�
+
+
+
+
+
+�����������ʾ���������һ����Ϊ `applicationName` ��Log4j2���ԣ�����Spring `Environment` �ж�ȡ `spring.application.name`��
+
+
+
+
+
+
+
+```
+<Properties>
+    <Property name="applicationName">${spring:spring.application.name}</Property>
+</Properties>
+```
+
+
+
+
+
+
+
+|  | ��ѯkeyӦ��kebabf���ָ������ `my.property-name`���� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.logging.log4j2-extensions.environment-property-source)4.10.3\. Log4j2 ϵͳ���ԣ�System Properties��
+
+
+
+Log4j2֧��һЩ [System Properties](https://logging.apache.org/log4j/2.x/manual/configuration.html#SystemProperties)�������������ø�����Ŀ�����磬`log4j2.skipJansi` ϵͳ���Կ����������� `ConsoleAppender` �Ƿ����Windows�ϳ���ʹ�� [Jansi](https://github.com/fusesource/jansi) �������
+
+
+
+
+
+Log4j2 ��ʼ������ص�����ϵͳ���Զ����Դ�Spring `Environment` �л�á����磬������� `application.properties` �ļ������� `log4j2.skipJansi=false`���� `ConsoleAppender` ��Windows��ʹ��Jansi��
+
+
+
+
+
+|  | ֻ�е�ϵͳ���ԣ�system properties���Ͳ���ϵͳ�����������������ڼ��ص�ֵʱ���Żῼ��Spring `Environment`�� |
+| --- | --- |
+
+
+
+
+
+|  | ������Log4j2��ʼ���ڼ���ص�ϵͳ���Բ�������Spring `Environment`�����磬Log4j2��������ѡ��Ĭ��Log4j2ʵ�ֵ��������� Spring Environment ����֮ǰʹ�õġ� |
+| --- | --- |
+
+
+
+
+
+
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\345\270\270\350\247\201\346\263\250\350\247\243.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\345\270\270\350\247\201\346\263\250\350\247\243.md"
new file mode 100644
index 0000000..c699974
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\345\270\270\350\247\201\346\263\250\350\247\243.md"
@@ -0,0 +1,158 @@
+## 1 ����
+Spring Boot ͨ�����Զ����ù���ʹ���� Spring ��ø������ס�
+
+�ڱ����ٽ̳��У����ǽ�̽�� org.springframework.boot.autoconfigure �� org.springframework.boot.autoconfigure.condition ���е�ע�⡣
+
+## 2 @SpringBootApplication
+����ʹ�����ע������� Spring Boot Ӧ�ó�������ࣺ
+
+@SpringBootApplication
+����ʹ�����ע������� Spring Boot Ӧ�ó�������ࣺ
+````
+@SpringBootApplication
+class VehicleFactoryApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(VehicleFactoryApplication.class, args);
+    }
+}
+````
+@SpringBootApplication ��װ��@Configuration��@EnableAutoConfiguration ��@ComponentScan ע�⼰��Ĭ�����ԡ�
+
+## 3 @EnableAutoConfiguration
+
+@EnableAutoConfiguration������˼�壬�����Զ����á� ����ζ�� Spring Boot ������·���в����Զ����� bean ���Զ�Ӧ�����ǡ�
+
+��ע�⣬���DZ��뽫��ע����@Configuration һ��ʹ�ã�
+
+````
+@Configuration
+@EnableAutoConfiguration
+class VehicleFactoryConfig {}
+````
+
+## 4 @Configuration�Լ������
+
+@Configuration�����ã���ע�����ϣ�����spring����(Ӧ��������)��
+
+����������spring������bean��ʹ�õ�xml�����ļ�������һ����bean����springboot�У�Ϊ�����������ã�spring����ṩ��@Configuration��һע��
+
+�൱�ڰѸ�����Ϊspring��xml�����ļ��е�<beans>
+
+@Configurationע������У�ʹ��@Beanע���ע�ķ��������ص����Ͷ���ֱ��ע��Ϊbean��
+
+@Configureע��Ķ������£�
+````
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Component
+public @interface Configuration {
+String value() default "";
+}
+````
+�Ӷ����������ײ��Ǻ���@Component ������@Configuration ���к� @Component �����á����context:component-scan/����@ComponentScan���ܴ���@Configurationע����ࡣ
+
+ͨ���������DZ�д�Զ����Զ�����ʱ������ϣ�� Spring ��������ʹ�����ǡ� ���ǿ���ͨ�������е�ע����ʵ����һ�㡣
+
+���ǿ��Խ��˲����е�ע�ͷ���@Configuration ���@Bean �����ϡ�
+
+�ڽ������IJ����У����ǽ�ֻ����ÿ����������Ļ������ ���˽������Ϣ���������ƪ���¡�
+
+### 4.1 @ConditionalOnClass and @ConditionalOnMissingClass
+����������һ�����������жϵ�����ע�⣬Ҫ֪�����ܶ�ʱ�����ǰ������bean�ģ������Ǹ����ⲿjar���Ƿ���������м��غ��жϵġ�
+
+����ʱ�򣬾�Ҫ�����ⲿ���Ƿ�����������Ƿ��Ƿ���ظ�bean
+
+ʹ����Щ���������ע�Ͳ����е������/�����ڣ�Spring ����ʹ�ñ�ǵ��Զ����� bean��
+
+````
+@Configuration
+@ConditionalOnClass(DataSource.class)
+class MySQLAutoconfiguration {
+//...
+}
+````
+
+### 4.2 @ConditionalOnBean and @ConditionalOnMissingBean
+
+��������Ҫ�����ض� bean �Ĵ��ڻ򲻴�������������ʱ�����ǿ���ʹ����Щע�ͣ�
+
+������һ��ע������Щ��ͬ����Ϊ���ǵ��ж����������bean
+
+````
+@Bean
+@ConditionalOnBean(name = "dataSource")
+LocalContainerEntityManagerFactoryBean entityManagerFactory() {
+// ...
+}
+````
+### 4.3 @ConditionalOnProperty
+ͨ�����ע�⣬���ǿ��Զ����Ե�ֵ��������
+
+Ҫע�⣬���������ֵ��Դ��application.properties�ļ��е�����
+
+````
+@Bean
+@ConditionalOnProperty(
+name = "usemysql",
+havingValue = "local"
+)
+DataSource dataSource() {
+// ...
+}
+````
+ 
+### 4.4 @ConditionalOnResource
+
+���ǿ����� Spring ���ڴ����ض���Դʱʹ�ö��壺
+����˼�壬Ҫ��classpath���������Դ�ļ�ʱ�Ž��м��أ���Ҳ�Ǻܳ��õ�һ��ע�⡣
+
+````
+
+@ConditionalOnResource(resources = "classpath:mysql.properties")
+Properties  ditionalProperties() {
+// ...
+}
+````
+ 
+### 4.5 @ConditionalOnWebApplication and @ConditionalOnNotWebApplication
+���ע��ͨ�����ں�web��ǿ������������ȫ�޹�����������
+
+ʹ����Щע�ͣ����ǿ��Ը��ݵ�ǰӦ�ó����Ƿ��� Web Ӧ�ó���������������
+````
+
+@ConditionalOnWebApplication
+HealthCheckController healthCheckController() {
+// ...
+}
+````
+ 
+### 4.6 @ConditionalExpression
+springboot���Ϊ�����뵽�������������������ע�⻹�����������Ҫ����ô�ɴ�������Լ�д������Ӧ��û������ɣ�
+
+���ǿ����ڸ����ӵ������ʹ�����ע�⡣ �� SpEL ����ʽ������Ϊ��ʱ��Spring ��ʹ�ñ�ǵĶ��壺
+
+````
+@Bean
+@ConditionalOnExpression("${usemysql} && ${mysqlserver == 'local'}")
+DataSource dataSource() {
+// ...
+}
+````
+
+### 4.7 @Conditional
+ʲô���������⣿
+��springbootҲ�����ṩʲô����ʽ�����ˣ�ֱ�����û�дһ���ж�������������true����false������
+
+���ڸ����ӵ����������ǿ��Դ���һ�������Զ����������ࡣ ���Ǹ��� Spring ������Զ��������� @Conditional һ��ʹ�ã�
+
+````
+@Conditional(HibernateCondition.class)
+Properties  ditionalProperties() {
+//...
+}
+````
+
+## 5 �ܽ�
+�ڱ����У����Ǹ��������΢���Զ����ù��̲�Ϊ�Զ����Զ����� bean �ṩ������
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\345\272\224\347\224\250\344\271\237\345\217\257\344\273\245\351\203\250\347\275\262\345\210\260\345\244\226\351\203\250Tomcat.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\345\272\224\347\224\250\344\271\237\345\217\257\344\273\245\351\203\250\347\275\262\345\210\260\345\244\226\351\203\250Tomcat.md"
new file mode 100644
index 0000000..e22fa00
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\345\272\224\347\224\250\344\271\237\345\217\257\344\273\245\351\203\250\347\275\262\345\210\260\345\244\226\351\203\250Tomcat.md"
@@ -0,0 +1,302 @@
+
+
+<header>
+
+# Spring Boot Tomcat����
+
+�������ݽ���վ�������Ѹ���ѧϰ�ʼǡ��ܽ���о��ղء�����֤��ȷ�ԣ���ʹ�ö������ķ����뱾վ�޹أ�
+
+</header>
+
+
+
+<script>( adsbygoogle = window.adsbygoogle || []).push({});</script>
+
+
+
+ͨ��ʹ��Spring BootӦ�ó��򣬿��Դ���һ��war�ļ��Բ���Web�������С��ڱ����У���ѧϰ��δ���WAR�ļ�����Tomcat Web�������в���Spring BootӦ�ó���
+
+## Spring Boot Servlet��ʼ������
+
+��ͳ�IJ���ʽ��ʹSpring BootӦ�ó���`[@SpringBootApplication](https://github.com/SpringBootApplication "@SpringBootApplication")`����չ`SpringBootServletInitializer`�ࡣ `SpringBootServletInitializer`���ļ�������ʹ��Servlet��������ʱ����Ӧ�ó���
+
+�������������JAR�ļ������Spring BootӦ�ó������ļ��Ĵ��� -
+
+```
+package com.yiibai.demo;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class DemoApplication {
+   public static void main(String[] args) {
+      SpringApplication.run(DemoApplication.class, args);
+   }
+}
+
+```
+
+��Ҫ��չ��`SpringBootServletInitializer`��֧��WAR�ļ����� Spring BootӦ�ó������ļ��Ĵ������� -
+
+```
+package com.yiibai.demo;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.boot.web.support.SpringBootServletInitializer;
+
+@SpringBootApplication
+public class DemoApplication  extends SpringBootServletInitializer {
+   @Override
+   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
+      return application.sources(DemoApplication.class);
+   }
+   public static void main(String[] args) {
+      SpringApplication.run(DemoApplication.class, args);
+   }
+}
+
+```
+
+## ����Main��
+
+��Spring Boot�У���Ҫ�ڹ����ļ���ָ�����������ࡣ
+����Maven����`pom.xml`����������`start`�࣬������ʾ -
+
+```
+<start-class>com.yiibai.demo.DemoApplication</start-class>
+
+```
+
+����Gradle����`build.gradle`��������������������ʾ -
+
+```
+mainClassName="com.yiibai.demo.DemoApplication"
+
+```
+
+## �����JAR����ΪWAR
+
+ʹ�����´��뽫��װJAR����ΪWAR��
+
+����Maven����_pom.xml_ �н���װ����ΪWAR��������ʾ -
+
+```
+<packaging>war</packaging>
+
+```
+
+����Gradle����_build.gradle_ ������Ӧ�ó�������war�����������ʾ -
+
+```
+apply plugin: 'war'
+apply plugin: 'application'
+
+```
+
+����GradlNow����дһ���򵥵�Rest�˵��������ַ���:`"Hello World from Tomcat"`�� Ҫ��дRest�˵㣬��Ҫ��Spring Boot Web starter���������ӵ������ļ��С�
+
+����Maven��ʹ��������ʾ�Ĵ�����_pom.xml_ ������Spring Boot�������������� -
+
+```
+<dependency>
+   <groupId>org.springframework.boot</groupId>
+   spring-boot-starter-web
+</dependency>
+
+```
+
+����Gradle��ʹ��������ʾ�Ĵ�����_build.gradle_ ������Spring Boot starter������ -
+
+```
+dependencies {
+   compile('org.springframework.boot:spring-boot-starter-web')
+}
+
+```
+
+���ڣ�ʹ��������ʾ�Ĵ�����Spring Boot Application���ļ��б�дһ���򵥵�Rest�˵� -
+
+```
+package com.yiibai.demo;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.boot.web.support.SpringBootServletInitializer;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@SpringBootApplication
+@RestController
+public class DemoApplication  extends SpringBootServletInitializer {
+   @Override
+   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
+      return application.sources(DemoApplication.class);
+   }
+   public static void main(String[] args) {
+      SpringApplication.run(DemoApplication.class, args);
+   }
+
+   @RequestMapping(value = "/")
+   public String hello() {
+      return "Hello World from Tomcat";
+   }
+}
+
+```
+
+## ���Ӧ�ó���
+
+���ڣ�ʹ��Maven��Gradle�����һ��WAR�ļ��Բ���Tomcat�������У��Դ��Ӧ�ó���������ʾ��
+
+����Maven��ʹ������`mvn package`���Ӧ�ó��� Ȼ�󴴽�WAR�ļ���������Ŀ��Ŀ¼���ҵ������������������Ļ��ͼ��ʾ -
+
+![](/uploads/images/2018/09/27/084613_17931.jpg)
+
+����Gradle��ʹ������`gradle clean build`���Ӧ�ó��� Ȼ�󣬽�����WAR�ļ���������`build/libs`Ŀ¼���ҵ������۲�˴���������Ļ��ͼ�Ա���õ����� -
+
+![](/uploads/images/2018/09/27/084717_10144.jpg)
+
+## ����Tomcat
+
+���ڣ�����Tomcat������������webappsĿ¼�²���WAR�ļ����۲�˴���ʾ����Ļ��ͼ�Ա���õ����� -
+
+![](/uploads/images/2018/09/27/084759_50620.jpg)
+
+�ɹ�����󣬵����ҳ������е�URL => `http://localhost:8080/demo-0.0.1-SNAPSHOT/`���۲�����������ͼ��ʾ -
+
+![](/uploads/images/2018/09/27/084848_70593.jpg)
+
+�����������£�
+
+�ļ���_pom.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.yiibai</groupId>
+   demo
+   <version>0.0.1-SNAPSHOT</version>
+   <packaging>war</packaging>
+   <name>demo</name>
+   <description>Demo project for Spring Boot</description>
+
+   <parent>
+      <groupId>org.springframework.boot</groupId>
+      spring-boot-starter-parent
+      <version>1.5.8.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>
+      <start-class>com.yiibai.demo.DemoApplication</start-class>
+   </properties>
+
+   <dependencies>
+      <dependency>
+         <groupId>org.springframework.boot</groupId>
+         spring-boot-starter-web
+      </dependency>
+      <dependency>
+         <groupId>org.springframework.boot</groupId>
+         spring-boot-starter-test
+         <scope>test</scope>
+      </dependency>
+   </dependencies>
+
+   <build>
+      <plugins>
+         <plugin>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-maven-plugin
+         </plugin>
+      </plugins>
+   </build>
+
+</project>
+
+```
+
+�ļ���_build.gradle_
+
+```
+buildscript {
+   ext {
+      springBootVersion = '1.5.8.RELEASE'
+   }
+   repositories {
+      mavenCentral()
+   }
+dependencies {
+      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
+   }
+}
+
+apply plugin: 'java'
+apply plugin: 'eclipse'
+apply plugin: 'org.springframework.boot'
+apply plugin: 'war'
+apply plugin: 'application'
+
+group = 'com.yiibai'
+version = '0.0.1-SNAPSHOT'
+sourceCompatibility = 1.8
+mainClassName = "com.yiibai.demo.DemoApplication"
+
+repositories {
+   mavenCentral()
+}
+dependencies {
+   compile('org.springframework.boot:spring-boot-starter-web')
+   testCompile('org.springframework.boot:spring-boot-starter-test')
+}
+
+```
+
+Spring BootӦ�ó������ļ��Ĵ������� -
+
+```
+package com.yiibai.demo;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.boot.web.support.SpringBootServletInitializer;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@SpringBootApplication
+@RestController
+public class DemoApplication  extends SpringBootServletInitializer {
+   @Override
+   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
+      return application.sources(DemoApplication.class);
+   }
+   public static void main(String[] args) {
+      SpringApplication.run(DemoApplication.class, args);
+   }
+
+   @RequestMapping(value = "/")
+   public String hello() {
+      return "Hello World from Tomcat";
+   }
+}
+```
+
+
+
+
+
+//�������Ķ���https://www.yiibai.com/spring-boot/spring_boot_tomcat_deployment.html
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\346\211\223\345\214\205\344\270\216\345\220\257\345\212\250.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\346\211\223\345\214\205\344\270\216\345\220\257\345\212\250.md"
new file mode 100644
index 0000000..9f13c13
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\346\211\223\345\214\205\344\270\216\345\220\257\345\212\250.md"
@@ -0,0 +1,1388 @@
+在使用`maven`构建`springboot`项目时，`springboot`相关 jar 包可以使用`parent方式`引入（即在`pom.xml`的`parent`节点引入`springboot`的`GAV`:`org.springframework.boot:spring-boot-starter-parent:2.1.1.RELEASE`），也可以使用`非parent方式`引入（即在 pom 的 dependencyManagement 节点引入`springboot`的`GAV`:`org.springframework.boot:spring-boot-dependencies:2.1.1.RELEASE`）。同时，在打包时，我们可以打成 jar 包，也可以打成 war 包，本文旨在梳理各引入、打包方式的异同。
+
+### 1\. parent 方式引入，打成 jar 包
+
+parent 方式，即在 pom 文件中，将 springboot 的依赖当成项目的 parent 引入，pom 文件示例如下：
+
+```
+<?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>
+
+    <!-- 引入springboot的parent -->
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        spring-boot-starter-parent
+        <version>2.1.1.RELEASE</version>
+    </parent>
+
+    <groupId>com.gitee.funcy</groupId>
+    springboot-parent-jar
+    <version>1.0.0</version>
+    <packaging>jar</packaging>
+    <name>springboot parent jar打包方式</name>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <java.version>1.8</java.version>
+        <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
+    </properties>
+
+    <dependencies>
+        <!-- springboot 的基础依赖 -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter
+        </dependency>
+        <!-- springboot 的web 依赖 -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter-web
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <!-- maven编译插件 -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                maven-compiler-plugin
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                    <encoding>${project.build.sourceEncoding}</encoding>
+                </configuration>
+            </plugin>
+            <!-- springboot编译插件 -->
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                spring-boot-maven-plugin
+                <!-- 其他内容不用指定，因为 spring-boot-starter-parent 已经指定了-->
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
+
+```
+
+添加一个 controller:
+
+```
+package com.gitee.funcy.mavenparent.jar.controller;
+
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * ｛这里添加描述｝
+ *
+ * @author funcy
+ * @date 2019-12-13 10:43 下午
+ */
+@RestController
+public class IndexController {
+
+    @RequestMapping("/")
+    public String helloWorld() {
+        return "hello world";
+    }
+
+}
+
+```
+
+再引入启动类：
+
+```
+package com.gitee.funcy.mavenparent.jar;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+/**
+ * ｛这里添加描述｝
+ *
+ * @author funcy
+ * @date 2019-12-13 10:36 下午
+ */
+@SpringBootApplication
+public class Main {
+
+    public static void main(String[] args) {
+        SpringApplication.run(Main.class, args);
+    }
+
+}
+
+```
+
+运行 Main 方法，请求`http://localhost:8080/`，结果如下：
+
+```
+ $ curl http://localhost:8080/
+hello world
+
+```
+
+可以看到，项目运行成功。
+
+接着，尝试使用 jar 包启动：
+
+```
+# 打包
+ mvn clean install -Dmaven.test.skip=true
+ # 启动jar包
+ java -jar target/springboot-parent-jar-1.0.0.jar
+
+```
+
+可以看到，项目启动成功，请求请求`http://localhost:8080/`，也能显示正确结果。
+
+### 2\. 非 parent 方式引入，打成 jar 包
+
+在实际项目中，项目的 parent 依赖可能给了其他项目，此时 parent 引用就无法进行了，这时我们需要非 parent 引入。非 parent 引入的 pom 如下：
+
+```
+<?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.gitee.funcy</groupId>
+    springboot-jar
+    <version>1.0.0</version>
+    <packaging>jar</packaging>
+    <name>springboot非parent jar打包方式</name>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <java.version>1.8</java.version>
+        <spring-boot.version>2.1.1.RELEASE</spring-boot.version>
+        <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
+    </properties>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <!-- Import dependency management from Spring Boot -->
+                <groupId>org.springframework.boot</groupId>
+                spring-boot-dependencies
+                <version>${spring-boot.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter-web
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                maven-compiler-plugin
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                    <encoding>${project.build.sourceEncoding}</encoding>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                spring-boot-maven-plugin
+                <version>${spring-boot.version}</version>
+                <!-- 与parent引入相比，需要指定goals，否则会打包失败-->
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
+
+```
+
+再添加一个`ControllerIndexController.java`与启动类`Main.java`，这两个文件与上述示例相同，这里就不作展示了。
+
+运行 Main 方法，请求`http://localhost:8080/`，结果如下：
+
+```
+ $ curl http://localhost:8080/
+hello world
+
+```
+
+可以看到，项目运行成功。
+
+接着，尝试使用 jar 包启动：
+
+```
+# 打包
+ mvn clean install -Dmaven.test.skip=true
+ # 启动jar包
+ java -jar target/springboot-jar-1.0.0.jar
+
+```
+
+可以看到，项目启动成功，请求请求`http://localhost:8080/`，也能显示正确结果。
+
+### 3\. parent 方式引入，打成 war 包
+
+以上两种方式都是打成 jar，为了兼容传统的 servlet 应用，springboot 也支持打包 war 包，parent 引入打包 war 包的 pom 文件如下：
+
+```
+<?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>
+
+    <!-- 引入springboot的parent -->
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        spring-boot-starter-parent
+        <version>2.1.1.RELEASE</version>
+    </parent>
+
+    <groupId>com.gitee.funcy</groupId>
+    springboot-parent-war
+    <version>1.0.0</version>
+    <!-- 指定打包方式为war包 -->
+    <packaging>war</packaging>
+    <name>springboot parent war打包方式</name>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <java.version>1.8</java.version>
+        <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter-web
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-test
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                maven-compiler-plugin
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                    <encoding>${project.build.sourceEncoding}</encoding>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                maven-war-plugin
+                <!-- 保持与 spring-boot-dependencies 版本一致 -->
+                <version>3.2.2</version>
+            </plugin>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                spring-boot-maven-plugin
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
+
+```
+
+再添加一个`ControllerIndexController.java`与启动类`Main.java`，这两个文件与上述示例相同，这里就不作展示了。
+
+除此之外，war 包方式还需要添加一个类，用以实现`SpringBootServletInitializer`，该类与启动类`Main.java`位于同一个包下，主要是用来引导 tomcat 等 servlet 容器加载 servlet，内容如下：
+
+```
+/**
+ * ｛这里添加描述｝
+ *
+ * @author funcy
+ * @date 2019-12-20 1:22 下午
+ */
+public class StartApplication extends SpringBootServletInitializer {
+
+    @Override
+    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
+        // 注意这里要指向原先用main方法执行的Application启动类
+        return builder.sources(Main.class);
+    }
+}
+
+```
+
+运行 Main 方法，请求`http://localhost:8080/`，结果如下：
+
+```
+ $ curl http://localhost:8080/
+hello world
+
+```
+
+可以看到，项目运行成功。
+
+接着，尝试使用 jar 包启动：
+
+```
+# 打包
+ mvn clean install -Dmaven.test.skip=true
+ # 启动jar包
+ java -jar target/springboot-parent-war-1.0.0.jar
+
+```
+
+可以看到，项目启动成功，请求请求`http://localhost:8080/`，也能显示正确结果。
+
+### 4\. 非 parent 方式引入，打成 war 包
+
+同样地，打成 war 包时，也可使用非 parent 引入方式：
+
+```
+<?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.gitee.funcy</groupId>
+    springboot-war
+    <version>1.0.0</version>
+    <!-- 指定打包方式为war包 -->
+    <packaging>war</packaging>
+    <name>springboot非parent war打包方式</name>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <java.version>1.8</java.version>
+        <spring-boot.version>2.1.1.RELEASE</spring-boot.version>
+        <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
+    </properties>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <!-- Import dependency management from Spring Boot -->
+                <groupId>org.springframework.boot</groupId>
+                spring-boot-dependencies
+                <version>${spring-boot.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter-web
+        </dependency>
+        <!-- 测试war包中 WEB-INF/lib-provided/ 目录内容-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-test
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                maven-compiler-plugin
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                    <encoding>${project.build.sourceEncoding}</encoding>
+                </configuration>
+            </plugin>
+            <!-- 打成war包时，需要添加该插件 -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                maven-war-plugin
+                <!-- 保持与 spring-boot-dependencies 版本一致 -->
+                <version>3.2.2</version>
+            </plugin>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                spring-boot-maven-plugin
+                <version>${spring-boot.version}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
+
+```
+
+再添加一个`ControllerIndexController.java`、`StartApplication.java`与启动类`Main.java`，这三个文件与上述示例相同，这里就不作展示了。
+
+运行 Main 方法，请求`http://localhost:8080/`，结果如下：
+
+```
+ $ curl http://localhost:8080/
+hello world
+
+```
+
+可以看到，项目运行成功。
+
+接着，尝试使用 jar 包启动：
+
+```
+# 打包
+ mvn clean install -Dmaven.test.skip=true
+ # 启动jar包
+ java -jar target/springboot-war-1.0.0.jar
+
+```
+
+可以看到，项目启动成功，请求请求`http://localhost:8080/`，也能显示正确结果。
+
+### 5\. 总结
+
+springboot 引入及打包方式组合下来有如下四种：
+
+| 打包 / 引入 | parent 方式 | 非 parent 方式 |
+| --- | --- | --- |
+| jar | parent-jar 方式 | 非 parent-jar 方式 |
+| war | parent-war 方式 | 非 parent-war 方式 |
+
+### 1\. 开发时启动
+
+在开发时启动 springboot 应用，指的是直接运行源码，如在开发时在 ide 中运行启动类的 main () 方法。
+
+#### 1.1 在 ide 中执行启动类的`main()`方法
+
+自从有了 springboot 后，web 项目就不必再放到 web 容器中运行了，直接运行项目的`main()`方法就行了：
+
+![](https://oscimg.oschina.net/oscnet/up-040888025c22694b18d7be748b8cbb89f06.png)
+
+启动日志如下：
+
+```
+  .   ____          _            __ _ _
+ /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
+( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
+ \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
+  '  |____| .__|_| |_|_| |_\__, | / / / /
+ =========|_|==============|___/=/_/_/_/
+ :: Spring Boot ::        (v2.1.1.RELEASE)
+
+2020-01-07 21:11:16.365  INFO 84046 --- [           main] com.gitee.funcy.maven.jar.Main           : Starting Main on l with PID 84046 (/Users/funcy/IdeaProjects/myproject/springboot-demo/springboot-maven/springboot-jar/target/classes started by funcy in /Users/funcy/IdeaProjects/myproject/springboot-demo)
+2020-01-07 21:11:16.368  INFO 84046 --- [           main] com.gitee.funcy.maven.jar.Main           : No active profile set, falling back to default profiles: default
+2020-01-07 21:11:17.468  INFO 84046 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
+2020-01-07 21:11:17.497  INFO 84046 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
+2020-01-07 21:11:17.497  INFO 84046 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/9.0.13
+2020-01-07 21:11:17.513  INFO 84046 --- [           main] o.a.catalina.core.AprLifecycleListener   : The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: [/Users/funcy/Library/Java/Extensions:/Library/Java/Extensions:/Network/Library/Java/Extensions:/System/Library/Java/Extensions:/usr/lib/java:.]
+2020-01-07 21:11:17.605  INFO 84046 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
+2020-01-07 21:11:17.605  INFO 84046 --- [           main] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 1206 ms
+2020-01-07 21:11:17.861  INFO 84046 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
+2020-01-07 21:11:18.096  INFO 84046 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
+2020-01-07 21:11:18.100  INFO 84046 --- [           main] com.gitee.funcy.maven.jar.Main           : Started Main in 1.988 seconds (JVM running for 2.34)
+2020-01-07 21:11:32.155  INFO 84046 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
+2020-01-07 21:11:32.155  INFO 84046 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
+2020-01-07 21:11:32.223  INFO 84046 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 68 ms
+
+```
+
+访问`http://localhost:8080/`，结果如下：
+
+```
+$ curl http://localhost:8080
+hello world
+
+```
+
+以上启动方式**war 与 jar 打包方式**都支持。
+
+#### 1.2`mvn spring-boot:run`启动
+
+这种方式也是源码启动，在命令行界面进入项目对应的源码目录下，然后执行`mvn spring-boot:run`命令：
+
+```
+springboot-parent-war $ mvn spring-boot:run
+[INFO] Scanning for projects...
+[INFO] 
+[INFO] ---------------< com.gitee.funcy:springboot-parent-war >----------------
+[INFO] Building springboot parent war打包方式 1.0.0
+[INFO] --------------------------------[ war ]---------------------------------
+[INFO] 
+[INFO] >>> spring-boot-maven-plugin:2.1.1.RELEASE:run (default-cli) > test-compile @ springboot-parent-war >>>
+[INFO] 
+[INFO] --- maven-resources-plugin:3.1.0:resources (default-resources) @ springboot-parent-war ---
+[INFO] Using 'UTF-8' encoding to copy filtered resources.
+[INFO] Copying 0 resource
+[INFO] Copying 0 resource
+[INFO] 
+[INFO] --- maven-compiler-plugin:3.8.1:compile (default-compile) @ springboot-parent-war ---
+[INFO] Changes detected - recompiling the module!
+[INFO] Compiling 3 source files to /Users/funcy/IdeaProjects/myproject/springboot-demo/springboot-maven/springboot-parent-war/target/classes
+[INFO] 
+[INFO] --- maven-resources-plugin:3.1.0:testResources (default-testResources) @ springboot-parent-war ---
+[INFO] Using 'UTF-8' encoding to copy filtered resources.
+[INFO] skip non existing resourceDirectory /Users/funcy/IdeaProjects/myproject/springboot-demo/springboot-maven/springboot-parent-war/src/test/resources
+[INFO] 
+[INFO] --- maven-compiler-plugin:3.8.1:testCompile (default-testCompile) @ springboot-parent-war ---
+[INFO] No sources to compile
+[INFO] 
+[INFO] <<< spring-boot-maven-plugin:2.1.1.RELEASE:run (default-cli) < test-compile @ springboot-parent-war <<<
+[INFO] 
+[INFO] 
+[INFO] --- spring-boot-maven-plugin:2.1.1.RELEASE:run (default-cli) @ springboot-parent-war ---
+
+  .   ____          _            __ _ _
+ /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
+( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
+ \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
+  '  |____| .__|_| |_|_| |_\__, | / / / /
+ =========|_|==============|___/=/_/_/_/
+ :: Spring Boot ::        (v2.1.1.RELEASE)
+
+2020-01-07 21:40:50.577  INFO 84448 --- [           main] com.gitee.funcy.mavenparent.war.Main     : Starting Main on funcydeMacBook-Pro.local with PID 84448 (/Users/funcy/IdeaProjects/myproject/springboot-demo/springboot-maven/springboot-parent-war/target/classes started by funcy in /Users/funcy/IdeaProjects/myproject/springboot-demo/springboot-maven/springboot-parent-war)
+2020-01-07 21:40:50.579  INFO 84448 --- [           main] com.gitee.funcy.mavenparent.war.Main     : No active profile set, falling back to default profiles: default
+2020-01-07 21:40:51.311  INFO 84448 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
+2020-01-07 21:40:51.336  INFO 84448 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
+2020-01-07 21:40:51.337  INFO 84448 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/9.0.13
+2020-01-07 21:40:51.347  INFO 84448 --- [           main] o.a.catalina.core.AprLifecycleListener   : The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: [/Users/funcy/Library/Java/Extensions:/Library/Java/Extensions:/Network/Library/Java/Extensions:/System/Library/Java/Extensions:/usr/lib/java:.]
+2020-01-07 21:40:51.406  INFO 84448 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
+2020-01-07 21:40:51.406  INFO 84448 --- [           main] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 800 ms
+2020-01-07 21:40:51.582  INFO 84448 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
+2020-01-07 21:40:51.736  INFO 84448 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
+2020-01-07 21:40:51.739  INFO 84448 --- [           main] com.gitee.funcy.mavenparent.war.Main     : Started Main in 1.39 seconds (JVM running for 3.943)
+2020-01-07 21:41:04.068  INFO 84448 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
+2020-01-07 21:41:04.069  INFO 84448 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
+2020-01-07 21:41:04.076  INFO 84448 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 7 ms
+
+```
+
+可以看到，项目启动成功，请求`http://localhost:8080`，也能获得结果：
+
+```
+ $ curl http://localhost:8080
+hello world
+
+```
+
+以上启动方式**war 与 jar 打包方式**都支持。
+
+### 2\. jar 包启动
+
+#### 2.1`java -jar`方式启动
+
+对于打成`jar包`的`springboot`项目，使用`java -jar xxx.jar`命令即可启动：
+
+```
+:target $ java -jar springboot-jar-1.0.0.jar
+
+  .   ____          _            __ _ _
+ /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
+( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
+ \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
+  '  |____| .__|_| |_|_| |_\__, | / / / /
+ =========|_|==============|___/=/_/_/_/
+ :: Spring Boot ::        (v2.1.1.RELEASE)
+
+2020-01-07 21:47:47.075  INFO 85080 --- [           main] com.gitee.funcy.maven.jar.Main           : Starting Main on funcydeMacBook-Pro.local with PID 85080 (/Users/funcy/IdeaProjects/myproject/springboot-demo/springboot-maven/springboot-jar/target/springboot-jar-1.0.0.jar started by funcy in /Users/funcy/IdeaProjects/myproject/springboot-demo/springboot-maven/springboot-jar/target)
+2020-01-07 21:47:47.077  INFO 85080 --- [           main] com.gitee.funcy.maven.jar.Main           : No active profile set, falling back to default profiles: default
+2020-01-07 21:47:48.152  INFO 85080 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
+2020-01-07 21:47:48.186  INFO 85080 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
+2020-01-07 21:47:48.186  INFO 85080 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/9.0.13
+2020-01-07 21:47:48.202  INFO 85080 --- [           main] o.a.catalina.core.AprLifecycleListener   : The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: [/Users/funcy/Library/Java/Extensions:/Library/Java/Extensions:/Network/Library/Java/Extensions:/System/Library/Java/Extensions:/usr/lib/java:.]
+2020-01-07 21:47:48.303  INFO 85080 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
+2020-01-07 21:47:48.303  INFO 85080 --- [           main] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 1177 ms
+2020-01-07 21:47:48.502  INFO 85080 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
+2020-01-07 21:47:48.677  INFO 85080 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
+2020-01-07 21:47:48.680  INFO 85080 --- [           main] com.gitee.funcy.maven.jar.Main           : Started Main in 1.977 seconds (JVM running for 2.398)
+
+```
+
+访问`http://localhost:8080`，同样也能获得结果.
+
+#### 2.2`java org.springframework.boot.loader.JarLauncher`方式启动
+
+这种启动方式就魔幻了：好好的一个 jar，要先解压，然后直接运行里面的类，操作如下：
+
+```
+target $ unzip -d ./tmp springboot-jar-1.0.0.jar
+Archive:  springboot-jar-1.0.0.jar
+   creating: ./tmp/META-INF/
+  inflating: ./tmp/META-INF/MANIFEST.MF  
+   creating: ./tmp/org/
+   creating: ./tmp/org/springframework/
+   creating: ./tmp/org/springframework/boot/
+··· 省略其他内容
+target $ cd tmp/
+tmp $ java org.springframework.boot.loader.JarLauncher
+
+  .   ____          _            __ _ _
+ /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
+( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
+ \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
+  '  |____| .__|_| |_|_| |_\__, | / / / /
+ =========|_|==============|___/=/_/_/_/
+ :: Spring Boot ::        (v2.1.1.RELEASE)
+
+2020-01-07 21:56:00.472  INFO 85431 --- [           main] com.gitee.funcy.maven.jar.Main           : Starting Main on funcydeMacBook-Pro.local with PID 85431 (/Users/funcy/IdeaProjects/myproject/springboot-demo/springboot-maven/springboot-jar/target/tmp/BOOT-INF/classes started by funcy in /Users/funcy/IdeaProjects/myproject/springboot-demo/springboot-maven/springboot-jar/target/tmp)
+2020-01-07 21:56:00.475  INFO 85431 --- [           main] com.gitee.funcy.maven.jar.Main           : No active profile set, falling back to default profiles: default
+2020-01-07 21:56:01.589  INFO 85431 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
+2020-01-07 21:56:01.619  INFO 85431 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
+2020-01-07 21:56:01.619  INFO 85431 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/9.0.13
+2020-01-07 21:56:01.634  INFO 85431 --- [           main] o.a.catalina.core.AprLifecycleListener   : The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: [/Users/funcy/Library/Java/Extensions:/Library/Java/Extensions:/Network/Library/Java/Extensions:/System/Library/Java/Extensions:/usr/lib/java:.]
+2020-01-07 21:56:01.722  INFO 85431 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
+2020-01-07 21:56:01.722  INFO 85431 --- [           main] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 1203 ms
+2020-01-07 21:56:01.931  INFO 85431 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
+2020-01-07 21:56:02.154  INFO 85431 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
+2020-01-07 21:56:02.157  INFO 85431 --- [           main] com.gitee.funcy.maven.jar.Main           : Started Main in 2.025 seconds (JVM running for 2.472)
+
+```
+
+总结下，步骤如下：
+
+1.  进入项目`target/`目录
+2.  解压`jar包`到`tmp`目录：`unzip -d ./tmp springboot-jar-1.0.0.jar`
+3.  进入`tmp目录`：`cd tmp/`
+4.  运行：`java org.springframework.boot.loader.JarLauncher`
+
+访问`http://localhost:8080`，也能得到正确结果。
+
+> 注：这种神奇的启动方式在什么情况下会使用呢？我曾经见过一些项目组，为了安全会把生产的配置文件放在服务器上，在部署项目的时候，先解压 jar 包，然后替换相应的配置文件，再运行。这种解压 jar 包、替换配置文件的方式就可以用此启动方式了。当然，这些解压、替换、启动等操作都会写进 shell 脚本里，自动化运行。
+
+### 3\. war 包启动
+
+#### 3.1`java -jar`方式启动
+
+项目都打成`war包`了，还能使用`java -jar`启动？是的，`springboot`就是这么方便：
+
+```
+target $ java -jar springboot-war-1.0.0.war
+
+  .   ____          _            __ _ _
+ /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
+( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
+ \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
+  '  |____| .__|_| |_|_| |_\__, | / / / /
+ =========|_|==============|___/=/_/_/_/
+ :: Spring Boot ::        (v2.1.1.RELEASE)
+
+2020-01-07 22:11:54.284  INFO 85638 --- [           main] com.gitee.funcy.maven.war.Main           : Starting Main on funcydeMacBook-Pro.local with PID 85638 (/Users/funcy/IdeaProjects/myproject/springboot-demo/springboot-maven/springboot-war/target/springboot-war-1.0.0.war started by funcy in /Users/funcy/IdeaProjects/myproject/springboot-demo/springboot-maven/springboot-war/target)
+2020-01-07 22:11:54.287  INFO 85638 --- [           main] com.gitee.funcy.maven.war.Main           : No active profile set, falling back to default profiles: default
+2020-01-07 22:11:55.257  INFO 85638 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
+2020-01-07 22:11:55.286  INFO 85638 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
+2020-01-07 22:11:55.287  INFO 85638 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/9.0.13
+2020-01-07 22:11:55.299  INFO 85638 --- [           main] o.a.catalina.core.AprLifecycleListener   : The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: [/Users/funcy/Library/Java/Extensions:/Library/Java/Extensions:/Network/Library/Java/Extensions:/System/Library/Java/Extensions:/usr/lib/java:.]
+2020-01-07 22:11:55.711  INFO 85638 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
+2020-01-07 22:11:55.711  INFO 85638 --- [           main] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 1379 ms
+2020-01-07 22:11:55.873  INFO 85638 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
+2020-01-07 22:11:56.031  INFO 85638 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
+2020-01-07 22:11:56.034  INFO 85638 --- [           main] com.gitee.funcy.maven.war.Main           : Started Main in 2.066 seconds (JVM running for 2.469)
+2020-01-07 22:12:01.189  INFO 85638 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
+2020-01-07 22:12:01.190  INFO 85638 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
+2020-01-07 22:12:01.195  INFO 85638 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 5 ms
+
+```
+
+看，项目真的跑起来了！
+
+#### 3.2`java org.springframework.boot.loader.WarLauncher`方式启动
+
+`springboot`的`jar包`可以解压，然后运行某个类来启动，`war包`竟然也有这种方法！`jar包`的启动类是`org.springframework.boot.loader.JarLauncher`，相应的`war包`启动类是`org.springframework.boot.loader.WarLauncher`，步骤如下：
+
+1.  进入项目`target/`目录
+2.  解压`war包`到`tmp`目录：`unzip -d ./tmp springboot-war-1.0.0.war`
+3.  进入`tmp目录`：`cd tmp/`
+4.  运行：`java org.springframework.boot.loader.WarLauncher`
+
+过程如下：
+
+```
+target $ unzip -d ./tmp springboot-war-1.0.0.war
+Archive:  springboot-war-1.0.0.war
+   creating: ./tmp/META-INF/
+  inflating: ./tmp/META-INF/MANIFEST.MF  
+   creating: ./tmp/org/
+   creating: ./tmp/org/springframework/
+   creating: ./tmp/org/springframework/boot/
+··· 省略其他
+target $ cd tmp/
+tmp $ java org.springframework.boot.loader.WarLauncher
+
+  .   ____          _            __ _ _
+ /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
+( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
+ \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
+  '  |____| .__|_| |_|_| |_\__, | / / / /
+ =========|_|==============|___/=/_/_/_/
+ :: Spring Boot ::        (v2.1.1.RELEASE)
+
+2020-01-07 22:17:09.637  INFO 85782 --- [           main] com.gitee.funcy.maven.war.Main           : Starting Main on funcydeMacBook-Pro.local with PID 85782 (/Users/funcy/IdeaProjects/myproject/springboot-demo/springboot-maven/springboot-war/target/tmp/WEB-INF/classes started by funcy in /Users/funcy/IdeaProjects/myproject/springboot-demo/springboot-maven/springboot-war/target/tmp)
+2020-01-07 22:17:09.640  INFO 85782 --- [           main] com.gitee.funcy.maven.war.Main           : No active profile set, falling back to default profiles: default
+2020-01-07 22:17:10.576  INFO 85782 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
+2020-01-07 22:17:10.603  INFO 85782 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
+2020-01-07 22:17:10.604  INFO 85782 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/9.0.13
+2020-01-07 22:17:10.616  INFO 85782 --- [           main] o.a.catalina.core.AprLifecycleListener   : The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: [/Users/funcy/Library/Java/Extensions:/Library/Java/Extensions:/Network/Library/Java/Extensions:/System/Library/Java/Extensions:/usr/lib/java:.]
+2020-01-07 22:17:10.725  INFO 85782 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
+2020-01-07 22:17:10.725  INFO 85782 --- [           main] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 1046 ms
+2020-01-07 22:17:10.942  INFO 85782 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
+2020-01-07 22:17:11.137  INFO 85782 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
+2020-01-07 22:17:11.140  INFO 85782 --- [           main] com.gitee.funcy.maven.war.Main           : Started Main in 1.817 seconds (JVM running for 2.183)
+2020-01-07 22:17:15.024  INFO 85782 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
+2020-01-07 22:17:15.024  INFO 85782 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
+2020-01-07 22:17:15.029  INFO 85782 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 5 ms
+
+```
+
+可以看到，项目也启动成功了！
+
+#### 3.3 传统方式启动：使用 tomcat 容器
+
+最初的`war包`就是放在 tomcat 等容器中运行的，我们也来试试`war包`在 tomcat 容器中运行情况如何。这里说的 tomcat 容器是指在[tomcat 官网](https://www.oschina.net/action/GoToLink?url=http%3A%2F%2Ftomcat.apache.org%2F "tomcat官网")下载的容器，非`springboot`内置容器。这里我下载的是`apache-tomcat-8.5.47`，过程如下：
+
+```
+... 省略tomcat日志输出
+  .   ____          _            __ _ _
+ /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
+( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
+ \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
+  '  |____| .__|_| |_|_| |_\__, | / / / /
+ =========|_|==============|___/=/_/_/_/
+ :: Spring Boot ::        (v2.1.1.RELEASE)
+
+2020-01-07 22:28:23.519  INFO 85904 --- [ost-startStop-1] c.g.funcy.maven.war.StartApplication     : Starting StartApplication on funcydeMacBook-Pro.local with PID 85904 (/Users/funcy/Applications/Tomcat/apache-tomcat-8.5.47/webapps/springboot-war-1.0.0/WEB-INF/classes started by funcy in /Users/funcy/Applications/Tomcat/apache-tomcat-8.5.47)
+2020-01-07 22:28:23.523  INFO 85904 --- [ost-startStop-1] c.g.funcy.maven.war.StartApplication     : No active profile set, falling back to default profiles: default
+2020-01-07 22:28:24.256  INFO 85904 --- [ost-startStop-1] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 676 ms
+2020-01-07 22:28:24.655  INFO 85904 --- [ost-startStop-1] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
+2020-01-07 22:28:24.920  INFO 85904 --- [ost-startStop-1] c.g.funcy.maven.war.StartApplication     : Started StartApplication in 1.86 seconds (JVM running for 3.98)
+07-Jan-2020 22:28:24.974 信息 [localhost-startStop-1] org.apache.jasper.servlet.TldScanner.scanJars 至少有一个JAR被扫描用于TLD但尚未包含TLD。 为此记录器启用调试日志记录，以获取已扫描但未在其中找到TLD的完整JAR列表。 在扫描期间跳过不需要的JAR可以缩短启动时间和JSP编译时间。
+07-Jan-2020 22:28:24.999 信息 [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployWAR Deployment of web application archive [/Users/funcy/Applications/Tomcat/apache-tomcat-8.5.47/webapps/springboot-war-1.0.0.war] has finished in [3,468] ms
+07-Jan-2020 22:28:25.000 信息 [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory 把web 应用程序部署到目录 [/Users/funcy/Applications/Tomcat/apache-tomcat-8.5.47/webapps/docs]
+07-Jan-2020 22:28:25.010 信息 [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory Deployment of web application directory [/Users/funcy/Applications/Tomcat/apache-tomcat-8.5.47/webapps/docs] has finished in [10] ms
+07-Jan-2020 22:28:25.010 信息 [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory 把web 应用程序部署到目录 [/Users/funcy/Applications/Tomcat/apache-tomcat-8.5.47/webapps/manager]
+07-Jan-2020 22:28:25.027 信息 [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory Deployment of web application directory [/Users/funcy/Applications/Tomcat/apache-tomcat-8.5.47/webapps/manager] has finished in [17] ms
+07-Jan-2020 22:28:25.027 信息 [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory 把web 应用程序部署到目录 [/Users/funcy/Applications/Tomcat/apache-tomcat-8.5.47/webapps/examples]
+07-Jan-2020 22:28:25.181 信息 [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory Deployment of web application directory [/Users/funcy/Applications/Tomcat/apache-tomcat-8.5.47/webapps/examples] has finished in [154] ms
+07-Jan-2020 22:28:25.181 信息 [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory 把web 应用程序部署到目录 [/Users/funcy/Applications/Tomcat/apache-tomcat-8.5.47/webapps/ROOT]
+07-Jan-2020 22:28:25.191 信息 [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory Deployment of web application directory [/Users/funcy/Applications/Tomcat/apache-tomcat-8.5.47/webapps/ROOT] has finished in [10] ms
+07-Jan-2020 22:28:25.191 信息 [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory 把web 应用程序部署到目录 [/Users/funcy/Applications/Tomcat/apache-tomcat-8.5.47/webapps/host-manager]
+07-Jan-2020 22:28:25.202 信息 [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory Deployment of web application directory [/Users/funcy/Applications/Tomcat/apache-tomcat-8.5.47/webapps/host-manager] has finished in [11] ms
+07-Jan-2020 22:28:25.206 信息 [main] org.apache.coyote.AbstractProtocol.start 开始协议处理句柄["http-nio-8080"]
+07-Jan-2020 22:28:25.212 信息 [main] org.apache.coyote.AbstractProtocol.start 开始协议处理句柄["ajp-nio-8009"]
+07-Jan-2020 22:28:25.213 信息 [main] org.apache.catalina.startup.Catalina.start Server startup in 3717 ms
+2020-01-07 22:29:30.754  INFO 85904 --- [nio-8080-exec-2] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
+2020-01-07 22:29:30.767  INFO 85904 --- [nio-8080-exec-2] o.s.web.servlet.DispatcherServlet        : Completed initialization in 12 ms
+
+```
+
+请求`http://localhost:8080/springboot-war-1.0.0/`，结果如下：
+
+```
+$ curl 'http://localhost:8080/springboot-war-1.0.0/'
+hello world
+
+```
+
+可以看到，已经部署成功了。
+
+### 4\. 总结
+
+|  | main () 方法 | mvn 命令 | java -jar | java xxx.WarLauncher | java xxx.JarLauncher | 外置容器 |
+| --- | --- | --- | --- | --- | --- | --- |
+| war | 支持 | 支持 | 支持 | 支持 | 不支持 | 支持 |
+| jar | 支持 | 支持 | 支持 | 不支持 | 支持 | 不支持
+
+### 1\. maven 打包后的文件
+
+进入`springboot-jar/target`目录，使用`tree`命令，目录结构如下：
+
+```
+ $ tree
+.
+├── classes
+│ └── com
+│     └── gitee
+│         └── funcy
+│             └── maven
+│                 └── jar
+│                     ├── Main.class
+│                     └── controller
+│                         └── IndexController.class
+├── generated-sources
+│ └── annotations
+├── maven-archiver
+│ └── pom.properties
+├── maven-status
+│ └── maven-compiler-plugin
+│     └── compile
+│         └── default-compile
+│             ├── createdFiles.lst
+│             └── inputFiles.lst
+├── springboot-jar-1.0.0.jar
+└── springboot-jar-1.0.0.jar.original
+
+14 directories, 7 files
+
+```
+
+注意`springboot-jar-1.0.0.jar`与`springboot-jar-1.0.0.jar.original`的区别：`springboot-jar-1.0.0.jar.original`属于原始 Maven 打包 jar 文件，该文件仅包含应用本地资源，如编译后的 classes 目录下的资源文件等，未引入第三方依赖资源；而`springboot-jar-1.0.0.jar`引入了第三方依赖资源（主要为 jar 包）。
+
+使用`unzip springboot-jar-1.0.0.jar -d tmp`解压 jar 包，内容如下：
+
+```
+ $ tree tmp/
+tmp/
+├── BOOT-INF
+│ ├── classes
+│ │ └── com
+│ │     └── gitee
+│ │         └── funcy
+│ │             └── maven
+│ │                 └── jar
+│ │                     ├── Main.class
+│ │                     └── controller
+│ │                         └── IndexController.class
+│ └── lib
+│     ├── classmate-1.4.0.jar
+│     ├── hibernate-validator-6.0.13.Final.jar
+│     ├── jackson-annotations-2.9.0.jar
+│     ├── jackson-core-2.9.7.jar
+│     ├── jackson-databind-2.9.7.jar
+│     ├── jackson-datatype-jdk8-2.9.7.jar
+│     ├── jackson-datatype-jsr310-2.9.7.jar
+│     ├── jackson-module-parameter-names-2.9.7.jar
+│     ├── javax.annotation-api-1.3.2.jar
+│     ├── jboss-logging-3.3.2.Final.jar
+│     ├── jul-to-slf4j-1.7.25.jar
+│     ├── log4j-api-2.11.1.jar
+│     ├── log4j-to-slf4j-2.11.1.jar
+│     ├── logback-classic-1.2.3.jar
+│     ├── logback-core-1.2.3.jar
+│     ├── slf4j-api-1.7.25.jar
+│     ├── snakeyaml-1.23.jar
+│     ├── spring-aop-5.1.3.RELEASE.jar
+│     ├── spring-beans-5.1.3.RELEASE.jar
+│     ├── spring-boot-2.1.1.RELEASE.jar
+│     ├── spring-boot-autoconfigure-2.1.1.RELEASE.jar
+│     ├── spring-boot-starter-2.1.1.RELEASE.jar
+│     ├── spring-boot-starter-json-2.1.1.RELEASE.jar
+│     ├── spring-boot-starter-logging-2.1.1.RELEASE.jar
+│     ├── spring-boot-starter-tomcat-2.1.1.RELEASE.jar
+│     ├── spring-boot-starter-web-2.1.1.RELEASE.jar
+│     ├── spring-context-5.1.3.RELEASE.jar
+│     ├── spring-core-5.1.3.RELEASE.jar
+│     ├── spring-expression-5.1.3.RELEASE.jar
+│     ├── spring-jcl-5.1.3.RELEASE.jar
+│     ├── spring-web-5.1.3.RELEASE.jar
+│     ├── spring-webmvc-5.1.3.RELEASE.jar
+│     ├── tomcat-embed-core-9.0.13.jar
+│     ├── tomcat-embed-el-9.0.13.jar
+│     ├── tomcat-embed-websocket-9.0.13.jar
+│     └── validation-api-2.0.1.Final.jar
+├── META-INF
+│ ├── MANIFEST.MF
+│ └── maven
+│     └── com.gitee.funcy
+│         └── springboot-jar
+│             ├── pom.properties
+│             └── pom.xml
+└── org
+    └── springframework
+        └── boot
+            └── loader
+                ├── ExecutableArchiveLauncher.class
+                ├── JarLauncher.class
+                ├── LaunchedURLClassLoader$UseFastConnectionExceptionsEnumeration.class
+                ├── LaunchedURLClassLoader.class
+                ├── Launcher.class
+                ├── MainMethodRunner.class
+                ├── PropertiesLauncher$1.class
+                ├── PropertiesLauncher$ArchiveEntryFilter.class
+                ├── PropertiesLauncher$PrefixMatchingArchiveFilter.class
+                ├── PropertiesLauncher.class
+                ├── WarLauncher.class
+                ├── archive
+                │ ├── Archive$Entry.class
+                │ ├── Archive$EntryFilter.class
+                │ ├── Archive.class
+                │ ├── ExplodedArchive$1.class
+                │ ├── ExplodedArchive$FileEntry.class
+                │ ├── ExplodedArchive$FileEntryIterator$EntryComparator.class
+                │ ├── ExplodedArchive$FileEntryIterator.class
+                │ ├── ExplodedArchive.class
+                │ ├── JarFileArchive$EntryIterator.class
+                │ ├── JarFileArchive$JarFileEntry.class
+                │ └── JarFileArchive.class
+                ├── data
+                │ ├── RandomAccessData.class
+                │ ├── RandomAccessDataFile$1.class
+                │ ├── RandomAccessDataFile$DataInputStream.class
+                │ ├── RandomAccessDataFile$FileAccess.class
+                │ └── RandomAccessDataFile.class
+                ├── jar
+                │ ├── AsciiBytes.class
+                │ ├── Bytes.class
+                │ ├── CentralDirectoryEndRecord.class
+                │ ├── CentralDirectoryFileHeader.class
+                │ ├── CentralDirectoryParser.class
+                │ ├── CentralDirectoryVisitor.class
+                │ ├── FileHeader.class
+                │ ├── Handler.class
+                │ ├── JarEntry.class
+                │ ├── JarEntryFilter.class
+                │ ├── JarFile$1.class
+                │ ├── JarFile$2.class
+                │ ├── JarFile$JarFileType.class
+                │ ├── JarFile.class
+                │ ├── JarFileEntries$1.class
+                │ ├── JarFileEntries$EntryIterator.class
+                │ ├── JarFileEntries.class
+                │ ├── JarURLConnection$1.class
+                │ ├── JarURLConnection$JarEntryName.class
+                │ ├── JarURLConnection.class
+                │ ├── StringSequence.class
+                │ └── ZipInflaterInputStream.class
+                └── util
+                    └── SystemPropertyUtils.class
+
+21 directories, 91 files
+
+```
+
+可以看到，文件中主要分为如下几个目录：
+
+*   `BOOT-INF/classes`目录存放应用编译后的 class 文件；
+*   `BOOT-INF/lib`目录存放应用依赖的 jar 包；
+*   `META-INF/`目录存放应用依赖的 jar 包；
+*   `org/`目录存放 spring boot 相关的 class 文件。
+
+### 2.`java -jar`启动 springboot jar 包
+
+java 官方规定，`java -jar`命令引导的具体启动类必须配置在`MANIFEST.MF`文件中，而根据`jar文件规范`，`MANIFEST.MF`文件必须存放在`/META-INF/`目录下。因此，启动类配置在 jar 包的`/META-INF/MANIFEST.MF`文件中，查看该文件，内容如下：
+
+```
+$ cat MANIFEST.MF 
+Manifest-Version: 1.0
+Archiver-Version: Plexus Archiver
+Built-By: fangchengyan
+Start-Class: com.gitee.funcy.maven.jar.Main
+Spring-Boot-Classes: BOOT-INF/classes/
+Spring-Boot-Lib: BOOT-INF/lib/
+Spring-Boot-Version: 2.1.1.RELEASE
+Created-By: Apache Maven 3.6.0
+Build-Jdk: 1.8.0_222
+Main-Class: org.springframework.boot.loader.JarLauncher
+
+```
+
+发现`Main-Class`属性指向的`Class`为`org.springframework.boot.loader.JarLauncher`，而该类存放在 jar 包的`org/springframework/boot/loader/`目录下，并且项目的引导类定义在`Start-Class`属性性中，该属性并非 java 平台标准`META-INF/MANIFEST.MF`属性。
+
+> 注：
+>
+> 1.  `org.springframework.boot.loader.JarLauncher`是可执行 jar 的启动器，`org.springframework.boot.loader.WarLauncher`是可执行 war 的启动器。
+>
+>
+> 2.  `org.springframework.boot.loader.JarLauncher`所在的 jar 文件的 Maven GAV 信息为`org.springframework.boot:spring-boot-loader:${springboot-version}`，通常情况下，这个依赖没有必要引入 springboot 项目的 pom.xml 文件。
+
+查看`JarLauncher`源码，如下：
+
+```
+public class JarLauncher extends ExecutableArchiveLauncher {
+
+	static final String BOOT_INF_CLASSES = "BOOT-INF/classes/";
+
+	static final String BOOT_INF_LIB = "BOOT-INF/lib/";
+
+	public JarLauncher() {
+	}
+
+	protected JarLauncher(Archive archive) {
+		super(archive);
+	}
+
+	@Override
+	protected boolean isNestedArchive(Archive.Entry entry) {
+		if (entry.isDirectory()) {
+			return entry.getName().equals(BOOT_INF_CLASSES);
+		}
+		return entry.getName().startsWith(BOOT_INF_LIB);
+	}
+
+	public static void main(String[] args) throws Exception {
+		new JarLauncher().launch(args);
+	}
+
+}
+
+```
+
+可以发现，`BOOT-INF/classes/`与`BOOT-INF/lib/`分别使用常量`BOOT_INF_CLASSES`和`BOOT_INF_LIB`表示，并且用于`isNestedArchive(Archive.Entry)`方法判断，从该方法的实现分析，方法参数`Archive.Entry`看似为 jar 文件中的资源，比如`application.properties`。
+
+`Archive.Entry`有两种实现，其中一种为`org.springframework.boot.loader.archive.JarFileArchive.JarFileEntry`，基于`java.util.jar.JarEntry`，表示`FAT JAR`嵌入资源，另一种为`org.springframework.boot.loader.archive.ExplodedArchive.FileEntry`，基于文件系统实现。这也说明了`JarLauncher`支持`JAR`和`文件系统`两种启动方式。
+
+> 文件系统启动方式如下：
+>
+> 1.  解压 jar 包到`temp`目录：`unzip springboot-jar-1.0.0.jar -d tmp`
+> 2.  进入`temp`目录，运行命令：`java org.springframework.boot.loader.JarLauncher`可以看到，项目同样能正常启动。
+
+在`JarLauncher`作为引导类时，当执行`java -jar`命令时，`/META-INF`资源的`Main-Class`属性将调用其`main(String[])`方法，实际上调用的是`JarLauncher#launch(args)`方法，而该方法继承于基类`org.springframework.boot.loader.Launcher`，它们之间的继承关系如下：
+
+*   `org.springframework.boot.loader.Launcher`
+  *   `org.springframework.boot.loader.ExecutableArchiveLauncher`
+    *   `org.springframework.boot.loader.JarLauncher`
+    *   `org.springframework.boot.loader.WarLauncher`
+
+简单来说，springboot jar 启动过程如下：
+
+1.  `java -jar xxx.jar`运行的是`JarLauncher`
+2.  `JarLauncher#main(String[])`方法会调用`Launcher#launch(String[])`方法，创建 ClassLoader () 及调用项目的`main`方法
+  *   项目主类的获取实现位于`ExecutableArchiveLauncher#getMainClass()`，主要是从`/META-INF/MANIFEST.MF`获取`Start-Class`属性
+  *   项目主类的 main () 方法调用位于`MainMethodRunner#run()`，使用反射方式进行调用
+
+### 3.`java -jar`启动 springboot war 包
+
+从上面的分析，我们得到了启动 jar 包的`org.springframework.boot.loader.JarLauncher`以及启动 war 包的`org.springframework.boot.loader.WarLauncher`，这里我们来分析下`WarLauncher`上如何工作的。
+
+`WarLauncher`代码如下：
+
+```
+public class WarLauncher extends ExecutableArchiveLauncher {
+
+	private static final String WEB_INF = "WEB-INF/";
+
+	private static final String WEB_INF_CLASSES = WEB_INF + "classes/";
+
+	private static final String WEB_INF_LIB = WEB_INF + "lib/";
+
+	private static final String WEB_INF_LIB_PROVIDED = WEB_INF + "lib-provided/";
+
+	public WarLauncher() {
+	}
+
+	protected WarLauncher(Archive archive) {
+		super(archive);
+	}
+
+	@Override
+	public boolean isNestedArchive(Archive.Entry entry) {
+		if (entry.isDirectory()) {
+			return entry.getName().equals(WEB_INF_CLASSES);
+		}
+		else {
+			return entry.getName().startsWith(WEB_INF_LIB)
+					|| entry.getName().startsWith(WEB_INF_LIB_PROVIDED);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		new WarLauncher().launch(args);
+	}
+
+}
+
+```
+
+可以看到，`WEB-INF/classes/`、`WEB-INF/lib/`、`WEB-INF/lib-provided/`均为`WarLauncher`的`Class Path`，其中`WEB-INF/classes/`、`WEB-INF/lib/`是传统的 Servlet 应用的 ClassPath 路径，而`WEB-INF/lib-provided/`属性 springboot`WarLauncher`定制实现。那么`WEB-INF/lib-provided/`究竟是干嘛的呢？看到`provided`，我们可以大胆猜想`WEB-INF/lib-provided/`存放的是`pom.xml`文件中，`scope`为`provided`的 jar。
+
+为了验证以上猜想，修改的 pom.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.gitee.funcy</groupId>
+    springboot-war
+    <version>1.0.0</version>
+    <!-- 指定打包方式为war包 -->
+    <packaging>war</packaging>
+    <name>springboot非parent war打包方式</name>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <java.version>1.8</java.version>
+        <spring-boot.version>2.1.1.RELEASE</spring-boot.version>
+        <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
+    </properties>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <!-- Import dependency management from Spring Boot -->
+                <groupId>org.springframework.boot</groupId>
+                spring-boot-dependencies
+                <version>${spring-boot.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter-web
+        </dependency>
+        <!-- 测试war包中 WEB-INF/lib-provided/ 目录内容-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-test
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                maven-compiler-plugin
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                    <encoding>${project.build.sourceEncoding}</encoding>
+                </configuration>
+            </plugin>
+            <!-- 打成war包时，需要添加该插件 -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                maven-war-plugin
+                <!-- 保持与 spring-boot-dependencies 版本一致 -->
+                <version>3.2.2</version>
+            </plugin>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                spring-boot-maven-plugin
+                <version>${spring-boot.version}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
+
+```
+
+这里我们添加了 springboot 的测试 jar`org.springframework.boot:spring-boot-test`，并将其`scope`设置为`provided`. 运行 maven 打包命令`mvn clean install -Dmaven.test.skip=true`，可以看到项目能正常打包。
+
+打包完成后，进入`target`目录，运行`java -jar springboot-war-1.0.0.war`，项目能正常启动。
+
+接下来，我们来看看`springboot-war-1.0.0.war`有些啥。首先使用`unzip springboot-war-1.0.0.war -d tmp`命令解压，再使用`tree -h`命令查看文件结构，结果如下
+
+```
+ $ tree -h
+.
+├── [ 128]  META-INF
+│ ├── [ 311]  MANIFEST.MF
+│ └── [  96]  maven
+│     └── [  96]  com.gitee.funcy
+│         └── [ 128]  springboot-war
+│             ├── [  95]  pom.properties
+│             └── [3.3K]  pom.xml
+├── [ 160]  WEB-INF
+│ ├── [  96]  classes
+│ │ └── [  96]  com
+│ │     └── [  96]  gitee
+│ │         └── [  96]  funcy
+│ │             └── [  96]  maven
+│ │                 └── [ 160]  war
+│ │                     ├── [ 688]  Main.class
+│ │                     ├── [ 891]  StartApplication.class
+│ │                     └── [  96]  controller
+│ │                         └── [ 646]  IndexController.class
+│ ├── [1.2K]  lib
+│ │ ├── [ 65K]  classmate-1.4.0.jar
+│ │ ├── [1.1M]  hibernate-validator-6.0.13.Final.jar
+│ │ ├── [ 65K]  jackson-annotations-2.9.0.jar
+│ │ ├── [316K]  jackson-core-2.9.7.jar
+│ │ ├── [1.3M]  jackson-databind-2.9.7.jar
+│ │ ├── [ 33K]  jackson-datatype-jdk8-2.9.7.jar
+│ │ ├── [ 98K]  jackson-datatype-jsr310-2.9.7.jar
+│ │ ├── [8.4K]  jackson-module-parameter-names-2.9.7.jar
+│ │ ├── [ 26K]  javax.annotation-api-1.3.2.jar
+│ │ ├── [ 65K]  jboss-logging-3.3.2.Final.jar
+│ │ ├── [4.5K]  jul-to-slf4j-1.7.25.jar
+│ │ ├── [258K]  log4j-api-2.11.1.jar
+│ │ ├── [ 17K]  log4j-to-slf4j-2.11.1.jar
+│ │ ├── [284K]  logback-classic-1.2.3.jar
+│ │ ├── [461K]  logback-core-1.2.3.jar
+│ │ ├── [ 40K]  slf4j-api-1.7.25.jar
+│ │ ├── [294K]  snakeyaml-1.23.jar
+│ │ ├── [360K]  spring-aop-5.1.3.RELEASE.jar
+│ │ ├── [656K]  spring-beans-5.1.3.RELEASE.jar
+│ │ ├── [935K]  spring-boot-2.1.1.RELEASE.jar
+│ │ ├── [1.2M]  spring-boot-autoconfigure-2.1.1.RELEASE.jar
+│ │ ├── [ 413]  spring-boot-starter-2.1.1.RELEASE.jar
+│ │ ├── [ 421]  spring-boot-starter-json-2.1.1.RELEASE.jar
+│ │ ├── [ 423]  spring-boot-starter-logging-2.1.1.RELEASE.jar
+│ │ ├── [ 422]  spring-boot-starter-tomcat-2.1.1.RELEASE.jar
+│ │ ├── [ 421]  spring-boot-starter-web-2.1.1.RELEASE.jar
+│ │ ├── [1.0M]  spring-context-5.1.3.RELEASE.jar
+│ │ ├── [1.2M]  spring-core-5.1.3.RELEASE.jar
+│ │ ├── [274K]  spring-expression-5.1.3.RELEASE.jar
+│ │ ├── [ 23K]  spring-jcl-5.1.3.RELEASE.jar
+│ │ ├── [1.3M]  spring-web-5.1.3.RELEASE.jar
+│ │ ├── [782K]  spring-webmvc-5.1.3.RELEASE.jar
+│ │ ├── [3.1M]  tomcat-embed-core-9.0.13.jar
+│ │ ├── [244K]  tomcat-embed-el-9.0.13.jar
+│ │ ├── [257K]  tomcat-embed-websocket-9.0.13.jar
+│ │ └── [ 91K]  validation-api-2.0.1.Final.jar
+│ └── [  96]  lib-provided
+│     └── [194K]  spring-boot-test-2.1.1.RELEASE.jar
+└── [  96]  org
+    └── [  96]  springframework
+        └── [  96]  boot
+            └── [ 544]  loader
+                ├── [3.5K]  ExecutableArchiveLauncher.class
+                ├── [1.5K]  JarLauncher.class
+                ├── [1.5K]  LaunchedURLClassLoader$UseFastConnectionExceptionsEnumeration.class
+                ├── [5.6K]  LaunchedURLClassLoader.class
+                ├── [4.6K]  Launcher.class
+                ├── [1.5K]  MainMethodRunner.class
+                ├── [ 266]  PropertiesLauncher$1.class
+                ├── [1.4K]  PropertiesLauncher$ArchiveEntryFilter.class
+                ├── [1.9K]  PropertiesLauncher$PrefixMatchingArchiveFilter.class
+                ├── [ 19K]  PropertiesLauncher.class
+                ├── [1.7K]  WarLauncher.class
+                ├── [ 416]  archive
+                │ ├── [ 302]  Archive$Entry.class
+                │ ├── [ 437]  Archive$EntryFilter.class
+                │ ├── [ 945]  Archive.class
+                │ ├── [ 273]  ExplodedArchive$1.class
+                │ ├── [1.1K]  ExplodedArchive$FileEntry.class
+                │ ├── [1.5K]  ExplodedArchive$FileEntryIterator$EntryComparator.class
+                │ ├── [3.7K]  ExplodedArchive$FileEntryIterator.class
+                │ ├── [5.1K]  ExplodedArchive.class
+                │ ├── [1.7K]  JarFileArchive$EntryIterator.class
+                │ ├── [1.1K]  JarFileArchive$JarFileEntry.class
+                │ └── [7.2K]  JarFileArchive.class
+                ├── [ 224]  data
+                │ ├── [ 485]  RandomAccessData.class
+                │ ├── [ 282]  RandomAccessDataFile$1.class
+                │ ├── [2.6K]  RandomAccessDataFile$DataInputStream.class
+                │ ├── [3.2K]  RandomAccessDataFile$FileAccess.class
+                │ └── [3.9K]  RandomAccessDataFile.class
+                ├── [ 768]  jar
+                │ ├── [4.9K]  AsciiBytes.class
+                │ ├── [ 616]  Bytes.class
+                │ ├── [3.0K]  CentralDirectoryEndRecord.class
+                │ ├── [5.1K]  CentralDirectoryFileHeader.class
+                │ ├── [4.5K]  CentralDirectoryParser.class
+                │ ├── [ 540]  CentralDirectoryVisitor.class
+                │ ├── [ 345]  FileHeader.class
+                │ ├── [ 12K]  Handler.class
+                │ ├── [3.5K]  JarEntry.class
+                │ ├── [ 299]  JarEntryFilter.class
+                │ ├── [2.0K]  JarFile$1.class
+                │ ├── [1.2K]  JarFile$2.class
+                │ ├── [1.3K]  JarFile$JarFileType.class
+                │ ├── [ 15K]  JarFile.class
+                │ ├── [1.6K]  JarFileEntries$1.class
+                │ ├── [2.0K]  JarFileEntries$EntryIterator.class
+                │ ├── [ 14K]  JarFileEntries.class
+                │ ├── [ 702]  JarURLConnection$1.class
+                │ ├── [4.2K]  JarURLConnection$JarEntryName.class
+                │ ├── [9.6K]  JarURLConnection.class
+                │ ├── [3.5K]  StringSequence.class
+                │ └── [1.8K]  ZipInflaterInputStream.class
+                └── [  96]  util
+                    └── [5.1K]  SystemPropertyUtils.class
+
+22 directories, 93 files
+
+```
+
+相比于`FAT JAR`的解压目录，`War`增加了`WEB-INF/lib-provided`，并且该目录仅有一个 jar 文件，即`spring-boot-test-2.1.1.RELEASE.jar`，这正是我们在 pom.xml 文件中设置的`scope`为`provided`的 jar 包。
+
+由此可以得出结论：**`WEB-INF/lib-provided`存放的是`scope`为`provided`的 jar 包**。
+
+我们现来看下`META-INF/MANIFEST.MF`的内容：
+
+```
+$ cat META-INF/MANIFEST.MF 
+Manifest-Version: 1.0
+Built-By: fangchengyan
+Start-Class: com.gitee.funcy.maven.war.Main
+Spring-Boot-Classes: WEB-INF/classes/
+Spring-Boot-Lib: WEB-INF/lib/
+Spring-Boot-Version: 2.1.1.RELEASE
+Created-By: Apache Maven 3.6.0
+Build-Jdk: 1.8.0_222
+Main-Class: org.springframework.boot.loader.WarLauncher
+
+```
+
+可以看到，该文件与 jar 包中的`META-INF/MANIFEST.MF`很相似，在文件中同样定义了`Main-Class`与`Start-Class`，这也说明了该 war 可以使用`java -jar xxx.jar`和`java org.springframework.boot.loader.WarLauncher`启动，这也与我们的验证结果一致。
+
+### 4\. tomcat 等外部容器启动 war 包
+
+在 springboo 刚开始推广的时候，我们还是习惯于将项目打成 war 包，然后部署到 tomcat 等 web 容器中运行。那 springboot 的 war 包是如何做到既能用 java 命令启动，又能放在 tomcat 容器中启动呢？这就是之前提到的`WEB-INF/lib-provided`目录的功能了。
+
+传统的`servlet`应用的`class path`路径仅关注`WEB-INF/classes/`和`WEB-INF/lib/`，`WEB-INF/lib-provided/`目录下的 jar 包将被`servlet`容器忽略，如`servlet api`，该 api 由`servlet`容器提供。我们在打包时，可以把`servlet`相关 jar 包的`scope`设置成`provided`，这样就完美实现了`servlet`容器启动与`java`命令启动的兼容：
+
+*   当部署到`servlet`容器中时，`WEB-INF/lib-provided/`目录下的 jar 包就被容器忽略了（由于`servlet`容器本身就提供了`servlet`的相关 jar 包，如果不忽略，就会出现 jar 包重复引入问题）；
+*   当使用`java`命令执行时，此时无`servlet`容器提供`servlet`的相关 jar 包，而`WarLauncher`在运行过程中会加载`WEB-INF/lib-provided/`目录下的 jar 包。
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\224\237\344\272\247\347\216\257\345\242\203\345\267\245\345\205\267Actuator.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\224\237\344\272\247\347\216\257\345\242\203\345\267\245\345\205\267Actuator.md"
new file mode 100644
index 0000000..e0eeb3e
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\224\237\344\272\247\347\216\257\345\242\203\345\267\245\345\205\267Actuator.md"
@@ -0,0 +1,5832 @@
+
+
+# ������������
+
+[Back to index](https://springdoc.cn/spring-boot/index.html)
+
+*   [1\. ����������������](https://springdoc.cn/spring-boot/actuator.html#actuator.enabling)
+*   [2\. �˵㣨Endpoint��](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints)
+*   [3\. ͨ��HTTP���м�غ͹���](https://springdoc.cn/spring-boot/actuator.html#actuator.monitoring)
+*   [4\. ͨ��JMX���м�غ͹���](https://springdoc.cn/spring-boot/actuator.html#actuator.jmx)
+*   [5\. �ɹ۲��ԣ�Observability��](https://springdoc.cn/spring-boot/actuator.html#actuator.observability)
+*   [6\. ��־��¼����Logger��](https://springdoc.cn/spring-boot/actuator.html#actuator.loggers)
+*   [7\. ָ�꣨Metrics��](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics)
+*   [8\. ׷�٣�Tracing��](https://springdoc.cn/spring-boot/actuator.html#actuator.micrometer-tracing)
+*   [9\. ���](https://springdoc.cn/spring-boot/actuator.html#actuator.auditing)
+*   [10\. ��¼ HTTP Exchange](https://springdoc.cn/spring-boot/actuator.html#actuator.http-exchanges)
+*   [11\. ���̼��](https://springdoc.cn/spring-boot/actuator.html#actuator.process-monitoring)
+*   [12\. Cloud Foundry ��֧��](https://springdoc.cn/spring-boot/actuator.html#actuator.cloud-foundry)
+*   [13\. ��������ʲô](https://springdoc.cn/spring-boot/actuator.html#actuator.whats-next)
+
+
+
+
+
+
+
+
+
+
+
+
+
+|  | ��վ([springdoc.cn](https://springdoc.cn/))�е�������Դ�� [spring.io](https://spring.io/) ��ԭʼ��Ȩ������ [spring.io](https://spring.io/)���� [springboot.io - Spring Boot��������](https://springboot.io/) ���з��룬�������ɹ�����ѧϰ���о���δ�����ɣ����ý����κ�ת�ء����û���֮��ص���Ϊ�� �̱�������Spring �� Pivotal Software, Inc. �������Լ��������ҵ��̱ꡣ |
+| --- | --- |
+
+
+
+
+
+Spring Boot����һЩ����Ĺ��ܣ��԰������ڽ�Ӧ�ó��򷢲�������ʱ��غ͹������Ӧ�ó��� �����ѡ��ͨ��ʹ��HTTP�˵��ʹ��JMX�������ͼ�����Ӧ�ó��� ��ơ�������ָ���ռ�Ҳ�����Զ�Ӧ�������Ӧ�ó���
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/actuator.html#actuator.enabling)1\. ����������������
+
+
+
+
+
+[`spring-boot-actuator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator) ģ���ṩ������Spring Boot�������������ܡ� ������Щ���ܵ��Ƽ����������Ӷ� `spring-boot-starter-actuator` ��Starter�� ��������
+
+
+
+
+
+
+
+Actuator�Ķ���
+
+
+
+actuator��ִ������ ��һ���������ָ���������ƶ������ij��Ļ�еװ�á�actuator ���Դ�һ��С�ı仯�в����������˶���
+
+
+
+
+
+
+
+
+
+Ҫ�ڻ���Maven����Ŀ������actuator������������ ��Starter�� ������
+
+
+
+
+
+
+
+```
+<dependencies>
+    <dependency>
+        <groupId>org.springframework.boot</groupId>
+        spring-boot-starter-actuator
+    </dependency>
+</dependencies>
+```
+
+
+
+
+
+
+
+����Gradle��ʹ������������
+
+
+
+
+
+
+
+```
+dependencies {
+    implementation 'org.springframework.boot:spring-boot-starter-actuator'
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints)2\. �˵㣨Endpoint��
+
+
+
+
+
+Actuator �˵㣨endpoint��������Լ�ز������Ӧ�ó��򻥶��� Spring Boot����һЩ���õĶ˵㣬�������������Լ��Ķ˵㡣 ���磬`health` �˵��ṩ������Ӧ�ó��򽡿���Ϣ��
+
+
+
+
+
+�����[���û����](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.enabling)ÿ�������Ķ˵㣬��[ͨ��HTTP��JMX�������ǣ�ʹ���ǿ���Զ�̷��ʣ�](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.exposing)����һ���˵㱻���úͱ�¶ʱ��������Ϊ�ǿ��õġ����õĶ˵�ֻ�������ǿ���ʱ�Żᱻ�Զ����á������Ӧ�ó���ѡ��ͨ��HTTP��¶�����ж˵��ID�� `/actuator` ��ǰ׺��ӳ�䵽һ��URL�����磬Ĭ������£�`health` �˵㱻ӳ�䵽 `/actuator/health`��
+
+
+
+
+
+|  | Ҫ�˽�������actuator�Ķ˵��Լ����ǵ��������Ӧ��ʽ���뿴������API�ĵ��� [HTML](https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/actuator-api/htmlsingle) �� [PDF](https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/actuator-api/pdf/spring-boot-actuator-web-api.pdf)���� |
+| --- | --- |
+
+
+
+
+
+�����Ǽ����޹ص��նˡ�
+
+
+
+<colgroup><col><col></colgroup>
+| ID | ˵�� |
+| --- | --- |
+| `auditevents` | ������ǰӦ�ó��������¼���Ϣ�� ��Ҫһ�� `AuditEventRepository` bean�� |
+| `beans` | ��ʾ���Ӧ�ó���������Spring Bean�������б��� |
+| `caches` | ��ʾ���õĻ��档 |
+| `conditions` | ��ʾ�����ú��Զ�����������������������Լ����Ƿ��ϻ򲻷��ϵ�ԭ�� |
+| `configprops` | ��ʾ���� `@ConfigurationProperties` �������б��� |
+| `env` | ��¶Spring�� `ConfigurableEnvironment` �е����ԡ� |
+| `flyway` | ��ʾ�κ��Ѿ�Ӧ�õ�Flyway���ݿ�Ǩ�ơ� ��Ҫһ������ `Flyway` bean�� |
+| `health` | ��ʾӦ�ó���Ľ�����Ϣ�� |
+| `httpexchanges` | ��ʾ HTTP exchange ��Ϣ��Ĭ������£���� 100 �� HTTP request/response exchange���� ��Ҫһ�� `HttpExchangeRepository` bean�� |
+| `info` | ��ʾ�����Ӧ�ó�����Ϣ�� |
+| `integrationgraph` | ��ʾSpring����ͼ�� ��Ҫ���� `spring-integration-core`�� |
+| `loggers` | ��ʾ���޸�Ӧ�ó�����logger�����á� |
+| `liquibase` | ��ʾ�κ��Ѿ�Ӧ�õ�Liquibase���ݿ�Ǩ�ơ� ��Ҫһ������ `Liquibase` Bean�� |
+| `metrics` | ��ʾ��ǰӦ�ó���� ��metrics�� ��Ϣ�� |
+| `mappings` | ��ʾ���� `@RequestMapping` ·���������б��� |
+| `quartz` | ��ʾ�й�Quartz Scheduler Job����Ϣ�� |
+| `scheduledtasks` | ��ʾ���Ӧ�ó����еļƻ����� |
+| `sessions` | ������Spring Session֧�ֵĻỰ�洢�м�����ɾ���û��Ự�� ��Ҫһ��ʹ��Spring Session�Ļ���Servlet��WebӦ�ó��� |
+| `shutdown` | ��Ӧ�ó������ŵعرա�ֻ��ʹ��jar���ʱ��Ч��Ĭ��������ǽ��õġ� |
+| `startup` | ��ʾ�� `ApplicationStartup` �ռ���[������������](https://springdoc.cn/spring-boot/features.html#features.spring-application.startup-tracking)��Ҫ�� `SpringApplication` ������Ϊ `BufferingApplicationStartup`�� |
+| `threaddump` | Performs a thread dump. |
+
+
+
+������Ӧ�ó�����һ��WebӦ�ó���Spring MVC��Spring WebFlux��Jersey���������ʹ�����¶���Ķ˵㡣
+
+
+
+<colgroup><col><col></colgroup>
+| ID | ˵�� |
+| --- | --- |
+| `heapdump` | ����һ����dump�ļ��� ��HotSpot JVM�ϣ�����һ�� `HPROF` ��ʽ���ļ��� ��OpenJ9 JVM�ϣ�����һ�� `PHD` ��ʽ���ļ��� |
+| `logfile` | ������־�ļ������ݣ���� `logging.file.name` �� `logging.file.path` �����ѱ����ã��� ֧��ʹ��HTTP `Range` ͷ��������־�ļ��IJ������ݡ� |
+| `prometheus` | �Կɱ� Prometheus ������ץȡ�ĸ�ʽչʾ������metric���� ������ `micrometer-registry-prometheus`�� |
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.enabling)2.1\. ���ö˵�
+
+
+
+Ĭ������£��� `shutdown` ������ж˵㶼�����á� Ҫ����һ���˵�����ã���ʹ���� `management.endpoint.<id>.enabled` ���ԡ� ��������������� `shutdown` �˵㡣
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoint.shutdown.enabled=true
+
+```
+
+
+
+
+
+
+
+�����ϣ���˵������ǡ�ѡ�����á������ǡ�ѡ����á����뽫 `management.endpoints.enabled-by-default` ��������Ϊ `false`����ʹ�õ����˵�� `enabled` ������ѡ���������á� ��������������� `info` �˵㣬�����������������˵㡣
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoints.enabled-by-default=false
+management.endpoint.info.enabled=true
+
+```
+
+
+
+
+
+
+
+|  | �����õĶ˵���Ӧ�ó�������������ȫɾ�����������ֻ�ı䱩¶�˵�ļ�������ʹ�� [`include` �� `exclude` ����](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.exposing)�����档 |
+| --- | --- |
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.exposing)2.2\. ��¶�˵�
+
+
+
+Ĭ������£�ֻ��health�˵���ͨ��HTTP��JMX��¶�ġ� ���ڶ˵���ܰ���������Ϣ����Ӧ����ϸ���Ǻ�ʱ��¶���ǡ�
+
+
+
+
+
+Ҫ�ı���Щ�˵㱻��¶����ʹ�������ض������� `include` �� `exclude` ���ԡ�
+
+
+
+<colgroup><col><col></colgroup>
+| ���� | Ĭ�� |
+| --- | --- |
+| `management.endpoints.jmx.exposure.exclude` |  |
+| `management.endpoints.jmx.exposure.include` | `health` |
+| `management.endpoints.web.exposure.exclude` |  |
+| `management.endpoints.web.exposure.include` | `health` |
+
+
+
+`include` �����г��˱���¶�Ķ˵��ID�� `exclude` �����г��˲�Ӧ�ñ������Ķ˵��ID�� `exclude` ���������� `include` ���ԡ� �������һ���˵�ID�б������� `include` �� `exclude` ���ԡ�
+
+
+
+
+
+���磬Ҫͨ��JMXֻ���� `health` �� `info` �˵㣬��ʹ���������ԡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoints.jmx.exposure.include=health,info
+
+```
+
+
+
+
+
+
+
+`*` ��������ѡ�����ж˵㡣 ���磬Ҫͨ��HTTP�������еĶ��������� `env` �� `beans` �˵㣬ʹ���������ԡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoints.web.exposure.include=*
+management.endpoints.web.exposure.exclude=env,beans
+
+```
+
+
+
+
+
+
+
+|  | `*` ��YAML�о������⺬�壬�������������������ų������еĶ˵㣬һ��Ҫ�����š� |
+| --- | --- |
+
+
+
+
+
+|  | ������Ӧ�ó����ǹ�����¶�ģ�����ǿ�ҽ�����Ҳ[������Ķ˵�](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.security)�� |
+| --- | --- |
+
+
+
+
+
+|  | ��������ڶ˵㱩¶ʱʵʩ�Լ��IJ��ԣ������ע��һ�� `EndpointFilter` bean�� |
+| --- | --- |
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.security)2.3\. ��ȫ��Security��
+
+
+
+Ϊ�˰�ȫ�����Ĭ�������ֻ�� `/health` �˵�ͨ��HTTP������ �����ʹ�� `management.endpoints.web.exposure.include` ���������ñ���¶�Ķ˵㡣
+
+
+
+
+
+|  | ������ `management.endpoints.web.exposure.include` ֮ǰ����ȷ����¶��ִ����������������Ϣ���������ڷ���ǽ֮�󣬻���Spring Security֮��Ķ�������֤��ȫ�� |
+| --- | --- |
+
+
+
+
+
+���Spring Security��classpath�ϣ�����û������ `SecurityFilterChain` bean����ô���� `/health` ֮�������ִ������actuator������Spring Boot�Զ���������֤��ȫ�� ����㶨����һ���Զ���� `SecurityFilterChain` bean��Spring Boot�Զ����þͻ�������������ȫ����ִ�����ķ��ʹ���
+
+
+
+
+
+�������ΪHTTP�˵������Զ��尲ȫ�����磬ֻ��������ij�ֽ�ɫ���û����ʣ���Spring Boot�ṩ��һЩ����� `RequestMatcher` �����������Spring Security���ʹ�á�
+
+
+
+
+
+һ�����͵�Spring Security���ÿ��ܿ���������������ӡ�
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Configuration(proxyBeanMethods = false)
+public class MySecurityConfiguration {
+
+    @Bean
+    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
+        http.securityMatcher(EndpointRequest.toAnyEndpoint());
+        http.authorizeHttpRequests((requests) -> requests.anyRequest().hasRole("ENDPOINT_ADMIN"));
+        http.httpBasic(withDefaults());
+        return http.build();
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+ǰ�������ʹ�� `EndpointRequest.toAnyEndpoint()` ��ƥ��һ�������κζ˵㣬Ȼ��ȷ�����еĶ˵㶼�� `ENDPOINT_ADMIN` �Ľ�ɫ�� `EndpointRequest` �ϻ�����������ƥ���������� �����API�ĵ��� [HTML](https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/actuator-api/htmlsingle) �� [PDF](https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/actuator-api/pdf/spring-boot-actuator-web-api.pdf)����
+
+
+
+
+
+������ڷ���ǽ���沿��Ӧ�ó��������ϣ���������ִ�����˵㶼�ܱ����ʣ�������Ҫ��֤�� �����ͨ���ı� `management.endpoints.web.exposure.include` ������������һ�㣬������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoints.web.exposure.include=*
+
+```
+
+
+
+
+
+
+
+���⣬�������Spring Security������Ҫ�����Զ��尲ȫ���ã�����δ����֤�ķ��ʶ˵㣬��������ʾ��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Configuration(proxyBeanMethods = false)
+public class MySecurityConfiguration {
+
+    @Bean
+    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
+        http.securityMatcher(EndpointRequest.toAnyEndpoint());
+        http.authorizeHttpRequests((requests) -> requests.anyRequest().permitAll());
+        return http.build();
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+|  | ��ǰ������������У�����ֻ������actuator�˵㡣 ����Spring Boot�İ�ȫ���������κ� `SecurityFilterChain` bean������¶�����ȫ�˳�����������Ҫ����һ������� `SecurityFilterChain` bean�������������Ӧ�ó�����������֡� |
+| --- | --- |
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.security.csrf)2.3.1\. ����վ����α�챣����CSRF��
+
+
+
+����Spring Boot����Spring Security��Ĭ��ֵ��CSRF������Ĭ������±��򿪡� ����ζ����ʹ��Ĭ�ϰ�ȫ����ʱ����Ҫ `POST`��shutdown��loggers�˵㣩��`PUT` �� `DELETE` ��actuator�˵�����403����ֹ���Ĵ���
+
+
+
+
+
+|  | ���ǽ���ֻ�����㴴���ķ��񱻷�������ͻ���ʹ��ʱ����ȫ����CSRF������ |
+| --- | --- |
+
+
+
+
+
+������� [Spring��ȫ�ο�ָ��](https://docs.spring.io/spring-security/reference/6.1.0-M1/features/exploits/csrf.html) ���ҵ�����CSRF������������Ϣ��
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.caching)2.4\. ���ö˵�
+
+
+
+�˵���Զ����治��Ҫ�κβ����Ķ�ȡ��������Ӧ�� Ҫ���ö˵㻺����Ӧ��ʱ�䣬��ʹ���� `cache.time-to-live` ���ԡ� ��������ӽ� `beans` �˵�Ļ�������ʱ������Ϊ10�롣
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoint.beans.cache.time-to-live=10s
+
+```
+
+
+
+
+
+
+
+|  | `management.endpoint.<name>` ǰ׺Ψһ�ر�ʶ���������õĶ˵㡣 |
+| --- | --- |
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.hypermedia)2.5\. ���� Actuator Web �˵�ij�ý�壨Hypermedia��
+
+
+
+һ�� ��discovery page�� �����ӵ����ж˵�������С� Ĭ������£���discovery page�� �� `/actuator` ���ǿ��õġ�
+
+
+
+
+
+Ҫ���� ��discovery page�����������Ӧ�ó��������������������ԡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoints.web.discovery.enabled=false
+
+```
+
+
+
+
+
+
+
+��������һ���Զ���Ĺ���������·��ʱ����discovery page�� ���Զ��� `/actuator` �Ƶ����������ĵĸ����� ���磬�������������·���� `/management`��discovery page���Դ� `/management` ��á� ������������·��������Ϊ `/` ʱ������ҳ�����ã��Է�ֹ������mapping������ͻ�Ŀ����ԡ�
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.cors)2.6\. CORS��֧��
+
+
+
+[��Դ��Դ����](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing)��CORS���� [W3C��һ���淶](https://www.w3.org/TR/cors/)���������������ķ�ʽָ�����ֿ���������Ȩ�������ʹ��Spring MVC��Spring WebFlux�����������Actuator��Web�˵���֧�����������
+
+
+
+
+
+CORS֧����Ĭ��������ǽ��õģ�ֻ������������ `management.endpoints.web.cors.allowed-origins` ���Ժ�Ż����á� ��������������� `example.com` �����е��� `GET` �� `POST`��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoints.web.cors.allowed-origins=https://example.com
+management.endpoints.web.cors.allowed-methods=GET,POST
+
+```
+
+
+
+
+
+
+
+|  | �μ� [`CorsEndpointProperties`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/endpoint/web/CorsEndpointProperties.java) �Ի��������ѡ���б��� |
+| --- | --- |
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom)2.7\. ʵ���Զ���˵�
+
+
+
+�����������һ������ `@Endpoint` ע��� `@Bean`���κδ��� `@ReadOperation`��`@WriteOperation` �� `@DeleteOperation` ע�͵ķ��������Զ�ͨ��JMX��������WebӦ�ó�����Ҳ��ͨ��HTTP������ ͨ��ʹ��Jersey��Spring MVC��Spring WebFlux���˵����ͨ��HTTP��¶�� ���Jersey��Spring MVC�����ã���ʹ��Spring MVC��
+
+
+
+
+
+��������ӱ�¶��һ����������������һ���Զ������
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@ReadOperation
+public CustomData getData() {
+    return new CustomData("test", 5);
+}
+
+```
+
+
+
+
+
+
+
+��Ҳ����ͨ��ʹ�� `@JmxEndpoint` �� `@WebEndpoint` ����д�ض������Ķ˵㡣 ��Щ�˵㱻���������Ǹ��Եļ����ϡ� ���磬`@WebEndpoint` ֻͨ��HTTP��¶��������ͨ��JMX��
+
+
+
+
+
+�����ͨ��ʹ�� `@EndpointWebExtension` �� `@EndpointJmxExtension` ����д�ض��ļ�����չ�� ��Щע�������ṩ�ض������IJ���������ǿ���еĶ˵㡣
+
+
+
+
+
+����������Ҫ����Web��ܵ��ض����ܣ������ʵ��servlet��Spring�� `@Controller` �� `@RestController` �˵㣬���������Dz���ͨ��JMX��ʹ�ò�ͬ��Web���ʱ���á�
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom.input)2.7.1\. ��������
+
+
+
+�˵��ϵIJ���ͨ��������������롣 ��ͨ��web����ʱ����Щ������ֵ����URL�IJ�ѯ������JSON�����塣 ��ͨ��JMX����ʱ��������ӳ�䵽MBean�����IJ����С� Ĭ������£������DZ���ġ� ���ǿ���ͨ��ʹ�� `@javax.annotation.Nullable` �� `@org.springframework.lang.Nullable` ����ע�����Ϊ��ѡ�
+
+
+
+
+
+����Խ�JSON�������е�ÿ��������ӳ�䵽�˵��һ�������� ����һ�������JSON�����塣
+
+
+
+
+
+
+
+```
+{
+    "name": "test",
+    "counter": 42
+}
+```
+
+
+
+
+
+
+
+���������������һ��д�������ò�����Ҫ `String name` �� `int counter` �������������������ʾ��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@WriteOperation
+public void updateData(String name, int counter) {
+    // injects "test" and 42
+}
+
+```
+
+
+
+
+
+
+
+|  | ��Ϊ�˵��Ǽ�������֪�ģ��ڷ���ǩ����ֻ��ָ���򵥵����͡� �ر��ǣ���֧���� `CustomData` ��������һ�������� `name` �� `counter` ���Եĵ�һ������ |
+| --- | --- |
+
+
+
+
+
+|  | Ϊ��������ӳ�䵽���������IJ�����ʵ�ֶ˵��Java����Ӧ���� `-parameters` ���룬��ʵ�ֶ˵��Kotlin����Ӧ���� `-java-parameters` ���롣 �����ʹ��Spring Boot��Gradle�����ʹ��Maven�� `spring-boot-starter-parent`���⽫�Զ������� |
+| --- | --- |
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom.input.conversion)��������ת��
+
+
+
+����б�Ҫ�����ݸ��˵���������IJ������Զ�ת��Ϊ�������͡� �ڵ��ò�������֮ǰ��ͨ��JMX��HTTP�յ������뱻ת��Ϊ��������ͣ�������ʹ�� `ApplicationConversionService` ��ʵ���Լ��κ� `Converter` �� `GenericConverter` Bean������ `@EndpointConverter` �޶���
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom.web)2.7.2\. �Զ���WEB�˵�
+
+
+
+�� `@Endpoint`��`@WebEndpoint` �� `@EndpointWebExtension` �������Զ�ʹ��Jersey��Spring MVC��Spring WebFluxͨ��HTTP������ ���Jersey��Spring MVC�����ã���ʹ��Spring MVC��
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom.web.request-predicates)WEB�˵�����ν�ʣ�Predicates��
+
+
+
+һ������ν�ʻ�Ϊweb��¶�Ķ˵��ϵ�ÿ��������operation���Զ����ɡ�
+
+
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom.web.path-predicates)Path
+
+
+
+pathν���ɶ˵��ID�����籩¶�Ķ˵�Ļ���·�������� Ĭ�ϵĻ���·���� `/actuator`�� ���磬һ��IDΪ `sessions` �Ķ˵���ν����ʹ�� `/actuator/sessions` ��Ϊ��·����
+
+
+
+
+
+�����ͨ���� `@Selector` ע�����������һ��������������һ������·���� �����IJ�������Ϊһ��·���������ӵ�·��ν���С� �ڵ��ö˵����ʱ���ñ�����ֵ�ᱻ������������� ������벶������ʣ���·��Ԫ�أ�����������һ������������ `@Selector(Match=ALL_REMAINING)`����ʹ���Ϊһ���� `String[]` ת�����ݵ����͡�
+
+
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom.web.method-predicates)HTTP method��������
+
+
+
+HTTP methodν�����ɲ������;����ģ����±���ʾ��
+
+
+
+<colgroup><col><col></colgroup>
+| Operation | HTTP method |
+| --- | --- |
+| `@ReadOperation` | `GET` |
+| `@WriteOperation` | `POST` |
+| `@DeleteOperation` | `DELETE` |
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom.web.consumes-predicates)Consumes
+
+
+
+����ʹ��request body�� `@WriteOperation`��HTTP `POST`����ν�ʵ� `consumes` �Ӿ��� `application/vnd.spring-boot.actuator.v2+json, application/json`�� ������������������`consumes` �Ӿ��ǿյġ�
+
+
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom.web.produces-predicates)Produces
+
+
+
+ν�ʵ� `produces` �Ӿ������ `@DeleteOperation`��`@ReadOperation` �� `@WriteOperation` ע�͵� `produces` ���Ծ����� �������ǿ�ѡ�ġ� �����ʹ������`produces` �Ӿ���Զ�ȷ����
+
+
+
+
+
+��������������� `void` �� `Void`���� `produces` �Ӿ�Ϊ�ա� ��������������� `org.springframework.core.io.Resource`��`produces` �Ӿ��� `application/octet-stream`�� ������������������`produces` �Ӿ��� `application/vnd.spring-boot.actuator.v2+json, application/json`��
+
+
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom.web.response-status)WEB�˵���Ӧ״̬
+
+
+
+�˵������Ĭ����Ӧ״̬ȡ���ڲ������ͣ�����д��ɾ�����Ͳ������ص����ݣ�����еĻ�����
+
+
+
+
+
+��� `@ReadOperation` ����һ��ֵ����Ӧ״̬����200(Ok)�� �����û�з���һ��ֵ����Ӧ״̬����404(Not Found)��
+
+
+
+
+
+��� `@WriteOperation` �� `@DeleteOperation` ����һ��ֵ����Ӧ״̬����200��OK���� �����û�з���һ��ֵ����Ӧ״̬����204��No Content����
+
+
+
+
+
+���һ�������ڵ���ʱû������IJ��������߲������ܱ�ת��Ϊ��������ͣ����������Ͳ��ᱻ���ã���Ӧ״̬����400��Bad Request����
+
+
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom.web.range-requests)WEB�˵� Range ����
+
+
+
+�����ʹ��HTTP range����������һ��HTTP��Դ��һ���֡� ��ʹ��Spring MVC��Spring Web Fluxʱ������ `org.springframework.core.io.Resource` �IJ����Զ�֧�ַ�Χ����
+
+
+
+
+
+|  | ʹ��Jerseyʱ��֧�� Range ���� |
+| --- | --- |
+
+
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom.web.security)Web�˵�İ�ȫ
+
+
+
+��web�˵��web�ض��˵���չ�ϵIJ������Խ��յ�ǰ�� `java.security.Principal` �� `org.springframework.boot.actuate.endpoint.SecurityContext` ��Ϊ���������� ǰ��ͨ���� `@Nullable` һ��ʹ�ã�Ϊ����֤��δ��֤���û��ṩ��ͬ����Ϊ�� ����ͨ������ͨ��ʹ���� `isUserInRole(String)` ������ִ����Ȩ��顣
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom.servlet)2.7.3\. Servlet �˵�
+
+
+
+һ��Servlet������Ϊһ���˵㱩¶������������ʵ��һ���� `@ServletEndpoint` ע����࣬ͬʱʵ�� `Supplier<EndpointServlet>`�� Servlet�˵��ṩ����servlet�����ĸ����ε����ϣ���ȴ�����˿���ֲ�ԡ� ���ǵ�Ŀ�������������е�Servlet��Ϊһ���˵��������� �����µĶ˵㣬Ӧ������ѡ�� `@Endpoint` �� `@WebEndpoint` ע�⡣
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.implementing-custom.controller)2.7.4\. Controller �˵�
+
+
+
+�����ʹ�� `@ControllerEndpoint` �� `@RestControllerEndpoint` ��ʵ��һ������Spring MVC��Spring WebFlux�����Ķ˵㡣 ����ͨ��ʹ��Spring MVC��Spring WebFlux�ı�׼ע�����ӳ�䣬�� `@RequestMapping` �� `@GetMapping`���˵��ID������·����ǰ׺�� �������˵��ṩ����Spring��Web��ܸ�����ļ��ɣ���ȴ�����˿���ֲ�ԡ� Ӧ������ѡ�� `@Endpoint` �� `@WebEndpoint` ע�⡣
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.health)2.8\. ������Ϣ
+
+
+
+�����ʹ�ý�����Ϣ����������е�Ӧ�ó����״̬�� �������������������������ϵͳ��������ʱ���ѱ��ˡ� `health` �˵㱩¶����Ϣȡ���� `management.endpoint.health.show-details` �� `management.endpoint.health.show-components` ���ԣ����ǿ�������Ϊ����ֵ֮һ��
+
+
+
+<colgroup><col><col></colgroup>
+| ֵ | ˵�� |
+| --- | --- |
+| `never` | ϸ�ڴӲ���ʾ�� |
+| `when-authorized` | ϸ��ֻ��ʾ����Ȩ�û��� ��Ȩ�Ľ�ɫ����ͨ��ʹ�� `management.endpoint.health.roles` �������á� |
+| `always` | ������ʾ�������û��� |
+
+
+
+Ĭ��ֵ�� `never`�� ���û����ڶ˵��һ��������ɫ��ʱ�����DZ���Ϊ�DZ���Ȩ�ġ� ����˵�û�����ý�ɫ��Ĭ��ֵ����������֤���û�������Ϊ����Ȩ�ġ� �����ͨ��ʹ�� `management.endpoint.health.roles` ���������ý�ɫ��
+
+
+
+
+
+|  | ������Ѿ����������Ӧ�ó���ϣ��ʹ�� `always`����İ�ȫ���ã�security configuration������������֤�ͷ���֤�û�����health�˵㡣 |
+| --- | --- |
+
+
+
+
+
+������Ϣ�Ǵ� [`HealthContributorRegistry`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthContributorRegistry.java) ���������ռ��ģ�Ĭ������£����� [`HealthContributor`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthContributor.java) ʵ������������� `ApplicationContext` �У��� Spring Boot����һЩ�Զ����õ� `HealthContributor`����Ҳ���Ա�д�Լ��ġ�
+
+
+
+
+
+һ�� `HealthContributor` ������һ�� `HealthIndicator` ��һ�� `CompositeHealthContributor`�� һ�� `HealthIndicator` �ṩʵ�ʵĽ�����Ϣ������ `Status`�� һ�� `CompositeHealthContributor` �ṩ���� `HealthContributors` ����ϡ� �ۺ�������contributor�γ�һ����״�ṹ����ʾ����ϵͳ�Ľ���״����
+
+
+
+
+
+Ĭ������£����յ�ϵͳ����״������һ�� `StatusAggregator` �ó��ģ�������һ�������״̬�б���ÿ�� `HealthIndicator` ��״̬�������� �����б��еĵ�һ��״̬���������彡��״̬�� ���û�� `HealthIndicator` ���ص�״̬�� `StatusAggregator` ��֪���ģ��ͻ�ʹ�� `UNKNOWN` ״̬��
+
+
+
+
+
+|  | �����ʹ�� `HealthContributorRegistry` ��������ʱע���ȡ��ע�ὡ��ָ�ꡣ |
+| --- | --- |
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.health.auto-configured-health-indicators)2.8.1\. �Զ����õ�HealthIndicators
+
+
+
+���ʵ���ʱ��Spring Boot���Զ������±����г��� `HealthIndicators`�� ��Ҳ����ͨ������ `management.health.key.enabled` �����û�ͣ����ѡָ�ꡣ ���±����г��� `key`��
+
+
+
+<colgroup><col><col><col></colgroup>
+| Key | Name | ˵�� |
+| --- | --- | --- |
+| `cassandra` | [`CassandraDriverHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/cassandra/CassandraDriverHealthIndicator.java) | ���Cassandra���ݿ��Ƿ��Ѿ������� |
+| `couchbase` | [`CouchbaseHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/couchbase/CouchbaseHealthIndicator.java) | ���Couchbase��Ⱥ�Ƿ��Ѿ������� |
+| `db` | [`DataSourceHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/jdbc/DataSourceHealthIndicator.java) | ����Ƿ���Ի����`DataSource`�����ӡ� |
+| `diskspace` | [`DiskSpaceHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/system/DiskSpaceHealthIndicator.java) | �����̿ռ��Ƿ��㡣 |
+| `elasticsearch` | [`ElasticsearchRestHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/elasticsearch/ElasticsearchRestHealthIndicator.java) | ���Elasticsearch��Ⱥ�Ƿ��Ѿ������� |
+| `hazelcast` | [`HazelcastHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/hazelcast/HazelcastHealthIndicator.java) | ���Hazelcast�������Ƿ��Ѿ������� |
+| `influxdb` | [`InfluxDbHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/influx/InfluxDbHealthIndicator.java) | ���InfluxDB�������Ƿ��Ѿ������� |
+| `jms` | [`JmsHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/jms/JmsHealthIndicator.java) | ���һ��JMS�����Ƿ��Ѿ������� |
+| `ldap` | [`LdapHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/ldap/LdapHealthIndicator.java) | ���һ��LDAP�������Ƿ������� |
+| `mail` | [`MailHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/mail/MailHealthIndicator.java) | ���һ���ʼ��������Ƿ������� |
+| `mongo` | [`MongoHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/data/mongo/MongoHealthIndicator.java) | ���Mongo���ݿ��Ƿ��Ѿ������� |
+| `neo4j` | [`Neo4jHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/neo4j/Neo4jHealthIndicator.java) | ���Neo4j���ݿ��Ƿ��Ѿ������� |
+| `ping` | [`PingHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/PingHealthIndicator.java) | ������Ӧ `UP` �� |
+| `rabbit` | [`RabbitHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/amqp/RabbitHealthIndicator.java) | ���һ��Rabbit�������Ƿ��Ѿ������� |
+| `redis` | [`RedisHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/data/redis/RedisHealthIndicator.java) | ���Redis�������Ƿ��Ѿ������� |
+
+
+
+|  | �����ͨ������ `management.health.defaults.enabled` �������������ǡ� |
+| --- | --- |
+
+
+
+
+
+����� `HealthIndicators` �ǿ��õģ�����Ĭ������²����á�
+
+
+
+<colgroup><col><col><col></colgroup>
+| Key | Name | ˵�� |
+| --- | --- | --- |
+| `livenessstate` | [`LivenessStateHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/availability/LivenessStateHealthIndicator.java) | ��ʾ ��Liveness�� Ӧ�ó���Ŀ�����״̬�� |
+| `readinessstate` | [`ReadinessStateHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/availability/ReadinessStateHealthIndicator.java) | ��¶ ��Readiness�� Ӧ�ó���Ŀ�����״̬�� |
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.health.writing-custom-health-indicators)2.8.2\. ��д�Զ���HealthIndicators
+
+
+
+Ϊ���ṩ�Զ���Ľ�����Ϣ�������ע��ʵ�� [`HealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthIndicator.java) �ӿڵ�Spring Bean�� ����Ҫ�ṩһ�� `health()` ������ʵ�֣�������һ�� `Health` ��Ӧ�� `Health` ��ӦӦ�ð���һ��status��������ѡ�����Ҫ��ʾ������ϸ�ڡ� ����Ĵ�����ʾ��һ�� `HealthIndicator` ��ʵ��������
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Component
+public class MyHealthIndicator implements HealthIndicator {
+
+    @Override
+    public Health health() {
+        int errorCode = check();
+        if (errorCode != 0) {
+            return Health.down().withDetail("Error Code", errorCode).build();
+        }
+        return Health.up().build();
+    }
+
+    private int check() {
+        // perform some specific health check
+        return ...
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+|  | һ�������� `HealthIndicator` �ı�ʶ����ID����û�� `HealthIndicator` ��׺��Bean�����֣���������ڵĻ��� ��ǰ��������У�������Ϣ������һ����Ϊ `my` ����Ŀ���ҵ��� |
+| --- | --- |
+
+
+
+
+
+|  | ����ָ��ͨ����ͨ��HTTP���õģ���Ҫ���κ����ӳ�ʱ֮ǰ������Ӧ�� ����κν���ָ�����Ӧʱ�䳬��10�룬Spring Boot����¼һ��������Ϣ�� ����������������ֵ�������ʹ�� `management.endpoint.health.logging.slow-indicator-threshold` ���ԡ� |
+| --- | --- |
+
+
+
+
+
+����Spring BootԤ����� [`Status`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/Status.java) �����⣬`Health` ���Է��ش�����ϵͳ״̬���Զ��� `Status`�� ����������£��㻹��Ҫ�ṩ `StatusAggregator` �ӿڵ��Զ���ʵ�֣����������ͨ��ʹ�� `management.endpoint.health.status.order` ��������������Ĭ��ʵ�֡�
+
+
+
+
+
+���磬���������һ�� `HealthIndicator` ʵ����ʹ����һ������Ϊ `FATAL` ���� `Status`�� Ϊ������������˳�������Ӧ�ó��������������������ԡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoint.health.status.order=fatal,down,out-of-service,unknown,up
+
+```
+
+
+
+
+
+
+
+��Ӧ�е�HTTP״̬���뷴ӳ�����彡��״̬�� Ĭ������£�`OUT_OF_SERVICE` �� `DOWN` ӳ�䵽503�� �κ�δӳ��Ľ���״̬������ `UP`����ӳ��Ϊ200�� �����ͨ��HTTP���ʽ����˵㣬����ܻ���ע���Զ���״̬ӳ�䡣 �����Զ���ӳ������ `DOWN` �� `OUT_OF_SERVICE` ��Ĭ��ӳ�䡣 ������뱣��Ĭ��ӳ�䣬�������ȷ���������ǣ��Լ��κ��Զ���ӳ�䡣 ���磬��������Խ� `FATAL` ӳ��Ϊ503�����񲻿��ã����������� `DOWN` �� `OUT_OF_SERVICE` ��Ĭ��ӳ�䡣
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoint.health.status.http-mapping.down=503
+management.endpoint.health.status.http-mapping.fatal=503
+management.endpoint.health.status.http-mapping.out-of-service=503
+
+```
+
+
+
+
+
+
+
+|  | �������Ҫ����Ŀ��ƣ�����Զ������Լ��� `HttpCodeStatusMapper` bean�� |
+| --- | --- |
+
+
+
+
+
+�±���ʾ������״̬��Ĭ��״̬ӳ�䡣
+
+
+
+<colgroup><col><col></colgroup>
+| Status | Mapping |
+| --- | --- |
+| `DOWN` | `SERVICE_UNAVAILABLE` (`503`) |
+| `OUT_OF_SERVICE` | `SERVICE_UNAVAILABLE` (`503`) |
+| `UP` | Ĭ�������û��ӳ�䣬����HTTP״̬Ϊ `200`�� |
+| `UNKNOWN` | Ĭ�������û��ӳ�䣬����HTTP״̬Ϊ `200`�� |
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.health.reactive-health-indicators)2.8.3\. ��Ӧʽ����ָ��
+
+
+
+������ӦʽӦ�ó���������Щʹ��Spring WebFlux��Ӧ�ó���`ReactiveHealthContributor` �ṩ��һ������������Լ����ȡӦ�ó���Ľ���״���� �봫ͳ�� `HealthContributor` ���ƣ�������Ϣ�� [`ReactiveHealthContributorRegistry`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/ReactiveHealthContributorRegistry.java) ���������ռ���Ĭ������£����� [`HealthContributor`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthContributor.java) �� [`ReactiveHealthContributor`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/ReactiveHealthContributor.java) ��ʵ����������� `ApplicationContext` ���
+
+
+
+
+
+������ӦʽAPI���м��ij��� `HealthContributors` �ڵ��Ե�������ִ�С�
+
+
+
+
+
+|  | ��һ����ӦʽӦ�ó����У���Ӧ��ʹ�� `ReactiveHealthContributorRegistry` ��������ʱע���ȡ��ע�ὡ��ָ�ꡣ �������Ҫע��һ����ͨ�� `HealthContributor`����Ӧ���� `ReactiveHealthContributor#adapt` ����װ���� |
+| --- | --- |
+
+
+
+
+
+Ϊ�˴���ӦʽAPI���ṩ�Զ���Ľ�����Ϣ�������ע��ʵ�� [`ReactiveHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/ReactiveHealthIndicator.java) �ӿڵ�Spring Bean�� ����Ĵ�����ʾ��һ�� `ReactiveHealthIndicator` ��ʾ��ʵ�֡�
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Component
+public class MyReactiveHealthIndicator implements ReactiveHealthIndicator {
+
+    @Override
+    public Mono<Health> health() {
+        return doHealthCheck().onErrorResume((exception) ->
+            Mono.just(new Health.Builder().down(exception).build()));
+    }
+
+    private Mono<Health> doHealthCheck() {
+        // perform some specific health check
+        return ...
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+|  | Ϊ���Զ��������󣬿��Կ��Ǵ� `AbstractReactiveHealthIndicator` ����չ�� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.health.auto-configured-reactive-health-indicators)2.8.4\. �Զ����õ� ReactiveHealthIndicators
+
+
+
+���ʵ���ʱ��Spring Boot���Զ��������µ� `ReactiveHealthIndicators`��
+
+
+
+<colgroup><col><col><col></colgroup>
+| Key | Name | ˵�� |
+| --- | --- | --- |
+| `cassandra` | [`CassandraDriverReactiveHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/cassandra/CassandraDriverReactiveHealthIndicator.java) | ���Cassandra���ݿ��Ƿ��Ѿ������� |
+| `couchbase` | [`CouchbaseReactiveHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/couchbase/CouchbaseReactiveHealthIndicator.java) | ���Couchbase��Ⱥ�Ƿ��Ѿ������� |
+| `elasticsearch` | [`ElasticsearchReactiveHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/data/elasticsearch/ElasticsearchReactiveHealthIndicator.java) | ���Elasticsearch��Ⱥ�Ƿ��Ѿ������� |
+| `mongo` | [`MongoReactiveHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/data/mongo/MongoReactiveHealthIndicator.java) | ���Mongo���ݿ��Ƿ��Ѿ������� |
+| `neo4j` | [`Neo4jReactiveHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/neo4j/Neo4jReactiveHealthIndicator.java) | ���Neo4j���ݿ��Ƿ��Ѿ������� |
+| `redis` | [`RedisReactiveHealthIndicator`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/data/redis/RedisReactiveHealthIndicator.java) | ���Redis�������Ƿ��Ѿ������� |
+
+
+
+|  | ����б�Ҫ����Ӧʽָ���ȡ������ָ�ꡣ ���⣬�κ�û�б���ȷ������ `HealthIndicator` ���ᱻ�Զ���װ������ |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.health.groups)2.8.5\. Health���飨Health Groups��
+
+
+
+��ʱ��������ָ����֯�ɿ������ڲ�ͬĿ�ĵ����Ǻ����õġ�
+
+
+
+
+
+Ҫ����һ������ָ���飬�����ʹ�� `management.endpoint.health.group.<name>` ���ԣ���ָ��һ������ָ��ID�б��� `include` �� `exclude`�� ���磬Ҫ����һ��ֻ�������ݿ�ָ����飬����Զ������¡�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoint.health.group.custom.include=db
+
+```
+
+
+
+
+
+
+
+Ȼ�������ͨ����� `[localhost:8080/actuator/health/custom](http://localhost:8080/actuator/health/custom)` ���������
+
+
+
+
+
+ͬ����Ҫ����һ���飬�����ݿ�ָ���ų��ڸ���֮�⣬��������������ָ�꣬����Զ������¡�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoint.health.group.custom.exclude=db
+
+```
+
+
+
+
+
+
+
+Ĭ������£���̳�����ϵͳ������ͬ�� `StatusAggregator` �� `HttpCodeStatusMapper` ���á� Ȼ������Ҳ������ÿ����Ļ����϶�����Щ�� �����Ҫ����Ҳ���Ը��� `show-details` �� `roles` ���ԡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoint.health.group.custom.show-details=when-authorized
+management.endpoint.health.group.custom.roles=admin
+management.endpoint.health.group.custom.status.order=fatal,up
+management.endpoint.health.group.custom.status.http-mapping.fatal=500
+management.endpoint.health.group.custom.status.http-mapping.out-of-service=500
+
+```
+
+
+
+
+
+
+
+|  | �������Ҫע���Զ���� `StatusAggregator` �� `HttpCodeStatusMapper` Bean�������飬�����ʹ�� `@Qualifier("groupname")`�� |
+| --- | --- |
+
+
+
+
+
+һ��������Ҳ���԰���/�ų�һ�� `CompositeHealthContributor`�� ��Ҳ����ֻ����/�ų�һ�� `CompositeHealthContributor` ��ij������� �����ʹ���������ȫ��������ɣ�������ʾ��
+
+
+
+
+
+
+
+```
+management.endpoint.health.group.custom.include="test/primary"
+management.endpoint.health.group.custom.exclude="test/primary/b"
+```
+
+
+
+
+
+
+
+������������У�`custom` �齫��������Ϊ `primary` �� `HealthContributor`�����Ǹ��� `test` ��һ����ɲ��֡� �����`primary` ��������һ�������壬����Ϊ `b` �� `HealthContributor` �����ų��� `custom` ��֮�⡣
+
+
+
+
+
+��������������˿ڻ�����˿ڵĶ���·�����ṩ�� ����Kubernetes���ƻ����к����ã�����Щ�����У����ڰ�ȫ���ǣ�Ϊִ�����˵�ʹ��һ�������Ĺ����˿��Ǻܳ����ġ� ��һ�������Ķ˿ڿ��ܵ��²��ɿ��Ľ�����飬��Ϊ��ʹ�������ɹ�����Ӧ�ó���Ҳ�����޷����������� �����������һ�������·���������ã�������ʾ��
+
+
+
+
+
+
+
+```
+management.endpoint.health.group.live.additional-path="server:/healthz"
+```
+
+
+
+
+
+
+
+�⽫ʹ `live` �����������������˿� `/healthz` �Ͽ��á� ǰ׺��ǿ���Եģ������� `server:`���������������˿ڣ��� `management:`�����������˿ڣ���������ã��� ·��������һ����һ��·���Ρ�
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.health.datasource)2.8.6\. ����Դ����
+
+
+
+`DataSource` ����ָ����ʾ��׼����Դ��·������ԴBean�Ľ���״���� ·������Դ�Ľ���״��������ÿ��Ŀ������Դ�Ľ���״���� �ڽ����˵����Ӧ�У�·������Դ��ÿ��Ŀ�궼��ͨ��ʹ����·�ɼ��������ġ� ����㲻ϣ����ָ�������а���·������Դ���뽫 `management.health.db.ignore-routing-data-sources` ����Ϊ `true`��
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.kubernetes-probes)2.9\. Kubernetes ̽��
+
+
+
+������Kubernetes�ϵ�Ӧ�ó������ͨ�� [����̽��](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#container-probes) �ṩ�й����ڲ�״̬����Ϣ������ [���Kubernetes����](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/)��kubelet�������Щ̽�벢�Խ��������Ӧ��
+
+
+
+
+
+Ĭ������£�Spring Boot��������[Ӧ�ÿ�����״̬](https://springdoc.cn/spring-boot/features.html#features.spring-application.application-availability)�� ���������Kubernetes�����У�actuator�� `ApplicationAvailability` �ӿ����ռ� ��Liveness�� �� ��Readiness�� ��Ϣ������ר��[����ָ��](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.health.auto-configured-health-indicators)��ʹ����Щ��Ϣ��`LivenessStateHealthIndicator` �� `ReadinessStateHealthIndicator`�� ��Щָ����ʾ��ȫ�ֽ����˵㣨`"/actuator/health"`���� ����Ҳ����ͨ��ʹ��[������](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.health.groups)��Ϊ������HTTP̽�룺`"/actuator/health/liveness"` �� `"/actuator/health/readiness"`��
+
+
+
+
+
+Ȼ������������¶˵���Ϣ�������Kubernetes������ʩ��
+
+
+
+
+
+
+
+```
+livenessProbe:
+  httpGet:
+    path: "/actuator/health/liveness"
+    port: 
+  failureThreshold: ...
+  periodSeconds: ...
+
+readinessProbe:
+  httpGet:
+    path: "/actuator/health/readiness"
+    port: 
+  failureThreshold: ...
+  periodSeconds: ...
+```
+
+
+
+
+
+
+
+|  | `` Ӧ�ñ�����Ϊִ�����˵���õĶ˿ڡ� ����������Web�������Ķ˿ڣ�Ҳ������һ�������Ĺ����˿ڣ���� `"management.server.port"` �����Ѿ������á� |
+| --- | --- |
+
+
+
+
+
+ֻ�е�Ӧ�ó���[��Kubernetes����������ʱ](https://springdoc.cn/spring-boot/deployment.html#deployment.cloud.kubernetes)����Щ������Ż��Զ����á� �����ͨ��ʹ�� `management.endpoint.health.probes.enabled` �����������κλ������������ǡ�
+
+
+
+
+
+|  | ���һ��Ӧ�ó��������ʱ�䳬�������õ���Ч�ڣ�Kubernetes ���ᵽ `"startupProbe"` ��Ϊһ�����ܵĽ��������һ����˵�����ﲻһ����Ҫ `"startupProbe"`����Ϊ `"readinessProbe"` �������������������֮ǰʧЧ������ζ�����Ӧ�ó�����׼����֮ǰ�����յ�������Ȼ����������Ӧ�ó�����Ҫ�ܳ�ʱ��������������Կ���ʹ�� `"startupProbe"` ��ȷ��Kubernetes���������Ӧ�ó�������������ɱ���������������[̽����Ӧ�ó������������е���Ϊ](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.kubernetes-probes.lifecycle)�IJ��֡� |
+| --- | --- |
+
+
+
+
+
+������Actuator�˵㱻������һ�������Ĺ����������У���ô��Щ�˵�Ͳ���������������ʹ����ͬ�����������ʩ���˿ڡ����ӳء����������� ����������£���ʹ���������������������磬�����ܽ����µ����ӣ���̽����Ҳ���ܳɹ��� �������ԭ�������������˿������� `liveness` �� `readiness` �������Ǹ������⡣ �����ͨ����������������ʵ�֡�
+
+
+
+
+
+
+
+```
+management.endpoint.health.probes.add-additional-paths=true
+```
+
+
+
+
+
+
+
+�⽫ʹ `liveness` �� `/livez` ���ã�`readiness` �� `readyz` �����������˿ڿ��á�
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.kubernetes-probes.external-state)2.9.1\. ��Kubernetes̽�����ⲿ״̬
+
+
+
+ִ������ ��liveness�� �� ��readiness�� ̽������Ϊ�����顣����ζ�����е�[������Ĺ���](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.health.groups)�����Ƕ��ǿ��õġ����磬��������ö���Ľ���ָ�ꡣ
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoint.health.group.readiness.include=readinessState,customCheck
+
+```
+
+
+
+
+
+
+
+Ĭ������£�Spring Boot��������Щ��������������ָ�ꡣ
+
+
+
+
+
+��liveness�� ̽�벻Ӧ���������ⲿϵͳ�Ľ�����顣���[Ӧ�ó������Ч��״̬](https://springdoc.cn/spring-boot/features.html#features.spring-application.application-availability.liveness)���ƻ���Kubernetes�᳢��ͨ����������Ӧ�ó���ʵ�������������⡣����ζ�ţ����һ���ⲿϵͳ�������ݿ⡢Web API���ⲿ���棩���ֹ��ϣ�Kubernetes���ܻ�������������Ӧ�ó���ʵ�����������������ϡ�
+
+
+
+
+
+���� ��readiness�� ̽�⣬����ⲿϵͳ��ѡ�������Ӧ�ó��򿪷���Ա�����������������ԭ��Spring Boot��׼��״̬̽���в������κζ���Ľ�����顣���[Ӧ�ó���ʵ����readiness state��unready](https://springdoc.cn/spring-boot/features.html#features.spring-application.application-availability.readiness)��Kubernetes�Ͳ��Ὣ����·�ɵ���ʵ����һЩ�ⲿϵͳ���ܲ���Ӧ��ʵ��������������������£����ǿ��Ա�������׼��״̬̽���С������ⲿϵͳ���ܲ���Ӧ�ó���Ĺؼ���Ӧ�ó�������ж�·���ͻ��ˣ�������������£����Ǿ��Բ�Ӧ�ñ��������ڡ����ҵ��ǣ�һ��������Ӧ��ʵ���������ⲿϵͳ�ܳ���������������жϡ�����������׼������̽���У����������ⲿ����������ʱ��Ӧ�ó���ᱻֹͣ���񣬻��߲�����������������ջ�и��߲�εĹ��ϣ�Ҳ��ͨ���ڵ�������ʹ�ö�·����
+
+
+
+
+
+|  | ���һ��Ӧ�ó��������ʵ����û��׼���ã�`type=ClusterIP` �� `NodePort` ��Kubernetes���񲻽����κδ������ӡ�û��HTTP������Ӧ��503�ȣ�����Ϊû�����ӡ�`type=LoadBalancer` �ķ�����ܽ���Ҳ���ܲ��������ӣ���ȡ�����ṩ�ߡ�һ������ȷ [ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) �ķ���Ҳ����һ��ȡ����ʵ�ֵķ�ʽ������Ӧ��?��ڷ��������������δ����������ε� ��connection refused�����ڸ��ؾ���������ڵ�����£�HTTP 503�Ǻ��п��ܵġ� |
+| --- | --- |
+
+
+
+
+
+���⣬���һ��Ӧ�ó���ʹ�� Kubernetes [autoscaling](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/)�������ܻ��Ӧ�ó��򱻴Ӹ���ƽ������ȡ��������ͬ�ķ�Ӧ����ȡ������autoscaler�����á�
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.kubernetes-probes.lifecycle)2.9.2\. Ӧ�ó����������ں�̽��״̬
+
+
+
+Kubernetes Probes֧�ֵ�һ����Ҫ����������Ӧ�ó����������ڵ�һ���ԡ� `AvailabilityState`����Ӧ�ó�����ڴ��ڲ�״̬����ʵ�ʵ�̽�루��¶��״̬��֮����������������� ��ʵ�ʵ�̽�루��¶�˸�״̬��֮���кܴ������ ����Ӧ�ó����������ڵIJ�ͬ�׶Σ�̽������޷�ʹ�á�
+
+
+
+
+
+Spring Boot��[�����͹ر��ڼ䷢��application event](https://springdoc.cn/spring-boot/features.html#features.spring-application.application-events-and-listeners)��̽����Լ�����Щ�¼�����¶�� `AvailabilityState` ��Ϣ��
+
+
+
+
+
+�±���ʾ�˲�ͬ�׶ε� `AvailabilityState` ��HTTP connector��״̬��
+
+
+
+
+
+��һ��Spring BootӦ�ó�������ʱ��
+
+
+
+<colgroup><col><col><col><col><col></colgroup>
+| �����׶� | LivenessState | ReadinessState | HTTP server | ��ע |
+| --- | --- | --- | --- | --- |
+| Starting | `BROKEN` | `REFUSING_TRAFFIC` | δ���� | Kubernetes��� "liveness" ̽�룬���ʱ�����������������Ӧ�ó��� |
+| Started | `CORRECT` | `REFUSING_TRAFFIC` | �ܾ����� | Ӧ�ó��������ı�ˢ�¡�Ӧ�ó���ִ���������񣬻�û���յ������� |
+| Ready | `CORRECT` | `ACCEPTING_TRAFFIC` | �������� | ���������Ѿ���ɡ���Ӧ�ó������ڽ��������� |
+
+
+
+��һ��Spring BootӦ�ó���ر�ʱ��
+
+
+
+<colgroup><col><col><col><col><col></colgroup>
+| ͣ���׶� | Liveness State | Readiness State | HTTP server | ��ע |
+| --- | --- | --- | --- | --- |
+| Running | `CORRECT` | `ACCEPTING_TRAFFIC` | �������� | ��Ҫ��رա� |
+| Graceful shutdown | `CORRECT` | `REFUSING_TRAFFIC` | �µ����󱻾ܾ� | ������ã� [���Źػ��ᴦ���������С�������](https://springdoc.cn/spring-boot/web.html#web.graceful-shutdown)�� |
+| Shutdown complete | N/A | N/A | ���������ر� | Ӧ�ó��������ı��رգ�Ӧ�ó��򱻹رա� |
+
+
+
+|  | ����Kubernetes����ĸ�����Ϣ����μ�[Kubernetes������������](https://springdoc.cn/spring-boot/deployment.html#deployment.cloud.kubernetes.container-lifecycle)���֡� |
+| --- | --- |
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.info)2.10\. Ӧ����Ϣ
+
+
+
+Ӧ�ó�����Ϣ�����˴���� `ApplicationContext` �ж�������� [`InfoContributor`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/info/InfoContributor.java) Bean�ռ��ĸ�����Ϣ�� Spring Boot����һЩ�Զ����õ� `InfoContributor` Bean����Ҳ���Ա�д�Լ��ġ�
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.info.auto-configured-info-contributors)2.10.1\. �Զ����õ� InfoContributor
+
+
+
+���ʵ���ʱ��Spring���Զ��������� `InfoContributor` Bean��
+
+
+
+<colgroup><col><col><col><col></colgroup>
+| ID | Name | ˵�� | ǰ������ |
+| --- | --- | --- | --- |
+| `build` | [`BuildInfoContributor`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/info/BuildInfoContributor.java) | ��¶�˹�����Ϣ�� | һ�� `META-INF/build-info.properties` ��Դ�� |
+| `env` | [`EnvironmentInfoContributor`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/info/EnvironmentInfoContributor.java) | ��¶ `Environment` �������� `info.` ��ͷ���κ����ԡ� | None. |
+| `git` | [`GitInfoContributor`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/info/GitInfoContributor.java) | ��¶��git��Ϣ�� | һ�� `git.properties` ��Դ�� |
+| `java` | [`JavaInfoContributor`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/info/JavaInfoContributor.java) | ��¶Java����ʱ��Runtime����Ϣ�� | None. |
+| `os` | [`OsInfoContributor`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/info/OsInfoContributor.java) | ��¶����ϵͳ��Ϣ�� | None. |
+
+
+
+���˹����ߣ�contributor���Ƿ����������� `management.info.<id>.enabled` ���Կ��ơ� ��ͬ��contributor����������в�ͬ��Ĭ��ֵ����ȡ�������ǵ��Ⱦ���������������¶����Ϣ�����ʡ�
+
+
+
+
+
+����û���Ⱦ�������������Ӧ�ñ����ã�`env`��`java` �� `os` contributor Ĭ���ǽ��õġ� ����ͨ������ `management.info.<id>.enabled` ����Ϊ `true` ���������ǡ�
+
+
+
+
+
+`build` �� `git` ��ϢcontributorĬ�������õġ� ����ͨ������ `management.info.<id>.enabled` ��������Ϊ `false` �����á� ���⣬Ҫ����ÿһ��Ĭ�����õ�contributor���뽫 `management.info.defaults.enabled` ������Ϊ `false`��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.info.custom-application-information)2.10.2\. �Զ���Ӧ����Ϣ��Application Information��
+
+
+
+�� `env` contributor ������ʱ�������ͨ������ `info.*` Spring���������� `info` �˵�����¶�����ݡ� `info` key�µ����� `Environment` ���Զ����Զ���¶�� ���磬���������� `application.properties` �ļ��������������á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+info.app.encoding=UTF-8
+info.app.java.source=17
+info.app.java.target=17
+
+```
+
+
+
+
+
+
+
+|  | ����Ӳ������Щֵ���㻹���� [�ڹ���ʱ��չ��Ϣ����](https://springdoc.cn/spring-boot/howto.html#howto.properties-and-configuration.expand-properties)��������ʹ��Maven������Խ�ǰ������Ӹ�д���¡�PropertiesYaml```info.app.encoding=@project.build.sourceEncoding@info.app.java.source=@java.version@info.app.java.target=@java.version@``` |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.info.git-commit-information)2.10.3\. Git Commit ��Ϣ
+
+
+
+`info` �˵����һ�����õĹ��������ܹ������������ `git` Դ���������Ŀ����ʱ��״̬����Ϣ�� �����һ�� `GitProperties` bean�������ʹ�� `info` �˵���������Щ���ԡ�
+
+
+
+
+
+|  | ���classpath�ĸ����� `git.properties` �ļ���`GitProperties` Bean�ͻᱻ�Զ����á�����ϸ�ڼ� "[�������git��Ϣ](https://springdoc.cn/spring-boot/howto.html#howto.build.generate-git-info)"�� |
+| --- | --- |
+
+
+
+
+
+Ĭ������£��˵�ᱩ¶ `git.branch`��`git.commit.id` �� `git.commit.time` ���ԣ�������ڣ��� ����㲻������Щ���Գ����ڶ˵���Ӧ�У���Ҫ�� `git.properties` �ļ����ų����ǡ� ���������ʾ������git��Ϣ���� `git.properties` ��ȫ�����ݣ���ʹ�� `management.info.git.mode` ���ԣ�������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.info.git.mode=full
+
+```
+
+
+
+
+
+
+
+Ҫ�� `info` �˵���ȫ����git�ύ��Ϣ���� `management.info.git.enabled` ������Ϊ `false`��������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.info.git.enabled=false
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.info.build-information)2.10.4\. ������Ϣ
+
+
+
+��� `BuildProperties` Bean�ǿ��õģ�`info` �˵�Ҳ���Է���������Ĺ�����Ϣ�����classpath�е� `META-INF/build-info.properties` �ļ����ã��ͻᷢ�����������
+
+
+
+
+
+|  | Maven��Gradle������������ɸ��ļ������ "[������ɹ�����Ϣ](https://springdoc.cn/spring-boot/howto.html#howto.build.generate-info)"�� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.info.java-information)2.10.5\. Java��Ϣ
+
+
+
+`info` �˵㷢���˹������Java���л�������Ϣ������ϸ�ڼ� [`JavaInfo`](https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/api/org/springframework/boot/info/JavaInfo.html)��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.info.os-information)2.10.6\. ����ϵͳ��OS����Ϣ
+
+
+
+`info` �˵㷢��������IJ���ϵͳ����Ϣ������ϸ�ڼ� [`OsInfo`](https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/api/org/springframework/boot/info/OsInfo.html)`��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.info.writing-custom-info-contributors)2.10.7\. ��д�Զ��� InfoContributor
+
+
+
+Ϊ���ṩ�Զ����Ӧ�ó�����Ϣ�������ע��ʵ�� [`InfoContributor`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/info/InfoContributor.java) �ӿڵ�Spring Bean��
+
+
+
+
+
+��������ӹ�����һ��ֻ��һ��ֵ�� `example` ��Ŀ��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Component
+public class MyInfoContributor implements InfoContributor {
+
+    @Override
+    public void contribute(Info.Builder builder) {
+        builder.withDetail("example", Collections.singletonMap("key", "value"));
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+��������� `info` �˵㣬��Ӧ�ÿ���һ���������¶�����Ŀ����Ӧ��
+
+
+
+
+
+
+
+```
+{
+    "example": {
+        "key" : "value"
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/actuator.html#actuator.monitoring)3\. ͨ��HTTP���м�غ͹���
+
+
+
+
+
+��������ڿ���һ��WebӦ�ó���Spring Boot Actuator���Զ������������õĶ˵㣬ʹ��ͨ��HTTP������ Ĭ�ϵĹ�����ʹ�ö˵�� `id` �� `/actuator` ��ǰ׺��ΪURL·���� ���磬`health` �� `/actuator/health` ����ʽ������
+
+
+
+
+
+|  | Actuator ֧�� Spring MVC��Spring WebFlux��Jersey�� ���Jersey��Spring MVC�����ã����ʹ��Spring MVC�� |
+| --- | --- |
+
+
+
+
+
+|  | Ϊ�˻��API�ĵ��� [HTML](https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/actuator-api/htmlsingle) �� [PDF](https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/actuator-api/pdf/spring-boot-actuator-web-api.pdf) ���м��ص���ȷ��JSON��Ӧ��Jackson��һ����Ҫ�������� |
+| --- | --- |
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.monitoring.customizing-management-server-context-path)3.1\. ���ƹ����˵�·��
+
+
+
+��ʱ��Ϊ�����˵㶨��ǰ׺�Ǻ����õġ� ���磬���Ӧ�ó�������Ѿ��� `/actuator` ��������Ŀ�ġ� �����ʹ�� `management.endpoints.web.base-path` �������ı�����˵��ǰ׺���������������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoints.web.base-path=/manage
+
+```
+
+
+
+
+
+
+
+ǰ��� `application.properties` ���ӽ��˵�� `/actuator/{id}` ��Ϊ `/manage/{id}` �����磬`/manage/info`����
+
+
+
+
+
+|  | ���ǹ����˿ڱ�����Ϊ[ʹ�ò�ͬ��HTTP�˿�](https://springdoc.cn/spring-boot/actuator.html#actuator.monitoring.customizing-management-server-port)����¶�˵㣬���� `management.endpoints.web.base-path` ������� `server.servlet.context-path` ������Servlet WebӦ�ã��� `spring.webflux.base-path` ������reactive WebӦ�ã������������ `management.server.port`�� `management.endpoints.web.base-path` ������� `management.server.base-path` �ġ� |
+| --- | --- |
+
+
+
+
+
+�������Ѷ˵�ӳ�䵽��ͬ��·���������ʹ�� `management.endpoints.web.path-mapping` ���ԡ�
+
+
+
+
+
+��������ӽ� `/actuator/health` ����ӳ��Ϊ `/healthcheck`��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoints.web.base-path=/
+management.endpoints.web.path-mapping.health=healthcheck
+
+```
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.monitoring.customizing-management-server-port)3.2\. ���ƹ����������˿�
+
+
+
+���ڻ����ƵIJ�����˵��ͨ��ʹ��Ĭ�ϵ�HTTP�˿�����¶�����˵���һ�����ǵ�ѡ�� Ȼ����������Ӧ�ó��������Լ����������������У�����ܸ�ϲ��ʹ�ò�ͬ��HTTP�˿�����¶�˵㡣
+
+
+
+
+
+��������� `management.server.port` �������ı�HTTP�˿ڣ��������������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.server.port=8081
+
+```
+
+
+
+
+
+
+
+|  | �� Cloud Foundry �ϣ�Ĭ������£�Ӧ�ó�����ڶ˿� 8080 �Ͻ��� HTTP �� TCP ·�ɵ����� ��������� Cloud Foundry ��ʹ���Զ�������˿ڣ�����Ҫ��ȷ����Ӧ�ó����·���Խ�����ת�����Զ���˿ڡ� |
+| --- | --- |
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.monitoring.management-specific-ssl)3.3\. �������Management�����������SSL
+
+
+
+������Ϊʹ���Զ���˿�ʱ����Ҳ����ͨ��ʹ�ø��� `management.server.ssl.*` ���������ù�����������SSL�� ���磬�����������ù���������ͨ��HTTP�ṩ���񣬶���Ӧ�ó���ʹ��HTTPS������������������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+server.port=8443
+server.ssl.enabled=true
+server.ssl.key-store=classpath:store.jks
+server.ssl.key-password=secret
+management.server.port=8080
+management.server.ssl.enabled=false
+
+```
+
+
+
+
+
+
+
+���ߣ����������͹���������������ʹ��SSL����ʹ�ò�ͬ����Կ�洢��������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+server.port=8443
+server.ssl.enabled=true
+server.ssl.key-store=classpath:main.jks
+server.ssl.key-password=secret
+management.server.port=8080
+management.server.ssl.enabled=true
+management.server.ssl.key-store=classpath:management.jks
+management.server.ssl.key-password=secret
+
+```
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.monitoring.customizing-management-server-address)3.4\. ����Management����������������ַ
+
+
+
+�����ͨ������ `management.server.address` �������ƹ����˵�Ŀ��õ�ַ�� �������ֻ���ڲ���������ά�������ϼ���������ֻ�������� `localhost` �����ӣ�������������á�
+
+
+
+
+
+|  | ֻ�е��˿������������˿ڲ�ͬʱ��������ڲ�ͬ�ĵ�ַ�Ͻ��м����� |
+| --- | --- |
+
+
+
+
+
+��������� `application.properties` ������Զ�̹������ӡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.server.port=8081
+management.server.address=127.0.0.1
+
+```
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.monitoring.disabling-http-endpoints)3.5\. ����HTTP�˵�
+
+
+
+����㲻��ͨ��HTTP��¶�˵㣬����԰ѹ����˿�����Ϊ `-1`����������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.server.port=-1
+
+```
+
+
+
+
+
+
+
+��Ҳ����ͨ��ʹ�� `management.endpoints.web.exposure.exclude` ������ʵ�֣���������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoints.web.exposure.exclude=*
+
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/actuator.html#actuator.jmx)4\. ͨ��JMX���м�غ͹���
+
+
+
+
+
+Java������չ��JMX���ṩ��һ����׼�Ļ�������غ͹���Ӧ�ó��� Ĭ������£��ù���δ�����á� �����ͨ������ `spring.jmx.enabled` ��������Ϊ `true` �������� Spring Boot������ʵ� `MBeanServer` ��ΪIDΪ `mbeanServer` ��Bean������ ����κδ���Spring JMXע���Bean��`@ManagedResource`��`@ManagedAttribute` �� `@ManagedOperation`�����ᱩ¶������
+
+
+
+
+
+������ƽ̨�ṩ��һ����׼�� `MBeanServer` ��Spring Boot��ʹ���������ڱ�ҪʱĬ��ΪVM `MBeanServer`�� ���������Щ��ʧ���ˣ��ͻᴴ��һ���µ� `MBeanServer`��
+
+
+
+
+
+����ϸ�ڼ� [`JmxAutoConfiguration`](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jmx/JmxAutoConfiguration.java) �ࡣ
+
+
+
+
+
+Ĭ������£�Spring BootҲ�������˵���ΪJMX MBeans�� `org.springframework.boot` ���¹����� Ҫ��ȫ����JMX���еĶ˵�ע�ᣬ���Կ���ע�����Լ��� `EndpointObjectNameFactory` ʵ�֡�
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.jmx.custom-mbean-names)4.1\. �Զ���MBean����
+
+
+
+MBean������ͨ���ɶ˵�� `id` ���ɡ� ���磬 `health` �˵㱻��¶Ϊ `org.springframework.boot:type=Endpoint,name=Health`��
+
+
+
+
+
+������Ӧ�ó������һ�����ϵ�Spring `ApplicationContext`������ܻᷢ�����ַ�����ͻ�� Ϊ�˽��������⣬����Խ� `spring.jmx.unique-names` ��������Ϊ `true`������MBean�����־�����Ψһ�ġ�
+
+
+
+
+
+�㻹�����Զ��屩¶�˵��JMX�� �����������ʾ���� `application.properties` ����������һ�����ӡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+spring.jmx.unique-names=true
+management.endpoints.jmx.domain=com.example.myapp
+
+```
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.jmx.disable-jmx-endpoints)4.2\. ����JMX�˵�
+
+
+
+����㲻��ͨ��JMX��¶�˵㣬����԰� `management.endpoints.jmx.exposure.exclude` ��������Ϊ `*`����������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.endpoints.jmx.exposure.exclude=*
+
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/actuator.html#actuator.observability)5\. �ɹ۲��ԣ�Observability��
+
+
+
+
+
+�ɹ۲�����ָ���ⲿ�۲�һ�������е�ϵͳ���ڲ�״̬����������������֧����ɣ���־�������͸��١�
+
+
+
+
+
+���ڶ����͸��٣�Spring Bootʹ�� [Micrometer Observation](https://micrometer.io/docs/observation)��Ҫ�������Լ��Ĺ۲죨�⽫���¶����͸��٣��������ע��һ�� `ObservationRegistry`��
+
+
+
+
+
+
+
+```
+@Component
+public class MyCustomObservation {
+
+    private final ObservationRegistry observationRegistry;
+
+    public MyCustomObservation(ObservationRegistry observationRegistry) {
+        this.observationRegistry = observationRegistry;
+    }
+
+    public void doSomething() {
+        Observation.createNotStarted("doSomething", this.observationRegistry)
+                .lowCardinalityKeyValue("locale", "en-US")
+                .highCardinalityKeyValue("userId", "42")
+                .observe(() -> {
+                    // Execute business logic here
+                });
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+|  | �Ϳ��ȵı�ǩ�������ӵ�ָ���׷���У����߿��ȵı�ǩ��ֻ�����ӵ�׷���С� |
+| --- | --- |
+
+
+
+
+
+`ObservationPredicate`��`GlobalObservationConvention` �� `ObservationHandler` ���͵� Bean �����Զ�ע�ᵽ `ObservationRegistry` �ϡ����������ע������������ `ObservationRegistryCustomizer` Bean����һ������ע�����
+
+
+
+
+
+����ϸ����� [Micrometer Observation �ĵ�](https://micrometer.io/docs/observation)��
+
+
+
+
+
+|  | JDBC��R2DBC�Ŀɹ۲��ԣ�Observability������ʹ�õ�������Ŀ�������á����� JDBC�� [Datasource Micrometer ��Ŀ](https://github.com/jdbc-observations/datasource-micrometer) �ṩ��һ�� Spring Boot Starter���ڵ���JDBC����ʱ�Զ������۲졣�� [�ο��ĵ�](https://jdbc-observations.github.io/datasource-micrometer/docs/current/docs/html/)���Ķ��������������Ϣ������R2DBC�� [R2DBC�۲��Spring Boot�Զ�����](https://github.com/spring-projects-experimental/r2dbc-micrometer-spring-boot) ����ΪR2DBC��ѯ���ô����۲졣 |
+| --- | --- |
+
+
+
+
+
+���������½ڽ��ṩ������־��ָ���׷�ٵĸ���ϸ�ڡ�
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/actuator.html#actuator.loggers)6\. ��־��¼����Logger��
+
+
+
+
+
+Spring Boot Actuator����������ʱ�鿴������Ӧ�ó������־����Ĺ��ܡ� ����Բ鿴�����б��򵥸���־��¼�������ã�������ȷ���õ���־�����Լ���־��ܸ���������Ч��־������ɡ� ��Щ�������������֮һ��
+
+
+
+
+
+*   `TRACE`
+
+*   `DEBUG`
+
+*   `INFO`
+
+*   `WARN`
+
+*   `ERROR`
+
+*   `FATAL`
+
+*   `OFF`
+
+*   `null`
+
+
+
+
+
+`null` ��ʾû����ȷ�����á�
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.loggers.configure)6.1\. ����һ�� Logger
+
+
+
+Ҫ����һ�������ļ�¼����`POST` һ������ʵ�嵽��Դ��URI���������������ʾ��
+
+
+
+
+
+
+
+```
+{
+    "configuredLevel": "DEBUG"
+}
+```
+
+
+
+
+
+
+
+|  | Ҫ ��reset�� �����ã���¼�����ض����𣨲�ʹ��Ĭ�����ã�������Դ���һ�� `null` ��ֵ��Ϊ `configuredLevel`�� |
+| --- | --- |
+
+
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics)7\. ָ�꣨Metrics��
+
+
+
+
+
+Spring Boot ActuatorΪ [Micrometer](https://micrometer.io/) �ṩ�������������Զ����ã�Micrometer��һ��֧�� [�ڶ���ϵͳ](https://micrometer.io/docs) ��Ӧ�ó���ָ��ӿڣ�������
+
+
+
+
+
+*   [AppOptics](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.appoptics)
+
+*   [Atlas](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.atlas)
+
+*   [Datadog](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.datadog)
+
+*   [Dynatrace](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.dynatrace)
+
+*   [Elastic](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.elastic)
+
+*   [Ganglia](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.ganglia)
+
+*   [Graphite](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.graphite)
+
+*   [Humio](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.humio)
+
+*   [Influx](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.influx)
+
+*   [JMX](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.jmx)
+
+*   [KairosDB](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.kairos)
+
+*   [New Relic](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.newrelic)
+
+*   [OpenTelemetry](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.otlp)
+
+*   [Prometheus](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.prometheus)
+
+*   [SignalFx](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.signalfx)
+
+*   [Simple (in-memory)](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.simple)
+
+*   [Stackdriver](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.stackdriver)
+
+*   [StatsD](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.statsd)
+
+*   [Wavefront](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.wavefront)
+
+
+
+
+
+|  | Ҫ�˽�������Micrometer�Ĺ��ܣ���μ��� [�ο��ĵ�](https://micrometer.io/docs)���ر��� [�����](https://micrometer.io/docs/concepts)�� |
+| --- | --- |
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.getting-started)7.1\. ����
+
+
+
+Spring Boot���Զ�����һ�����ϵ� `MeterRegistry`����Ϊ����classpath�Ϸ��ֵ�ÿ��֧�ֵ�ʵ������һ��ע����� ���������ʱclasspath���ж� `micrometer-registry-{system}` ��������������Spring Boot����ע����ˡ�
+
+
+
+
+
+�����ע����й�ͬ���ص㡣 ���磬��ʹ Micrometer ע�����ʵ����classpath�ϣ���Ҳ���Խ���һ���ض���ע����� ��������ӽ�����Datadog��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.datadog.metrics.export.enabled=false
+
+```
+
+
+
+
+
+
+
+��Ҳ���Խ������е�ע���������ע����ض���������˵������������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.defaults.metrics.export.enabled=false
+
+```
+
+
+
+
+
+
+
+Spring Boot�����κ��Զ����õ�ע������ӵ� `Metrics` ���ϵ�ȫ�־�̬����ע�������������ȷ��������Ҫ��������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.metrics.use-global-registry=false
+
+```
+
+
+
+
+
+
+
+�����ע������������ `MeterRegistryCustomizer` Bean����һ������ע������������κα���ע��֮ǰӦ����ͨ��ǩ��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Configuration(proxyBeanMethods = false)
+public class MyMeterRegistryConfiguration {
+
+    @Bean
+    public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
+        return (registry) -> registry.config().commonTags("region", "us-east-1");
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+�����ͨ��������ķ��ͽ�����Ӧ�����ض���ע���ʵ�֡�
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Configuration(proxyBeanMethods = false)
+public class MyMeterRegistryConfiguration {
+
+    @Bean
+    public MeterRegistryCustomizer<GraphiteMeterRegistry> graphiteMetricsNamingConvention() {
+        return (registry) -> registry.config().namingConvention(this::name);
+    }
+
+    private String name(String name, Meter.Type type, String baseUnit) {
+        return ...
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+Spring Boot�� [���������� instrumentation](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported)�������ͨ�����û�ר��ע���������ơ�
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export)7.2\. ֧�ֵļ��ϵͳ
+
+
+
+���ڼ�Ҫ����ÿ��֧�ֵļ��ϵͳ��
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.appoptics)7.2.1\. AppOptics
+
+
+
+Ĭ������£�AppOpticsע�����Ļᶨ�ڽ�ָ�����͵� `[api.appoptics.com/v1/measurements](https://api.appoptics.com/v1/measurements)`��Ҫ��ָ�굼���� SaaS [AppOptics](https://micrometer.io/docs/registry/appOptics)�������ṩ���API���ơ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.appoptics.metrics.export.api-token=YOUR_TOKEN
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.atlas)7.2.2\. Atlas
+
+
+
+Ĭ������£�ָ��ᱻ�������������㱾�ػ����ϵ� [Atlas](https://micrometer.io/docs/registry/atlas)��������ṩ [Atlas server](https://github.com/Netflix/atlas) ��λ�á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.atlas.metrics.export.uri=https://atlas.example.com:7101/api/v1/publish
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.datadog)7.2.3\. Datadog
+
+
+
+һ��Datadogע�����Ļᶨ�ڽ�ָ�����͵� [datadoghq](https://www.datadoghq.com/)�� Ҫ����ָ�굽 [Datadog](https://micrometer.io/docs/registry/datadog)��������ṩ���API��Կ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.datadog.metrics.export.api-key=YOUR_KEY
+
+```
+
+
+
+
+
+
+
+����������ṩһ��Ӧ����Կ����ѡ������ôԪ���ݣ����DZ����������ͺͻ�����λҲ����������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.datadog.metrics.export.api-key=YOUR_API_KEY
+management.datadog.metrics.export.application-key=YOUR_APPLICATION_KEY
+
+```
+
+
+
+
+
+
+
+Ĭ������£�ָ�걻���͵�Datadog���� [site](https://docs.datadoghq.com/getting_started/site) ��`[api.datadoghq.com](https://api.datadoghq.com/)`���� ������Datadog��Ŀ�й���������վ�ϣ���������Ҫͨ����������ָ�꣬����Ӧ����URI��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.datadog.metrics.export.uri=https://api.datadoghq.eu
+
+```
+
+
+
+
+
+
+
+�㻹���Ըı���Datadog����ָ���ʱ������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.datadog.metrics.export.step=30s
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.dynatrace)7.2.4\. Dynatrace
+
+
+
+Dynatrace�ṩ������ָ����ȡAPI������Ϊ [Micrometer](https://micrometer.io/docs/registry/dynatrace) ʵ�ֵġ�������� [����](https://www.dynatrace.com/support/help/how-to-use-dynatrace/metrics/metric-ingestion/ingestion-methods/micrometer) �ҵ�Dynatrace����Micrometerָ��������ĵ���`v1` �����ռ��е���������ֻ�����ڵ����� [Timeseries v1 API](https://www.dynatrace.com/support/help/dynatrace-api/environment-api/metric-v1/) ʱ��`v2` �����ռ��е���������ֻ�����ڵ����� [Metrics v2 API](https://www.dynatrace.com/support/help/dynatrace-api/environment-api/metric-v2/post-ingest-metrics/) ʱ����ע�⣬�ü���ÿ��ֻ�ܵ�����API�� `v1` �� `v2` �汾��`v2` �汾����ѡ����� `device-id`��v1����Ҫ������v2���в�ʹ�ã��� `v1` �������ռ��б����ã���ômetric���������� `v1` ��˵㡣���򣬾ͼٶ��� `v2` �汾��
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.dynatrace.v2-api)v2 API
+
+
+
+�����ͨ�����ַ�ʽʹ��v2 API��
+
+
+
+
+
+###### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.dynatrace.v2-api.auto-config)�Զ�����
+
+
+
+Dynatrace�Զ�������������OneAgent��Dynatrace Operator for Kubernetes��ص�������
+
+
+
+
+
+**����OneAgent��**�������������OneAgent��ָ����Զ������ [local OneAgent ingest endpoint](https://www.dynatrace.com/support/help/how-to-use-dynatrace/metrics/metric-ingestion/ingestion-methods/local-api/) �� ��ȡ�˵㽫ָ��ת����Dynatrace��ˡ�
+
+
+
+
+
+**Dynatrace Kubernetes Operator��**�ڰ�װ��Dynatrace Operator��Kubernetes������ʱ��ע������Զ��Ӳ���Ա�����ȡ��Ķ˵�URI��API���ơ�
+
+
+
+
+
+����Ĭ����Ϊ���������� `io.micrometer:micrometer-registry-dynatrace` ֮�⣬����Ҫ�ر�����á�
+
+
+
+
+
+
+
+###### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.dynatrace.v2-api.manual-config)�ֶ�����
+
+
+
+���û���Զ����ã�����Ҫ [Metrics v2 API](https://www.dynatrace.com/support/help/dynatrace-api/environment-api/metric-v2/post-ingest-metrics/) �Ķ˵��һ�� API ���ơ�API���Ʊ����� ��Ingest metrics�� ��`metrics.ingest`����Ȩ�����á����ǽ��齫���Ƶķ�Χ��������һ��Ȩ���ϡ������ȷ���˵�URI����·�������磬`/api/v2/metrics/ingest`����
+
+
+
+
+
+Metrics API v2��ȡ�˵��URL������IJ���ѡ�����ͬ��
+
+
+
+
+
+*   SaaS: `https://{your-environment-id}.live.dynatrace.com/api/v2/metrics/ingest`
+
+*   Managed deployments: `https://{your-domain}/e/{your-environment-id}/api/v2/metrics/ingest`
+
+
+
+
+
+������������� `example` environment id ���ö���ֵ������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.dynatrace.metrics.export.uri=https://example.live.dynatrace.com/api/v2/metrics/ingest
+management.dynatrace.metrics.export.api-token=YOUR_TOKEN
+
+```
+
+
+
+
+
+
+
+��ʹ��Dynatrace v2 APIʱ������ʹ�����¿�ѡ���ܣ�����ϸ�ڿ��� [Dynatrace�ĵ�](https://www.dynatrace.com/support/help/how-to-use-dynatrace/metrics/metric-ingestion/ingestion-methods/micrometer#dt-configuration-properties) ���ҵ�����
+
+
+
+
+
+*   Metric key ��ǰ׺������һ��ǰ׺����ǰ׺�������ӵ����е�����metric key�С�
+
+*   ��DynatraceԪ��������ʵ�����OneAgent��Dynatrace����Ա�������У��ö����Ԫ���ݣ����磬�������������̻�Pod�����ḻָ�ꡣ
+
+*   Ĭ��ά�ȡ�ָ�����ӵ����е��������ļ�ֵ�ԡ� �����Micrometerָ���˾�����ͬ���ı�ǩ�����ǽ�����Ĭ��dimension��
+
+*   ʹ��Dynatrace Summary instrument����ijЩ����£�Micrometer Dynatraceע���������ָ�걻�ܾ��� ��Micrometer 1.9.x�У�ͨ������Dynatrace�ض���ժҪ���������������⡣ �������������Ϊ `false` ����ʹMicrometer�ص�1.9.x֮ǰ��Ĭ����Ϊ�� ֻ���ڴ�Micrometer 1.8.xǨ�Ƶ�1.9.xʱ��������ʱ�ſ���ʹ�á�
+
+
+
+
+
+���Բ�ָ��URI��API���ƣ�������������ʾ�� ����������£���ʹ���Զ����õĶ˵㡣
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.dynatrace.metrics.export.v2.metric-key-prefix=your.key.prefix
+management.dynatrace.metrics.export.v2.enrich-with-dynatrace-metadata=true
+management.dynatrace.metrics.export.v2.default-dimensions.key1=value1
+management.dynatrace.metrics.export.v2.default-dimensions.key2=value2
+management.dynatrace.metrics.export.v2.use-dynatrace-summary-instruments=true
+
+```
+
+
+
+
+
+
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.dynatrace.v1-api)v1 API (Legacy)
+
+
+
+Dynatrace v1 APIָ��ע���ͨ��ʹ�� [Timeseries v1 API](https://www.dynatrace.com/support/help/dynatrace-api/environment-api/metric-v1/) ���ڽ�ָ�����͵����õ�URI�� Ϊ�����������е����ã��� `device-id` ������ʱ��v1��Ҫ������v2�в�ʹ�ã���ָ�걻������Timeseries v1�˵㡣 Ҫ�� [Dynatrace](https://micrometer.io/docs/registry/dynatrace) ����ָ�꣬�����ṩ���API���ơ��豸ID��URI��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.dynatrace.metrics.export.uri=https://{your-environment-id}.live.dynatrace.com
+management.dynatrace.metrics.export.api-token=YOUR_TOKEN
+management.dynatrace.metrics.export.v1.device-id=YOUR_DEVICE_ID
+
+```
+
+
+
+
+
+
+
+����v1��API�������ָ����������URI������ָ��·������Ϊv1��Ķ˵�·�����Զ����ӡ�
+
+
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.dynatrace.version-independent-settings)��汾�޹ص�����
+
+
+
+����API�˵�������⣬�㻹���Ըı���Dynatrace����ָ��ļ��ʱ�䡣 Ĭ�ϵĵ���ʱ������ `60s`�� ��������ӽ�����ʱ��������Ϊ30�롣
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.dynatrace.metrics.export.step=30s
+
+```
+
+
+
+
+
+
+
+������� [Micrometer�ĵ�](https://micrometer.io/docs/registry/dynatrace) �� [Dynatrace�ĵ�](https://www.dynatrace.com/support/help/how-to-use-dynatrace/metrics/metric-ingestion/ingestion-methods/micrometer) ���ҵ��������ΪMicrometer����Dynatrace exporter�����������ĸ�����Ϣ��
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.elastic)7.2.5\. Elastic
+
+
+
+Ĭ������£�ָ�걻�������������㱾�ػ����ϵ� [Elastic](https://micrometer.io/docs/registry/elastic) �� �����ͨ��ʹ�����������ṩҪʹ�õ�Elastic��������λ�á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.elastic.metrics.export.host=https://elastic.example.com:8086
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.ganglia)7.2.6\. Ganglia
+
+
+
+Ĭ������£�ָ�걻�������������㱾�ػ����ϵ� [Ganglia](https://micrometer.io/docs/registry/ganglia) ��������ṩ [Ganglia server](http://ganglia.sourceforge.net/) �������Ͷ˿ڣ���������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.ganglia.metrics.export.host=ganglia.example.com
+management.ganglia.metrics.export.port=9649
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.graphite)7.2.7\. Graphite
+
+
+
+Ĭ������£�ָ��ᱻ�������������㱾�ػ����ϵ� [Graphite](https://micrometer.io/docs/registry/graphite) ��������ṩ [Graphite server](https://graphiteapp.org/) �������Ͷ˿ڣ���������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.graphite.metrics.export.host=graphite.example.com
+management.graphite.metrics.export.port=9004
+
+```
+
+
+
+
+
+
+
+Micrometer�ṩ��һ��Ĭ�ϵ� `HierarchicalNameMapper`������dimensional meter ID���https://micrometer.io/docs/registry/graphite#_hierarchical_name_mapping[ӳ�䵽 flat hierarchical name]��
+
+
+
+
+
+|  | Ҫ����������Ϊ���붨����� `GraphiteMeterRegistry` ���ṩ���Լ��� `HierarchicalNameMapper`�� �������Լ����壬������ṩһ���Զ����õ� `GraphiteConfig` �� `Clock` Bean��JavaKotlin```@Configuration(proxyBeanMethods = false)public class MyGraphiteConfiguration {    @Bean    public GraphiteMeterRegistry graphiteMeterRegistry(GraphiteConfig config, Clock clock) {        return new GraphiteMeterRegistry(config, clock, this::toHierarchicalName);    }    private String toHierarchicalName(Meter.Id id, NamingConvention convention) {        return ...    }}``` |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.humio)7.2.8\. Humio
+
+
+
+Ĭ������£�Humioע�����Ļᶨ�ڽ�ָ�����͵� [cloud.humio.com](https://cloud.humio.com/) �� Ҫ��ָ�굼����SaaS [Humio](https://micrometer.io/docs/registry/humio)��������ṩ���API���ơ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.humio.metrics.export.api-token=YOUR_TOKEN
+
+```
+
+
+
+
+
+
+
+�㻹Ӧ������һ��������ǩ����ȷ������ָ�������Դ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.humio.metrics.export.tags.alpha=a
+management.humio.metrics.export.tags.bravo=b
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.influx)7.2.9\. Influx
+
+
+
+Ĭ������£�ָ��ᱻ�����������ڱ��ػ����ϵ� [Influx](https://micrometer.io/docs/registry/influx) v1ʵ����������Ĭ�����á�Ҫ����ָ�굽InfluxDB v2�������� `org`��`bucket` ������д��ָ���authentication `token`�������ͨ�����·�ʽ�ṩҪʹ�õ� [Influx server](https://www.influxdata.com/) ��λ�á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.influx.metrics.export.uri=https://influx.example.com:8086
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.jmx)7.2.10\. JMX
+
+
+
+Micrometer�ṩ�˶� [JMX](https://micrometer.io/docs/registry/jmx) �ķֲ�ӳ�䣬��Ҫ����Ϊһ�����ۺͿ���ֲ�ķ�ʽ���鿴���صĶ����� Ĭ������£�ָ�걻������ `metrics` JMX�� �����ͨ�����·�ʽ�ṩҪʹ�õ���
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.jmx.metrics.export.domain=com.example.app.metrics
+
+```
+
+
+
+
+
+
+
+Micrometer�ṩ��һ��Ĭ�ϵ� `HierarchicalNameMapper`������dimensional meter ID ��� [ӳ�䵽 flat hierarchical name](https://micrometer.io/docs/registry/jmx#_hierarchical_name_mapping)��
+
+
+
+
+
+|  | Ҫ����������Ϊ���붨����� `JmxMeterRegistry` ���ṩ���Լ��� `HierarchicalNameMapper`�� �������Լ����壬������ṩһ���Զ����õ� `JmxConfig` �� `Clock` Bean��JavaKotlin```@Configuration(proxyBeanMethods = false)public class MyJmxConfiguration {    @Bean    public JmxMeterRegistry jmxMeterRegistry(JmxConfig config, Clock clock) {        return new JmxMeterRegistry(config, clock, this::toHierarchicalName);    }    private String toHierarchicalName(Meter.Id id, NamingConvention convention) {        return ...    }}``` |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.kairos)7.2.11\. KairosDB
+
+
+
+Ĭ������£�ָ�걻�������������㱾�ػ����ϵ� [KairosDB](https://micrometer.io/docs/registry/kairos) �������ͨ�����·�ʽ�ṩҪʹ�õ� [KairosDB server](https://kairosdb.github.io/) ��λ�á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.kairos.metrics.export.uri=https://kairosdb.example.com:8080/api/v1/datapoints
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.newrelic)7.2.12\. New Relic
+
+
+
+New Relicע�����Ļᶨ�ڽ�ָ�����͵� [New Relic](https://micrometer.io/docs/registry/new-relic)��Ҫ����ָ�굽 [New Relic](https://newrelic.com/)��������ṩ���API��Կ���˻�ID��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.newrelic.metrics.export.api-key=YOUR_KEY
+management.newrelic.metrics.export.account-id=YOUR_ACCOUNT_ID
+
+```
+
+
+
+
+
+
+
+�㻹���Ըı���New Relic����ָ���ʱ������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.newrelic.metrics.export.step=30s
+
+```
+
+
+
+
+
+
+
+Ĭ������£�ָ����ͨ��REST���÷����ģ����������classpath����Java Agent API����Ҳ����ʹ������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.newrelic.metrics.export.client-provider-type=insights-agent
+
+```
+
+
+
+
+
+
+
+��������ͨ���������Լ��� `NewRelicClientProvider` ������ȫ���ơ�
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.otlp)7.2.13\. OpenTelemetry
+
+
+
+Ĭ������£�ָ�걻�������������㱾�ػ����ϵ� [OpenTelemetry](https://micrometer.io/docs/registry/otlp) �������ͨ�����·�ʽ�ṩҪʹ�õ� [OpenTelemtry metric endpoint](https://opentelemetry.io/) ��λ�á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.otlp.metrics.export.url=https://otlp.example.com:4318/v1/metrics
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.prometheus)7.2.14\. Prometheus
+
+
+
+[Prometheus](https://micrometer.io/docs/registry/prometheus) ϣ��scrape����ѯ����Ӧ�ó���ʵ����ָ�ꡣSpring Boot�� `/actuator/prometheus` �ṩ��һ��actuator�˵㣬�Ա����ʵ��ĸ�ʽ���� [Prometheus scrape](https://prometheus.io/)��
+
+
+
+
+
+|  | Ĭ������£��ö˵��Dz����õģ����뱻��¶������ϸ����μ�[��¶�˵�](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.exposing)�� |
+| --- | --- |
+
+
+
+
+
+��������� `scrape_config` ���ӵ� `prometheus.yml`��
+
+
+
+
+
+
+
+```
+scrape_configs:
+  - job_name: "spring"
+    metrics_path: "/actuator/prometheus"
+    static_configs:
+      - targets: ["HOST:PORT"]
+```
+
+
+
+
+
+
+
+Ҳ֧�� [Prometheus Exemplars](https://prometheus.io/docs/prometheus/latest/feature_flags/#exemplars-storage)��Ҫ����������ܣ�Ӧ����һ�� `SpanContextSupplier` Bean�������ʹ�� [Micrometer Tracing](https://micrometer.io/docs/tracing)���⽫Ϊ���Զ����ã���������룬�����ǿ��Դ����Լ��ġ���鿴 [Prometheus �ĵ�](https://prometheus.io/docs/prometheus/latest/feature_flags/#exemplars-storage) ����Ϊ���������Ҫ��Prometheus�����ȷ���ã�����ֻ֧��ʹ�� [OpenMetrics](https://github.com/OpenObservability/OpenMetrics/blob/v1.0.0/specification/OpenMetrics.md#exemplars) ��ʽ��
+
+
+
+
+
+���ڶ��ݵĻ�����������ҵ�����ܴ��ڵ�ʱ�䲻�������޷�����ȡ�������ʹ�� [Prometheus Pushgateway](https://github.com/prometheus/pushgateway) ֧�֣���ָ�걩¶��Prometheus��Ҫ����Prometheus Pushgateway֧�֣����������Ŀ����������������
+
+
+
+
+
+
+
+```
+<dependency>
+    <groupId>io.prometheus</groupId>
+    simpleclient_pushgateway
+</dependency>
+```
+
+
+
+
+
+
+
+��Prometheus Pushgateway������������classpath�ϣ����� `management.prometheus.metrics.export.pushgateway.enabled` ���Ա�����Ϊ `true` ʱ��һ�� `PrometheusPushGatewayManager` bean�ͱ��Զ������ˡ� �����������Prometheus Pushgateway����ָ��Ĺ�����
+
+
+
+
+
+�����ͨ��ʹ�� `management.prometheus.metrics.export.pushgateway` �µ����������� `PrometheusPushGatewayManager`�� ���ڸ߼����ã���Ҳ�����ṩ���Լ��� `PrometheusPushGatewayManager` bean��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.signalfx)7.2.15\. SignalFx
+
+
+
+SignalFxע�����Ļᶨ�ڽ�ָ�����͵� [SignalFx](https://micrometer.io/docs/registry/signalFx)��Ҫ����ָ�굽 [SignalFx](https://www.signalfx.com/)��������ṩ���access token��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.signalfx.metrics.export.access-token=YOUR_ACCESS_TOKEN
+
+```
+
+
+
+
+
+
+
+��Ҳ���Ըı���SignalFx����ָ���ʱ������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.signalfx.metrics.export.step=30s
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.simple)7.2.16\. Simple
+
+
+
+Micrometer�ṩ��һ���򵥵ġ��ڴ��еĺ�ˣ����û����������ע������ú�˻��Զ���Ϊ���á���������㿴���� [metrics endpoint](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.endpoint) ���ռ�����Щ������
+
+
+
+
+
+һ����ʹ���κ��������õĺ�ˣ��ڴ��еĺ�˾ͻ��Զ��رա���Ҳ������ȷ�ؽ�������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.simple.metrics.export.enabled=false
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.stackdriver)7.2.17\. Stackdriver
+
+
+
+Stackdriverע�����Ļᶨ���� [Stackdriver](https://cloud.google.com/stackdriver/) ����ָ�ꡣҪ����ָ�굽SaaS [Stackdriver](https://micrometer.io/docs/registry/stackdriver)��������ṩ���Google Cloud project ID��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.stackdriver.metrics.export.project-id=my-project
+
+```
+
+
+
+
+
+
+
+�㻹���Ըı���Stackdriver����ָ���ʱ������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.stackdriver.metrics.export.step=30s
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.statsd)7.2.18\. StatsD
+
+
+
+StatsDע������еؽ�ָ��ͨ��UDP���͸�StatsD agent��Ĭ������£�ָ�걻�������������㱾�ػ����ϵ� [StatsD](https://micrometer.io/docs/registry/statsD) agent�������ͨ�����·�ʽ�ṩStatsD�������������˿ں�Э�飬�Ա�ʹ�á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.statsd.metrics.export.host=statsd.example.com
+management.statsd.metrics.export.port=9125
+management.statsd.metrics.export.protocol=udp
+
+```
+
+
+
+
+
+
+
+�㻹���Ըı�Ҫʹ�õ�StatsD��·Э�飨Ĭ��ΪDatadog����
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.statsd.metrics.export.flavor=etsy
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.export.wavefront)7.2.19\. Wavefront
+
+
+
+Wavefrontע������ڽ�ָ�����͵� [Wavefront](https://micrometer.io/docs/registry/wavefront)�������ֱ�ӽ�ָ�굼���� [Wavefront](https://www.wavefront.com/)��������ṩ���API token��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.wavefront.api-token=YOUR_API_TOKEN
+
+```
+
+
+
+
+
+
+
+���⣬�����������Ļ�����ʹ��Wavefront sidecar���ڲ�������ת��ָ�����ݵ�Wavefront API������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.wavefront.uri=proxy://localhost:2878
+
+```
+
+
+
+
+
+
+
+�������ָ�귢����Wavefront�������� [Wavefront�ĵ�](https://docs.wavefront.com/proxies_installing.html) �������������������� `proxy://HOST:PORT` ��ʽ��
+
+
+
+
+
+��Ҳ���Ըı���Wavefront����ָ���ʱ������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.wavefront.metrics.export.step=30s
+
+```
+
+
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported)7.3\. ֧�ֵ�ָ�� ��Metric���Ͷ�����Meter��
+
+
+
+Spring BootΪ���ָ����ļ����ṩ���Զ�������ע�ᡣ �ڴ��������£�Ĭ��ֵ�ṩ�˺�����ָ�꣬���Է������κ�֧�ֵļ��ϵͳ�С�
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.jvm)7.3.1\. JVMָ��
+
+
+
+�Զ�����ͨ��ʹ�ú��� Micrometer ������JVM������ JVMָ���� `jvm.` meter name �·�����
+
+
+
+
+
+�ṩ����JVMָ�ꡣ
+
+
+
+
+
+*   �����ڴ�ͻ����ϸ��
+
+*   �������ռ��йص�ͳ������
+
+*   �߳�������
+
+*   ���غ�ж�ص��������
+
+*   JVM�İ汾��Ϣ
+
+*   JIT ����ʱ��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.system)7.3.2\. ϵͳָ��
+
+
+
+�Զ�����ͨ��ʹ�ú���Micrometer����ʵ��ϵͳ������ ϵͳָ���� `system.`��`process.` �� `disk.` meter ���·�����
+
+
+
+
+
+�ṩ����ϵͳָ�ꡣ
+
+
+
+
+
+*   CPUָ��
+
+*   �ļ�������ָ��
+
+*   ��������ʱ��ָ�꣨����Ӧ�ó����Ѿ����е�ʱ��;�������ʱ��Ĺ̶���������
+
+*   ���õĴ��̿ռ�
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.application-startup)7.3.3\. Ӧ�ó�������ָ��
+
+
+
+�Զ����ñ�¶��Ӧ�ó��������ʱ��ָ�ꡣ
+
+
+
+
+
+*   `application.started.time`: ����Ӧ�ó����ʱ�䡣
+
+*   `application.ready.time`��Ӧ�ó���׼����Ϊ�����ṩ���������ʱ�䡣
+
+
+
+
+
+ָ������Ӧ�������ȫ��������ǵġ�
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.logger)7.3.4\. ��־��¼��ָ��
+
+
+
+�Զ�����������Logback��Log4J2���¼������� ϸ���� `log4j2.events.` �� `logback.events.` meter���¹�����
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.tasks)7.3.5\. ����ִ�к͵���ָ��
+
+
+
+�Զ�����ʹ���п��õ� `ThreadPoolTaskExecutor` �� `ThreadPoolTaskScheduler` Bean���ܱ�������ֻҪ�ײ�� `ThreadPoolExecutor` ���á� ָ����executor����������ǣ�executor������������Bean�����ơ�
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.spring-mvc)7.3.6\. Spring MVC ָ��
+
+
+
+�Զ������ܹ��� Spring MVC Controller�ͱ��ʽhandler����������������ж����� Ĭ������£�ָ������ `http.server.requests` Ϊ�������ɵġ� �����ͨ������ `management.observations.http.server.requests.name` ���������Ƹ����ơ�
+
+
+
+
+
+���ڲ����Ĺ۲�����observation���ĸ�����Ϣ����μ� [Spring Framework �ο��ĵ�](https://docs.spring.io/spring-framework/docs/6.0.5/reference/html/integration.html#integration.observability.http-server.servlet)��
+
+
+
+
+
+Ҫ���ӵ�Ĭ�ϱ�ǩ�У����ṩһ���̳��� `org.springframework.http.server.observation` ���е� `DefaultServerRequestObservationConvention` �� `@Bean`��Ҫ�滻Ĭ�ϱ�ǩ�����ṩһ��ʵ�� `ServerRequestObservationConvention` �� `@Bean`��
+
+
+
+
+
+|  | ��ijЩ����£�Web�������д������쳣���ᱻ��¼Ϊ���������ǩ��Ӧ�ó������ѡ����벢ͨ����[handled exception ����Ϊ request attribute](https://springdoc.cn/spring-boot/web.html#web.servlet.spring-mvc.error-handling)����¼�쳣�� |
+| --- | --- |
+
+
+
+
+
+Ĭ������£��������󶼱������� Ҫ�Զ�������������ṩһ��ʵ�� `FilterRegistrationBean<WebMvcMetricsFilter>` �� `@Bean`��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.spring-webflux)7.3.7\. Spring WebFlux ָ��
+
+
+
+�Զ������ܹ���Spring WebFlux controller�ͱ��ʽhandler������������ж����� Ĭ������£�ָ������ `http.server.requests` Ϊ�����ɵġ� �����ͨ������ `management.observations.http.server.requests.name` ���������Ƹ����ơ�
+
+
+
+
+
+���ڲ����Ĺ۲�����observation���ĸ�����Ϣ����μ� [Spring Framework �ο��ĵ�](https://docs.spring.io/spring-framework/docs/6.0.5/reference/html/integration.html#integration.observability.http-server.reactive)��
+
+
+
+
+
+Ҫ���ӵ�Ĭ�ϱ�ǩ�У����ṩ�̳��� `org.springframework.http.server.reactive.observation` ���е� `DefaultServerRequestObservationConvention` �� `@Bean`��Ҫ�滻Ĭ�ϱ�ǩ�����ṩһ��ʵ�� `ServerRequestObservationConvention` �� `@Bean`��
+
+
+
+
+
+|  | ��ijЩ����£��������ʹ��������д������쳣���ᱻ��¼Ϊ���������ǩ��Ӧ�ó������ѡ����벢ͨ��[��handled exception����Ϊrequest attribute](https://springdoc.cn/spring-boot/web.html#web.reactive.webflux.error-handling)����¼�쳣�� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.jersey)7.3.8\. Jersey Server ָ��
+
+
+
+�Զ�����ʹJersey JAX-RSʵ�������������������ܱ������� Ĭ������£�ָ������ `http.server.requests` Ϊ�������ɵġ� �����ͨ������ `management.observations.http.server.requests.name` �������������ơ�
+
+
+
+
+
+Ĭ������£�Jersey������ָ�걻���Ϊ������Ϣ��
+
+
+
+<colgroup><col><col></colgroup>
+| Tag | ˵�� |
+| --- | --- |
+| `exception` | ��������ʱ�׳����κ��쳣�ļ������� |
+| `method` | ����ķ��������磬`GET` �� `POST`���� |
+| `outcome` | ����Ľ����������Ӧ��״̬���롣 1xx�� `INFORMATIONAL`��2xx�� `SUCCESS`��3xx�� `REDIRECTION`��4xx�� `CLIENT_ERROR`��5xx�� `SERVER_ERROR`�� |
+| `status` | ��Ӧ��HTTP״̬���루���磬`200` �� `500`���� |
+| `uri` | ������ܵĻ����ڽ��б����滻֮ǰ�������URIģ�壨���磺`/api/person/{id}`���� |
+
+
+
+Ҫ���Ʊ�ǩ�����ṩһ��ʵ�� `JerseyTagsProvider` �� `@Bean`��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.http-clients)7.3.9\. HTTP Client ָ��
+
+
+
+Spring Boot Actuator������� `RestTemplate` �� `WebClient` �Ĺ��ߡ�Ϊ�ˣ������ע���Զ����õĹ�������ʹ����������ʵ����
+
+
+
+
+
+*   `RestTemplateBuilder` ���� `RestTemplate`
+
+*   `WebClient.Builder` ���� `WebClient`
+
+
+
+
+
+��Ҳ�����ֶ�Ӧ�ø���������ߵ�customizer���� `ObservationRestTemplateCustomizer` �� `ObservationWebClientCustomizer`��
+
+
+
+
+
+Ĭ������£�ָ������ `http.client.requests` ����������ɵġ�
+
+
+
+
+
+�����ͨ������ `management.observations.http.client.requests.name` ����������������֡�
+
+
+
+
+
+���ڲ����Ĺ۲�����observation���ĸ�����Ϣ����μ� [Spring Framework �ο��ĵ�](https://docs.spring.io/spring-framework/docs/6.0.5/reference/html/integration.html#integration.observability.http-client)��
+
+
+
+
+
+Ҫ��ʹ�� `RestTemplate` ʱ���Ʊ�ǩ�����ṩһ��ʵ���� `org.springframework.http.client.observation` ���� `ClientRequestObservationConvention` �� `@Bean`��Ҫ��ʹ�� `WebClient` ʱ�Զ����ǩ�����ṩһ��ʵ���� `org.springframework.web.reactive.function.client` ���� `ClientRequestObservationConvention` �� `@Bean`��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.tomcat)7.3.10\. Tomcat ָ��
+
+
+
+�Զ����ý��� `MBeanRegistry` ������ʱ�Ż�����Tomcat�������� Ĭ������£�`MBeanRegistry` �ǽ��õģ��������ͨ������ `server.tomcat.mbeanregistry.enabled` Ϊ `true` ����������
+
+
+
+
+
+Tomcat��ָ���� `tomcat.` meter ���·�����
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.cache)7.3.11\. Cache ָ��
+
+
+
+�Զ����ÿ���������ʱ�����п��õ� `Cache` ʵ�����м�⣬��ָ���� `cache` Ϊǰ׺��
+
+
+
+
+
+�����DZ��DZ�׼���Ļ���ָ�꼯��
+
+
+
+
+
+Ҳ����ʹ�ö���ġ���Ի����ָ�ꡣ
+
+
+
+
+
+֧�����»���⡣
+
+
+
+
+
+*   Cache2k
+
+*   Caffeine
+
+*   Hazelcast
+
+*   �κμ��ݵ�JCache��JSR-107��ʵ��
+
+*   Redis
+
+
+
+
+
+ָ���ɻ�������ƺ� `CacheManager` ����������ǣ�`CacheManager` ����������Bean���������ġ�
+
+
+
+
+
+|  | ֻ��������ʱ���õĻ��汻�󶨵�ע����� ����û���ڻ��������ж���Ļ��棬�����������׶κ���ʱ�����Ļ�����Ա�̷�ʽ�����Ļ��棬��Ҫ��ȷע�ᡣ һ�� `CacheMetricsRegistrar` Bean����ʹ������̸����ס� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.spring-graphql)7.3.12\. Spring GraphQL ָ��
+
+
+
+�μ� [Spring GraphQL �ο��ĵ�](https://docs.spring.io/spring-graphql/docs/1.1.2/reference/html/)��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.jdbc)7.3.13\. DataSource ָ��
+
+
+
+�Զ�����ʹ���п��õ� `DataSource` �������������ָ��ǰ׺Ϊ `jdbc.connections`�� ����Դ���Ľ���DZ�ʾ���е�ǰ��ġ����еġ���������ĺ���С���������������DZ���
+
+
+
+
+
+������׼Ҳ�ɻ���bean���Ƽ���� `DataSource` ����������ǡ�
+
+
+
+
+
+|  | Ĭ������£�Spring BootΪ����֧�ֵ�����Դ�ṩԪ���ݡ� �����ϲ��������Դ����֧�֣���������Ӷ���� `DataSourcePoolMetadataProvider` Bean�� ����� `DataSourcePoolMetadataProvidersConfiguration` ���˽�ʵ���� |
+| --- | --- |
+
+
+
+
+
+���⣬Hikari�ض���ָ���� `hikaricp` ǰ׺��¶�� ÿ��ָ�궼��pool����������ǣ�������� `spring.datasource.name` �����ƣ���
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.hibernate)7.3.14\. Hibernate ָ��
+
+
+
+��� `org.hibernate.orm:hibernate-micrometer` ��classpath�ϣ�����������ͳ�ƹ��ܵ�Hibernate `EntityManagerFactory` ʵ�����ᱻһ����Ϊ `hibernate` ��ָ������⡣
+
+
+
+
+
+������׼Ҳ�� `EntityManagerFactory` ����������ǣ�����������Bean���������ġ�
+
+
+
+
+
+Ҫ����ͳ�ƣ���׼JPA���� `hibernate.generate_statistics` ��������Ϊ `true`�� ��������Զ����õ� `EntityManagerFactory` �����á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+spring.jpa.properties[hibernate.generate_statistics]=true
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.spring-data-repository)7.3.15\. Spring Data Repository ָ��
+
+
+
+�Զ������ܹ�������Spring Data `Repository` �����ĵ��ý��ж����� Ĭ������£�ָ���� `spring.data.repository.invocations` Ϊ�����ɡ� �����ͨ������ `management.metrics.data.repository.metric-name` �������Զ������ơ�
+
+
+
+
+
+`io.micrometer.core.annotation` ���е� `@Timed` ע��֧�� `Repository` �ӿںͷ���������㲻���¼���� `Repository` ���õĶ�����metric��������Խ� `management.metrics.data.repository.autotime.enabled` ����Ϊ `false`����ר��ʹ�� `@Timed` ע�⡣
+
+
+
+
+
+|  | һ������ `longTask = true` �� `@Timed` ע�����Ϊ�÷�������һ���������ʱ����������ʱ����Ҫһ�������� metric name�����ҿ����������ʱ����task timer�����ӡ� |
+| --- | --- |
+
+
+
+
+
+Ĭ������£�repository������صĶ�����׼�����Ϊ������Ϣ��
+
+
+
+<colgroup><col><col></colgroup>
+| Tag | ˵�� |
+| --- | --- |
+| `repository` | Դ `Repository` �ļ������� |
+| `method` | �����õ� `Repository` ���������ơ� |
+| `state` | ���״̬��`SUCCESS`, `ERROR`, `CANCELED`, `RUNNING`���� |
+| `exception` | �������׳����κ��쳣�ļ������� |
+
+
+
+Ҫ�滻Ĭ�ϱ�ǩ����Ҫ�ṩһ��ʵ���� `RepositoryTagsProvider` �� `@Bean`��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.rabbitmq)7.3.16\. RabbitMQ ָ��
+
+
+
+�Զ�����ʹ���п��õ� RabbitMQ ���ӹ���������������ָ����Ϊ `rabbitmq`��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.spring-integration)7.3.17\. Spring Integration ָ��
+
+
+
+ֻҪ�� `MeterRegistry` bean��Spring Integration�ͻ��Զ��ṩ [Micrometer support](https://docs.spring.io/spring-integration/docs/6.1.0-M1/reference/html/system-management.html#micrometer-integration)�� ������׼�� `spring.integration.` meter �����·�����
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.kafka)7.3.18\. Kafka ָ��
+
+
+
+�Զ�����Ϊ�Զ����õ������߹����������߹����ֱ�ע����һ�� `MicrometerConsumerListener` �� `MicrometerProducerListener`�� ����Ϊ `StreamsBuilderFactoryBean` ע����һ�� `KafkaStreamsMicrometerListener`�� ����ϸ�ڣ������Spring Kafka�ĵ��е� [Micrometer Native Metrics](https://docs.spring.io/spring-kafka/docs/3.0.3/reference/html/#micrometer-native) ���֡�
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.mongodb)7.3.19\. MongoDB ָ��
+
+
+
+���ڼ�Ҫ����MongoDB�Ŀ��ö�����
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.mongodb.command)MongoDB����ָ��
+
+
+
+�Զ����ý� `MongoMetricsCommandListener` ���Զ����õ� `MongoClient` ע�ᡣ
+
+
+
+
+
+һ����Ϊ `mongodb.driver.commands` ��timerָ�걻������������ײ�MongoDB driver������ÿ����� Ĭ������£�ÿ��ָ�궼�����Ϊ������Ϣ��
+
+
+
+<colgroup><col><col></colgroup>
+| Tag | ˵�� |
+| --- | --- |
+| `command` | ��������������ơ� |
+| `cluster.id` | ���͸�����ļ�Ⱥ�ı�ʶ���� |
+| `server.address` | ��������ķ������ĵ�ַ�� |
+| `status` | ����Ľ����`SUCCESS` �� `FAILED���� |
+
+
+
+Ϊ���滻Ĭ�ϵĶ������ǩ������һ�� `MongoCommandTagsProvider` bean����������ʾ��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Configuration(proxyBeanMethods = false)
+public class MyCommandTagsProviderConfiguration {
+
+    @Bean
+    public MongoCommandTagsProvider customCommandTagsProvider() {
+        return new CustomCommandTagsProvider();
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+Ҫ�����Զ����õ�����������������������ԡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.metrics.mongo.command.enabled=false
+
+```
+
+
+
+
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.mongodb.connection-pool)MongoDB ���ӳ�ָ��
+
+
+
+�Զ����ý� `MongoMetricsConnectionPoolListener` ���Զ����õ� `MongoClient` ע�ᡣ
+
+
+
+
+
+������Ϊ���ӳش����IJ���ָ�ꡣ
+
+
+
+
+
+*   `mongodb.driver.pool.size` �������ӳصĵ�ǰ��С���������к�����ʹ�õij�Ա��
+
+*   `mongodb.driver.pool.checkedout` ���浱ǰʹ���е���������
+
+*   `mongodb.driver.pool.waitqueuesize` ����������ӵĵȴ����еĵ�ǰ��С��
+
+
+
+
+
+Ĭ������£�ÿ��ָ�궼�����Ϊ������Ϣ��
+
+
+
+<colgroup><col><col></colgroup>
+| Tag | ˵�� |
+| --- | --- |
+| `cluster.id` | ���ӳ�����Ӧ�ļ�Ⱥ�ı�ʶ���� |
+| `server.address` | ���ӳ�����Ӧ�ķ������ĵ�ַ�� |
+
+
+
+Ҫȡ��Ĭ�ϵĶ������ǩ���붨��һ�� `MongoConnectionPoolTagsProvider` bean��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Configuration(proxyBeanMethods = false)
+public class MyConnectionPoolTagsProviderConfiguration {
+
+    @Bean
+    public MongoConnectionPoolTagsProvider customConnectionPoolTagsProvider() {
+        return new CustomConnectionPoolTagsProvider();
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+Ҫ�����Զ����õ����ӳض������������������ԡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.metrics.mongo.connectionpool.enabled=false
+
+```
+
+
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.jetty)7.3.20\. Jetty ָ��
+
+
+
+�Զ�����ͨ��ʹ��Micrometer�� `JettyServerThreadPoolMetrics` ΪJetty�� `ThreadPool` ��ָ�ꡣ Jetty�� `Connector` ʵ����ָ��ͨ��ʹ��Micrometer�� `JettyConnectionMetrics` ���󶨣��� `server.ssl.enabled` ������Ϊ `true` ʱ��Micrometer�� `JettySslHandshakeMetrics`��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.timed-annotation)7.3.21\. @Timed ע���֧��
+
+
+
+Ҫ��Spring Boot��ֱ��֧�ֵĵط�ʹ�� `@Timed`����ο� [Micrometer �ĵ�](https://micrometer.io/docs/concepts#_the_timed_annotation)��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.supported.redis)7.3.22\. Redis ָ��
+
+
+
+�Զ�����Ϊ�Զ����õ� `LettuceConnectionFactory` ע����һ�� `MicrometerCommandLatencyRecorder`�� ����ϸ�ڣ������Lettuce�ĵ��� [Micrometer Metrics����](https://lettuce.io/core/6.2.3.RELEASE/reference/index.html#command.latency.metrics.micrometer)��
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.registering-custom)7.4\. ע���Զ���ָ��
+
+
+
+Ҫע���Զ���������뽫 `MeterRegistry` ע���������С�
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Component
+public class MyBean {
+
+    private final Dictionary dictionary;
+
+    public MyBean(MeterRegistry registry) {
+        this.dictionary = Dictionary.load();
+        registry.gauge("dictionary.size", Tags.empty(), this.dictionary.getWords().size());
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+�����Ķ�����׼����������Bean�����ǽ�����ʹ�� `MeterBinder` ��ע�����ǡ�
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+public class MyMeterBinderConfiguration {
+
+    @Bean
+    public MeterBinder queueSize(Queue queue) {
+        return (registry) -> Gauge.builder("queueSize", queue::size).register(registry);
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+ʹ�� `MeterBinder` ����ȷ��������ȷ��������ϵ�������ڼ�������ֵ��ʱ��Bean�ǿ��õġ� ����㷢�����������Ӧ�ó������ظ�����һ��ָ�꣬��ô `MeterBinder` ��ʵ��Ҳ������á�
+
+
+
+
+
+|  | Ĭ������£����� `MeterBinder` Bean��ָ�궼���Զ��󶨵�Spring������ `MeterRegistry`�� |
+| --- | --- |
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.customizing)7.5\. ���Ƹ���ָ��
+
+
+
+�������Ҫ���ض��� `Meter` ʵ�������Զ��壬�����ʹ�� `io.micrometer.core.instrument.config.MeterFilter` �ӿڡ�
+
+
+
+
+
+���磬�������������� `com.example` ��ͷ���DZ�ID�� `mytag.region` ��ǩ������Ϊ `mytag.area`������������¹�����
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Configuration(proxyBeanMethods = false)
+public class MyMetricsFilterConfiguration {
+
+    @Bean
+    public MeterFilter renameRegionTagMeterFilter() {
+        return MeterFilter.renameTag("com.example", "mytag.region", "mytag.area");
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+|  | Ĭ������£����е� `MeterFilter` Bean���Զ��󶨵�Spring������ `MeterRegistry`�� ��ȷ��ʹ��Spring������ `MeterRegistry` ��ע�����ָ�꣬������ʹ�� `Metrics` ���κξ�̬������ ��Щ����ʹ�õ��Dz���Spring������ȫ��ע����� |
+| --- | --- |
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.customizing.common-tags)7.5.1\. ������ǩ��Tag��
+
+
+
+ͨ�ñ�ǩһ�����ڶ����л�������ά�����꣬��������ʵ�������򡢶�ջ�ȡ� ���ñ�ǩ�����������DZ������Խ������ã���������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.metrics.tags.region=us-east-1
+management.metrics.tags.stack=prod
+
+```
+
+
+
+
+
+
+
+ǰ�������Ϊ����ֵΪ `us-east-1` �� `prod` ���DZ������� `region` �� `stack` ��ǩ��
+
+
+
+
+
+|  | �����ʹ��Graphite����ͨ��ǩ��˳���Ǻ���Ҫ�ġ� ����ʹ�����ַ������ܱ�֤������ǩ��˳�򣬽���Graphite�û�����һ���Զ���� `MeterFilter` �����档 |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.customizing.per-meter-properties)7.5.2\. Per-meter Properties
+
+
+
+���� `MeterFilter` Bean���㻹����ʹ��������ÿ�����Ļ�����Ӧ��һ�����޵��Զ��幦�ܡ� ʹ��Spring Boot�� `PropertiesMeterFilter`��ÿ�����Ķ��Ʊ�Ӧ�����Ը������ƿ�ͷ���κα���ID�� ��������ӹ��˵��κ�ID�� `example.remote` ��ͷ���DZ���
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.metrics.enable.example.remote=false
+
+```
+
+
+
+
+
+
+
+�������������per-meter�Ķ��ơ�
+
+
+
+<caption>Table 1\. Per-meter customizations</caption><colgroup><col><col></colgroup>
+| Property | ˵�� |
+| --- | --- |
+| `management.metrics.enable` | �Ƿ���ܾ����ض�ID��Meter�� �����ܵ�Meter���� `MeterRegistry` �й��˵��� |
+| `management.metrics.distribution.percentiles-histogram` | �Ƿ񷢲��ʺϼ���ɾۼ�����ά�ȣ��İٷ�λ������ֵ��ֱ��ͼ�� |
+| `management.metrics.distribution.minimum-expected-value`, `management.metrics.distribution.maximum-expected-value` | ͨ��ǯ��Ԥ��ֵ�ķ�Χ���������ٵ�ֱ��ͼͰ�� |
+| `management.metrics.distribution.percentiles` | ���������Ӧ�ó����м���İٷ�λֵ |
+| `management.metrics.distribution.expiry`, `management.metrics.distribution.buffer-length` | ͨ���ڻ��λ������л�������������������Ǹ����Ȩ�أ����λ������ڿ����õĹ��ں���ת������������Ϊ �����õĻ��������ȡ� |
+| `management.metrics.distribution.slo` | ����һ���ۻ�ֱ��ͼ�����е�Ͱ����ķ���ˮƽĿ�궨�塣 |
+
+
+
+���� `percentiles-histogram` ���ٷ���-ֱ��ͼ����`percentiles`���ٷ������� `slo` ����ĸ���ĸ���ϸ�ڣ���μ�Micrometer�ĵ��е� [��Histograms and percentiles�� ��ֱ��ͼ�Ͱٷ���������](https://micrometer.io/docs/concepts#_histograms_and_percentiles)��
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.endpoint)7.6\. ָ��˵�
+
+
+
+Spring Boot�ṩ��һ�� `metrics` �˵㣬���������Ե�ʹ���������Ӧ�ó����ռ���ָ�ꡣ�ö˵�Ĭ��������Dz����õģ����빫��������ϸ����μ� [��¶�˵�](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints.exposing)��
+
+
+
+
+
+������ `/actuator/metrics` ����ʾһ�����õ��DZ������б��� �����ͨ���ṩ������Ϊѡ����������鿴ij���ض��DZ�����Ϣ�����磬`/actuator/metrics/jvm.memory.max`��
+
+
+
+
+
+|  | ��������ʹ�õ�����Ӧ���������ʹ�õ�����һ�£������������������ļ��ϵͳ�о������������淶��������֡� ���仰˵����� `jvm.memory.max` ��Prometheus����ʾΪ `jvm_memory_max`����Ϊ����������������������ȻӦ��ʹ�� `jvm.memory.max` ��Ϊѡ�������� `metrics` �˵��м���DZ��� |
+| --- | --- |
+
+
+
+
+
+��Ҳ������URL��ĩβ�������������� `tag=KEY:VALUE` ��ѯ�������Զ��DZ�����ά������?��?���磬`/actuator/metrics/jvm.memory.max?tag=area:nonheap`��
+
+
+
+
+
+|  | ����IJ���ֵ���������DZ�������ƥ����DZ����κ���Ӧ�õı�ǩ��ͳ������ _�ܺ�_�� ��ǰ��������У����ص� `Value` ͳ���Ƕѵ� ��Code Cache������Compressed Class Space�� �� ��Metaspace�� ���������ڴ桰�㼣��֮�͡� �������ֻ���� ��Metaspace�� �����ߴ磬���������һ������� `tag=id:Metaspace` --�� `/actuator/metrics/jvm.memory.max?tag=area:nonheap&tag=id:Metaspace`�� |
+| --- | --- |
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.metrics.micrometer-observation)7.7\. ���� Micrometer Observation
+
+
+
+һ�� `DefaultMeterObservationHandler` ���Զ�ע���� `ObservationRegistry` �ϣ���Ϊÿ����ɵĹ۲죨completed observation������������metric����
+
+
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/actuator.html#actuator.micrometer-tracing)8\. ׷�٣�Tracing��
+
+
+
+
+
+Spring Boot Actuator Ϊ Micrometer Tracing �ṩ�������Թ������Զ����ã� [Micrometer Tracing](https://micrometer.io/docs/tracing) �����е�׷������tracer�����һ���ӿڣ�facade����
+
+
+
+
+
+|  | Ҫ�˽������� Micrometer Tracing ���ܵ���Ϣ��������� [�ο��ĵ�](https://micrometer.io/docs/tracing)�� |
+| --- | --- |
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.micrometer-tracing.tracers)8.1\. ֧�ֵ�׷����
+
+
+
+Spring BootΪ����׷�����ṩ���Զ����á�
+
+
+
+
+
+*   ʹ�� [Zipkin](https://zipkin.io/) �� [Wavefront](https://docs.wavefront.com/) �� [OpenTelemetry](https://opentelemetry.io/)
+
+*   ʹ�� [Zipkin](https://zipkin.io/) �� [Wavefront](https://docs.wavefront.com/) �� [OpenZipkin Brave](https://github.com/openzipkin/brave)
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.micrometer-tracing.getting-started)8.2\. ����
+
+
+
+������Ҫһ������������ʼ׷�ٵ�ʾ��Ӧ�ó��򡣾����ǵ�Ŀ�Ķ��ԣ���[getting-started.html](https://springdoc.cn/spring-boot/getting-started.html#getting-started.first-application)�� �������漰�ļ򵥵� ��Hello World!�� web������㹻�ˡ����ǽ�ʹ�� `OpenTelemetry` ׷������ `Zipkin` ��Ϊ׷�ٺ�ˡ�
+
+
+
+
+
+�ع�һ�£����ǵ���ҪӦ�ô��뿴�����������ġ�
+
+
+
+
+
+
+
+```
+@RestController
+@SpringBootApplication
+public class MyApplication {
+
+    private static final Log logger = LogFactory.getLog(MyApplication.class);
+
+    @RequestMapping("/")
+    String home() {
+        logger.info("home() has been called");
+        return "Hello World!";
+    }
+
+    public static void main(String[] args) {
+        SpringApplication.run(MyApplication.class, args);
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+|  | �� `home()` �����У���һ�����ӵ�logger��䣬���ں�������Ҫ�� |
+| --- | --- |
+
+
+
+
+
+���ڣ����DZ����������������
+
+
+
+
+
+*   `org.springframework.boot:spring-boot-starter-actuator`
+
+*   `io.micrometer:micrometer-tracing-bridge-otel` - �������� Micrometer Observation API �� OpenTelemetry �ı�Ҫ������
+
+*   `io.opentelemetry:opentelemetry-exporter-zipkin` - ������Zipkin���� [traces](https://micrometer.io/docs/tracing#_glossary) ����Ҫ�ġ�
+
+
+
+
+
+�������µ� application properties:
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.tracing.sampling.probability=1.0
+
+```
+
+
+
+
+
+
+
+Ĭ������£�Spring Bootֻ��10%��������в������Է�ֹ׷�ٺ�˲����ظ��������Խ����л�Ϊ100%������ÿ�����󶼻ᱻ���͵����ٺ�ˡ�
+
+
+
+
+
+Ϊ���ռ��Ϳ��ӻ����٣�������Ҫһ�����и��ٵĺ�ˡ�����������ʹ��Zipkin��Ϊ���ǵĸ��ٺ�ˡ� [Zipkin��������ָ��](https://zipkin.io/pages/quickstart) �ṩ������ڱ�������Zipkin��˵����
+
+
+
+
+
+Zipkin���к�������������Ӧ�ó���
+
+
+
+
+
+������web��������� `[localhost:8080](http://localhost:8080/)`����Ӧ�ÿ������������
+
+
+
+
+
+
+
+ Hello World! 
+
+
+
+
+
+
+
+��Ļ���Ѿ�ΪHTTP���󴴽���һ�� observation�������������Žӵ� `OpenTelemetry`��������Zipkin����һ���µĸ��٣�trace����
+
+
+
+
+
+���ڣ��� `[localhost:9411](http://localhost:9411/)` ��Zipkin�û����棬��� "Run Query" ��ť���г������ռ����ĸ�����Ϣ����Ӧ�ÿ���һ��׷�١���� "Show" ��ť���鿴��׷�ٵ�ϸ�ڡ�
+
+
+
+
+
+|  | �����ͨ���� `logging.pattern.level` ��������Ϊ `%5p [${spring.application.name:},%X{traceId:-},%X{spanId:-}]`������־�а�����ǰ�ĸ��٣�trace���� span id�� |
+| --- | --- |
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.micrometer-tracing.tracer-implementations)8.3\. ��������Tracer����ʵ��
+
+
+
+����Micrometer Tracer֧�ֶ���ʾ������ʵ�֣����Spring Boot�����ж���������ϡ�
+
+
+
+
+
+����׷������ʵ�ֶ���Ҫ `org.springframework.boot:spring-boot-starter-actuator` ������
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.micrometer-tracing.tracer-implementations.otel-zipkin)8.3.1\. ʹ�� Zipkin �� OpenTelemetry
+
+
+
+*   `io.micrometer:micrometer-tracing-bridge-otel` - �������� Micrometer Observation API �� OpenTelemetry �ı�Ҫ������
+
+*   `io.opentelemetry:opentelemetry-exporter-zipkin` - ������Zipkin����trace����Ҫ�ġ�
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.micrometer-tracing.tracer-implementations.otel-wavefront)8.3.2\. ʹ�� Wavefront �� OpenTelemetry
+
+
+
+*   `io.micrometer:micrometer-tracing-bridge-otel` - �������� Micrometer Observation API �� OpenTelemetry �ı�Ҫ������
+
+*   `io.micrometer:micrometer-tracing-reporter-wavefront` - ������Wavefront����trace����Ҫ�ġ�
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.micrometer-tracing.tracer-implementations.brave-zipkin)8.3.3\. ʹ�� Zipkin �� OpenZipkin Brave
+
+
+
+*   `io.micrometer:micrometer-tracing-bridge-brave` - �������� Micrometer Observation API �� Brave �ı�Ҫ������
+
+*   `io.zipkin.reporter2:zipkin-reporter-brave` - ������Zipkin���� trace ����Ҫ�ġ�
+
+
+
+
+
+|  | ��������Ŀû��ʹ��Spring MVC��Spring WebFlux��Ҳ��Ҫʹ�� `io.zipkin.reporter2:zipkin-sender-urlconnection` ����� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/actuator.html#actuator.micrometer-tracing.tracer-implementations.brave-wavefront)8.3.4\. ʹ��Wavefront��OpenZipkin Brave
+
+
+
+*   `io.micrometer:micrometer-tracing-bridge-brave` - �������Ӳ�Micrometer Observation API��Brave�ı�Ҫ������
+
+*   `io.micrometer:micrometer-tracing-reporter-wavefront` - ������Wavefront����trace����Ҫ�ġ�
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.micrometer-tracing.creating-spans)8.4\. �����Զ����ȣ�span��
+
+
+
+�����ͨ������һ�� observation ���������Լ���span��Ϊ�ˣ��� `ObservationRegistry` ע�뵽�������С�
+
+
+
+
+
+
+
+```
+@Component
+class CustomObservation {
+
+    private final ObservationRegistry observationRegistry;
+
+    CustomObservation(ObservationRegistry observationRegistry) {
+        this.observationRegistry = observationRegistry;
+    }
+
+    void someOperation() {
+        Observation observation = Observation.createNotStarted("some-operation", this.observationRegistry);
+        observation.lowCardinalityKeyValue("some-tag", "some-value");
+        observation.observe(() -> {
+            // Business logic ...
+        });
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+�⽫����һ����Ϊ "some-operation" �� observation����ǩΪ����ǩΪ "some-tag=some-value"��
+
+
+
+
+
+|  | ��������ڲ�����metric������´���һ��span������Ҫʹ�� Micrometer �� [�ͼ�Tracer API](https://micrometer.io/docs/tracing#_using_micrometer_tracing_directly)�� |
+| --- | --- |
+
+
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/actuator.html#actuator.auditing)9\. ���
+
+
+
+
+
+һ��Spring Security�������ã�Spring Boot Actuator����һ��������ƿ�ܣ����Է����¼���Ĭ��Ϊ ��authentication success��, ��failure�� �� ��access denied�� ���쳣���� ��һ���ܶ��ڱ����ʵʩ������֤ʧ�ܵ��������Էdz����á�
+
+
+
+
+
+�����ͨ����Ӧ�ó�����������ṩһ�� `AuditEventRepository` ���͵�bean��������ơ� Ϊ�˷��㣬Spring Boot�ṩ��һ�� `InMemoryAuditEventRepository`�� `InMemoryAuditEventRepository` �Ĺ������ޣ����ǽ���ֻ�ڿ���������ʹ������ ���������������뿼�Ǵ������Լ������ `AuditEventRepository` ʵ�֡�
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.auditing.custom)9.1\. �������
+
+
+
+Ϊ�˶��Ʒ����İ�ȫ�¼���������ṩ���Լ��� `AbstractAuthenticationAuditListener` �� `AbstractAuthorizationAuditListener` ��ʵ�֡�
+
+
+
+
+
+��Ҳ����Ϊ���Լ���ҵ���¼�ʹ����Ʒ��� Ҫ������һ�㣬Ҫô�� `AuditEventRepository` beanע�����Լ��������ֱ��ʹ������Ҫô��Spring�� `ApplicationEventPublisher` ���� `AuditApplicationEvent`��ͨ��ʵ�� `ApplicationEventPublisherAware`����
+
+
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/actuator.html#actuator.http-exchanges)10\. ��¼ HTTP Exchange
+
+
+
+
+
+�����ͨ����Ӧ�ó�����������ṩһ�� `HttpExchangeRepository` ���͵� bean ������ HTTP exchange �ļ�¼��Ϊ�˷��������Spring Boot �ṩ�� `InMemoryHttpExchangeRepository`��Ĭ������£����洢�����100�� request/response exchange����׷�ٽ��������tracing solutions����ȣ�`InMemoryHttpExchangeRepository` �����޵ģ����ǽ���ֻ�ڿ���������ʹ�����������������������ǽ���ʹ��һ�����������ĸ��ٻ�۲����������� `Zipkin` �� `OpenTelemetry`�����⣬��Ҳ���Դ������Լ��� `HttpExchangeRepository`��
+
+
+
+
+
+�����ʹ�� `httpexchanges` �˵�����ȡ�洢�� `HttpExchangeRepository` �е� request/response exchange ����Ϣ��
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.http-exchanges.custom)10.1\. �Զ��� HTTP Exchange ��¼
+
+
+
+Ҫ�Զ��������ÿ����¼�� exchange ��Ŀ����ʹ�� `management.httpexchanges.recording.include` �������ԡ�
+
+
+
+
+
+Ҫ��ȫ��ֹ���±��룬�뽫 `management.httpexchanges.recording.enabled` ����Ϊ `false`��
+
+
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/actuator.html#actuator.process-monitoring)11\. ���̼��
+
+
+
+
+
+�� `spring-boot` ģ���У�������ҵ����������ļ����࣬��Щ�ļ��ڽ��̼����ͨ�������á�
+
+
+
+
+
+*   `ApplicationPidFileWriter` ����һ������Ӧ�ó���PID���ļ���Ĭ������£���Ӧ�ó���Ŀ¼�£��ļ���Ϊ `application.pid`����
+
+*   `WebServerPortFileWriter` ����һ�����������ļ������������е�Web�������Ķ˿ڣ�Ĭ������£���Ӧ�ó���Ŀ¼�£��ļ���Ϊ `application.port`����
+
+
+
+
+
+Ĭ������£���Щд��û�б������������������ǡ�
+
+
+
+
+
+*   [ͨ����չ����](https://springdoc.cn/spring-boot/actuator.html#actuator.process-monitoring.configuration)
+
+*   [�Ա�̷�ʽʵ�ֽ��̼��](https://springdoc.cn/spring-boot/actuator.html#actuator.process-monitoring.programmatically)
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.process-monitoring.configuration)11.1\. ��չ����
+
+
+
+�� `META-INF/spring.factories` �ļ��У�����Լ���д��PID�ļ���listener��һ�����߶������
+
+
+
+
+
+
+
+ org.springframework.context.ApplicationListener=\
+org.springframework.boot.context.ApplicationPidFileWriter,\
+org.springframework.boot.web.context.WebServerPortFileWriter 
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.process-monitoring.programmatically)11.2\. �Ա�̷�ʽʵ�ֽ��̼��
+
+
+
+��Ҳ����ͨ������ `SpringApplication.addListeners(��?)` �����������ʵ��� `Writer` ����������һ���������� ������������������� `Writer` ���캯�����Զ����ļ�����·����
+
+
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/actuator.html#actuator.cloud-foundry)12\. Cloud Foundry ��֧��
+
+
+
+
+
+Spring Boot ��actuatorģ����������֧�֣��������𵽼��ݵ� Cloud Foundry ʵ��ʱ����֧�ֽ������ `/cloudfoundryapplication` ·��Ϊ���� `@Endpoint` Bean�ṩ����һ����ȫ·�ߡ�
+
+
+
+
+
+��չ֧��ʹ Cloud Foundry ���� UI�����������������鿴�Ѳ����Ӧ�ó���� Web Ӧ�ó��򣩵õ� Spring Boot ִ������Ϣ����ǿ�� ���磬Ӧ�ó���״̬ҳ����԰��������Ľ�����Ϣ�������ǵ��͵� ��running�� �� ��stopped�� ״̬��
+
+
+
+
+
+|  | ��ͨ�û��޷�ֱ�ӷ��� `/cloudfoundryapplication` ·���� Ҫʹ�øö˵㣬�������������д���һ����Ч�� UAA ���ơ� |
+| --- | --- |
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.cloud-foundry.disable)12.1\. ������չ�� Cloud Foundry Actuator ֧��
+
+
+
+���������ȫ���� `/cloudfoundryapplication` �˵㣬������������ `application.properties` �ļ��������������á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.cloudfoundry.enabled=false
+
+```
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.cloud-foundry.ssl)12.2\. Cloud Foundry��ǩ��֤��
+
+
+
+Ĭ������£�`/cloudfoundryapplication` �˵�İ�ȫ��֤��Ը��� Cloud Foundry ������� SSL ���á� ������� Cloud Foundry UAA �� Cloud Controller ����ʹ����ǩ��֤�飬����Ҫ�����������ԡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+management.cloudfoundry.skip-ssl-validation=true
+
+```
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/actuator.html#actuator.cloud-foundry.custom-context-path)12.3\. �Զ��� Context Path
+
+
+
+����������� context-path ������Ϊ `/` ������κ����ݣ��� Cloud Foundry �˵���Ӧ�ó���ĸ��������á� ���磬��� `server.servlet.context-path=/app`���� Cloud Foundry �˵��� `/app/cloudfoundryapplication/*` �����á�
+
+
+
+
+
+�����ϣ�� Cloud Foundry �˵�ʼ���� `/cloudfoundryapplication/*` �����ã����۷�������������·����Σ�����Ҫ������Ӧ�ó�������ȷ���á� ��������ʹ�õ� Web ��������ͬ����ͬ�� ���� Tomcat�������������������á�
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Configuration(proxyBeanMethods = false)
+public class MyCloudFoundryConfiguration {
+
+    @Bean
+    public TomcatServletWebServerFactory servletWebServerFactory() {
+        return new TomcatServletWebServerFactory() {
+
+            @Override
+            protected void prepareContext(Host host, ServletContextInitializer[] initializers) {
+                super.prepareContext(host, initializers);
+                StandardContext child = new StandardContext();
+                child.addLifecycleListener(new Tomcat.FixContextListener());
+                child.setPath("/cloudfoundryapplication");
+                ServletContainerInitializer initializer = getServletContextInitializer(getContextPath());
+                child.addServletContainerInitializer(initializer, Collections.emptySet());
+                child.setCrossContext(true);
+                host.addChild(child);
+            }
+
+        };
+    }
+
+    private ServletContainerInitializer getServletContextInitializer(String contextPath) {
+        return (classes, context) -> {
+            Servlet servlet = new GenericServlet() {
+
+                @Override
+                public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
+                    ServletContext context = req.getServletContext().getContext(contextPath);
+                    context.getRequestDispatcher("/cloudfoundryapplication").forward(req, res);
+                }
+
+            };
+            context.addServlet("cloudfoundry", servlet).addMapping("/*");
+        };
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/actuator.html#actuator.whats-next)13\. ��������ʲô
+
+
+
+
+
+��������һ�� [Graphite](https://graphiteapp.org/) ��ͼ�ι��ߡ�
+
+
+
+
+
+��������Լ����Ķ� [������ѡ�](https://springdoc.cn/spring-boot/deployment.html#deployment) ����������ǰ��ȥ�˽��й�Spring Boot [�������߲�](https://springdoc.cn/spring-boot/build-tool-plugins.html#build-tool-plugins)����һЩ������Ϣ��
+
+
+
+
+
+
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\232\204Starter\346\234\272\345\210\266.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\232\204Starter\346\234\272\345\210\266.md"
new file mode 100644
index 0000000..0318193
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\232\204Starter\346\234\272\345\210\266.md"
@@ -0,0 +1,262 @@
+starter��SpringBoot�е�һ���·���������Ч�Ľ�������Ŀ�������̵ĸ��ӳ̶ȣ����ڼ򻯿����������ŷdz��õ�Ч��������ת����һƬ���£���ϸ������spring boot stater��ʲô������������ʲô��
+
+Spring Boot Starter����SpringBoot����б��������һ�ָ��stackoverflow�����Ѿ����˸��������starter��ʲô�������뿴�����Ļش��[����](https://stackoverflow.com/a/28273660)��https://stackoverflow.com/questions/28273543/what-are-spring-boot-starter-jars/28273660#28273660��
+
+![](https://images2018.cnblogs.com/blog/697611/201804/697611-20180409110042391-1447358002.png)
+
+�����˼����˵starter��һ�ֶ�������synthesize���ϳɣ�������ʲô��˼�أ��ҿ��Ծٸ�������˵����
+
+### �� ? ��ͳ������
+
+��û��starter֮ǰ����������Ҫ��Spring��ʹ��jpa�����ҿ�����Ҫ�����²�����
+
+1.  ��Maven������ʹ�õ����ݿ����������JDBC��jar��
+2.  ����jpa������
+3.  ��xxx.xml������һЩ������Ϣ
+4.  �����ĵ���ֱ��������������
+
+��Ҫע����ǣ��������������**_ÿ���½�һ����Ҫ�õ�jpa����Ŀ��ʱ����Ҫ�ظ�����һ��_**��Ҳ�����ڵ�һ���Լ�������Ŀ��ʱ������Google���Լ�������һ�������˰���ʱ�������˸�����ֵ�����֮��jpa���������������ˡ���Щ�о�����˻���OneNote�������ν�����Ŀ�Ĺ��̸���¼���������������IJ����Լ���Ҫ�õ��������ļ������ݣ�����һ���ٴ���jpa��Ŀ��ʱ�򣬾Ͳ���Ҫ�ٴ�ȥGoogle�ˣ�ֻ��Ҫ���űʼ�����֮���ٰ����е������ļ�copy&paste�Ϳ����ˡ�
+
+�����������IJ���Ҳ���㲻�У���ʵ��������û��starter֮ǰ������ô�ɵģ������������м������⣺
+
+1.  ������̱ȽϷ���������һ�������������ӳ����Ŀ�����
+2.  ��ͣ��copy&paste������[Don��t repeat yourself](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)����
+3.  �ڵ�һ�����õ�ʱ��������������߱Ƚ�С�ף�����Ҫ���ѵ�������ʱ��
+
+### ����ʹ��Spring Boot Starter����Ч��
+
+starter����ҪĿ�ľ���Ϊ�˽���������Щ���⡣
+
+starter�����starter��������õ��������������������������˿������Լ�ȥ�����������������鷳����Ҫע����Dz�ͬ��starter��Ϊ�˽����ͬ�����������������ڲ���ʵ�ֿ��ܻ��кܴ�IJ��죬����jpa��starter��Redis��starter����ʵ�־Ͳ�һ����������Ϊstarter�ı�������synthesize������һ�����߼�����ij���Ҳ�����������е�������Docker����Ϊ���Ƕ�������һ������װ���IJ����������֪��Docker��Ϊ�˽��ʲô����ģ�Ҳ���������Docker��starter��һ����ȡ�
+
+starter��ʵ�֣���Ȼ��ͬ��starterʵ���������в��죬�������ǻ����϶���ʹ�õ�������ͬ�����ݣ�ConfigurationProperties��AutoConfiguration����ΪSpring Boot���š�Լ���������á���һ�����������ʹ��ConfigurationProperties���������ǵ����ã�������Щ���ö�������һ��Ĭ��ֵ����������û��������дԭʼ���õ�����£�Ĭ��ֵ�ͻ���Ч�����ںܶ�������Ƿdz����õġ�����֮�⣬starter��ConfigurationProperties��ʹ�����е��������Ա��ۼ���һ���ļ��У�һ����resourcesĿ¼�µ�application.properties�����������Ǿ͸����Spring��Ŀ��XML������
+
+starter�������߼���
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/697611-20180409110236645-2097376440.png)
+
+�����starter������jar�������Լ��ֶ����õ�ʱ��������jar��û��ʲô��ͬ���������ǿ�����Ϊstarter��ʵ�ǰ���һЩ���������ò����������Լ������Ѽ򵥽������û������˰����û�ȥ���˷����Ĺ����������ڡ�Լ���������á��������£�ConfigurationProperties�������û���������ν�����ò�����������Ϊ?`application.properties`?�ļ��Ĵ��ڣ���ʹ��Ҫ�Զ������ã����е�����Ҳֻ��Ҫ��һ���ļ��н��У�ʹ�������dz����㡣
+
+�˽���starter��ʵ���ǰ����û��������õIJ���֮��Ҫ����starter�ͱ�������starter�����֮�䲢���Ǿ�����ϵ�����Ǹ�����ϵ�������ǿ��Ը�һ���������һ��starter���������û���ʹ����������ʱ����ӵļ򵥷��㡣��������������ǿ��Ը�����һ�����е��������һ��starter���ñ�����ʹ����������ʱ����ӵļ򵥷��㣬��ʵ��Spring Boot�Ŷ��Ѿ��������д󲿷ֵ����е���������������ǵ�starter���������[����](https://github.com/spring-projects/spring-boot/tree/v1.5.7.RELEASE/spring-boot-starters)�鿴��Щstarter���б���
+
+����springboot ��ô���˾�Ȼ����û�Զ����starter�����붼�������������Խ�������һ�¡�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416200541.png)
+
+# SpringBoot starter
+
+SpringBoot�е�starter��һ�ַdz���Ҫ�Ļ��ƣ��ܹ�������ǰ���ӵ����ã�����ͳһ���ɽ�starter��Ӧ����ֻ��Ҫ��maven������starter������SpringBoot�����Զ�ɨ�赽Ҫ���ص���Ϣ��������Ӧ��Ĭ�����á�starter�����ǰ����˸���������Ĵ�������Ҫ���ø�����Ϣ�����š�SpringBoot���Զ�ͨ��classpath·���µ��෢����Ҫ��Bean����ע���IOC������SpringBoot�ṩ������ճ���ҵӦ���з����ֳ�����spring-boot-starter����ģ�顣������Щ����ģ�鶼��ѭ��Լ�����׵�Ĭ�����ã����������ǵ�����Щ���ã�����ѭ��Լ���������á������
+
+# �Զ���starter
+
+�ճ���������ʱ��һЩ������ҵ��֮��Ĺ��ܻ�ģ�飬���������Ŀ���ã���һ����ĿҲҪ�ã����ÿ�ζ����¼��ɵĻ��ͻ���鷳����ʱ����ֻҪ����Щ���ܻ�ģ���װ��һ����starter�Ļ�����ʹ�õ�ʱ�������ȥ�ͺܷ����ˡ�
+
+## �Զ���starter����
+
+��ʵ�Զ���starter�ܼ򵥣�������Ҫ����5����
+
+1.  �½�����ģ�飬�����淶�� springboot�Դ���starter�����淶Ϊspring-boot-starter-xxx�� �Զ����starter�����淶Ϊxxx-spring-boot-starter
+
+�� xxx-spring-boot-autoconfigure���Զ����ú��Ĵ���
+�� xxx-spring-boot-starter����������
+�������Ҫ���Զ����ô����������������뿪��������Խ�������ϵ�һ��ģ���С�ֻ����springboot�ٷ����齫����ģ��ֿ���
+2\. ����spring-boot-autoconfigure����
+3\. �����Զ����XXXProperties ��: ���������Ը�����Ҫ��Ҫ�����������ļ��еġ�
+4\. �����Զ����XXXAutoConfiguration�ࣺ�����Ҫ�����Զ�����ʱ��һЩ�߼���ͬʱҲҪ��XXXProperties ����Ч��
+5\. �����Զ����spring.factories�ļ�����resources/META-INF����һ��spring.factories�ļ���spring-configuration-metadata.json��spring-configuration-metadata.json�ļ�����������д�����ļ�ʱ��������ʾ����Ҫ�ɲ�Ҫ���еĻ���ʾ�������Ѻá�spring.factories���ڵ����Զ������࣬����Ҫ��
+
+## ʵ��
+
+������Ϊ�˷����ֻ����һ��ģ���ˣ�
+
+1.  ����һ��ģ�飬����Ϊspring-boot-starter-my-starter����Ӧpom�ļ�
+
+```
+	<groupId>com.example</groupId>
+	spring-boot-starter-my-starter
+	<version>1.0</version>
+	<name>my-starter</name>
+���ƴ���
+```
+
+1.  ����spring-boot-autoconfigure���� ������ʹ�õ�spring-boot-autoconfigure�汾��2.6.2
+
+```
+<dependencies>
+    <dependency>
+        <groupId>org.springframework.boot</groupId>
+        spring-boot-autoconfigure
+        <version>2.6.2</version>
+    </dependency>
+</dependencies>
+���ƴ���
+```
+
+1.  �����Զ����XXXProperties ��
+
+```
+@ConfigurationProperties(prefix = "com.arron")
+public class MyStarterProperties {
+
+    private String name;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}
+���ƴ���
+```
+
+�ٴ���һ��MyStarterConfig���ڶ�ȡMyStarterProperties �������
+
+```
+public class MyStarterConfig {
+
+    private MyStarterProperties myStarterProperties;
+
+    private String name;
+
+    public MyStarterConfig(MyStarterProperties myStarterProperties) {
+        this.myStarterProperties = myStarterProperties;
+    }
+
+    public String getName() {
+        return myStarterProperties.getName();
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}
+���ƴ���
+```
+
+1.  �����Զ����XXXAutoConfiguration��
+
+```
+@Configuration
+// EnableConfigurationProperties value�����������������
+@EnableConfigurationProperties(value = {MyStarterProperties.class})
+public class MyStarterAutoConfiguration {
+
+    @Autowired
+    private MyStarterProperties myStarterProperties;
+
+    @Bean
+    @ConditionalOnMissingBean(MyStarterConfig.class)
+    public MyStarterConfig myStarterConfig(){
+        return new MyStarterConfig(myStarterProperties);
+    }
+
+}
+���ƴ���
+```
+
+1.  ��resources/META-INF����һ��spring.factories�ļ�
+
+spring.factories
+
+```
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.example.myStarter.MyStarterAutoConfiguration
+���ƴ���
+```
+
+spring-configuration-metadata.json
+
+```
+{
+  "group": [
+    {
+      "name": "com.arron",
+      "type": "com.example.myStarter.MyStarterProperties",
+      "sourceType": "com.example.myStarter.MyStarterProperties"
+    }
+  ],
+  "properties": [
+    {
+      "name": "com.arron.name",
+      "type": "java.lang.String",
+      "description": "my start name",
+      "sourceType": "com.example.myStarter.MyStarterProperties",
+      "defaultValue": "MyStarterProperties name"
+    }
+  ]
+}
+���ƴ���
+```
+
+## �������
+
+�ҵ���ͼmaven�����install����װ������ ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230416200527082.png)
+
+Ȼ���½�һ����Ŀ�������в��ԣ�������Ŀ���̾Ͳ������ˡ�
+
+1.  ��������
+
+```
+	<dependency>
+       <groupId>com.example</groupId>
+       spring-boot-starter-my-starter
+       <version>1.0</version>
+   </dependency>
+���ƴ���
+```
+
+1.  �����ļ��������ԣ�
+
+```
+com:
+  arron:
+    name: myname
+���ƴ���
+```
+
+1.  ��Ԫ���ԣ�
+
+```
+@RunWith(SpringRunner.class)
+@SpringBootTest
+class RabbitmqApplicationTests {
+    @Autowired
+    private MyStarterConfig myStarterConfig;
+
+    @Test
+    public void testMyStarter(){
+        String name = myStarterConfig.getName();
+        System.out.println(name);
+    }
+}
+���ƴ���
+```
+
+����̨�����
+
+```
+myname
+���ƴ���
+```
+
+���ˣ�һ�����Զ����springboot starter������ˡ�
+
+# ע�����
+
+������Щע�����Զ���starter�ǿ��ܻ��õ���
+
+*   @Conditional������һ�������������жϣ���������������ע��bean
+*   @ConditionalOnMissingBean����������bean������ʱ,��ʵ������ǰBean
+*   @ConditionalOnProperty�������ļ������㶨��������򴴽�bean�����򲻴���
+*   @ConditionalOnBean����������bean����ʱ,��ʵ������ǰBean
+*   @ConditionalOnClass�� ����������������·���ϴ��ڣ���ʵ������ǰBean
+*   @ConditionalOnMissingClass ������������������·���ϲ����ڣ���ʵ������ǰBean
+
+
+
+���ߣ�������
+���ӣ�https://juejin.cn/post/7127468724046528525
+��Դ��ϡ�����
+����Ȩ���������С���ҵת������ϵ���߻����Ȩ������ҵת����ע��������
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\232\204\345\211\215\344\270\226\344\273\212\347\224\237.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\232\204\345\211\215\344\270\226\344\273\212\347\224\237.md"
new file mode 100644
index 0000000..c524bd5
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\232\204\345\211\215\344\270\226\344\273\212\347\224\237.md"
@@ -0,0 +1,246 @@
+# SpringBoot��ǰ������
+
+Spring Boot 2.0 ���Ƴ��ּ�����һ��ѧϰ Spring Boot �ȣ��͵����Ҹ��˵IJ��͵ķ�����������ӾͿ��Ը��ܵ���Ҷ�ѧϰ Spring Boot �����飬��ô����ô����������ѧϰ Spring Boot ֮ʱ�����Լ�Ҳ��˼���� Spring Boot �����ı�����ʲô��Spring ��ҵ���ǻ���ʲô���Ŀ��Ǵ��� Spring Boot? ��ͳ��ҵʹ�� Spring Boot ������Ǵ���ʲô�����?
+
+������Щ���⣬����һ�����˽��� Spring Boot ������ʲô?
+
+## Spring ��ʷ
+
+˵�� Spring Boot ���Dz��ò����˽�һ�� Spring �����ҵ��������Ϊ Spring Boot ��Դ�� Spirng ����壬���� Spring Boot �ĵ����� Sping ��ܵķ�չϢϢ��ء�
+
+ʱ��ص�2002�꣬��ʱ���� Java EE �� EJB ���������ʱ�򣬺ܶ�֪����˾���Dz��ô˼�������������Ŀ��������ʱ����һ��������С������Ϊ EJB ̫��ӷ�ף����������е���Ŀ����Ҫʹ�� EJB ���ִ��Ϳ�ܣ�Ӧ�û���һ�ָ��õķ��������������⡣
+
+Ϊ��֤�������뷨����ȷ�ģ���2002��10������д��һ���顶 Expert One-on-One J2EE ���������˵�ʱ Java ��ҵӦ�ó��򿪷����������ָ���� Java EE �� EJB �������д��ڵ�һЩ��Ҫȱ�ݡ����Ȿ���У��������һ��������ͨ Java �������ע��ĸ��򵥵Ľ��������
+
+�����У���չʾ������ڲ�ʹ�� EJB ������¹���������������չ��������λԤ��ϵͳ��Ϊ�˹���Ӧ�ó�������д�˳��� 30,000 �еĻ����ṹ���룬��Ŀ�еĸ�������Ϊ com.interface21������������������׿�Դ���Ϊ interface21��Ҳ���� Spring ��ǰ����
+
+����˭�أ������Ǵ��������� Rod Johnson ����ͼ��, Rod Johnson ��Ϥ���ѧ��������˼����ѧλ��ͬʱ�����������ѧλ�������˳Ծ������ڻص�������������֮ǰ���������������ѧ�IJ�ʿѧλ������ Rod Johnson �Ѿ��뿪�� Spring ����Ϊ��һ����ʹͶ���ˣ�ͬʱҲ�Ƕ����˾�Ķ��£��������������۷塣
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/springboot-hot.png)
+
+���Ȿ�鷢����һ��һ�� J2EE ��ƺͿ���һ�ڶ��졣�Ȿ������ṩ�Ĵ󲿷ֻ����ܹ����붼�Ǹ߶ȿ����õġ� 2003 �� Rod Johnson ��ͬ���ڴ˿�ܵĻ����Ͽ�����һ��ȫ�µĿ������Ϊ Spring ,�� Rod Johnson ���� Spring �Ǵ�ͳ J2EE �µĿ�ʼ����� Spring ��չ����쳵����
+
+*   2004 �� 03 �£�1.0 �淢����
+*   2006 �� 10 �£�2.0 �淢����
+*   2007 �� 11 �¸���Ϊ SpringSource��ͬʱ������ Spring 2.5��
+*   2009 �� 12 �£�Spring 3.0 ������
+*   2013 �� 12 �£�Pivotal �������� Spring ��� 4.0��
+*   2017 �� 09 �£�Spring 5.0 ������
+
+## Spring Boot �ĵ���
+
+����ʹ�� Spring ���п����ĸ��˺���ҵԽ��Խ�࣬Spring Ҳ������һ����һ����С��ܱ��һ�����ȫ�Ŀ�Դ������Spring �ı߽粻�ϵĽ������䣬���˺��� Spring �����������κ������ˣ������������Ŀ�Դ�������м������ Spring ��Ӧ���֧�֣����������� Spring �����ֱ���֮��Ҳ������һЩ���⡣
+
+Spring ÿ����һ����Դ����������Ҫ����һЩ�������ã��������������ǿ�������ĿԽ��Խ�Ӵ�������Ҫ���ɺܶ࿪Դ��������˺���ʹ�� Spirng ����������Ŀ��Ҫ����ܶ������ļ���̫������÷dz��������⣬���������ó��������˺������������� Spring Ϊ���õ�����
+
+Spring �ƺ�Ҳ��ʶ������Щ���⣬��������ôһ���������Խ����Щ���⣬���ʱ��΢����ĸ���Ҳ�������𣬿��ٿ���΢С������Ӧ�ñ�ø�Ϊ���ȣ�Spring �պô�����ôһ��������ϣ��� 2013 �����ʼ�� Spring Boot ��Ŀ���з���2014��4�£�Spring Boot 1.0.0 ������
+
+Spring Boot ����֮�������ܵ���Դ�����ij�����ע��½����һЩ���˺���ҵ������ʹ���� Spring Boot����Ѹ��ϲ��������Դ������ֱ��2016�꣬�ڹ��� Spring Boot �ű�����ʹ�����������ڼ�ܶ��о� Spring Boot �Ŀ�����������д�˴������� Spring Boot �����£�ͬʱ��һЩ��˾����ҵ�ڲ�������С��ģ��ʹ�ã�����ʹ�þ�������˳�������2016�굽2018�꣬ʹ�� Spring Boot ����ҵ�͸��˿�����Խ��Խ�࣬���Ǵ� Spring Boot �ؼ��ֵİٶ�ָ���Ϳ��Կ�����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/springboot-hot.png)
+
+��ͼΪ2014�굽2018�� Spring Boot �İٶ�ָ�������Կ��� Spring Boot 2.0 ���Ƴ������������߷塣
+
+��Ȼ Spring Boot ����Ϊ��ȡ�� Spring ,Spring Boot ���� Spring ��������Ϊ�������Ǹ����׵�ʹ�� Spring������ Spring Boot ���г���Ӧ��Spring �ٷ�Ҳ�dz����� Spring Boot �ĺ�����չ���Ѿ��� Spring Boot ��Ϊ��˾�������Ŀ���ƹ㣬�ŵ��˹����ϵ�һ��λ�ã���˺��� Spring Boot �ij�����չҲ�����á�
+
+# ��������
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230415111020.png)
+
+����spring��������springboot�Ļ�������
+
+Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can "just run".
+
+We take an opinionated view of the Spring platform and third-party libraries so you can get started with minimum fuss. Most Spring Boot applications need minimal Spring configuration.
+
+�����֮�������ڸ������ǣ�springboot���԰������ǿ��ٹ������������������Ӧ��
+
+��ֻ��Ҫһ������@SpringBootApplication ע���Ӧ����ڣ����ɱ�ʶ��Ϊһ��springbootӦ��
+
+���ң�springboot�̳��˴����ĵ������⣬���ǽ��������������ȫ����Ҫ��������ã��Ϳ��Խ���Ӧ�ô����Ϊspringboot��ܱ����Ѿ����������ú��˴�����Ĭ�����á�
+
+# ��������
+
+Features
+
+*   Create stand-alone Spring applications
+*   Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)
+*   Provide opinionated 'starter' dependencies to simplify your build configuration
+*   Automatically configure Spring and 3rd party libraries whenever possible
+*   Provide production-ready features such as metrics, health checks, and externalized configuration
+*   Absolutely no code generation and no requirement for XML configuration
+
+�ٷ�����springboot�������Ե���������
+
+1������һ�����������springӦ�ã��������ڶ���΢���񣬻�����һ��webӦ��
+
+2�����õ�tomcat������������Ҳ��Ҫ��springӦ�ô����war��������ֻ��Ҫ��������jar�����в��𼴿ɡ�
+
+3���ṩstarter���������Ӽ���springboot��̬�е����������ã����統����ʹ��springweb�������ʱ�����Dz���Ҫ���������Ӷ��springmvc��ص�maven����������ֱ������spring-boot-starter-web�Ϳ����ˣ����starter���Զ�������ص����������Ұ�������汾�ţ�������ؼ򻯺��Ż����maven����
+
+4���Զ�װ��spring�͵������⣬������Ҫ��ָͨ��ע��������ļ������Զ�װ�䣬���һ���һЩ�ǻ���Լ�����Զ�װ����ƣ�����԰����ǽ�ʡ�����Ķ������ã�Ҳ�����Զ�װ���ⲿjar���ṩ��spring���bean�����á�
+
+5���ṩ������������ص����ԣ������ء�ָ���㡢�������ȹ��ܣ�springboot�ṩ��ǿ�����̬��������ﲻ������springboot�Լ��������Ҳ����һЩ�ⲿ����̬�����
+
+6���������ڴ������ɣ�Ҳ����Ҫxml�����ļ�����֤����springboot�Ŀ�������ȣ��Լ��������ü򻯵ļ���׷�����ǽ���Ҫapplication.properties���л������ò�����������Ҳ������springboot�������ҵ���̬���ɵĶ���class�ļ���
+
+# ��Spring�Ĺ�ϵ
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230415111139.png)
+
+## SpringFramework�����ʲô���⣿
+
+Spring��Java��ҵ�棨Java Enterprise Edition��JEE��Ҳ��J2EE��������������Ʒ�����迪����������EnterpriseJavaBean��EJB����SpringΪ��ҵ��Java�����ṩ��һ����Լ򵥵ķ�����ͨ������ע������������̣��ü򵥵�Java����Plain Old Java Object��POJO��ʵ����EJB�Ĺ��ܡ�
+
+1.ʹ��Spring��IOC����,������֮���������ϵ����Spring,�������֮��������,�����Ǹ�רע��Ӧ���߼�
+
+2.�����ṩ�ڶ����,�������,WS�ȡ�
+
+3.�ܺõ�֧��AOP,�������������̡�
+
+4.�������Ŀ���ṩ�˺ܺõļ���֧��,��Hibernate,Struts2,JPA��
+
+5.Spring DI���ƽ�����ҵ������滻�ĸ����ԡ�
+
+6.Spring���ڵ�����,������Ⱦ���͡�
+
+7.Spring�ĸ߶ȿɿ�����,����ǿ��������Spring,�����߿�������ѡ��Spring���ֻ�ȫ��
+
+## SpringFrameworkû�н����ʲô���⣿
+
+��ȻSpring������������������ģ�����������ȴ���������ġ�һ��ʼ��Spring��XML���ã������Ǻܶ�XML���á�Spring 2.5�����˻���ע������ɨ�裬�������˴������Ӧ�ó��������������ʽXML���á�Spring 3.0�����˻���Java�����ã�����һ�����Ͱ�ȫ�Ŀ��ع����÷�ʽ�����Դ���XML��
+
+������Щ���ö������˿���ʱ����ġ���Ϊ��˼��Spring�������úͽ��ҵ������֮����Ҫ����˼ά�л������Ա�д���ü�ռ�˱�дӦ�ó����߼���ʱ�䡣�����п��һ����Springʵ�ã������ͬʱ��Ҫ��Ļر�Ҳ���١�
+
+����֮�⣬��Ŀ����������Ҳ��һ����ʱ���������顣�ڻ����ʱ����Ҫ����Ҫ������Щ������꣬���һ���Ҫ����������֮��������ϵ������������꣬һ��ѡ���������İ汾����֮�����IJ���������ͻ������谭��Ŀ�Ŀ������ȡ�
+
+## SpringBoot�������Spring��ȱ��
+
+SpringBoot������Spring��ȱ����еĸ��ƺ��Ż�������Լ���������õ�˼�룬�����ÿ�����Ա�������������߼�ҵ��֮�����˼ά���л���ȫ���ĵ�Ͷ�뵽�߼�ҵ��Ĵ����д�У��Ӷ��������˿�����Ч�ʣ�һ���̶�����������Ŀ���ڡ�
+
+��ʹ��Spring��ܽ��п����Ĺ����У���Ҫ���úܶ�Spring��ܰ�����������spring-core��spring-bean��spring-context�ȣ�����Щ����ͨ�������ظ����ӵģ�������Ҫ���ܶ���ʹ�ü������������ظ����ã��翪��ע�⡢������־�ȡ�Spring Boot������������Щ����Ҫ�IJ������ṩĬ�����ã���Ȼ��ЩĬ�������ǿ��԰����޸ĵģ����ٴ������������SpringӦ��
+
+# ��SpringMVC�Ĺ�ϵ
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230415111153.png)
+
+Spring Boot��Spring Bootʹ���������Ϳ�ʼ��������Spring��Ӧ�ó��������ס� �������˺ܶ�������롣 ����Ļ�������˺ܶิ���ԣ���˿�����Ա���Կ������ֲ����ɿ�������Spring��Ӧ�ó���
+
+Spring MVC��Spring MVC�����ڹ���WebӦ�ó����Web MVC��ܡ� �������������ڸ��ֹ��ܵ������ļ��� ����һ������HTTP��WebӦ�ó��򿪷���ܡ�
+
+
+
+Spring Boot��Spring MVC���ڲ�ͬ��Ŀ�Ķ����ڡ� ����������Spring Boot��Spring MVC֮�����Ҫ����
+
+
+
+| Spring Boot | Spring MVC |
+| --- | --- |
+| Spring Boot����ʹ�ú�����Ĭ��ֵ�������Spring��Ӧ�ó��� | Spring MVC��Spring����»���ģ����ͼ��������Web��ܡ� |
+| ���ṩ��Ĭ������������Spring֧�ֵĿ�ܡ� | ���ṩ�����ڹ���WebӦ�ó���ļ����͹��ܡ� |
+| �����ֶ��������á� | ����Ҫ�ֶ����й������á� |
+| ����Ҫ������������ | �����������DZ���ġ� |
+| ��������������룬�����������װ��һ����Ԫ�С� | ���ֱ�ָ��ÿ������� |
+| �������˿���ʱ�䲢����������ʡ� | ʵ����ͬĿ����Ҫ����ʱ�䡣 |
+
+# ��΢����SpringCloud�Ĺ�ϵ
+
+Spring Boot��Spring����ij�Ա������һ��ȫ�µĿ�ܣ��������Ŀ���Ǿ����ܼ򵥺Ϳ��ٵĿ���������SpringӦ�ó��򣬼����á���Ϊ�����߿�ݵ�ʹ��Spring����ؿ�������ṩ�˱�����������������΢����Ŀ�ܣ���ֻ��Ϊ΢�����ܵ�ʹ��Ҳ�ṩ�˺ܺõĽ��ּܡ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230415111929.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230415111950.png)
+��������ͼ���������ߵĻ�������springboot���ڹ�����������Ӧ�ã�Ҳ�������dz�˵��΢����
+
+��springcloud���ڷ���������Ҳ���Ǵ�����������Э�����΢����springbootӦ�ó���
+
+springcloud�а������ڶ����������ص����������API����Springcloud Gateway�������������Config Serever����·��Circuit Breaker������ע������Service Registty��������Sleuth��
+
+# ʹ��Springboot��8��ԭ��
+
+## ����Ŀ���
+
+Spring Boot �� Spring ��̬ϵͳ�������˺ܶ�����͹�ִ������Ĭ�����á� �������������ڿ�����Ա�������ò�Ͷ�뿪����
+
+���磬Spring MVC ����ͨ������ XML bean ������Զ��� servlet ��ʵ�֡� ����ʹ�� Spring Boot������������������������һ���򵥡� ���Բ���Ҫ�������� XML ���á�
+
+## һ�н����Ȼ�
+
+Spring Boot Starters �ǰ���������ǵ�һЩ�Զ����õ� Maven �������� ���ң���Щ������������Ϊ Spring Boot Ӧ�ó����ṩ���ܡ� ��Ҫ�������ݿ����ӣ� ��һ������������� ������Ϣ����ͨ�����͵����ʼ��� Spring Boot ��������һ�С�
+
+���ڼ������е� Spring ģ�飬����һ�����������������Ϊ�������������ݡ� ����һЩ��������Ҳͨ�����ǵ�����ģ���ṩ�� Spring ��֧�֡� ���û����Щ������������Ϊ������Ա�����ò�ά��������� XML ���á� ������Ӧ��ʹ�� Spring Boot ����һ��ԭ��
+
+## Ƕ��ʽ������
+
+Spring Boot ΪǶ��ʽ Tomcat��Jetty �� Undertow �������ṩ���伴�õ�֧�֡� ������������Ա�Ͳ��ص����ڴ�ͳӦ�÷������в��� Web Ӧ�ó��� ͨ���ʵ�����������������������Խ�һ�ַ������������������������������� ������ʵ�������յõ���һ���������κ� JAR һ�����е� JAR �ļ��� ������ʱ��JAR �����㹻�Ŀ����������ΪӦ�ó����������������������
+
+�������Ƕ��ʽ������������Ȥ����������ʱ�� Spring Boot Ӧ�ó���� JAR ת��Ϊ WAR���������Dz��𵽴�ͳ��������
+
+## IDE �� Spring Boot ��֧��
+
+������Ҫ�� IDE ���ṩ�� Spring Boot ���������֧�֡� ���磬IntelliJ IDEA Ultimate Ϊ Spring Boot ��Ŀ�ṩ�˳�ɫ�Ĵ�����ɺ͵������ܡ�����֮�⣬VSCode �� Eclipse Ҳ�����ṩ�˷ḻ�Ĺ���֧�֡�
+
+## �����������ù���
+
+Spring Boot �ṩ���������������ԣ������ء�ָ��Ϳ��伴�õ�ע���� ������Щ���ԣ�������Ա���Ա����������á� ���磬����ִ�����˵�ȹ���ʹӦ�ó���״̬��س�Ϊ���ܡ� ���磬
+
+���������� Prometheus �����Ĺ����ռ�Ӧ�ó���ָ��
+
+������ Kubernetes �� Openshift ������ʹ�þ����Ժͻ�Ծ�Ƚ����˵㡣
+
+ֻ�������������Ի�ͨ�� /actuator/logging �˵㼴�ɸ�����־��¼����
+
+���⣬������Ա����ʹ���Լ����Զ��彡���˵�������Щִ�����˵㡣
+
+## ���伴�õ� JUnit ֧��
+
+Ĭ������£����� Spring Boot ��Ŀ������ JUnit 5�� ���⣬Spring Boot �ṩ��@SpringBootTest ע������������Ҫʱ��ʼ�����������ġ� ���Կ�����Աֻ��Ҫ��д���������� ���Dz����ٵ��IJ��������ĸ��� spring �����ġ�
+
+���磬�����Զ����ɵIJ��Խ�����������Ƿ���ȷ���ء�
+
+````
+@SpringBootTest
+class SpringBootDerbyDatabaseApplicationTests {
+
+     @����
+     void contextLoads() {
+     }
+
+}
+````
+
+## Spring Profiles
+
+Spring Profiles �� spring Boot ��һ��ǿ�����ԣ������ڸ���Ӧ�ó����еIJ�ͬ����� ʹ�������ļ������������ض����������û��������� ������������ض�����ʹ�ò�ͬ�����ʱ������ܻ������ó���
+````
+@Profile(value = {"prod","uat"})
+class RabbitMQConfig {
+
+// ����
+
+}
+````
+
+������Ĵ����У������Ľ������������������ھ��� prod �� uat ��Ϊ������ļ��Ļ��������С�
+
+## ���ִ���Ͳ���ѡ��
+
+�ÿ���ṩ�˶��ַ�ʽ���������Ӧ�ó��� ��������֮ǰ��˵��Ӧ�ó�������� JAR �� WAR �ļ��� ͨ��һЩ��������úͲ������������Դ������伴�õĸ����� docker ����
+
+������ֹͣ Spring Boot Ӧ�ó���dz��򵥡� ���⣬������ͨ����������IJ��轫��Щ JAR �ļ�����Ϊ linux ���� JAR �ļ���Ϊ FAT jar�����ǰ�����Ӧ�ó�����ص���������� ��ʹ�ò�����̲���ô���ӡ� ʵ���ϣ���Щ�����������κ�װ�� Java 8 ����߰汾�Ļ��������С�
+
+# �����
+
+[https://spring.io/](https://spring.io/)
+
+[https://pdai.tech/md/spring/springboot/springboot-x-overview.html](https://pdai.tech/md/spring/springboot/springboot-x-overview.html)
+
+[https://springhow.com/why-use-spring-boot/](https://springhow.com/why-use-spring-boot/)
+
+[https://dzone.com/articles/why-springboot](https://dzone.com/articles/why-springboot)
+
+[https://scand.com/company/blog/pros-and-cons-of-using-spring-boot/](https://scand.com/company/blog/pros-and-cons-of-using-spring-boot/)
+
+[https://cloud.tencent.com/developer/article/1620255](https://cloud.tencent.com/developer/article/1620255)
+
+[https://www.yiibai.com/spring-boot/spring-vs-spring-boot-vs-spring-mvc.html](https://www.yiibai.com/spring-boot/spring-vs-spring-boot-vs-spring-mvc.html)
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\232\204\345\237\272\346\234\254\344\275\277\347\224\250.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\232\204\345\237\272\346\234\254\344\275\277\347\224\250.md"
new file mode 100644
index 0000000..247e419
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\232\204\345\237\272\346\234\254\344\275\277\347\224\250.md"
@@ -0,0 +1,108 @@
+# ���ٹ���SpringBootӦ��
+
+����̳�������springboot�������㹻Ȩ����Ҳ�㹻�򵥡�
+
+##  ��һ�� hello world ����
+
+��������һ������ġ�Hello World�����κ���������������ӵ��Ķ˵㡣���������Ը�����������֣������Ը��Ѻõķ�ʽ��Ӧ��
+
+## ��������Ҫ��
+
+1�������������һ�����ֵ�IDE,����ѡ����� IntelliJ IDEA��Spring Tools��Visual Studio Code �� Eclipse �ȵȡ�
+
+2��JDK�����ڰ汾�Ļ���8-17���Dz�����ѡ��
+
+3����Ȼ���ﻹ��Ҫ����maven��pom��������������Ҳ��Ҫmaven��maven�����idea�Դ��ˡ����ǻ��ڽ������IJ��ֽ��н��ܣ���Ҫ������Щ����
+
+## ��һ��������һ���µ�Spring Boot��Ŀ
+
+ʹ��[start.spring.io](http://start.spring.io/)����һ����web����Ŀ���ڡ�dependencies���Ի��������������ӡ�web�����������Ļ��ͼ��ʾ��
+
+��������ɡ���ť������ zip �ļ����������ѹ����������ϵ�һ���ļ����С�
+
+![Start.spring.io ��������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/quickstart-1.png)
+
+[start.spring.io](http://start.spring.io/)��������Ŀ����[Spring Boot](https://spring.io/projects/spring-boot)��һ����Spring׼����������Ӧ�ó����ڲ�������������Ҫ̫���������á� Spring Boot ������ Spring ��Ŀ�����������еķ�ʽ��
+
+��������ѡ��ʹ��maven��Ϊ���������ߣ�������������Ŀ������pom�ļ���pom�ļ��������������ӵ�������
+
+````  
+<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">   <modelVersion>4.0.0</modelVersion>   <parent>      <groupId>org.springframework.boot</groupId>      <artifactId>spring-boot-starter-parent</artifactId>      <version>3.0.5</version>      <relativePath/> <!-- lookup parent from repository -->   </parent>   <groupId>com.example</groupId>   <artifactId>demo</artifactId>   <version>0.0.1-SNAPSHOT</version>   <name>demo</name>   <description>Demo project for Spring Boot</description>   <properties>      <java.version>17</java.version>   </properties>   <dependencies>      <dependency>         <groupId>org.springframework.boot</groupId>         <artifactId>spring-boot-starter-web</artifactId>      </dependency>  
+      <dependency>         <groupId>org.springframework.boot</groupId>         <artifactId>spring-boot-starter-test</artifactId>         <scope>test</scope>      </dependency>   </dependencies>  
+   <build>      <plugins>         <plugin>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-maven-plugin</artifactId>         </plugin>      </plugins>   </build>  
+</project>  
+````  
+
+
+## �ڶ�����������Ĵ���
+
+������ IDE �д���Ŀ���� `src/main/java/com/example/demo` �ļ������ҵ� `DemoApplication.java` �ļ���
+
+����ͨ�����������������ʾ�Ķ��ⷽ����ע���������ļ������ݡ������Ը��Ʋ�ճ�������ֱ�Ӽ�����롣
+```  
+package com.example.demo;  
+import org.springframework.boot.SpringApplication;  
+import org.springframework.boot.autoconfigure.SpringBootApplication;  
+import org.springframework.web.bind.annotation.GetMapping;  
+import org.springframework.web.bind.annotation.RequestParam;  
+import org.springframework.web.bind.annotation.RestController;  
+  
+@SpringBootApplication  
+@RestController  
+public class DemoApplication {  
+    public static void main(String[] args) {      SpringApplication.run(DemoApplication.class, args);    }    @GetMapping("/hello")    public String hello(@RequestParam(value = "name", defaultValue = "World") String name) {      return String.format("Hello %s!", name);    }}  
+  
+```  
+
+������ Spring Boot �д���һ���򵥵ġ�Hello World�� Web ������������д��롣
+
+�������ӵ�`hello()`����ּ�ڻ�ȡһ����Ϊname��String������Ȼ�󽫴˲���������еĵ���`"Hello"`���������
+
+����ζ��������������н�������������Ϊ��Amy��������Ӧ���ǡ�Hello Amy����
+
+`@RestController` ע�͸��� Spring���˴���������һ���˵㣬�ö˵�Ӧ�� Web �Ͽ��á�   
+@GetMapping(��/hello��) ���� Spring ʹ�����ǵ� hello() ��������Ӧ���͵� http://localhost:8080/hello ��ַ������
+
+���@RequestParam ���� Spring ������������һ������ֵ������������ڣ�����Ĭ��ʹ�õ��ʡ�World����
+
+## ������������
+
+�����ǹ��������г��򡣴������У����նˣ�����������ӵ����Ŀ�ļ����ļ��С�
+
+���ǿ���ͨ��������������������������Ӧ�ó���
+
+**MacOS/Linux:**
+
+```  
+COPY./gradlew bootRun  
+  
+```  
+
+**Windows:**
+
+```  
+COPY.\gradlew.bat bootRun  
+  
+```  
+
+��Ӧ�ûῴ��һЩ��˷dz����Ƶ������  
+![Quick Start On Start.spring.io](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/quickstart-2.png)
+
+���������и������ǣ�SpringӦ���Ѿ���ʼ�����ˡ� Spring Boot ��Ƕ��ʽ Apache Tomcat �������䵱����������������ڼ�����localhost���˿ڡ�8080���ϵ�����
+
+����������ڶ����ĵ�ַ��������`http://localhost:8080/hello`��
+
+��Ӧ�õõ�����һ���ѺõĻ�Ӧ��  
+![Quick Start On Start.spring.io](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/quickstart-3.png)
+
+# �ܽ�
+������˼򵥣���һ��SpringBootӦ�þ���ô��������ˣ��㲻��Ҫ����������ļ�������������������Ƕ���ķ�������  
+ֻ��Ҫһ�������࣬�Ϳ���ʵ��һ���������SpringBoot��Ӧ�á�
+
+��Ҳ��Ϊʲôspringboot�����������ٹ���һ��΢������Ϊ��ʵ����̫�����ˡ�  
+��Ȼ��ʵ�ʿ�����������Ҫ�õ�����springboot�Ĺ��ܺ����ԣ����ǽ����ڽ��������½�����չ�����ܡ�
+
+# �����
+https://spring.io/quickstart
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\232\204\351\205\215\347\275\256\346\226\207\344\273\266\347\256\241\347\220\206.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\232\204\351\205\215\347\275\256\346\226\207\344\273\266\347\256\241\347\220\206.md"
new file mode 100644
index 0000000..46c6771
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\347\232\204\351\205\215\347\275\256\346\226\207\344\273\266\347\256\241\347\220\206.md"
@@ -0,0 +1,2989 @@
+## 1.SpringBoot���ù����ı��������
+
+Ϊʵ�ֿ��ٴ�Ϳ�������Ŀ��Springboot��ܴ��springboot�����Ŀ���Խ���Ŀֱ�Ӵ��jar�������У������Լ���װ����Tomcat������������������һ�ַ����ݵIJ���ʽ��
+
+������Ŀ�����ķ�ʽ�����һ�������jar�����𣬼������ļ��͵�������������������jar����ͻ���������������
+
+����һ����Ŀ���й����У�Ҫ�Ķ������ļ��Ļ���Ҫ���´��������
+
+�������������������������������ĿҪ������ͬһ̨������ʱ�����Ե�jar������������ͬ�ĵ�������������������Ŀjar����100M�����������������ܾ�ռ����99M����������������������������˷�������Դ���˷��Լ���������Ŀ�����Ч�ʡ�
+
+���������Ŀ�������ļ�������������������ȡ��jar����ͳһ��������������������Ŀ���Ч���ֽ�Լ�˷������Ĵ������ģ�ͬʱ��Ŀ����άҲ�Ƿdz�����ģ��Ķ��������ļ������·���Ϳ����ˣ��������¹�������
+
+�����Ǿ����ʵ�ַ���
+
+### 1.1 **�����ļ�ͳһ����**
+
+```
+	- springboot���������ļ�
+	- Springboot��ȡ���������ļ���application.properties�������ȼ�Ϊ
+	- Jar��ͬ��Ŀ¼��configĿ¼
+	- Jar��ͬ��Ŀ¼
+	- classPath(��resourcesĿ¼)��configĿ¼
+	- classpathĿ¼
+
+```
+
+������springbootĬ��ȥ���Լ��ĺ��������ļ������ȼ�������һ��������ȼ��ķ�ʽ����Ŀ����ʱͨ������ķ�ʽָ����Ŀ���غ��������ļ�����������
+java �Cjar -Dspring.config.location=xxx/xxx/xxxx.properties xxxx.jar
+
+���Spring Boot�����ȼ����ߵ�λ���ҵ������ã���ô�����������ȼ����͵�����
+
+### 1.2 **������Դ�����ļ�**
+
+����������Springboot�����ļ��Ѿ��ܹ���ȡ��jar������й����ˣ����ǻ�������һЩҵ���ϵ������ļ���������Դ�����ļ���������Դ���������ļ���������FTP��Ϣ�ȣ���quartz��ʱ������־�������ļ��������ȥ��ȡ������ȷ�����ڴ��������õ���
+
+����֪��Springboot��Ŀ����ͨ��ע�ⷽʽ����ȡ��������ļ�����������Ҳ��ͨ��ע�ⷽʽ����Ŀ�ܹ����õ�jar���ⲿ�������ļ��ģ�����ͼ��
+![���������ͼƬ����](https://img-blog.csdnimg.cn/20190121170400864.png)
+
+@PropertySource�����value������ֵ����һ����classpath��configĿ¼�µ�����Դ�����ļ����ڶ������Ǹ���spring.profiles.path��̬��ȡ��Ŀ¼��spring.profiles.path�������ں����ļ��Զ����һ�����������ֵ�����������ļ�ͳһ�������ļ���·���������ignoreResourceNotFound=true�����趨�������ǰ��һ��·��û���ҵ���������ļ�������ݵڶ���·��ȥ�ҡ�
+
+���ǻ�����ֱ�Ӹ���·������FileSystemResource��ȥ����һ�������ļ�ʵ������������ͼ
+![���������ͼƬ����](https://img-blog.csdnimg.cn/20190121170338934.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0dlZUxvb25n,size_16,color_FFFFFF,t_70)
+
+ԭ�����ƣ������ں����ļ��Զ����ͳһ����Ŀ¼��·�������������ļ�
+
+����logback��־�����ļ����ط�ʽ���£�
+![���������ͼƬ����](https://img-blog.csdnimg.cn/20190121170306979.png)
+
+������������������һ��ʵ�ַ�����˼·
+
+```
+	- ��springboot�����ļ��ﶨ��һ��spring.profiles.path���������ֵָ���������������ļ�ͳһ���õ�Ŀ¼�����������ļ�����Ҳ�Ƿ����������
+
+	- ������������ļ�����������ļ��ĵط�ҲӦ�û�ȡspring.profiles.path����������̬���ظ�·���µ������ļ�
+
+	- Pom.xml�ļ��޸Ĵ�����ģ�飬�������ļ��ų����������Ǵ����jar���Dz��������ļ��ģ����������ο��ĵ��ڵ�3
+
+	- ����jar��ʱ��ͨ������ָ�����صĺ����ļ�Ϊspring.profiles.path�µĺ����ļ�
+
+```
+**������������ͳһ����**
+
+ͨ��������jar�����Դ��jar���Ҳ���Է�����Ŀjar��ͬ��Ŀ¼�µ�libĿ¼�����ǿ��Ը����޸�pom.xml���������ʵ�֣���ο��ĵ��ڵ�3�������
+
+**�������**
+
+```
+<build>
+		<resources>
+			<resource>
+				<directory>src/main/java</directory>
+				<includes>
+					<include>**/*.properties</include>
+					<include>**/*.xml</include>
+				</includes>
+				<filtering>true</filtering>
+			</resource>
+			<resource>
+				<directory>src/main/resources</directory>
+				<!�����ʱ�ų������ļ�-->
+                                <excludes>
+					<exclude>**/*.properties</exclude>
+					<exclude>**/*.xml</exclude>
+					<exclude>**/*.yml</exclude>
+				</excludes>
+				<filtering>false</filtering>
+			</resource>
+		</resources>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				maven-compiler-plugin
+				<configuration>
+					<source>1.8</source>
+					<target>1.8</target>
+					<fork>true</fork>
+					<skip>true</skip>
+					<executable>
+						C:/Program Files/Java/jdk1.8.0_161/bin/javac.exe
+					</executable>
+				</configuration>
+			</plugin>
+			<plugin>
+				maven-jar-plugin
+				<configuration>
+					
+						<manifest>
+							true
+							<classpathPrefix>lib/</classpathPrefix>
+							<useUniqueVersions>false</useUniqueVersions>
+							<mainClass>com.xrq.demo.Application</mainClass>
+						</manifest>
+						<manifestEntries>
+							<Class-Path>./</Class-Path>
+						</manifestEntries>
+					
+					<excludes>
+						<exclude>*.properties</exclude>
+						<exclude>*.yml</exclude>
+						<exclude>*.xml</exclude>
+						<exclude>config/**</exclude>
+					</excludes>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				maven-dependency-plugin
+				<executions>
+					<execution>
+						<id>copy</id>
+						<phase>package</phase>
+						<goals>
+							<goal>copy-dependencies</goal>
+						</goals>
+						<configuration>
+							<outputDirectory>
+								${project.build.directory}/lib
+							</outputDirectory>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+		</plugins>
+	</build>
+
+```
+
+�ĺ�pom.xml��buildģ��󣬾Ϳ���ͨ��mvn package ����mvn install������ǵ�jar����
+
+1.  **��Ŀ����shell�ű���д**
+    �Զ���shell�ű���ʵ����Ŀ��������ֹͣ��״̬������������
+
+```
+#!/bin/bash 
+#������滻Ϊ���Լ���ִ�г���,��������������� 
+APP_NAME=demo1-0.0.1-SNAPSHOT.jar 
+JVM="-server -Xms512m -Xmx512m -XX:PermSize=64M -XX:MaxNewSize=128m -XX:MaxPermSize=128m -Djava.awt.headless=true -XX:+CMSClassUnloadingEnabled -XX:+CMSPermGenSweepingEnabled"
+APPFILE_PATH="-Dspring.config.location=/usr/local/demo/config/application-demo1.properties"
+#ʹ��˵��,������ʾ������� 
+usage() { 
+echo "Usage: sh ִ�нű�.sh [start|stop|restart|status]" 
+exit 1 
+} 
+#�������Ƿ������� 
+is_exist(){ 
+pid=`ps -ef|grep $APP_NAME|grep -v grep|awk '{print $2}' ` 
+#��������ڷ���1,���ڷ���0 
+if [ -z "${pid}" ]; then 
+return 1 
+else 
+return 0 
+fi 
+} 
+#�������� 
+start(){ 
+is_exist 
+if [ $? -eq "0" ]; then 
+echo "${APP_NAME} is already running. pid=${pid} ." 
+else 
+nohup java $JVM -jar $APPFILE_PATH $APP_NAME > /dev/null 2>&1 
+fi
+} 
+#ֹͣ���� 
+stop(){ 
+is_exist 
+if [ $? -eq "0" ]; then 
+kill -9 $pid 
+else 
+echo "${APP_NAME} is not running" 
+fi 
+} 
+#�������״̬ 
+status(){ 
+is_exist 
+if [ $? -eq "0" ]; then 
+echo "${APP_NAME} is running. Pid is ${pid}" 
+else 
+echo "${APP_NAME} is NOT running." 
+fi 
+} 
+#���� 
+restart(){ 
+stop 
+start 
+} 
+#�����������,ѡ��ִ�ж�Ӧ����,��������ִ��ʹ��˵�� 
+case "$1" in 
+"start") 
+start 
+;; 
+"stop") 
+stop 
+;; 
+"status") 
+status 
+;; 
+"restart") 
+restart 
+;; 
+*) 
+usage 
+;; 
+esac
+
+```
+
+**����**
+
+linux���������½����ļ��У������Ǵ�õ���Ŀjar��������ȥ����jar����ͬ��Ŀ¼�½�config��lib�ļ��У��ֱ������ļ��͵���������������ȥ����ṹ����ͼ��*.shΪ�Լ�д����Ŀ����shell�ű�
+
+![���������ͼƬ����](https://img-blog.csdnimg.cn/20190121170223384.png)
+
+��config�ڵ�springboot�����ļ�����application-demo1.properties�ļ�����
+
+spring.profiles.path������ijɵ�ǰ�����ļ����ڵ�Ŀ¼������Ϊ/usr/local/demo/config
+
+��*.sh�ű����޸�APPFILE_PATH��ֵ������
+
+APPFILE_PATH="-Dspring.config.location=/usr/local/demo/config/application-demo1.properties"
+
+**��Ŀ����**
+
+����jar������Ŀ¼ִ����������
+
+sh [demo1.sh](http://demo1.sh/) start ������Ŀ
+
+sh [demo1.sh](http://demo1.sh/) stop ֹͣ��Ŀ
+
+sh [demo1.sh](http://demo1.sh/) restart������Ŀ
+
+sh [demo1.sh](http://demo1.sh/) status��Ŀ״̬
+
+## 2\. �ⲿ��������
+
+
+
+
+
+Spring Boot�������㽫�����ⲿ����������Ϳ����ڲ�ͬ�Ļ�����ʹ����ͬ��Ӧ�ó�����롣 �����ʹ�ø����ⲿ����Դ������Java properties �ļ���YAML�ļ������������������в�����
+
+
+
+
+
+����ֵ����ͨ��ʹ�� `@Value` ע��ֱ��ע�����Bean��Ҳ����ͨ��Spring �� `Environment` ���ʣ�����ͨ�� `@ConfigurationProperties` [�󶨵�����](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties)��
+
+
+
+
+
+Spring Boot ʹ��һ���dz��ر�� `PropertySource` ˳��ּ��������������дֵ�� ����� property source ���Ը���ǰ������Դ�ж����ֵ�� ������˳���ǡ�
+
+
+
+
+
+1.  Ĭ�����ԣ�ͨ�� `SpringApplication.setDefaultProperties` ָ������
+
+2.  @Configuration ���ϵ� [`@PropertySource`](https://docs.spring.io/spring-framework/docs/6.0.5/javadoc-api/org/springframework/context/annotation/PropertySource.html) ע�⡣��ע�⣬����������Դֱ��application context��ˢ��ʱ�Żᱻ���ӵ������С����������ijЩ������˵�Ѿ�̫���ˣ����� `logging.*` �� `spring.main.*` ��������ˢ�¿�ʼǰ���Ѿ�����ȡ�ˡ�
+
+3.  �������ݣ��� `application.properties` �ļ�����
+
+4.  `RandomValuePropertySource`����ֻ�� `random.*` ���ԡ�
+
+5.  ����ϵͳ��������
+
+6.  Java System properties (`System.getProperties()`).
+
+7.  `java:comp/env` �е� JNDI ���ԡ�
+
+8.  `ServletContext` init parameters.
+
+9.  `ServletConfig` init parameters.
+
+10.  ���� `SPRING_APPLICATION_JSON` �����ԣ�Ƕ�뻷��������ϵͳ�����е�����JSON����
+
+11.  �������
+
+12.  ���ڲ����е� `properties` ���ԡ��� [`@SpringBootTest`](https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/api/org/springframework/boot/test/context/SpringBootTest.html) �Ͳ���ע���п��ã�[���ڲ������Ӧ�ó����һ���ض�Ƭ��](https://springdoc.cn/spring-boot/features.html#features.testing.spring-boot-applications.autoconfigured-tests)��
+
+13.  ������е�https://docs.spring.io/spring-framework/docs/6.0.5/javadoc-api/org/springframework/test/context/TestPropertySource.html[`@TestPropertySource`] ע��.
+
+14.  ��devtools���ڻ״̬ʱ��`$HOME/.config/spring-boot` Ŀ¼�µ�[Devtoolsȫ����������](https://springdoc.cn/spring-boot/using.html#using.devtools.globalsettings)��
+
+
+
+
+
+���������ļ�������˳���ǡ�
+
+
+
+
+
+1.  �����jar����[Application properties](https://springdoc.cn/spring-boot/features.html#features.external-config.files)��application.properties �� YAML����
+
+2.  �����jar�д���� [�ض��� Profile application properties](https://springdoc.cn/spring-boot/features.html#features.external-config.files.profile-specific)��`application-{profile}.properties` �� YAML����
+
+3.  ��������jar֮���[Application properties](https://springdoc.cn/spring-boot/features.html#features.external-config.files)�ԣ�application.properties��YAML����
+
+4.  ��������jar֮���[�ض��� Profile application properties](https://springdoc.cn/spring-boot/features.html#features.external-config.files.profile-specific)�� `application-{profile}.properties` ��YAML����
+
+
+
+
+
+|  | ������������Ӧ�ó����м��ʹ��һ�ָ�ʽ�� �������ͬһ���ط��� `.properties` �� `.yml` ��ʽ�������ļ���`.properties` ���ȡ� |
+| --- | --- |
+
+
+
+
+
+Ϊ���ṩһ����������ӣ������㿪����һ�� `@Component`��ʹ����һ�� `name` ���ԣ��������������ʾ��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Component
+public class MyBean {
+
+    @Value("${name}")
+    private String name;
+
+    // ...
+
+}
+
+```
+
+
+
+
+
+
+
+�����Ӧ�ó����classpath�����磬�����jar�У����������һ�� `application.properties` �ļ���Ϊ `name` �ṩһ��������Ĭ������ֵ������һ���µĻ���������ʱ�����������jar֮���ṩһ�� `application.properties` �ļ������� `name` ������һ���ԵIJ��ԣ��������һ���ض��������в��������������磬`java -jar app.jar --name="Spring"`����
+
+
+
+
+
+|  | `env` �� `configprops` �˵���ȷ��һ������Ϊʲô��һ���ض���ֵʱ�dz����á������ʹ���������˵���������������ֵ����� "[������������](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints)" ���֡� |
+| --- | --- |
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.external-config.command-line-args)2.1\. ��������������
+
+
+
+Ĭ������£�`SpringApplication` �Ὣ�κ�������ѡ����������� `--` ��ͷ�IJ������� `--server.port=9000` ��ת��Ϊ `property` ���������ӵ�Spring `Environment` �С� ��ǰ�������������������������ڻ����ļ�������Դ��
+
+
+
+
+
+����㲻ϣ�����������Ա����ӵ� `Environment` �У������ͨ�� `SpringApplication.setAddCommandLineProperties(false)` �������ǡ�
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.external-config.application-json)2.2\. JSON Application Properties
+
+
+
+����������ϵͳ�������������ƣ�����ζ����Щ�������Ʋ���ʹ�á� Ϊ�˰������������⣬Spring Boot�����㽫һ�����Կ����Ϊһ����һ��JSON�ṹ��
+
+
+
+
+
+�����Ӧ�ó�������ʱ���κ� `spring.application.json` �� `SPRING_APPLICATION_JSON` ���Խ������������ӵ� `Environment` �С�
+
+
+
+
+
+���磬`SPRING_APPLICATION_JSON` ���Կ����� UN*X shell ������������Ϊ���������ṩ��
+
+
+
+
+
+
+
+```
+$ SPRING_APPLICATION_JSON='{"my":{"name":"test"}}' java -jar myapp.jar
+```
+
+
+
+
+
+
+
+��ǰ��������У�����Spring�� `Environment` �����յõ��� `my.name=test`��
+
+
+
+
+
+ͬ����JSONҲ������Ϊһ��ϵͳ�����ṩ��
+
+
+
+
+
+
+
+```
+$ java -Dspring.application.json='{"my":{"name":"test"}}' -jar myapp.jar
+```
+
+
+
+
+
+
+
+���������ͨ��ʹ��һ�������в������ṩJSON��
+
+
+
+
+
+
+
+```
+$ java -jar myapp.jar --spring.application.json='{"my":{"name":"test"}}'
+```
+
+
+
+
+
+
+
+�����Ҫ����һ�������Ӧ�÷������У���Ҳ����ʹ��һ����Ϊ `java:comp/env/spring.application.json` ��JNDI������
+
+
+
+
+
+|  | ����JSON�е� `null` ֵ�������ӵ����ɵ�����Դ�У��� `PropertySourcesPropertyResolver` �� `null` ������Ϊȱʧֵ�� ����ζ��JSON������ `null` ֵ�������Եͽ�����Դ�����ԡ� |
+| --- | --- |
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.external-config.files)2.3\. �ⲿ�� Application Properties
+
+
+
+�����Ӧ�ó�������ʱ��Spring Boot���Զ�������λ���ҵ������� `application.properties` �� `application.yaml` �ļ���
+
+
+
+
+
+1.  classpath
+
+
+
+    1.  classpath ��·��
+
+    2.  classpath �µ� `/config` ��
+
+
+
+2.  ��ǰĿ¼
+
+
+
+    1.  ��ǰĿ¼��
+
+    2.  ��ǰĿ¼�µ� `config/` ��Ŀ¼
+
+    3.  `config/` ��Ŀ¼��ֱ����Ŀ¼
+
+
+
+
+
+
+
+�б������ȼ����򣨽ϵ���Ŀ��ֵ���ǽ�����Ŀ��ֵ���� ���ص��ļ�����Ϊ `PropertySources` ���ӵ�Spring�� `Environment` �С�
+
+
+
+
+
+����㲻ϲ�� `application` ��Ϊ�����ļ����ƣ������ͨ��ָ�� `spring.config.name` ���������л�����һ���ļ����ơ� ���磬Ϊ��Ѱ�� `myproject.properties` �� `myproject.yaml` �ļ�������԰����·�ʽ�������Ӧ�ó���
+
+
+
+
+
+
+
+```
+$ java -jar myproject.jar --spring.config.name=myproject
+```
+
+
+
+
+
+
+
+��Ҳ����ͨ��ʹ�� `spring.config.location` ��������������һ����ȷ��λ�á� �����Խ���һ�����ŷָ����б������а���һ������Ҫ����λ�á�
+
+
+
+
+
+�����������ʾ�����ָ��������ͬ���ļ���
+
+
+
+
+
+
+
+```
+$ java -jar myproject.jar --spring.config.location=\
+    optional:classpath:/default.properties,\
+    optional:classpath:/override.properties
+```
+
+
+
+
+
+
+
+|  | ��� [�����ļ��ǿ�ѡ��](https://springdoc.cn/spring-boot/features.html#features.external-config.files.optional-prefix)�����ҿ����Dz����ڵģ���ô��ʹ�� `optional:` ǰ׺�� |
+| --- | --- |
+
+
+
+
+
+|  | `spring.config.name`, `spring.config.location`, �� `spring.config.extra-location` ���������ȷ����Щ�ļ����뱻���ء� ���DZ��뱻����Ϊ�������ԣ�ͨ���Dz���ϵͳ����������ϵͳ���ԣ��������в������� |
+| --- | --- |
+
+
+
+
+
+��� `spring.config.location` ����Ŀ¼���������ļ���������Ӧ���� `/` ��β�� ������ʱ�����ǽ����������� `spring.config.name` ���ɵ����ƣ�Ȼ�󱻼��ء� �� `spring.config.location` ��ָ�����ļ���ֱ�ӵ��롣
+
+
+
+
+
+|  | Ŀ¼���ļ�λ��ֵҲ����չ���Լ��[�ض��������ļ�](https://springdoc.cn/spring-boot/features.html#features.external-config.files.profile-specific)�����磬������ `spring.config.location` �� `classpath:myconfig.properties`����Ҳ�ᷢ���ʵ��� `classpath:myconfig-<profile>.properties` �ļ������ء� |
+| --- | --- |
+
+
+
+
+
+�ڴ��������£������ӵ�ÿ�� `spring.config.location` �����һ���ļ���Ŀ¼�� λ���ǰ������DZ������˳���������ģ������λ�ÿ��Ը���ǰ���λ�õ�ֵ��
+
+
+
+
+
+�������һ�����ӵ�λ�����ã�������ʹ���ض��������ļ����������Ҫ�ṩ��һ������ʾ���Ա�Spring Boot֪������Ӧ����η��顣һ��λ������һ��λ�õļ��ϣ���Щλ�ö�����Ϊ����ͬһ�������磬������������classpathλ�÷��飬Ȼ���������ⲿλ�á�һ��λ�����ڵ���ĿӦ���� `;` �ָ�������ϸ�ڼ� ��[ָ�� profile](https://springdoc.cn/spring-boot/features.html#features.external-config.files.profile-specific)�� ���ֵ����ӡ�
+
+
+
+
+
+ͨ��ʹ�� `spring.config.location` ���õ�λ��ȡ��Ĭ��λ�á� ���磬��� `spring.config.location` ������Ϊ `optional:classpath:/custom-config/,optional:file:./custom-config/` �����ǵ�����λ�ü����¡�
+
+
+
+
+
+1.  `optional:classpath:custom-config/`
+
+2.  `optional:file:./custom-config/`
+
+
+
+
+
+�����ϲ�����Ӷ����λ�ã��������滻���ǣ������ʹ�� `spring.config.extra-location` �� �Ӹ���λ�ü��ص����Կ��Ը���Ĭ��λ�õ����ԡ� ���磬��� `spring.config.extra-location` ������Ϊ `optional:classpath:/custom-config/,optional:file:./custom-config/` �����ǵ�����λ�ü����¡�
+
+
+
+
+
+1.  `optional:classpath:/;optional:classpath:/config/`
+
+2.  `optional:file:./;optional:file:./config/;optional:file:./config/*/`
+
+3.  `optional:classpath:custom-config/`
+
+4.  `optional:file:./custom-config/`
+
+
+
+
+
+������������������һ�������ļ���ָ��Ĭ��ֵ��Ȼ������һ���ļ���ѡ���Եظ�����Щֵ�� �����������һ��Ĭ��λ�õ� `application.properties` �������� `spring.config.name` ѡ�������basename����Ϊ���Ӧ�ó����ṩĬ��ֵ�� Ȼ����ЩĬ��ֵ����������ʱ��λ������һ���Զ���λ�õIJ�ͬ�ļ����ǡ�
+
+
+
+
+
+|  | �����ʹ�û�������������ϵͳ���ԣ����������ϵͳ������ʹ�þ��ָ��ļ������������ʹ���»��ߴ��棨���磬 `SPRING_CONFIG_NAME` ������ `spring.config.name` ���� �μ�[�ӻ���������](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables) �˽����顣 |
+| --- | --- |
+
+
+
+
+
+|  | ������Ӧ�ó�����servlet������Ӧ�÷����������У���ôJNDI���ԣ��� `java:comp/env` �У���servlet�����ij�ʼ���������Դ��滷��������ϵͳ���ԣ�������֮һ���� |
+| --- | --- |
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.files.optional-prefix)2.3.1\. ��ѡ��λ��(Optional Locations)
+
+
+
+Ĭ������£���ָ������������λ�ò�����ʱ��Spring Boot���׳�һ�� `ConfigDataLocationNotFoundException` �����Ӧ�ó����޷�������
+
+
+
+
+
+�������ָ��һ��λ�ã����㲻�������������Ǵ��ڣ������ʹ�� `optional:` ǰ׺��������� `spring.config.location��spring.config.extra-location` ������ʹ�����ǰ׺��Ҳ������ [`spring.config.import`](https://springdoc.cn/spring-boot/features.html#features.external-config.files.importing) ������ʹ�á�
+
+
+
+
+
+���磬`spring.config.import` ֵΪ `optional:file:./myconfig.properties` �������Ӧ�ó�����������ʹ `myconfig.properties` �ļ���ʧ��
+
+
+
+
+
+�������������е� `ConfigDataLocationNotFoundExceptions` ��ʼ�ռ����������Ӧ�ó��������ʹ�� `spring.config.on-not-found` ���ԡ� ʹ�� `SpringApplication.setDefaultProperties(..)` ��ʹ��ϵͳ/������������ֵ����Ϊ `ignore`��
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.files.wildcard-locations)2.3.2\. ͨ�����ַ
+
+
+
+���һ�������ļ���λ�������һ��·�����а��� `*` �ַ������ͱ���Ϊ��һ��ͨ���λ�á� ͨ����ڼ�������ʱ����չ����ˣ�ֱ�ӵ���Ŀ¼Ҳ����顣 ͨ���λ����Kubernetes�����ж���������Ե���Դ�Ļ������ر����á�
+
+
+
+
+
+���磬�������һЩRedis���ú�һЩMySQL���ã��������������������÷ֿ���ͬʱҪ���������ֶ�������һ�� `application.properties` �ļ��С�
+
+
+
+
+
+����ܻᵼ������������ `application.properties` �ļ������ڲ�ͬ��λ�ã��� `/config/redis/application.properties` �� `/config/mysql/application.properties` �� ����������£���һ��ͨ���λ�� `config/*/` �������������ļ���������
+
+
+
+
+
+Ĭ������£�Spring Boot�� `config/*/` ����Ĭ������λ�á� ����ζ�����jar֮��� `/config` Ŀ¼��������Ŀ¼���ᱻ��������
+
+
+
+
+
+������� `spring.config.location` �� `spring.config.extra-location` ������ʹ��ͨ���λ�á�
+
+
+
+
+
+|  | ͨ���λ�ñ���ֻ����һ�� `*` ���� `*/` ��β��������������Ŀ¼��λ�ã��� `*/<filename>` �������������ļ���λ�á� ����ͨ�����λ�ý������ļ����ľ���·������ĸ˳������ |
+| --- | --- |
+
+
+
+
+
+|  | ͨ���λ��ֻ���ⲿĿ¼�����á� �㲻���� `classpath:` λ����ʹ��ͨ����� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.files.profile-specific)2.3.3\. �ض��ļ���Profile Specific Files��
+
+
+
+���� `application` �����ļ���Spring Boot��������ʹ�� `application-{profile}` ��������������profile�ض����ļ��� ���磬������Ӧ�ó��򼤻�����Ϊ `prod` �������ļ���`spring.profiles.active=prod`����ʹ��YAML�ļ�����ô `application.yml` �� `application-prod.yml` ���������ǡ�
+
+
+
+
+
+�ض��ļ�(`profiles`)���������׼�� `application.properties` ��λ����ͬ���ض��ļ����������ڷ��ض��ļ��� ���ָ���˼��������ļ�����������ʤ���IJ��ԡ� ���磬��������ļ� `prod,live` ���� `spring.profiles.active` ����ָ���ģ�`application-prod.properties` �е�ֵ���Ա� `application-live.properties` �е�ֵ�����ǡ�
+
+
+
+
+
+|  | ���ʤ���IJ���������[location group](https://springdoc.cn/spring-boot/features.html#features.external-config.files.location-groups)���� `spring.config.location` �� `classpath:/cfg/,classpath:/ext/` ���������� `classpath:/cfg/;classpath:/ext/` ��ͬ�ĸ��ǹ������磬����������� `prod,live` ������˵�����ǿ����������ļ��� /cfg  application-live.properties/ext  application-live.properties  application-prod.properties ��������һ�� `spring.config.location` Ϊ `classpath:/cfg/,classpath:/ext/` ʱ�����ǻ������� `/ext` �ļ�֮ǰ�������� `/cfg` �ļ���1.  `/cfg/application-live.properties`        2.  `/ext/application-prod.properties`        3.  `/ext/application-live.properties`        �������� `classpath:/cfg/;classpath:/ext/` ����ʱ���� `;` �ָ�������������ͬһ������ `/cfg` �� `/ext` ��1.  `/ext/application-prod.properties`        2.  `/cfg/application-live.properties`        3.  `/ext/application-live.properties`         |
+| --- | --- |
+
+
+
+
+
+`Environment` ��һ��Ĭ�ϵ������ļ���Ĭ��Ϊ `[default]` �������û�����û�������ļ����ͻ�ʹ����Щ�����ļ��� ���仰˵�����û����ȷ����������ļ�����ô�ͻῼ������ `application-default` �����ԡ�
+
+
+
+
+
+|  | �����ļ�ֻ������һ�Ρ� ������Ѿ�ֱ��[������](https://springdoc.cn/spring-boot/features.html#features.external-config.files.importing)һ�������ļ����ض������ļ�����ô�������ᱻ�ڶ��ε��롣 |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.files.importing)2.3.4\. ������������
+
+
+
+application properties �п���ʹ�� `spring.config.import` ���Դ������ط����������������ݡ� �����ڱ�����ʱ��������������Ϊ����������������ļ��������Ķ����ļ���
+
+
+
+
+
+���磬���������� classpath `application.properties` �ļ������������ݡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+spring.application.name=myapp
+spring.config.import=optional:file:./dev.properties
+
+```
+
+
+
+
+
+
+
+�⽫�������뵱ǰĿ¼�µ� `dev.properties` �ļ�����������������ļ����� ����� `dev.properties` �е�ֵ�������ڴ���������ļ��� ������������У�`dev.properties` ���Խ� `spring.application.name` ���¶���Ϊһ����ͬ��ֵ��
+
+
+
+
+
+һ������ֻ�ᱻ����һ�Σ����������������ٴΡ� һ��������properties/yaml�ļ��ڵĵ����ļ��б������˳�򲢲���Ҫ�� ���磬������������Ӳ�����ͬ�Ľ����
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+spring.config.import=my.properties
+my.property=value
+
+```
+
+
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+my.property=value
+spring.config.import=my.properties
+
+```
+
+
+
+
+
+
+
+���������������У�`my.properties` �ļ���ֵ�������ڴ����䵼����ļ���
+
+
+
+
+
+��һ����һ�� `spring.config.import` �����¿���ָ�����λ�á� λ�ý��������DZ������˳�򱻴����������ĵ��뽫�����ȴ�����
+
+
+
+
+
+|  | ���ʵ���ʱ��[�ض������ļ��ı���](https://springdoc.cn/spring-boot/features.html#features.external-config.files.profile-specific)Ҳ�����ǵ��롣 ��������ӽ����� `my.properties` �Լ��κ� `my-<profile>.properties` ���塣 |
+| --- | --- |
+
+
+
+
+
+|  | Spring Boot �ṩ�˿ɲ�ε�API�������������֧�ָ��ֲ�ͬ��λ�õ�ַ�� Ĭ������£�����Ե���Java Properties��YAML�� ��[������](https://springdoc.cn/spring-boot/features.html#features.external-config.files.configtree)�� ��������jar�����ṩ������������֧�֣���Ҫ������DZ����ļ����� ���磬����������������������ⲿ�洢����Consul��Apache ZooKeeper��Netflix Archaius������Nacos�����������֧�����Լ���λ�ã�ʵ���Լ���������ü��أ�������� `org.springframework.boot.context.config` ���е� `ConfigDataLocationResolver` �� `ConfigDataLoader` �ࡣ |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.files.importing-extensionless)2.3.5\. ��������չ�����ļ�
+
+
+
+��Щ��ƽ̨����Ϊ��װ�ļ���volume mounted files�������ļ���չ���� Ҫ������Щ����չ�����ļ�������Ҫ��Spring Bootһ����ʾ���Ա���֪����μ������ǡ� �����ͨ������չ����ʾ���ڷ���������������һ�㡣
+
+
+
+
+
+���磬��������һ�� `/etc/config/myconfig` �ļ�����ϣ����yaml��ʽ���롣 �����������ķ�������� `application.properties` �е�������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+spring.config.import=file:/etc/config/myconfig[.yaml]
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.files.configtree)2.3.6\. ʹ����������Configuration Trees��
+
+
+
+������ƽ̨����Kubernetes��������Ӧ�ó���ʱ���㾭����Ҫ��ȡƽ̨�ṩ������ֵ�� �������������ڴ���Ŀ�IJ����ټ������������ȱ�㣬�ر��������ֵ�� secret �ġ�
+
+
+
+
+
+��Ϊ�������������������������ƽ̨���������㽫����ӳ�䵽���ص����ݾ��� ���磬Kubernetes ���Ծ����� [`ConfigMaps`](https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/#populate-a-volume-with-data-stored-in-a-configmap) �� [`Secrets`](https://kubernetes.io/docs/concepts/configuration/secret/#using-secrets-as-files-from-a-pod)��
+
+
+
+
+
+����ʹ�����ֳ����� volume ����ģʽ��
+
+
+
+
+
+1.  һ���ļ�����һ�����������ԣ�ͨ��д��YAML����
+
+2.  ����ļ���д��һ��Ŀ¼���У��ļ�����Ϊ ��key�������ݳ�Ϊ ��value����
+
+
+
+
+
+���ڵ�һ������������ʹ�� `spring.config.import` ֱ�ӵ���YAML�������ļ���[��������](https://springdoc.cn/spring-boot/features.html#features.external-config.files.importing)�� ���ڵڶ������������Ҫʹ�� `configtree:` ǰ׺���Ա�Spring Boot֪������Ҫ�������ļ���Ϊ���Թ�����
+
+
+
+
+
+�ٸ����ӣ�����������һ�£�Kubernetes�Ѿ�����������volume��
+
+
+
+
+
+
+
+ etc/
+  config/
+    myapp/
+      username
+      password 
+
+
+
+
+
+
+
+`username` �ļ������ݽ���һ������ֵ���� `password` �����ݽ���һ�� secret��
+
+
+
+
+
+Ҫ������Щ���ԣ����������� `application.properties` �� `application.yaml` �ļ��������������ݡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+spring.config.import=optional:configtree:/etc/config/
+
+```
+
+
+
+
+
+
+
+Ȼ������Դ� `Environment` ���Գ��淽ʽ���ʻ�ע�� `myapp.username` �� `myapp.password` ���ԡ�
+
+
+
+
+
+|  | �������µ��ļ��й������������ơ� ������������У�Ϊ�˷�������Ϊ `username` �� `password`������Խ� `spring.config.import` ����Ϊ `optional:configtree:/etc/config/myapp` �� |
+| --- | --- |
+
+
+
+
+
+|  | ���е���ŵ��ļ���Ҳ�ᱻ��ȷӳ�䡣 ���磬������������У�`/etc/config` ����Ϊ `myapp.username` ���ļ��� `Environment` �е������������� `myapp.username` �� |
+| --- | --- |
+
+
+
+
+
+|  | ��������ֵ���Ա��󶨵��ַ��� `String` �� `byte[]` ���ͣ���ȡ����Ԥ�ڵ����ݡ� |
+| --- | --- |
+
+
+
+
+
+������ж��������Ҫ��ͬһ�����ļ��е��룬�����ʹ��ͨ�����ݷ�ʽ�� �κ��� `/*/` ��β�� `configtree:` λ�ý���������ֱ�ӵ����ļ�����Ϊ��������
+
+
+
+
+
+���磬��������volume��
+
+
+
+
+
+
+
+ etc/
+  config/
+    dbconfig/
+      db/
+        username
+        password
+    mqconfig/
+      mq/
+        username
+        password 
+
+
+
+
+
+
+
+�����ʹ�� `configtree:/etc/config/*/` ��Ϊ����λ�á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+spring.config.import=optional:configtree:/etc/config/*/
+
+```
+
+
+
+
+
+
+
+�⽫���� `db.username`��`db.password`��`mq.username` �� `mq.password` ���ԡ�
+
+
+
+
+
+|  | ʹ��ͨ������ص�Ŀ¼�ǰ���ĸ˳�����еġ� �������Ҫһ����ͬ��˳����ô��Ӧ�ð�ÿ��λ����Ϊһ�������ĵ����г��� |
+| --- | --- |
+
+
+
+
+
+������Ҳ������Docker secret�� ��Docker swarm���������secret�ķ���Ȩʱ����secret�ᱻװ�ص������С� ���磬���һ����Ϊ `db.password` ��secret���������� `/run/secrets/` ��λ�ã�����������·����� `db.password` ��Spring�������á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+spring.config.import=optional:configtree:/run/secrets/
+
+```
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.files.property-placeholders)2.3.7\. ����ռλ��
+
+
+
+`application.properties` �� `application.yml` �е�ֵ��ʹ��ʱͨ�����е� `Environment` ���ˣ���������Բο���ǰ�����ֵ�����磬����ϵͳ���Ի򻷾��������� ��׼�� `${name}` ����ռλ���﷨��������һ��ֵ���κεط��� ����ռλ��Ҳ����ָ��һ��Ĭ��ֵ��ʹ�� `:` ���ָ�Ĭ��ֵ���������ƣ����� `${name:default}` ��
+
+
+
+
+
+�����������ʾ�˴�Ĭ��ֵ�Ͳ���Ĭ��ֵ��ռλ����ʹ�������
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+app.name=MyApp
+app.description=${app.name} is a Spring Boot application written by ${username:Unknown}
+
+```
+
+
+
+
+
+
+
+���� `username` ����û���������ط����ã�`app.description` ��ֵ���� `MyApp is a Spring Boot application written by Unknown`��
+
+
+
+
+
+|  | ��Ӧ��ʼ��ʹ��ռλ���е��������ƵĹ淶��ʽ����ʹ��Сд��ĸ��kebab-case�����������ǡ� �⽫����Spring Bootʹ����[���ɰ�](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.relaxed-binding) `@ConfigurationProperties` ʱ��ͬ���߼������磬`${demo.item-price}` ���� `application.properties` �ļ��л�ȡ `demo.item-price` �� `demo.itemPrice` ��ʽ�����ԣ��Լ���ϵͳ�����л�ȡ `DEMO_ITEMPRICE` �� ������� `${demo.itemPrice}` �Ļ��� `demo.item-price` �� `DEMO_ITEMPRICE` �Ͳ��ᱻ���ǡ� |
+| --- | --- |
+
+
+
+
+
+|  | ��Ҳ����ʹ�����ּ�������������Spring Boot���Ե� ��short�� ���塣 ������μ�_[howto.html](https://springdoc.cn/spring-boot/howto.html#howto.properties-and-configuration.short-command-line-arguments)_�ķ����� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.files.multi-document)2.3.8\. ʹ�ö��ĵ��ļ���Working with Multi-Document Files��
+
+
+
+Spring Boot�����㽫һ�������ļ��ֳɶ���߼��ļ���ÿ���ļ����Ƕ������ӵġ� �ļ��ǰ�˳�����ģ����ϵ��¡� ������ļ����Ը���ǰ���ļ��ж�������ԡ�
+
+
+
+
+
+���� `application.yml` �ļ���ʹ�ñ�׼��YAML���ĵ��﷨�� �������������ַ���`---`������һ���ļ��Ľ���������һ���ļ��Ŀ�ʼ��
+
+
+
+
+
+���磬������ļ��������߼��ĵ���
+
+
+
+
+
+
+
+```
+spring:
+  application:
+    name: "MyApp"
+---
+spring:
+  application:
+    name: "MyCloudApp"
+  config:
+    activate:
+      on-cloud-platform: "kubernetes"
+```
+
+
+
+
+
+
+
+���� `application.properties` �ļ���һ������� `#---` �� `!---` ע�ͱ���������ļ��ķָ
+
+
+
+
+
+
+
+```
+spring.application.name=MyApp
+#---
+spring.application.name=MyCloudApp
+spring.config.activate.on-cloud-platform=kubernetes
+```
+
+
+
+
+
+
+
+|  | properties �ļ��ķָ����������κ�ǰ���հף����ұ����������������ַ��� �ָ�����ǰ�����в�������ͬ��ע��ǰ׺�� |
+| --- | --- |
+
+
+
+
+
+|  | ���ĵ������ļ�ͨ���뼤������һ��ʹ�ã��� `spring.config.activated.on-profile`�� ���[��һ��](https://springdoc.cn/spring-boot/features.html#features.external-config.files.activation-properties)�� |
+| --- | --- |
+
+
+
+
+
+|  | ���ĵ������ļ�����ͨ��ʹ�� `@PropertySource` �� `@TestPropertySource` ע����ء� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.files.activation-properties)2.3.9\. �������ԣ�Activation Properties��
+
+
+
+��ʱ��ֻ������ijЩ����ʱ����һ���ض��������Ǻ����õġ� ���磬�������һЩ����ֻ�����ض��������ļ�������ʱ����ء�
+
+
+
+
+
+�����ʹ�� `spring.config.activation.*` �������ؼ���һ�������ļ���
+
+
+
+
+
+�������������¡�
+
+
+
+<caption>Table 2\. activation properties</caption><colgroup><col><col></colgroup>
+| ���� | ˵�� |
+| --- | --- |
+| `on-profile` | һ��������֮ƥ��������ļ�����ʽ����ʹ�ļ����ڻ״̬������ָ���������ļ�ʱ��Ч���� |
+| `on-cloud-platform` | �����⵽�� `CloudPlatform`����ʹ�ļ����ڻ״̬������ƽ̨״̬����Ч�� |
+
+
+
+���磬����ָ���ڶ����ļ�ֻ����Kubernetes������ʱ����Ч������ֻ���� ��prod�� �� ��staging�� �����ļ����ڻ״̬ʱ����Ч��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+myprop=always-set
+#---
+spring.config.activate.on-cloud-platform=kubernetes
+spring.config.activate.on-profile=prod | staging
+myotherprop=sometimes-set
+
+```
+
+
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.external-config.encrypting)2.4\. �����������ԣ�Encrypting Properties��
+
+
+
+Spring Bootû��Ϊ��������ֵ�ṩ�κ�����֧�֣������ṩ��Hookm�����������޸�Spring `Environment` �а�����ֵ�� `EnvironmentPostProcessor` �ӿ���������Ӧ�ó�������ǰ���� `Environment`�� �μ�[howto.html](https://springdoc.cn/spring-boot/howto.html#howto.application.customize-the-environment-or-application-context)���˽����顣
+
+
+
+
+
+�������Ҫһ�ְ�ȫ�ķ�ʽ���洢ƾ֤�����룬 [Spring Cloud Vault](https://cloud.spring.io/spring-cloud-vault/) ��Ŀ�ṩ�˶��� [HashiCorp Vault](https://www.vaultproject.io/)�д洢�ⲿ�����õ�֧�֡�
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.external-config.yaml)2.5\. ʹ�� YAML
+
+
+
+[YAML](https://yaml.org/) ��JSON�ij����������ָ���ֲ��������ݵķ����ʽ�� ֻҪ���classpath���� [SnakeYAML](https://github.com/snakeyaml/snakeyaml) �⣬`SpringApplication` ��ͻ��Զ�֧��YAML��Ϊproperties�����Ʒ��
+
+
+
+
+
+|  | �����ʹ�� ��Starter����SnakeYAML���� `spring-boot-starter` �Զ��ṩ�� |
+| --- | --- |
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.yaml.mapping-to-properties)2.5.1\. ��YAMLӳ�䵽Properties
+
+
+
+YAML �ĵ���Ҫ����ֲ��ʽת��Ϊ���� Spring `Environment` һ��ʹ�õı�ƽ�ṹ�� ���磬�����������YAML�ĵ���
+
+
+
+
+
+
+
+```
+environments:
+  dev:
+    url: "https://dev.example.com"
+    name: "Developer Setup"
+  prod:
+    url: "https://another.example.com"
+    name: "My Cool App"
+```
+
+
+
+
+
+
+
+Ϊ�˴� `Environment` �з�����Щ���ԣ����ǽ�����ƽ����������ʾ��
+
+
+
+
+
+
+
+```
+environments.dev.url=https://dev.example.com
+environments.dev.name=Developer Setup
+environments.prod.url=https://another.example.com
+environments.prod.name=My Cool App
+```
+
+
+
+
+
+
+
+ͬ���أ�YAML�е��б�Ҳ��Ҫ���б�ƽ�������� ���DZ���ʾΪ���� `[index]` ������key�� ���磬���������YAML��
+
+
+
+
+
+
+
+```
+my:
+ servers:
+ - "dev.example.com"
+ - "another.example.com"
+```
+
+
+
+
+
+
+
+ǰ������ӽ���ת��Ϊ�������ԡ�
+
+
+
+
+
+
+
+```
+my.servers[0]=dev.example.com
+my.servers[1]=another.example.com
+```
+
+
+
+
+
+
+
+|  | ʹ�� `[index]` ���ŵ����Կ���ʹ��Spring Boot�� `Binder` ��󶨵�Java `List` �� `Set` ���� ����ϸ�ڼ������ ��[���Ͱ�ȫ����������](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties)�� ���֡� |
+| --- | --- |
+
+
+
+
+
+|  | YAML�ļ�����ͨ��ʹ�� `@PropertySource` �� `@TestPropertySource` ע�������ء� ���ԣ�������Ҫ�����ַ�ʽ����ֵ������£�����Ҫʹ��һ�� properties �ļ��� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.yaml.directly-loading)2.5.2\. ֱ�Ӽ���YAML
+
+
+
+Spring Framework�ṩ������������࣬������������YAML�ĵ��� `YamlPropertiesFactoryBean` ��YAML��Ϊ `Properties` ���أ�`YamlMapFactoryBean` ��YAML��Ϊ `Map` ���ء�
+
+
+
+
+
+��������YAML����ΪSpring�� `PropertySource` ����Ҳ����ʹ�� `YamlPropertySourceLoader` �ࡣ
+
+
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.external-config.random-values)2.6\. �������ֵ
+
+
+
+The `RandomValuePropertySource` is useful for injecting random values (for example, into secrets or test cases). It can produce integers, longs, uuids, or strings, as shown in the following example:
+
+
+
+
+
+`RandomValuePropertySource` ����ע�����ֵ�����ã����磬ע���������԰������� �����Բ���Integer��Long��UUID����String���������������ʾ��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+my.secret=${random.value}
+my.number=${random.int}
+my.bignumber=${random.long}
+my.uuid=${random.uuid}
+my.number-less-than-ten=${random.int(10)}
+my.number-in-range=${random.int[1024,65536]}
+
+```
+
+
+
+
+
+
+
+`random.int*` ���﷨�� `OPEN value (,max) CLOSE`������ `OPEN,CLOSE` ���κ��ַ��� `value,max` �������� ����ṩ�� `max`����ô `value` ����Сֵ�� `max` �����ֵ����ռ����
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.external-config.system-environment)2.7\. ����ϵͳ��������
+
+
+
+Spring Boot֧��Ϊ������������һ��ǰ׺�� ���ϵͳ������������в�ͬ����Ҫ���Spring BootӦ�ó���������ͺ����á� ϵͳ�������Ե�ǰ׺����ֱ���� `SpringApplication` �����á�
+
+
+
+
+
+���磬����㽫ǰ׺����Ϊ `input` ������ `remote.timeout` ������������ϵͳ������Ҳ��������Ϊ `input.remote.timeout`��
+
+
+
+
+
+
+
+### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties)2.8\. ���Ͱ�ȫ����������
+
+
+
+ʹ�� `@Value("${property}")` ע����ע������������ʱ����鷳���ر��ǵ���Ҫ����������Ի���������Ƿֲ�ġ� Spring Boot�ṩ��һ�ִ������Ե������������ǿ���͵�Bean��������֤���Ӧ�ó�������á�
+
+
+
+
+
+|  | ����μ�[`@Value` �����Ͱ�ȫ��������֮�������](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.vs-value-annotation)�� |
+| --- | --- |
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.java-bean-binding)2.8.1\. JavaBean ���԰�
+
+
+
+�������������ʾ�����԰�һ�������˱�׼JavaBean���Ե�bean��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@ConfigurationProperties("my.service")
+public class MyProperties {
+
+    private boolean enabled;
+
+    private InetAddress remoteAddress;
+
+    private final Security security = new Security();
+
+    // getters / setters...
+
+    public static class Security {
+
+        private String username;
+
+        private String password;
+
+        private List<String> roles = new ArrayList<>(Collections.singleton("USER"));
+
+        // getters / setters...
+
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+ǰ���POJO�������������ԡ�
+
+
+
+
+
+*   `my.service.enabled`��Ĭ��ֵΪ`false`��
+
+*   `my.service.remote-address`�������Ϳ���`String`ǿ���ṩ��
+
+*   `my.service.security.username`����һ��Ƕ�׵� `security` �����������ɸ����Ե����ƾ����� �ر��ǣ�������ȫû��ʹ�����ͣ������� `SecurityProperties`��
+
+*   `my.service.security.password`.
+
+*   `my.service.security.role`����һ�� `String` �ļ��ϣ�Ĭ��Ϊ `USER`��
+
+
+
+
+
+|  | ӳ�䵽Spring Boot�п��õ� `@ConfigurationProperties` ������ԣ�ͨ��properties�ļ���YAML�ļ��������������������ƽ������ã���Щ�����ǹ���API�����౾���� getters/setters ������ζ�ſ���ֱ��ʹ�ã�һ�仰��SpringҲ��ͨ��getter/setter��Щpublic������������ֵ�ģ�����ã��� |
+| --- | --- |
+
+
+
+
+
+|  | ���������������һ��Ĭ�ϵ��޲ι��캯����getter��setterͨ���DZ���ģ���Ϊ����ͨ����׼��Java Beans property descriptor��Java��ʡ��ʵ�ֵģ�������Spring MVC��һ���� ����������£�����ʡ��setter��*   Map, ֻҪ���DZ���ʼ��������Ҫһ��getter������һ����Ҫһ��setter����Ϊ���ǿ��Ա�����ͻ�䡣        *   Collection��array ����ͨ��������ͨ����YAML����ʹ�õ������ŷָ���ֵ�����ԣ������ʡ� �ں�һ������£�һ��setter�DZ���ġ� ���ǽ�������Ϊ������������һ��setter�� ������ʼ��һ�����ϣ�ȷ�������Dz��ɱ�ģ���ǰ������ӣ���        *   ���Ƕ�׵�POJO���Ա���ʼ��������ǰ�������е� `Security` �ֶΣ����Ͳ���Ҫsetter�� ��������ð���ͨ��ʹ������Ĭ�Ϲ��캯������ʱ����ʵ��������Ҫһ��setter��        ��Щ��ʹ��Project Lombok���Զ�����getter��setter�� ��ȷ��Lombok����Ϊ���������������κ��ض��Ĺ��캯������Ϊ���������Զ�����ʵ�����������ֻ���DZ�׼��Java Bean���ԣ���֧�ֶԾ�̬���Եİ󶨡� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.constructor-binding)2.8.2\. ���캯����
+
+
+
+��һ�ڵ����ӿ����ò��ɱ�ķ�ʽ��д����������ʾ��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@ConfigurationProperties("my.service")
+public class MyProperties {
+
+    // fields...
+
+    public MyProperties(boolean enabled, InetAddress remoteAddress, Security security) {
+        this.enabled = enabled;
+        this.remoteAddress = remoteAddress;
+        this.security = security;
+    }
+
+    // getters...
+
+    public static class Security {
+
+        // fields...
+
+        public Security(String username, String password, @DefaultValue("USER") List<String> roles) {
+            this.username = username;
+            this.password = password;
+            this.roles = roles;
+        }
+
+        // getters...
+
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+�����������У�Ψһ�ġ����������캯�����Ĵ�����ζ��Ӧ��ʹ�øù��캯�����а󶨡� ����ζ�Ű������ҵ�һ��������ϣ���󶨵IJ����Ĺ��캯���� ���������ж�����캯��������ʹ�� `@ConstructorBinding` ע����ָ��ʹ���ĸ����캯�����й��캯���󶨡� ���ҪΪһ��ֻ��һ�������������캯��������ѡ�񲻰󶨹��캯�����ù��캯�������� `@Autowired` ��ע�⡣ ���캯���󶨿����� `Record` һ��ʹ�á� ������ļ�¼�ж�����캯��������û�б�Ҫʹ�� `@ConstructorBinding`��
+
+
+
+
+
+���캯�������Ƕ�׳�Ա�������������е� `Security`��Ҳ��ͨ���乹�캯�����󶨡�
+
+
+
+
+
+Ĭ��ֵ�����ڹ��캯��������Record�����ʹ�� `@DefaultValue` ��ָ���� ת�����񽫱�Ӧ���ڽ�ע��� `String` ֵǿ��ת��Ϊȱʧ���Ե�Ŀ�����͡�
+
+
+
+
+
+�ο�ǰ������ӣ����û�����԰󶨵� `Security` �� `MyProperties` ʵ��������һ�� `security` ���͵� `null` ֵ�� Ϊ��ʹ������һ���� null �� `Security` ʵ������ʹû��������֮�󶨣���ʹ��Kotlinʱ���⽫Ҫ�� `Security` �� `username` �� `password` ����������Ϊ nullable����Ϊ����û��Ĭ��ֵ����ʹ��һ���յ� `@DefaultValue` ע�⡣
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+public MyProperties(boolean enabled, InetAddress remoteAddress, @DefaultValue Security security) {
+    this.enabled = enabled;
+    this.remoteAddress = remoteAddress;
+    this.security = security;
+}
+
+```
+
+
+
+
+
+
+
+|  | Ҫʹ�ù��캯���󶨣��������ʹ�� `@EnableConfigurationProperties` ����������ɨ�������á� �㲻�ܶ�ͨ������Spring���ƴ�����Beanʹ�ù��캯���󶨣����� `@Component` Bean��ͨ��ʹ�� `@Bean` ����������Bean��ͨ��ʹ�� `@Import` ���ص�Bean���� |
+| --- | --- |
+
+
+
+
+
+|  | Ҫ��ԭ��������ʹ�ù��캯���󶨣������� `-parameters` ����������ࡣ�����ʹ�� Spring Boot �� Gradle �����ʹ�� Maven �� `spring-boot-starter-parent`���⽫�Զ����á� |
+| --- | --- |
+
+
+
+
+
+|  | �����齫 `java.util.Optional` �� `@ConfigurationProperties` һ��ʹ�ã���Ϊ����Ҫ����Ϊһ����������ʹ�á� ��ˣ��������ʺ���������ע�롣 Ϊ�����������͵����Ա���һ�£������ȷʵ������һ�� `Optional` ���ԣ�����û��ֵ��`null` ������һ���յ� `Optional` �����󶨡� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.enabling-annotated-types)2.8.3\. ���� @ConfigurationProperties ��
+
+
+
+Spring Boot�ṩ�˰� `@ConfigurationProperties` ���Ͳ�����ע��ΪBean�Ļ�����ʩ�� ������������Ļ����������������ԣ�����������������ɨ�裬�乤����ʽ�����ɨ�����ơ�
+
+
+
+
+
+��ʱ���� `@ConfigurationProperties` ע�������ܲ��ʺ�ɨ�裬���磬��������ڿ������Լ����Զ����û����������������������ǡ� ����Щ����£�ʹ�� `@EnableConfigurationProperties` ע��ָ��Ҫ�����������б��� ������ע�����κ� `@Configuration` ���ϣ��������������ʾ��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Configuration(proxyBeanMethods = false)
+@EnableConfigurationProperties(SomeProperties.class)
+public class MyConfiguration {
+
+}
+
+```
+
+
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@ConfigurationProperties("some.properties")
+public class SomeProperties {
+
+}
+
+```
+
+
+
+
+
+
+
+Ҫʹ����������ɨ�裬�������application���� `@ConfigurationPropertiesScan` ע�⡣ ͨ�����������ӵ��� `@SpringBootApplication` ע���main���У�����Ҳ���Ա����ӵ��κ� `@Configuration` ���ϡ� Ĭ������£�ɨ����ע�����ڵİ���ʼ����������Զ���ɨ�������������Բο����¡�
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@SpringBootApplication
+@ConfigurationPropertiesScan({ "com.example.app", "com.example.another" })
+public class MyApplication {
+
+}
+
+```
+
+
+
+
+
+
+
+|  | �� `@ConfigurationProperties` Beanʹ����������ɨ���ͨ�� `@EnableConfigurationProperties` ע��ʱ����Bean��һ���������ƣ�`<prefix>-<fqn>`������ `<prefix>` �� `@ConfigurationProperties` ע����ָ���Ļ�����ǰ׺�� `<fqn>` ��Bean����ȫ�޶����ơ� ���ע��û���ṩ�κ�ǰ׺����ֻʹ��Bean����ȫ�޶����ơ��������� `com.example.app` ���У������ `SomeProperties` ���ӵ� bean ������ `some.properties-com.example.app.SomeProperties`�� |
+| --- | --- |
+
+
+
+
+
+���ǽ��� `@ConfigurationProperties` ֻ���� environment���ر��Dz���������ע������Bean�� ���ڱ߽ǰ��������������������ʹ�� setter ע������ṩ���κ� `*Aware` �ӿڣ��� `EnvironmentAware` ���������Ҫ���� `Environment`���� �������Ȼ��ʹ�ù�����ע������Bean����������Bean������ `@Component` ��ע�⣬��ʹ�û���JavaBean�����԰󶨡�
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.using-annotated-types)2.8.4\. ʹ�� @ConfigurationProperties ��
+
+
+
+�������÷�ʽ�� `SpringApplication` �ⲿYAML������ϵ��ر�ã�������������ʾ��
+
+
+
+
+
+
+
+```
+my:
+  service:
+    remote-address: 192.168.1.1
+    security:
+      username: "admin"
+      roles:
+      - "USER"
+      - "ADMIN"
+```
+
+
+
+
+
+
+
+Ҫʹ�� `@ConfigurationProperties` Bean���������������Bean��ͬ�ķ�ʽע�����ǣ���������ʾ��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Service
+public class MyService {
+
+    private final MyProperties properties;
+
+    public MyService(MyProperties properties) {
+        this.properties = properties;
+    }
+
+    public void openConnection() {
+        Server server = new Server(this.properties.getRemoteAddress());
+        server.start();
+        // ...
+    }
+
+    // ...
+
+}
+
+```
+
+
+
+
+
+
+
+|  | ʹ�� `@ConfigurationProperties` ��������������Ԫ�����ļ�����Щ�ļ����Ա�IDE�����������Եġ��Զ���ȫ�����ܡ� �����[��¼](https://springdoc.cn/spring-boot/configuration-metadata.html#appendix.configuration-metadata)�� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.third-party-configuration)2.8.5\. ����������
+
+
+
+����ʹ�� `@ConfigurationProperties` ��ע��һ����֮�⣬�㻹�����ڹ����� `@Bean` ������ʹ������ ����������԰󶨵������֮��ĵ��������ʱ���������ر����á�
+
+
+
+
+
+Ҫ�� `Environment` ����������һ��Bean��������Beanע�������� `@ConfigurationProperties` ����������ʾ��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@Configuration(proxyBeanMethods = false)
+public class ThirdPartyConfiguration {
+
+    @Bean
+    @ConfigurationProperties(prefix = "another")
+    public AnotherComponent anotherComponent() {
+        return new AnotherComponent();
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+�κ��� `another` ǰ׺�����JavaBean���Զ��ᱻӳ�䵽 `AnotherComponent` Bean�ϣ��䷽ʽ������ǰ��� `SomeProperties` ���ӡ�
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.relaxed-binding)2.8.6\. ���ɵİ�
+
+
+
+Spring Boot�ڽ� `Environment` ���԰󶨵� `@ConfigurationProperties` beanʱʹ����һЩ���ɵĹ������ `Environment` �������ƺ�bean��������֮�䲻��Ҫ��ȫƥ�䡣 ������ã����������Ӱ������ۺŷָ����������ƣ����磬 `context-path` �󶨵� `contextPath` �����ʹ�д���������ƣ����磬`PORT` �󶨵� `port` ����
+
+
+
+
+
+��ʾһ�����ӣ��������� `@ConfigurationProperties` �ࡣ
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@ConfigurationProperties(prefix = "my.main-project.person")
+public class MyPersonProperties {
+
+    private String firstName;
+
+    public String getFirstName() {
+        return this.firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+�����ϵĴ�����˵�����µ��������ƶ�����ʹ�á�
+
+
+
+<caption>Table 3\. relaxed binding</caption><colgroup><col><col></colgroup>
+| Property | Note |
+| --- | --- |
+| `my.main-project.person.first-name` | Kebab ��񣨶̺��߸������������� `.properties` �� `.yml` �ļ���ʹ�á� |
+| `my.main-project.person.firstName` | ��׼���շ��﷨�� |
+| `my.main-project.person.first_name` | �»��ߣ�����һ������ `.properties` �� `.yml` �ļ��������ʽ�� |
+| `MY_MAINPROJECT_PERSON_FIRSTNAME` | ��д��ʽ����ʹ��ϵͳ��������ʱ����ʹ�ô�д��ʽ�� |
+
+
+
+|  | ע��� `prefix` ֵ _����_ ��kebab���Сд���� `-` �ָ����� `my.main-project.person` ���� |
+| --- | --- |
+
+
+
+<caption>Table 4\. ÿ������Դ�Ŀ��ɰ󶨹���</caption><colgroup><col><col><col></colgroup>
+| ����Դ | �򵥵� | �б� |
+| --- | --- | --- |
+| Properties �ļ� | �շ�, kebab , �»��� | ʹ�� `[ ]` �򶺺ŷָ�ֵ�ı�׼�б��﷨ |
+| YAML �ļ� | �շ�, kebab , �»��� | ��׼YAML�б��﷨�򶺺ŷָ���ֵ |
+| �������� | ��д���»���Ϊ�ָ���(�� [�ӻ���������](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables)). | Numeric values surrounded by underscores (see [�ӻ���������](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables)) |
+| ϵͳ���ԣ�System properties�� | �շ�, kebab , �»��� | ʹ�� `[ ]` �򶺺ŷָ�ֵ�ı�׼�б��﷨ |
+
+
+
+|  | ���ǽ��飬�ڿ��ܵ�����£�����Ӧ��Сд��kebab��ʽ�洢������ `my.person.first-name=Rod` �� |
+| --- | --- |
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.relaxed-binding.maps)��Map
+
+
+
+���󶨵� `Map` ����ʱ���������Ҫʹ��һ����������ŷ��ţ��Ա㱣��ԭʼ�� `key` ֵ�� ���keyû�б� `[ ]` �������κη���ĸ���֡�`-` �� `.` ���ַ�����ɾ����
+
+
+
+
+
+���磬���ǽ��������԰󶨵�һ�� `Map<String,String>`��
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+my.map.[/key1]=value1
+my.map.[/key2]=value2
+my.map./key3=value3
+```
+
+
+
+
+
+
+
+|  | ����YAML�ļ���������Ҫ�����Ű�������ʹkey����ȷ������ |
+| --- | --- |
+
+
+
+
+
+��������Խ��󶨵�һ�� `Map` ��`/key1`��`/key2` �� `key3` ��Ϊmap��key�� б���Ѿ��� `key3` ��ɾ������Ϊ��û�б������Ű�����
+
+
+
+
+
+���󶨵�����ֵʱ������ `.` �ļ�����Ҫ�� `[]` ������ ����ֵ����ö�ٺ����� `java.lang` ���е����ͣ����� `Object` �� �� `a.b=c` �󶨵� `Map<String, String>` ���������е� `.` ��������һ������ `{"a.b"="c"}` Entry��Map�� �����κ��������ͣ������� `key` ���� `.` ������Ҫʹ�����ŷ��š� ���磬�� `a.b=c` �󶨵� `Map<String, Object>` ������һ������ `{"a"={"b"="c"}` entry��Map���� `[a.b]=c` ������һ������ `{"a.b"="c"}` entry ��Map��
+
+
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables)�ӻ���������
+
+
+
+���磬Linux shell����ֻ�ܰ�����ĸ��`a` �� `z` �� `A` �� `Z` �������֣� `0` �� `9` �����»����ַ��� `_` ���� ���չ�����Unix shell����������Ҳ�����ô�д��ĸ��
+
+
+
+
+
+Spring Boot���ɵİ󶨹������Ϊ�����ܵ�����Щ�������Ƽ��ݡ�
+
+
+
+
+
+Ҫ���淶��ʽ����������ת��Ϊ�����������ƣ��������ѭ��Щ����
+
+
+
+
+
+*   ���»��ߣ�`_`���滻�㣨`.`����
+
+*   ɾ���κ����ۺţ�`-`����
+
+*   ת��Ϊ��д��ĸ��
+
+
+
+
+
+���磬�������� `spring.main.log-startup-info` ����һ����Ϊ `SPRING_MAIN_LOGSTARTUPINFO` �Ļ���������
+
+
+
+
+
+��������Ҳ�����ڰ󶨵������б���List��ʱʹ�á� Ҫ�󶨵�һ�� `List`���ڱ��������У�Ԫ�ر�ţ�������Ӧ�����»��߰�����
+
+
+
+
+
+���磬�������� `my.service[0].other` ��ʹ��һ����Ϊ `MY_SERVICE_0_OTHER` �Ļ���������
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.merging-complex-types)2.8.7\. �ϲ����ӵ�����
+
+
+
+��List�������ڶ���ط�ʱ�����ǵ��������滻����list��
+
+
+
+
+
+���磬����һ�� `MyPojo` ����� `name` �� `description` ����Ĭ��Ϊ `null`�� ��������Ӵ� `MyProperties` �б�¶��һ�� `MyPojo` ������б���
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@ConfigurationProperties("my")
+public class MyProperties {
+
+    private final List<MyPojo> list = new ArrayList<>();
+
+    public List<MyPojo> getList() {
+        return this.list;
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+�����������á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+my.list[0].name=my name
+my.list[0].description=my description
+#---
+spring.config.activate.on-profile=dev
+my.list[0].name=my another name
+
+```
+
+
+
+
+
+
+
+��� `dev` �����ļ�δ�����`MyProperties.list` ����һ�� `MyPojo` ��Ŀ����֮ǰ����������� Ȼ������� `dev` �����ļ������`list` ��Ȼֻ����һ����Ŀ��name Ϊ `my another name`��descriptionΪ `null`���� �������ò������б������ӵڶ��� `MyPojo` ʵ����Ҳ����ϲ���Ŀ��
+
+
+
+
+
+��һ�� `List` �ڶ�������ļ��б�ָ��ʱ����ʹ�þ���������ȼ����Ǹ�������ֻ���Ǹ����� ������������ӡ�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+my.list[0].name=my name
+my.list[0].description=my description
+my.list[1].name=another name
+my.list[1].description=another description
+#---
+spring.config.activate.on-profile=dev
+my.list[0].name=my another name
+
+```
+
+
+
+
+
+
+
+��ǰ��������У���� `dev` �����ļ��Ǽ���ģ�`MyProperties.list` ���� _һ��_ `MyPojo` ��Ŀ��name �� `my another name`��description�� `null`���� ����YAML�����ŷָ����б���YAML�б�������������ȫ�����б������ݡ�
+
+
+
+
+
+���� `Map` ���ԣ�������ôӶ����Դ��ȡ������ֵ���а󶨡� Ȼ�������ڶ����Դ�е�ͬһ���ԣ�ʹ�þ���������ȼ����Ǹ��� ��������Ӵ� `MyProperties` ��¶��һ�� `Map<String, MyPojo>`��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@ConfigurationProperties("my")
+public class MyProperties {
+
+    private final Map<String, MyPojo> map = new LinkedHashMap<>();
+
+    public Map<String, MyPojo> getMap() {
+        return this.map;
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+�����������á�
+
+
+
+
+
+
+
+Properties
+
+Yaml
+
+
+
+
+
+```
+my.map.key1.name=my name 1
+my.map.key1.description=my description 1
+#---
+spring.config.activate.on-profile=dev
+my.map.key1.name=dev name 1
+my.map.key2.name=dev name 2
+my.map.key2.description=dev description 2
+
+```
+
+
+
+
+
+
+
+��� `dev` �����ļ�û�м��`MyProperties.map` ����һ��keyΪ `key1` ����Ŀ��nameΪ `my name 1` ��descriptionΪ `my description 1` ���� Ȼ������� `dev` �����ļ������`map` ����������Ŀ��keyΪ `key1` ��nameΪ `dev name 1`��descriptionΪ `my description 1` ���� `key2`��nameΪ `dev name 2`��descriptionΪ `dev description 2`����
+
+
+
+
+
+|  | ǰ��ĺϲ�������������������Դ�����ԣ������������ļ��� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.conversion)2.8.8\. ���ԣ�Properties��ת��
+
+
+
+��Spring Boot�� `@ConfigurationProperties` Bean��ʱ������ͼ���ⲿapplication propertiesǿ�Ƹ�Ϊ��ȷ�����͡� �������Ҫ�Զ�������ת����������ṩһ�� `ConversionService` bean��Bean������Ϊ `conversionService` �����Զ������Ա༭����ͨ�� `CustomEditorConfigurer` bean�����Զ��� `Converters` Bean��ʹ�� `@ConfigurationPropertiesBinding` ע�⣩��
+
+
+
+
+
+|  | �������Bean����Ӧ�ó����������ڵ����ڱ�����ģ���ȷ��������� `ConversionService` ��ʹ�õ�������ϵ�� ͨ������£�������Ҫ���κ�������ϵ�ڴ���ʱ����û����ȫ��ʼ���� �������Զ��� `ConversionService` ����Ҫ����keys coercion�����������������������ֻ������ `@ConfigurationPropertiesBinding` �޶����Զ���ת������ |
+| --- | --- |
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.conversion.durations)ת��Ϊ Duration
+
+
+
+Spring Boot�Ա������ʱ����ר�ŵ�֧�֡� ����㹫����һ�� `java.time.Duration` ���ԣ�application properties�е����¸�ʽ�Ϳ��á�
+
+
+
+
+
+*   ��ͨ�� `long` ��ʹ�ú�����ΪĬ�ϵ�λ������ָ���� `@DurationUnit` ����
+
+*   ��׼��ISO-8601��ʽ [�� `java.time.Duration` ʹ��](https://docs.oracle.com/javase/17/docs/api/java/time/Duration.html#parse-java.lang.CharSequence-)��
+
+*   һ�����׶��ĸ�ʽ������ֵ�͵�λ����ϵģ�`10s` ��ʾ10�룩��
+
+
+
+
+
+�뿼���������ӡ�
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@ConfigurationProperties("my")
+public class MyProperties {
+
+    @DurationUnit(ChronoUnit.SECONDS)
+    private Duration sessionTimeout = Duration.ofSeconds(30);
+
+    private Duration readTimeout = Duration.ofMillis(1000);
+
+    // getters / setters...
+
+}
+
+```
+
+
+
+
+
+
+
+Ҫָ��һ��30��ĻỰ��ʱ�� `30` �� `PT30S` �� `30s` ���ǵȼ۵ġ� ��ȡ��ʱΪ500ms�������������κ�һ����ʽָ���� `500`, `PT0.5S` �� `500ms`.
+
+
+
+
+
+��Ҳ����ʹ������֧�ֵ�ʱ�䵥λ��
+
+
+
+
+
+*   `ns` ����
+
+*   `us` ΢��
+
+*   `ms` ����
+
+*   `s` ��
+
+*   `m` ��
+
+*   `h` Сʱ
+
+*   `d` ��
+
+
+
+
+
+Ĭ�ϵ�λ�Ǻ��룬����ʹ�� `@DurationUnit` ����д���������������ʾ��
+
+
+
+
+
+�����ϲ��ʹ�ù��캯���󶨣�ͬ�������Կ��Ա���¶�������������������ʾ��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@ConfigurationProperties("my")
+public class MyProperties {
+
+    // fields...
+
+    public MyProperties(@DurationUnit(ChronoUnit.SECONDS) @DefaultValue("30s") Duration sessionTimeout,
+            @DefaultValue("1000ms") Duration readTimeout) {
+        this.sessionTimeout = sessionTimeout;
+        this.readTimeout = readTimeout;
+    }
+
+    // getters...
+
+}
+
+```
+
+
+
+
+
+
+
+|  | �����Ҫ����һ�� `Long` �����ԣ���������Ǻ��룬��ȷ�����嵥λ��ʹ�� `@DurationUnit` ���� �������ṩ��һ��͸��������·����ͬʱ֧�ָ��ḻ�ĸ�ʽ |
+| --- | --- |
+
+
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.conversion.periods)ת��Ϊ�ڼ䣨Period��
+
+
+
+����duration��Spring Boot������ʹ�� `java.time.Period` ���͡� ���¸�ʽ������application properties��ʹ�á�
+
+
+
+
+
+*   һ������� `int` ��ʾ����ʹ������ΪĬ�ϵ�λ������ָ���� `@PeriodUnit` ����
+
+*   ��׼��ISO-8601��ʽ [�� `java.time.Period` ʹ��](https://docs.oracle.com/javase/17/docs/api/java/time/Period.html#parse-java.lang.CharSequence-)��
+
+*   һ�����򵥵ĸ�ʽ������ֵ�͵�λ������ϵģ� `1y3d` ��ʾ1��3�죩��
+
+
+
+
+
+֧�����м򵥵ĵ�λ��ʽ��
+
+
+
+
+
+*   `y` ��
+
+*   `m` ��
+
+*   `w` ��
+
+*   `d` ��
+
+
+
+
+
+|  | `java.time.Period` ����ʵ���ϴ�δ�洢������������һ����ݷ�ʽ����ζ�� ��7�족�� |
+| --- | --- |
+
+
+
+
+
+
+
+##### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.conversion.data-sizes)ת��Ϊ���ݴ�С��Data Sizes��
+
+
+
+Spring Framework��һ�� `DataSize` ֵ���ͣ����ֽ�Ϊ��λ�����С�� ����㹫����һ�� `DataSize` ���ԣ�application properties�е����¸�ʽ�Ϳ��á�
+
+
+
+
+
+*   һ������� `long` ��ʾ��ʹ���ֽ���ΪĬ�ϵ�λ������ָ���� `@DataSizeUnit`����
+
+*   һ�����׶��ĸ�ʽ������ֵ�͵�λ����ϵģ�`10MB` ��ζ��10���ֽڣ���
+
+
+
+
+
+�����������ӡ�
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@ConfigurationProperties("my")
+public class MyProperties {
+
+    @DataSizeUnit(DataUnit.MEGABYTES)
+    private DataSize bufferSize = DataSize.ofMegabytes(2);
+
+    private DataSize sizeThreshold = DataSize.ofBytes(512);
+
+    // getters/setters...
+
+}
+
+```
+
+
+
+
+
+
+
+Ҫָ��һ��10���ֽڣ�Mb���Ļ�������С�� `10` �� `10MB` �ǵȼ۵ġ� 256�ֽڵĴ�С��ֵ����ָ��Ϊ `256` �� `256B`��
+
+
+
+
+
+��Ҳ����ʹ��������Щ֧�ֵĵ�λ��
+
+
+
+
+
+*   `B` �ֽ�
+
+*   `KB` KB
+
+*   `MB` MB
+
+*   `GB` GB
+
+*   `TB` TB
+
+
+
+
+
+Ĭ�ϵ�λ���ֽڣ�����ʹ�� `@DataSizeUnit` ����д���������������ʾ��
+
+
+
+
+
+�����ϲ��ʹ�ù��캯���󶨣�ͬ�������Կ��Ա���¶�������������������ʾ��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@ConfigurationProperties("my")
+public class MyProperties {
+
+    // fields...
+
+    public MyProperties(@DataSizeUnit(DataUnit.MEGABYTES) @DefaultValue("2MB") DataSize bufferSize,
+            @DefaultValue("512B") DataSize sizeThreshold) {
+        this.bufferSize = bufferSize;
+        this.sizeThreshold = sizeThreshold;
+    }
+
+    // getters...
+
+}
+
+```
+
+
+
+
+
+
+
+|  | �������������һ�� `Long` ���ԣ�ȷ�����嵥λ��ʹ�� `@DataSizeUnit`��������������ֽڡ� �������ṩ��һ��͸��������·����ͬʱ֧�ָ��ḻ�ĸ�ʽ�� |
+| --- | --- |
+
+
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.validation)2.8.9\. @ConfigurationProperties ��
+
+
+
+ֻҪʹ��Spring�� `@Validated` ע�⣬Spring Boot�ͻ᳢����֤ `@ConfigurationProperties` �ࡣ �����ֱ���������������ʹ��JSR-303�� `jakarta.validation` Լ��ע�⡣ Ҫ������һ�㣬��ȷ�����classpath����һ�����ݵ�JSR-303ʵ�֣�Ȼ��Լ��ע�����ӵ�����ֶ��У��������������ʾ��
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@ConfigurationProperties("my.service")
+@Validated
+public class MyProperties {
+
+    @NotNull
+    private InetAddress remoteAddress;
+
+    // getters/setters...
+
+}
+
+```
+
+
+
+
+
+
+
+|  | ��Ҳ����ͨ���� configuration properties �� `@Bean` ������ע�� `@Validated` ��������֤�� |
+| --- | --- |
+
+
+
+
+
+Ϊ��ȷ������ΪǶ�׵����Դ�����֤����ʹû���ҵ����ԣ���ص��ֶα����� `@Valid` ��ע�͡� ��������ӽ�����ǰ��� `MyProperties` �Ļ����ϡ�
+
+
+
+
+
+
+
+Java
+
+Kotlin
+
+
+
+
+
+```
+@ConfigurationProperties("my.service")
+@Validated
+public class MyProperties {
+
+    @NotNull
+    private InetAddress remoteAddress;
+
+    @Valid
+    private final Security security = new Security();
+
+    // getters/setters...
+
+    public static class Security {
+
+        @NotEmpty
+        private String username;
+
+        // getters/setters...
+
+    }
+
+}
+
+```
+
+
+
+
+
+
+
+��Ҳ����ͨ������һ����Ϊ `configurationPropertiesValidator` ��bean����������һ���Զ����Spring `Validator`�� `@Bean` ����Ӧ�ñ�����Ϊ `static`�� ����������֤������Ӧ�ó����������ڵ����ڴ����ģ��� `@Bean` ��������Ϊ��̬��������Bean�Ĵ�������Ҫʵ���� `@Configuration` �ࡣ ���������Ա������ʵ��������������κ����⡣
+
+
+
+
+
+|  | `spring-boot-actuator` ģ�����һ����¶���� `@ConfigurationProperties` Bean �Ķ˵㡣 �����ͨ����������� `/actuator/configprops` ��ʹ����Ӧ��JMX�˵㡣 �����"[��������](https://springdoc.cn/spring-boot/actuator.html#actuator.endpoints)"���֡� |
+| --- | --- |
+
+
+
+
+
+
+
+#### [](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.vs-value-annotation)2.8.10\. @ConfigurationProperties vs. @Value
+
+
+
+`@Value` ע����һ�����ĵ��������ܣ������ṩ�����Ͱ�ȫ������������ͬ�Ĺ��ܡ� �±��ܽ��� `@ConfigurationProperties` �� `@Value` ��֧�ֵĹ��ܡ�
+
+
+
+<colgroup><col><col><col></colgroup>
+| ���� | `@ConfigurationProperties` | `@Value` |
+| --- | --- | --- |
+| [���ɰ�](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.relaxed-binding) | Yes | ������ (�� [����ע��](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.vs-value-annotation.note)) |
+| [֧�� Meta-data](https://springdoc.cn/spring-boot/configuration-metadata.html#appendix.configuration-metadata) | Yes | No |
+| `SpEL` ����ʽ | No | Yes |
+
+
+
+|  | �����ȷʵ��ʹ�� `@Value`�����ǽ�����ʹ���������ƵĹ淶��ʽ����ʹ��Сд��ĸ��kebab-case���������������ơ� �⽫����Spring Bootʹ���� [���ɰ�](https://springdoc.cn/spring-boot/features.html#features.external-config.typesafe-configuration-properties.relaxed-binding) `@ConfigurationProperties` ʱ��ͬ���߼������磬`@Value("${demo.item-price}")` ���� `application.properties` �ļ��л�ȡ `demo.item-price` �� `demo.itemPrice` ��ʽ���Լ���ϵͳ�����л�ȡ `DEMO_ITEMPRICE`�� ������� `@Value("${demo.itemPrice}")` ���棬`demo.item-price` �� `DEMO_ITEMPRICE` �����ᱻ���ǡ� |
+| --- | --- |
+
+
+
+
+
+�����Ϊ���Լ������������һ�����ü������ǽ����㽫���Ƿ�����һ���� `@ConfigurationProperties` ע���POJO�С� ��������Ϊ���ṩ�ṹ���ġ����Ͱ�ȫ�Ķ�������Խ���ע�뵽���Լ���bean�С�
+
+
+
+
+
+����Ӧ��[application property](https://springdoc.cn/spring-boot/features.html#features.external-config.files) �ļ��� `SpEL` ����ʽ�ڽ�����Щ�ļ������environmentʱ���ᱻ������ Ȼ���������� `@Value` ��дһ�� `SpEL` ����ʽ�� �������Ӧ�ó��������ļ�������ֵ��һ�� `SpEL` ����ʽ�������ڱ� `@Value` ����ʱ��������
+
+
+
+
+
+
+
+
+
+
+
+
+
+## [](https://springdoc.cn/spring-boot/features.html#features.profiles)
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\350\207\252\345\270\246\347\232\204\347\203\255\351\203\250\347\275\262\345\267\245\345\205\267.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\350\207\252\345\270\246\347\232\204\347\203\255\351\203\250\347\275\262\345\267\245\345\205\267.md"
new file mode 100644
index 0000000..477370a
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\350\207\252\345\270\246\347\232\204\347\203\255\351\203\250\347\275\262\345\267\245\345\205\267.md"
@@ -0,0 +1,345 @@
+# SpringBoot���� - �����Ȳ���devtools����
+
+> ��SpringBoot���������У������ÿ�д�����޸Ķ���Ҫ���������ٵ��ԣ����ܱȽϷ�ʱ�䣻SpringBoot�Ŷ���Դ������ṩ��spring-boot-devtools�����devtools�����������ͼ�����������Ե�Ч�ʡ�@pdai
+
+*   [SpringBoot���� - �����Ȳ���devtools����](#springboot%E5%85%A5%E9%97%A8---%E9%85%8D%E7%BD%AE%E7%83%AD%E9%83%A8%E7%BD%B2devtools%E5%B7%A5%E5%85%B7)
+    *   [׼��֪ʶ��](#%E5%87%86%E5%A4%87%E7%9F%A5%E8%AF%86%E7%82%B9)
+        *   [ʲô���Ȳ�����ȼ��أ�](#%E4%BB%80%E4%B9%88%E6%98%AF%E7%83%AD%E9%83%A8%E7%BD%B2%E5%92%8C%E7%83%AD%E5%8A%A0%E8%BD%BD)
+        *   [ʲô��LiveLoad��](#%E4%BB%80%E4%B9%88%E6%98%AFliveload)
+    *   [����devtoolsʵ���Ȳ���](#%E9%85%8D%E7%BD%AEdevtools%E5%AE%9E%E7%8E%B0%E7%83%AD%E9%83%A8%E7%BD%B2)
+        *   [POM����](#pom%E9%85%8D%E7%BD%AE)
+        *   [IDEA����](#idea%E9%85%8D%E7%BD%AE)
+        *   [application.yml����](#applicationyml%E9%85%8D%E7%BD%AE)
+        *   [ʹ��LiveLoad](#%E4%BD%BF%E7%94%A8liveload)
+    *   [��һ������](#%E8%BF%9B%E4%B8%80%E6%AD%A5%E7%90%86%E8%A7%A3)
+        *   [devtool��ԭ����Ϊ�λ��Զ�������](#devtool%E7%9A%84%E5%8E%9F%E7%90%86%E4%B8%BA%E4%BD%95%E4%BC%9A%E8%87%AA%E5%8A%A8%E9%87%8D%E5%90%AF)
+        *   [devtool�Ƿ�ᱻ�����Jar��](#devtool%E6%98%AF%E5%90%A6%E4%BC%9A%E8%A2%AB%E6%89%93%E5%8C%85%E8%BF%9Bjar)
+        *   [devtoolΪ�λ�Ĭ�Ͻ��û���ѡ�](#devtool%E4%B8%BA%E4%BD%95%E4%BC%9A%E9%BB%98%E8%AE%A4%E7%A6%81%E7%94%A8%E7%BC%93%E5%AD%98%E9%80%89%E9%A1%B9)
+        *   [devtool�Ƿ���Ը�����SpringbootӦ����ȫ�ֵ����ã�](#devtool%E6%98%AF%E5%90%A6%E5%8F%AF%E4%BB%A5%E7%BB%99%E6%89%80%E6%9C%89springboot%E5%BA%94%E7%94%A8%E5%81%9A%E5%85%A8%E5%B1%80%E7%9A%84%E9%85%8D%E7%BD%AE)
+        *   [����Ҳ���devtool������ʲôѡ��](#%E5%A6%82%E6%9E%9C%E6%88%91%E4%B8%8D%E7%94%A8devtool%E8%BF%98%E6%9C%89%E4%BB%80%E4%B9%88%E9%80%89%E6%8B%A9)
+    *   [ʾ��Դ��](#%E7%A4%BA%E4%BE%8B%E6%BA%90%E7%A0%81)
+    *   [�����](#%E5%8F%82%E8%80%83%E6%96%87%E7%AB%A0)
+
+## [#](#׼��֪ʶ��) ׼��֪ʶ��
+
+### [#](#ʲô���Ȳ�����ȼ���) ʲô���Ȳ�����ȼ��أ�
+
+> �Ȳ�����ȼ�������Ӧ���������е�ʱ���Զ����£����¼��ػ����滻class�ȣ�Ӧ�õ�һ����������PS��spring-boot-devtools�ṩ�ķ���Ҳ��Ҫ�����ģ�ֻ�������ֶ�������ʵ���Զ����ض��ѡ���
+
+�ϸ������ϣ�������Ҫ�������Ȳ�����ȼ���, ����Java��Ŀ���ԣ�
+
+*   **�Ȳ���**
+
+    *   �ڷ���������ʱ���²�����Ŀ
+    *   ����ֱ�����¼�������Ӧ�ã����ַ�ʽ���ͷ��ڴ棬���ȼ��ظ��Ӹɾ����ף���ͬʱҲ����ʱ�䡣
+*   **�ȼ���**
+
+    *   ��������ʱ���¼���class���Ӷ�����Ӧ�á�
+    *   �ȼ��ص�ʵ��ԭ����Ҫ����[java������ػ���](/md/java/jvm/java-jvm-classload.html)����ʵ�ַ�ʽ���Ը���Ϊ������������ʱ����һ����̨�̣߳���ʱ�ļ�����ļ���ʱ����仯��������ʱ�������ˣ������������롣
+    *   �Աȷ�����ƣ�������������ʱ��ȡ����Ϣ��ͨ����̬�ĵ������ı������Ϊ�� �ȼ�������������ʱͨ�����¼��ظı�����Ϣ��ֱ�Ӹı������Ϊ��
+
+### [#](#ʲô��liveload) ʲô��LiveLoad��
+
+LiveLoad���ṩ������ͻ����Զ����ظ��µĹ��ߣ���ΪLiveLoad��������Liveload�������������֣� devtools���Ѿ�������LiveLoad������������������ǿ�������webӦ�ã���������������Զ�ˢ�£� ��ʱ����Կ���LiveLoad.
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416205152.png)
+
+ͬһʱ��ֻ������һ��LiveReload�������� ��ʼӦ�ó���֮ǰ����ȷ��û������LiveReload�������������С������IDE�������Ӧ�ó�����ֻ�е�һ��Ӧ�ó���֧��LiveReload��
+
+## [#](#����devtoolsʵ���Ȳ���) ����devtoolsʵ���Ȳ���
+
+> ����ͨ������������ʵ���Զ�������ʽ���Ȳ���
+
+### [#](#pom����) POM����
+
+����spring-boot-devtools������
+
+
+
+```
+<dependencies>
+    <dependency>
+        <groupId>org.springframework.boot</groupId>
+        spring-boot-devtools
+        <optional>true</optional> <!-- ���Է�ֹ��devtools�������ݵ�����ģ���� -->
+    </dependency>
+</dependencies>
+
+```
+
+
+
+### [#](#idea����) IDEA����
+
+> �����ʹ��IDEA�������ߣ�ͨ�����������ַ�ʽ��
+
+*   ��ʽһ�� **���κ�����ʱ���ֶ������������£�Ctrl+F9��**
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416205320.png)
+��Ҳ������`mvn compile`���봥���������£�
+
+*   ��ʽ���� **IDEA�迪������ʱ���룬�Զ���������**
+
+**����1**��
+
+File->Setting->Build,Execution,Deployment->Compile
+
+��ѡ��Make project automatically
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416205335.png)
+
+**����2**��
+
+��ݼ���ctrl+alt+shift+/
+
+ѡ��Registry
+
+��ѡ��compiler.automake.allow.when.app.running
+
+�°汾��IDEA������File->setting->Advanced Setttings����ĵ�һ�����ã�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416205405.png)
+### [#](#application-yml����) application.yml����
+
+
+
+```
+spring:
+  devtools:
+    restart:
+      enabled: true  #���ÿ����Ȳ���
+      additional-paths: src/main/java #����Ŀ¼
+      exclude: WEB-INF/**
+  thymeleaf:
+    cache: false #ʹ��Thymeleafģ�����棬�رջ���
+
+```
+
+
+
+### [#](#ʹ��liveload) ʹ��LiveLoad
+
+spring-boot-devtoolsģ�����**Ƕ��ʽLiveReload������**����������Դ����ʱ���ڴ��������ˢ�¡� LiveReload�������չ����֧��Chrome��Firefox��Safari������Դ�livereload.com������ء�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416205417.png)
+���ߴ����������������أ�����firefox:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416205426.png)
+
+��װ��֮�󣬿���ͨ������ͼ�����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416205442.png)
+
+����㲻����Ӧ�ó�������ʱ����LiveReload������������Խ�spring.devtools.livereload.enabled��������Ϊfalse ��
+
+ͬһʱ��ֻ������һ��LiveReload�������� ��ʼӦ�ó���֮ǰ����ȷ��û������LiveReload�������������С������IDE�������Ӧ�ó�����ֻ�е�һ��Ӧ�ó���֧��LiveReload��
+
+## [#](#��һ������) ��һ������
+
+> ��ȻһЩ�����߻�ʹ��devtool���ߣ����Ǻ������ܹ���������ģ��������������¼������⣬�������һ�����⡣@pdai
+
+### [#](#devtool��ԭ��-Ϊ�λ��Զ�����) devtool��ԭ����Ϊ�λ��Զ�������
+
+> Ϊʲôͬ��������Ӧ�ã�Ϊʲô���ֶ����������ǽ���ʹ��spring-boot-devtools�����Ȳ���������
+
+spring-boot-devtoolsʹ���������������ClassLoader��һ��ClassLoader���ز��ᷢ�����ĵ��ࣨ������jar��������һ��ClassLoader��restart ClassLoader�����ػ���ĵ��ࣨ�Զ�����ࣩ��
+
+��̨����һ��**�ļ������̣߳�File Watcher��**��**����Ŀ¼�е��ļ������䶯ʱ�� ԭ����restart ClassLoader���������������¼����µ�restart ClassLoader**��
+
+��Ϊ�ļ��䶯�󣬵�����jar���������¼��أ�ֻ�����Զ�����࣬���ص���Ƚ��٣����������ȽϿ졣
+
+��Ҳ��Ϊʲô��ͬ��������Ӧ�ã�Ϊʲô���ֶ�����������ʹ��spring-boot-devtools�����Ȳ���������
+
+���Զ��������м�����Ҫע��:
+
+*   **�Զ��������¼��־��**
+
+����¼��ʲô�������������־��
+
+����ͨ�����¹ر�
+
+
+
+```
+spring:
+  devtools:
+    restart:
+      log-condition-evaluation-delta: false
+
+```
+
+
+
+*   **�ų�һЩ����Ҫ�Զ���������Դ**
+
+ijЩ��Դ�ڸ���ʱ��һ����Ҫ��������������Ĭ������£��ı���Դ/META-INF/maven��/META-INF/resources��/resources��/static��/public����/templates������������������ȷ�ᴥ���ֳ���װ�����Ҫ�Զ�����Щ�ų������ʹ�ø�spring.devtools.restart.exclude���ԡ����磬Ҫ���ų�/static��/public�㽫�����������ԣ�
+
+
+
+```
+spring:
+  devtools:
+    restart:
+      exclude: "static/**,public/**"
+
+```
+
+
+
+���Ҫ������ЩĬ��ֵ�����������ų������ø�spring.devtools.restart.additional-exclude���ԡ�
+
+*   **�Զ��������������**
+
+����������ͨ��ʹ���������������ʵ�ֵġ����ڴ����Ӧ�ó������ַ���Ч���ܺá����ǣ�����ʱ�ᵼ����������⡣
+
+Ĭ������£�IDE �е��κδ���Ŀ��ʹ�á�����������������أ��κγ���.jar�ļ���ʹ�á�����������������ء�����㴦��һ����ģ����Ŀ�����Ҳ���ÿ��ģ�鶼���뵽��� IDE �У��������Ҫ�Զ���һЩ������Ϊ�ˣ�����Դ���һ��META-INF/spring-devtools.properties�ļ���
+
+��spring-devtools.properties�ļ����԰�����restart.exclude��Ϊǰ׺������restart.include����includeԪ����Ӧ�ñ����ߵ����������������������Ŀ���Լ�excludeҪ����Ӧ���������롰Base�������������Ŀ�������Ե�ֵ��Ӧ������·�����������ʽģʽ��������ʾ����ʾ��
+
+
+
+```
+restart:
+  exclude:
+    companycommonlibs: "/mycorp-common-[\\w\\d-\\.]+\\.jar"
+  include:
+    projectcommon: "/mycorp-myproj-[\\w\\d-\\.]+\\.jar"
+
+```
+
+
+
+������ص���Ϣ������[�������´��ڴ�](https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.devtools)�鿴��
+
+### [#](#devtool�Ƿ�ᱻ�����jar) devtool�Ƿ�ᱻ�����Jar��
+
+> devtoolԭ������˵Ӧ����ֻ�ڿ������Ե�ʱ��ʹ�ã�����������������jar��ʱ�Dz���Ҫ�ģ�����Spring����᲻��������JAR��
+
+*   **Ĭ������£����ᱻ�����JAR**
+
+���д����Ӧ�ó���ʱ��������Ա����**���Զ�����**�������ͨ�� java -jar����������������������������ʱ�����ᱻ��Ϊ�ǡ�����������Ӧ�á���
+
+*   **�����������Զ�̵���Ӧ��**
+
+��_�����������ã�ֻ���������ε����������л�ʹ�� SSL ���б���ʱ����Ӧ������_��
+
+����������£�devtoolҲ�߱�Զ�̵��Ե�������Զ�̿ͻ���Ӧ�ó���ּ�ڴ���� IDE �����С�����Ҫorg.springframework.boot.devtools.RemoteSpringApplicationʹ���������ӵ�Զ����Ŀ��ͬ����·�����С�Ӧ�ó����Ψһ��������������ӵ���Զ�� URL��
+
+���磬���ʹ�� Eclipse �� Spring Tools����������һ��my-app�Ѳ��� Cloud Foundry ����Ϊ����Ŀ��ִ�����²�����
+
+1.  ѡ��Run Configurations��?��Run�˵���
+2.  ����һ���µ�Java Application���������á���
+3.  ���my-app��Ŀ��
+4.  ʹ��org.springframework.boot.devtools.RemoteSpringApplication��Ϊ���ࡣ
+5.  ����https://myapp.cfapps.io��Program arguments�����κ����Զ�� URL����
+
+�������е�Զ�̿ͻ��˿��������������б���
+
+
+
+```
+  .   ____          _                                              __ _ _
+ /\\ / ___'_ __ _ _(_)_ __  __ _          ___               _      \ \ \ \
+( ( )\___ | '_ | '_| | '_ \/ _` |        | _ \___ _ __  ___| |_ ___ \ \ \ \
+ \\/  ___)| |_)| | | | | || (_| []::::::[]   / -_) '  \/ _ \  _/ -_) ) ) ) )
+  '  |____| .__|_| |_|_| |_\__, |        |_|_\___|_|_|_\___/\__\___|/ / / /
+ =========|_|==============|___/===================================/_/_/_/
+ :: Spring Boot Remote :: 2.5.4
+
+2015-06-10 18:25:06.632  INFO 14938 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Starting RemoteSpringApplication on pwmbp with PID 14938 (/Users/pwebb/projects/spring-boot/code/spring-boot-project/spring-boot-devtools/target/classes started by pwebb in /Users/pwebb/projects/spring-boot/code)
+2015-06-10 18:25:06.671  INFO 14938 --- [           main] s.c.a.AnnotationConfigApplicationContext : Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@2a17b7b6: startup date [Wed Jun 10 18:25:06 PDT 2015]; root of context hierarchy
+2015-06-10 18:25:07.043  WARN 14938 --- [           main] o.s.b.d.r.c.RemoteClientConfiguration    : The connection to http://localhost:8080 is insecure. You should use a URL starting with 'https://'.
+2015-06-10 18:25:07.074  INFO 14938 --- [           main] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
+2015-06-10 18:25:07.130  INFO 14938 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Started RemoteSpringApplication in 0.74 seconds (JVM running for 1.105)
+
+```
+
+
+
+### [#](#devtoolΪ�λ�Ĭ�Ͻ��û���ѡ��) devtoolΪ�λ�Ĭ�Ͻ��û���ѡ�
+
+> Spring Boot ֧�ֵ�һЩ��**ʹ�û������������**�����磬ģ�����滺���ѱ����ģ���Ա����ظ�����ģ���ļ������⣬Spring MVC �������ṩ��̬��Դʱ����Ӧ���� HTTP �����ͷ��
+
+��Ȼ����**�������зdz����棬���ڿ��������п��ܻ��ʵ��䷴**��ʹ���޷������ո���Ӧ�ó����������ĸ��ġ��������ԭ�� spring-boot-devtools Ĭ�Ͻ��û���ѡ�
+
+����Thymeleaf �ṩ��spring.thymeleaf.cache������ģ������Ļ��棬ʹ��spring-boot-devtoolsģ��ʱ�Dz���Ҫ�ֶ�������Щ���Եģ���Ϊspring-boot-devtools���Զ��������á�
+
+��ô���Զ�������Щ�����أ��������DevToolsPropertyDefaultsPostProcessor���ҵ���Ӧ��Ĭ�����á�
+
+
+
+```
+public class DevToolsPropertyDefaultsPostProcessor implements EnvironmentPostProcessor {
+
+	static {
+		Map<String, Object> properties = new HashMap<>();
+		properties.put("spring.thymeleaf.cache", "false");
+		properties.put("spring.freemarker.cache", "false");
+		properties.put("spring.groovy.template.cache", "false");
+		properties.put("spring.mustache.cache", "false");
+		properties.put("server.servlet.session.persistent", "true");
+		properties.put("spring.h2.console.enabled", "true");
+		properties.put("spring.web.resources.cache.period", "0");
+		properties.put("spring.web.resources.chain.cache", "false");
+		properties.put("spring.template.provider.cache", "false");
+		properties.put("spring.mvc.log-resolved-exception", "true");
+		properties.put("server.error.include-binding-errors", "ALWAYS");
+		properties.put("server.error.include-message", "ALWAYS");
+		properties.put("server.error.include-stacktrace", "ALWAYS");
+		properties.put("server.servlet.jsp.init-parameters.development", "true");
+		properties.put("spring.reactor.debug", "true");
+		PROPERTIES = Collections.unmodifiableMap(properties);
+	}
+
+```
+
+
+
+��Ȼ����㲻�뱻Ӧ�����Ա�spring-boot-devtoolsĬ�����ã� ����ͨ��spring.devtools.add-properties��false��application.yml�С�
+
+### [#](#devtool�Ƿ���Ը�����springbootӦ����ȫ�ֵ�����) devtool�Ƿ���Ը�����SpringbootӦ����ȫ�ֵ����ã�
+
+> ����ͨ����spring-boot-devtools.yml�ļ����ӵ�$HOME/.config/spring-bootĿ¼��**����ȫ�� devtools ����**��
+
+���ӵ���Щ�ļ����κ����Զ��������������ʹ�� devtools ������Spring Boot Ӧ�ó������磬Ҫ��������������Ϊʼ��ʹ�ô������ļ�������Ҫ�������������ӵ����spring-boot-devtools�ļ��У�
+
+
+
+```
+spring:
+  devtools:
+    restart:
+      trigger-file: ".reloadtrigger"
+
+```
+
+
+
+### [#](#����Ҳ���devtool-����ʲôѡ��) ����Ҳ���devtool������ʲôѡ��
+
+> ����Ҳ���devtool������ʲôѡ��
+
+**��ʵ�ʵĿ��������У���Ҳ����ȥʹ��devtool����**, ��Ϊ��
+
+*   devtool��������������ʽ��������Ȼ�������������滻������JRebel���ǣ������շѵģ�
+*   ������������Ҫ�Ļ���һ��Ȩ��
+    *   �Զ������Ŀ���������ֶ�����û��ʲô̫������ô�������ֶ�����������������
+    *   ��������£������**�����ڲ����޸Ļ��߾�̬��Դ���޸�**����IDEA���ǿ���ͨ��Rebuild��Ctrl + Shift + F9�������ȸ���
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416211745.png)
+
+*   ���⻹��һ������spring loaded�� ��ʵ���޸����ļ����Ȳ��𣬾���ɿ���[github��ַ���´��ڴ�](https://github.com/spring-projects/spring-loaded)�ϵ�˵����
+
+## [#](#ʾ��Դ��) ʾ��Դ��
+
+https://github.com/realpdai/tech-pdai-spring-demos
+
+## [#](#�����) �����
+
+https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.devtools
+
+https://liayun.blog.csdn.net/article/details/116541775
+
+* * *
+
+����Ȩ��@pdai���� ԭ�����ӣ�https://pdai.tech/md/spring/springboot/springboot-x-hello-devtool.html
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\351\233\206\346\210\220Swagger\345\256\236\347\216\260API\346\226\207\346\241\243\350\207\252\345\212\250\347\224\237\346\210\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\351\233\206\346\210\220Swagger\345\256\236\347\216\260API\346\226\207\346\241\243\350\207\252\345\212\250\347\224\237\346\210\220.md"
new file mode 100644
index 0000000..e225d74
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/SpringBoot\351\233\206\346\210\220Swagger\345\256\236\347\216\260API\346\226\207\346\241\243\350\207\252\345\212\250\347\224\237\346\210\220.md"
@@ -0,0 +1,625 @@
+
+
+Ŀ¼
+
+*   [Swagger�Ľ���](https://www.cnblogs.com/progor/p/13297904.html#swagger%E7%9A%84%E4%BB%8B%E7%BB%8D)
+    *   [�ŵ���ȱ��](https://www.cnblogs.com/progor/p/13297904.html#%E4%BC%98%E7%82%B9%E4%B8%8E%E7%BC%BA%E7%82%B9)
+*   [����swagger](https://www.cnblogs.com/progor/p/13297904.html#%E6%B7%BB%E5%8A%A0swagger)
+    *   [1.������������](https://www.cnblogs.com/progor/p/13297904.html#1%E6%B7%BB%E5%8A%A0%E4%BE%9D%E8%B5%96%E5%8C%85)
+    *   [2.����Swagger:](https://www.cnblogs.com/progor/p/13297904.html#2%E9%85%8D%E7%BD%AEswagger)
+    *   [3.����](https://www.cnblogs.com/progor/p/13297904.html#3%E6%B5%8B%E8%AF%95)
+*   [������](https://www.cnblogs.com/progor/p/13297904.html#%E5%9C%BA%E6%99%AF)
+    *   [����ӿ���](https://www.cnblogs.com/progor/p/13297904.html#%E5%AE%9A%E4%B9%89%E6%8E%A5%E5%8F%A3%E7%BB%84)
+    *   [����ӿ�](https://www.cnblogs.com/progor/p/13297904.html#%E5%AE%9A%E4%B9%89%E6%8E%A5%E5%8F%A3)
+    *   [����ӿ��������](https://www.cnblogs.com/progor/p/13297904.html#%E5%AE%9A%E4%B9%89%E6%8E%A5%E5%8F%A3%E8%AF%B7%E6%B1%82%E5%8F%82%E6%95%B0)
+        *   [����һ�����������ʵ���ࡣ](https://www.cnblogs.com/progor/p/13297904.html#%E5%9C%BA%E6%99%AF%E4%B8%80%E8%AF%B7%E6%B1%82%E5%8F%82%E6%95%B0%E6%98%AF%E5%AE%9E%E4%BD%93%E7%B1%BB)
+        *   [����������������Ƿ�ʵ���ࡣ](https://www.cnblogs.com/progor/p/13297904.html#%E5%9C%BA%E6%99%AF%E4%BA%8C%E8%AF%B7%E6%B1%82%E5%8F%82%E6%95%B0%E6%98%AF%E9%9D%9E%E5%AE%9E%E4%BD%93%E7%B1%BB)
+    *   [����ӿ���Ӧ](https://www.cnblogs.com/progor/p/13297904.html#%E5%AE%9A%E4%B9%89%E6%8E%A5%E5%8F%A3%E5%93%8D%E5%BA%94)
+        *   [��Ӧ��ʵ���ࣺ](https://www.cnblogs.com/progor/p/13297904.html#%E5%93%8D%E5%BA%94%E6%98%AF%E5%AE%9E%E4%BD%93%E7%B1%BB)
+        *   [��Ӧ�Ƿ�ʵ���ࣺ](https://www.cnblogs.com/progor/p/13297904.html#%E5%93%8D%E5%BA%94%E6%98%AF%E9%9D%9E%E5%AE%9E%E4%BD%93%E7%B1%BB)
+*   [Swagger UI��ǿ](https://www.cnblogs.com/progor/p/13297904.html#swagger-ui%E5%A2%9E%E5%BC%BA)
+    *   [UI�Աȣ�](https://www.cnblogs.com/progor/p/13297904.html#ui%E5%AF%B9%E6%AF%94)
+    *   [ʹ��](https://www.cnblogs.com/progor/p/13297904.html#%E4%BD%BF%E7%94%A8)
+    *   [�ŵ�](https://www.cnblogs.com/progor/p/13297904.html#%E4%BC%98%E7%82%B9)
+*   [����Spring Securityע��](https://www.cnblogs.com/progor/p/13297904.html#%E6%95%B4%E5%90%88spring-security%E6%B3%A8%E6%84%8F)
+*   [����token�Ĵ���](https://www.cnblogs.com/progor/p/13297904.html#%E5%AF%B9%E4%BA%8Etoken%E7%9A%84%E5%A4%84%E7%90%86)
+*   [Swagger�İ�ȫ����](https://www.cnblogs.com/progor/p/13297904.html#swagger%E7%9A%84%E5%AE%89%E5%85%A8%E7%AE%A1%E7%90%86)
+
+
+
+* * *
+
+# Swagger�Ľ���
+
+?����ܳ��Թ�д��һ���ӿں��Լ�ȥ�����ӿ��ĵ��������޸Ľӿں��޸Ľӿ��ĵ�������֮����϶��ᷢ��һ���������Ǿ����������޸��ĵ����ߴ����ĵ����������ǹ�˾�ѽӿ��ĵ���д�ӿ�Ҫ��úܽ���?����д�ĵ��Ϳ۹��ʣ���������������Ĺ��������п�����©�ģ�����swagger����һ������д�ӿڵ�ʱ���Զ��������ɽӿ��ĵ��Ķ�����ֻҪ����ѭ���Ĺ淶��дһЩ�ӿڵ�˵��ע�⼴�ɡ�
+
+## �ŵ���ȱ��
+
+?�ŵ㣺
+
+*   �Զ������ĵ���ֻ��Ҫ�ڽӿ���ʹ��ע����б�ע���������ɶ�Ӧ�Ľӿ��ĵ���
+*   �Զ������ĵ��������Ƕ�̬���ɵģ�����������޸��˽ӿڣ��ĵ�Ҳ���Զ���Ӧ�޸ģ������Ҳ������ע��Ļ����������Ͳ��ᷢ�����޸��˽ӿڣ�ȴ���Ǹ��½ӿ��ĵ��������
+*   ֧�����ߵ��ԣ�swagger�ṩ�����ߵ��ýӿڵĹ��ܡ�
+
+?ȱ�㣺
+
+*   ���ܴ���������������������ʱ���ܰ��㴦�������е����顣��ֻ���ṩһ���򵥵����ߵ��ԣ��������洢��IJ�������������ʹ��Postman����YAPI����֧�ִ��������û��Ĺ��ܡ�
+*   Ҫ��ѭһЩ�淶������������淶�ġ�����˵������ܻ᷵��һ��json���ݣ���������ݿ�����һ��Map��ʽ�ģ���ô���Ǵ�ʱ���ܱ�ע���Map��ʽ�ķ������ݵ�ÿ���ֶε�˵�������������һ��ʵ����Ļ������ǿ���ͨ����ע����������������ֶμ�˵����Ҳ����˵������swagger�����Ƽ���ʹ��GET��ʽ�ύ���ݵ�ʱ��ʹ��Body�����Ƽ�ʹ��query������header��������·����������Ȼ���������ֻ���������ߵ��ԡ�
+*   û�нӿ��ĵ����¹�������Ȼһ���ӿڸ���֮�󣬿��ܲ�����ľɰ�Ľӿ���Ϣ�����㡰���ܡ��뿴���ɰ�Ľӿ���Ϣ��������Щ�Ҷȸ��·�����ʱ����ܻ�����ľɰ�Ľӿڡ���ô��ʱֻ���ɺ��ȥ������û��ע�������ˣ����Կ��Կ��ǽӿ��ĵ�����µ�ʱ��ע�;ɰ�ģ�Ȼ��д���°�ġ�����Ȼ����������ͨ�������ӿ��ĵ����Աȡ���
+*   ��Ȼ����Java��ʵ�������в���ģ�ͣ�po,dto,vo�ȣ�ģ�͵�������Ϊ������һЩ�������������һ���û���¼��ʱ��ֻ��Ҫusername,password������Ȩ�޵�ʱ����Ҫ������Ȩ�ޱ�����Ϣ�����������������������ʹ����User���ʵ��Ļ������ĵ��оͻ��Զ������˶������Ϣ�����Ҫ���������ģ�����������ʵ���࣬�����¼��ʱ��һ��LoginForm����Ҫ�û�-Ȩ�޵���Ϣ��ʱ���ʹ��User�ࡣ����Ȼ�ˣ������������swagger֮����ʹ�žͻ���ô�����������ˡ���
+
+?�����ȱ�����д���е�࣬����ܻ����swagger������е�󡣵���ʵ��Ҫ�ǹ淶���⣬���淶������ʱ���ֻ������Ĵ���淶�ԣ�����ͼ��ʼ����ˣ�����ǰ����ʲô�ӿڵIJ�����ʹ��һ���࣬������swaggerҪ����ֿ���ij�ֲ�����������Ĵ���淶�ԡ�
+
+?ע�����´���ʾ������Spring Boot������������Բο���[swagger-demo](https://github.com/alprogor/swagger-demo)
+
+* * *
+
+# ����swagger
+
+?�����Ƚ�����swagger��Ҳ���������Ͻ�����������ôʹ�ã�����ġ����������ٽ��⡣
+
+## 1.������������
+
+?ע�⣬�����ǰ�����Ѿ�������spring boot��web����
+
+���ƴ���
+
+```
+        <dependency>
+            <groupId>io.springfox</groupId>
+            springfox-swagger2
+            <version>2.9.2</version>
+        </dependency>
+        <dependency>
+            <groupId>io.springfox</groupId>
+            springfox-swagger-ui
+            <version>2.9.2</version>
+        </dependency>
+
+```
+
+## 2.����Swagger:
+
+Ҫʹ��swagger�����DZ����swagger�������ã�������Ҫ����һ��swagger�������࣬�����������ΪSwaggerConfig.java
+
+���ƴ���
+
+```
+package com.example.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import springfox.documentation.builders.ApiInfoBuilder;
+import springfox.documentation.builders.PathSelectors;
+import springfox.documentation.builders.RequestHandlerSelectors;
+import springfox.documentation.service.ApiInfo;
+import springfox.documentation.spi.DocumentationType;
+import springfox.documentation.spring.web.plugins.Docket;
+import springfox.documentation.swagger2.annotations.EnableSwagger2;
+
+@Configuration // ������������
+@EnableSwagger2 //����swagger����
+public class SwaggerConfig {
+    @Bean
+    public Docket createRestApi() {
+        return new Docket(DocumentationType.SWAGGER_2)  // DocumentationType.SWAGGER_2 �̶��ģ�����swagger2
+//                .groupName("�ֲ�ʽ����ϵͳ") // ������ö���ĵ���ʱ����ô��Ҫ����groupName�������ʶ
+                .apiInfo(apiInfo()) // ��������API��Ϣ
+                .select() // select()��������һ��ApiSelectorBuilderʵ��,�������ƽӿڱ�swagger�����ĵ�
+                .apis(RequestHandlerSelectors.basePackage("com.example.controller")) // ����ָ��ɨ���ĸ����µĽӿ�
+                .paths(PathSelectors.any())// ѡ�����е�API,�������ֻΪ����API�����ĵ���������������
+                .build();
+    }
+
+    /**
+     * ���ڶ���API���������Ϣ����������������е�API���ܱ��⡢�������汾
+     * @return
+     */
+    private ApiInfo apiInfo() {
+        return new ApiInfoBuilder()
+                .title("XX��ĿAPI") //  ���������Զ���API��������
+                .description("XX��ĿSwaggerAPI����") // �����������������API
+                .termsOfServiceUrl("") // ���ڶ�����������
+                .version("1.0") // ������������汾��
+                .build(); //
+    }
+}
+
+```
+
+## 3.����
+
+�������ǵ�Spring Boot��Ŀ������Ĭ����8080�˿ڣ�����㲻һ������ע���޸ĺ�����url��������`http://localhost:8080/swagger-ui.html`
+Ȼ����Ϳ��Կ���һ�����µĽ��棬����������ʱû�����ýӿ����ݣ�����������ʾ`No operations defined in spec!`
+
+![20200711013419](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20200711013419.png)
+
+?�������ǽ�������ζ���ӿڣ��Լ���swagger UI�����е����ݡ�
+
+* * *
+
+# ������
+
+## ����ӿ���
+
+�ӿ���ʱ��Ӧ���Ƿ���ģ����Ҵ󲿷ֶ�����һ��controller�еģ������û�������صĽӿ�Ӧ�ö���UserController�У���ô��ͬ��ҵ���ʱ��Ӧ�ö���/���ֲ�ͬ�Ľӿ��顣�ӿ������ʹ��`@Api`�����֡�
+���磺
+
+���ƴ���
+
+```
+@Api(tags = "��ɫ����") //  tags������Ե��������������֡�
+@RestController
+public class RoleController {
+}
+
+```
+
+��
+
+���ƴ���
+
+```
+@Api(tags = "�û�����") //  tags������Ե��������������֡�
+@RestController
+public class UserController {
+}
+
+```
+
+?��Ҳ��������ɻ���tags�����飬�ͺ���һЩ��������ı�ǩһ����ʹ�ñ�ǩ�����ࡣ
+?������Controller�£��ӿ��飩����û�нӿڣ���ô��swagger ui���Dz�����ʾ�ģ�����еĻ��ͻ�������ʾ��
+![20200712022545](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20200712022545.png)
+
+## ����ӿ�
+
+ʹ����`@Api`����עһ��Controller֮����������нӿڣ���ô�ͻ�Ĭ�������ĵ�����û�������Զ����˵����
+
+���ƴ���
+
+```
+@Api(tags = "�û�����")
+@RestController
+public class UserController {
+    // ע�⣬����swagger����Ҫʹ��@RequestMapping��
+    // ��Ϊ@RequestMapping֧����������ʽ��swagger��Ϊ����ӿ�����7������ʽ�Ľӿ��ĵ�
+    @GetMapping("/info") 
+    public String info(String id){
+        return "aaa";
+    }
+}
+
+```
+
+![20200711015840](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20200711015840.png)
+
+![20200711020149](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20200711020149.png)
+
+���ǿ���ʹ��`@ApiOperation`�������ӿڣ����磺
+
+���ƴ���
+
+```
+    @ApiOperation(value = "�û�����",notes = "�û�����notes")
+    @GetMapping("/test")
+    public String test(String id){
+        return "test";
+    }
+
+```
+
+![20200711021112](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20200711021112.png)
+���������
+
+*   value�����Ե����ǽӿڵļ��
+*   notes���ӿڵ�����
+*   tags�����Զ��ⶨ��ӿ��飬��������ӿ�����Ѿ���`@Api(tags = "�û�����")`�����ӿڻ��ֵ��ˡ��û��������У�������Զ����ʹ��tags������`tags = "��ɫ����"`�ý�ɫ������Ҳ������ӿ��ĵ���
+
+## ����ӿ��������
+
+����ʹ����`@ApiOperation`���������ӿڣ�����ʵ��ȱ�ٽӿ����������˵�����������Ƿֳ���������
+?ע��һ�£�**����GET��ʽ��swagger���Ƽ�ʹ��body��ʽ����������**��Ҳ���Dz�ϣ����GET��ʽʱʹ��json��form-data�ȷ�ʽ�����ݣ���ʱ�����ʹ��·����������url������(?��ȻPOSTMAN����֧�ֵ�)����������ӿڴ��ݵ�������json����form-data��ʽ�ģ�����ʹ��POST��ʽ�á�
+
+### ����һ�����������ʵ���ࡣ
+
+��ʱ������Ҫʹ��`@ApiModel`����עʵ���࣬Ȼ���ڽӿ��ж������Ϊʵ���༴�ɣ�
+
+*   @ApiModel����������
+    *   ���������
+        *   value��ʵ������
+        *   description��ʵ����˵��
+*   @ApiModelProperty��������������ֶε����塣
+    *   ���������
+        *   value���ֶ�˵��
+        *   example����������ʾ����Example Value����Ĭ��ֵ����������ã����ֶ�Ϊstring��ʱ�򣬴�ʱ����ʾ����Ĭ��ֵΪ"".
+        *   name�����µ��ֶ���������ɵ��ֶ�����
+        *   allowableValues������ֵ�÷�Χ������`{1,2,3}`����ֻ��ȡ������ֵ��`[1,5]`����ȡ1��5��ֵ��`(1,5)`����1��5��ֵ��������1��5��������ʹ��infinity��-infinity������ֵ������`[1, infinity]`������СֵΪ1�����ֵ�����
+        *   required������ֶ��Ƿ���Ĭ����false,
+        *   hidden�����������ֶΣ�Ĭ����false�����Ҫ������Ҫʹ��true����Ϊ�ֶ�Ĭ�϶�����ʾ������û��`@ApiModelProperty`��
+
+���ƴ���
+
+```
+// ��ʹ��@ApiModel����ע��
+@ApiModel(value="�û���¼��������",description="�û���¼��������")
+public class LoginForm {
+    // ʹ��ApiModelProperty����ע�ֶ����ԡ�
+    @ApiModelProperty(value = "�û���",required = true,example = "root")
+    private String username;
+    @ApiModelProperty(value = "����",required = true,example = "123456")
+    private String password;
+
+    // �˴�ʡ����θ�ֵʱ��Ҫ��getter,setter,swaggerҲ��Ҫ���
+}
+
+```
+
+��������
+
+���ƴ���
+
+```
+    @ApiOperation(value = "��¼�ӿ�",notes = "��¼�ӿڵ�˵��")
+    @PostMapping("/login")
+    public LoginForm login(@RequestBody LoginForm loginForm){
+        return loginForm;
+    }
+
+```
+
+����
+
+![20200711181038](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20200711181038.png)
+
+### ����������������Ƿ�ʵ���ࡣ
+
+��**��˵һ�Σ�����GET��ʽ��swagger���Ƽ�ʹ��body��ʽ���������ݣ�������ȻSpring MVC�����Զ���װ������������GET�����Dz�Ҫʹ��form-data��json�ȷ�ʽ���ݲ�����������ʹ��Postman�����Խӿڣ�swagger���߲����Dz�֧�����������**��
+���ڷ�ʵ�������������ʹ��`@ApiImplicitParams`��`@ApiImplicitParam`���������������
+`@ApiImplicitParams`���ڷ���ͷ�ϣ�`@ApiImplicitParam`������`@ApiImplicitParams`���棬һ��`@ApiImplicitParam`��Ӧһ��������
+`@ApiImplicitParam`���������
+
+*   name������������������֣�Ҳ�����ֶε�����,������ӿڵ��������Ӧ��**�������Ӧ��Ҳ�����ɣ����Կ�������������������**
+*   value��������������
+*   required��������ע�����Ƿ����
+*   paramType��path,query,body,form,header�ȷ�ʽ�������ڶ��ڷ�ʵ���������ʱ�򣬳��õ�ֻ��path,query,header��body��form�Dz����õġ�body�������ڶ����ɢ�����������ֻ������json�����������������Ľӿ���`form-data`,`x-www-form-urlencoded`��ʱ����ܲ���ʹ��swaggerҳ��API���ԣ��������ں��潲������BootstrapUI��swagger��ǿ�е��ԣ�����BootstrapUI��swagger֧��ָ��`form-data`��`x-www-form-urlencoded`��
+
+ʾ��һ�����������URL����
+
+���ƴ���
+
+```
+    // ʹ��URL query����
+    @ApiOperation(value = "��¼�ӿ�2",notes = "��¼�ӿڵ�˵��2")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "username",//��������
+                    value = "�û���",//����������
+                    required = true,//�Ƿ���봫��
+                    //paramType��������������ͣ���path,query,body,form,header
+                    paramType = "query"
+                    )
+            ,
+            @ApiImplicitParam(name = "password",//��������
+                    value = "����",//����������
+                    required = true,//�Ƿ���봫��
+                    paramType = "query"
+                    )
+    })
+    @PostMapping(value = "/login2")
+    public LoginForm login2(String username,String password){
+        System.out.println(username+":"+password);
+        LoginForm loginForm = new LoginForm();
+        loginForm.setUsername(username);
+        loginForm.setPassword(password);
+        return loginForm;
+    }
+
+```
+
+ʾ���������������URL·������
+
+���ƴ���
+
+```
+    // ʹ��·������
+    @PostMapping("/login3/{id1}/{id2}")
+    @ApiOperation(value = "��¼�ӿ�3",notes = "��¼�ӿڵ�˵��3")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "id1",//��������
+                    value = "�û���",//����������
+                    required = true,//�Ƿ���봫��
+                    //paramType��������������ͣ���path,query,body,form,header
+                    paramType = "path"
+            )
+            ,
+            @ApiImplicitParam(name = "id2",//��������
+                    value = "����",//����������
+                    required = true,//�Ƿ���봫��
+                    paramType = "path"
+            )
+    })
+    public String login3(@PathVariable Integer id1,@PathVariable Integer id2){
+        return id1+":"+id2;
+    }
+
+```
+
+ʾ���������������header����
+
+���ƴ���
+
+```
+    // ��header���ݲ���
+    @PostMapping("/login4")
+    @ApiOperation(value = "��¼�ӿ�4",notes = "��¼�ӿڵ�˵��4")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "username",//��������
+                    value = "�û���",//����������
+                    required = true,//�Ƿ���봫��
+                    //paramType��������������ͣ���path,query,body,form,header
+                    paramType = "header"
+            )
+            ,
+            @ApiImplicitParam(name = "password",//��������
+                    value = "����",//����������
+                    required = true,//�Ƿ���봫��
+                    paramType = "header"
+            )
+    })
+    public String login4( @RequestHeader String username,
+                          @RequestHeader String password){
+        return username+":"+password;
+    }
+
+```
+
+ʾ���ģ������ļ��ϴ�����
+
+���ƴ���
+
+```
+    // ���ļ��ϴ�ʱҪ��@ApiParam���÷�������@ApiImplicitParamһ��������@ApiParam���ڲ�����
+    // ������Ҳ���Բ�ע�⣬swagger���Զ�����˵��
+    @ApiOperation(value = "�ϴ��ļ�",notes = "�ϴ��ļ�")
+    @PostMapping(value = "/upload")
+    public String upload(@ApiParam(value = "ͼƬ�ļ�", required = true)MultipartFile uploadFile){
+        String originalFilename = uploadFile.getOriginalFilename();
+
+        return originalFilename;
+    }
+
+    // ����ļ��ϴ�ʱ��**swaggerֻ�ܲ��Ե��ļ��ϴ�**
+    @ApiOperation(value = "�ϴ�����ļ�",notes = "�ϴ�����ļ�")
+    @PostMapping(value = "/upload2",consumes = "multipart/*", headers = "content-type=multipart/form-data")
+    public String upload2(@ApiParam(value = "ͼƬ�ļ�", required = true,allowMultiple = true)MultipartFile[] uploadFile){
+        StringBuffer sb = new StringBuffer();
+        for (int i = 0; i < uploadFile.length; i++) {
+            System.out.println(uploadFile[i].getOriginalFilename());
+            sb.append(uploadFile[i].getOriginalFilename());
+            sb.append(",");
+        }
+        return sb.toString();
+    }
+
+    // �����ļ������в���
+    @ApiOperation(value = "�����ļ������в���",notes = "�����ļ������в���")
+    @PostMapping(value = "/upload3")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "name",
+                    value = "ͼƬ������",
+                    required = true
+            )
+    })
+    public String upload3(@ApiParam(value = "ͼƬ�ļ�", required = true)MultipartFile uploadFile,
+                          String name){
+        String originalFilename = uploadFile.getOriginalFilename();
+
+        return originalFilename+":"+name;
+    }
+
+```
+
+## ����ӿ���Ӧ
+
+����ӿ���Ӧ���Ƿ���鿴�ӿ��ĵ������ܹ�֪���ӿڷ��ص����ݵ����塣
+
+### ��Ӧ��ʵ���ࣺ
+
+ǰ���ڶ���ӿ����������ʱ�����ᵽʹ��`@ApiModel`����ע�࣬����ӿڷ���������࣬��ô������ϵ�˵��Ҳ����Ϊ��Ӧ��˵����
+
+���ƴ���
+
+```
+    // ���ر�@ApiModel��ע�������
+    @ApiOperation(value = "ʵ������Ӧ",notes = "��������Ϊʵ����Ľӿ�")
+    @PostMapping("/role1")
+    public LoginForm role1(@RequestBody LoginForm loginForm){
+        return loginForm;
+    }
+
+```
+
+![20200712000406](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20200712000406.png)
+
+### ��Ӧ�Ƿ�ʵ���ࣺ
+
+swagger�޷��Է�ʵ�������Ӧ������ϸ˵����ֻ�ܱ�ע��Ӧ�����Ϣ����ͨ��`@ApiResponses`��`@ApiResponse`��ʵ�ֵġ�
+`@ApiResponses`��`@ApiResponse`������`@ApiModel`һ��ʹ�á�
+
+���ƴ���
+
+```
+    // �������͵�,��ʱ���������ֶ�ע�ͣ�������ʵswagger�Ƽ�ʹ��ʵ����
+    @ApiOperation(value = "��ʵ����",notes = "��ʵ����")
+    @ApiResponses({
+            @ApiResponse(code=200,message = "���óɹ�"),
+            @ApiResponse(code=401,message = "��Ȩ��" )
+    }
+    )
+    @PostMapping("/role2")
+    public String role2(){
+        return " {\n" +
+                " name:\"�㶫\",\n" +
+                "     citys:{\n" +
+                "         city:[\"����\",\"����\",\"�麣\"]\n" +
+                "     }\n" +
+                " }";
+    }
+
+```
+
+![20200712013503](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20200712013503.png)
+
+* * *
+
+# Swagger UI��ǿ
+
+����ܻ�����������UI���Ǻܺÿ���������һЩ�������ṩ��һЩSwagger UI��ǿ���Ƚ����е���`swagger-bootstrap-ui`������������`swagger-bootstrap-ui`Ϊ����
+
+## UI�Աȣ�
+
+![20200712013653](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20200712013653.png)
+
+![20200712013723](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20200712013723.png)
+
+## ʹ��
+
+1.������������
+
+���ƴ���
+
+```
+        <!--����swagger-->
+        <dependency>
+            <groupId>io.springfox</groupId>
+            springfox-swagger2
+            <version>2.9.2</version>
+        </dependency>
+        <dependency>
+            <groupId>io.springfox</groupId>
+            springfox-swagger-ui
+            <version>2.9.2</version>
+        </dependency>
+        <!-- ����swagger-bootstrap-ui������-->
+        <dependency>
+            <groupId>com.github.xiaoymin</groupId>
+            swagger-bootstrap-ui
+            <version>1.8.7</version>
+        </dependency>
+
+```
+
+2.��swagger������������ע��`@EnableSwaggerBootstrapUI`:
+
+���ƴ���
+
+```
+@Configuration // ������������
+@EnableSwagger2 //����swagger����
+@EnableSwaggerBootstrapUI // ����SwaggerBootstrapUI
+public class SwaggerConfig {
+    // ʡ����������
+}
+
+```
+
+3.����API��`http://localhost:8080/doc.html`������Ԥ��������bootstarp��Swagger UI���档
+
+## �ŵ�
+
+1.?����ÿ���һ��
+
+2.����˵���ˣ�����BootstrapUI��swagger֧��ָ��`form-data`��`x-www-form-urlencoded`��
+![20200712024858](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20200712024858.png)
+
+3.֧�ָ��Ƶ���API�ĵ��͵���ȫ��API�ĵ���
+![20200712025020](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20200712025020.png)
+
+![20200712025044](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20200712025044.png)
+
+* * *
+
+# ����Spring Securityע��
+
+��Spring Boot����Spring Security��Swagger��ʱ����Ҫ�������ص�·���ͷ��е�·����ע���Ƿ������¼���·����
+
+���ƴ���
+
+```
+.antMatchers("/swagger**/**").permitAll()
+.antMatchers("/webjars/**").permitAll()
+.antMatchers("/v2/**").permitAll()
+.antMatchers("/doc.html").permitAll() // ���������bootstarp��Swagger UI���棬��һ�������
+
+```
+
+* * *
+
+# ����token�Ĵ���
+
+��swagger��ֻ֧���˼򵥵ĵ��ԣ�������һЩ�ӿڣ����Dz��Ե�ʱ�������Ҫ��token��Ϣд��header�У�Ŀǰ����û���������Զ��������ͷ�ĵط���
+?����һ��
+���������ʹ����Swagger BootstrapUI����ô������ڡ��ĵ�������������ȫ�ֲ����������������header������
+
+?����������swagger������������ȫ�ֲ������ã�
+
+���ƴ���
+
+```
+        //����ж����ȫ�ֲ���������˵����ͷ������������������
+        ParameterBuilder parameterBuilder = new ParameterBuilder();
+        List<Parameter> parameters = new ArrayList<Parameter>();
+        parameterBuilder.name("authorization").description("����")
+                .modelRef(new ModelRef("string")).parameterType("header").required(false).build();
+        parameters.add(parameterBuilder.build());
+        return new Docket(DocumentationType.SWAGGER_2)  // DocumentationType.SWAGGER_2 �̶��ģ�����swagger2
+                .apiInfo(apiInfo()) // ��������API��Ϣ
+                .select() // select()��������һ��ApiSelectorBuilderʵ��,�������ƽӿڱ�swagger�����ĵ�
+                .apis(RequestHandlerSelectors.basePackage("com.example.controller")) // ����ָ��ɨ���ĸ����µĽӿ�
+                .paths(PathSelectors.any())// ѡ�����е�API,�������ֻΪ����API�����ĵ���������������
+                .build().globalOperationParameters(parameters);
+
+```
+
+?��������ʹ��`@ApiImplicitParams`�������עһ������ͷ���������磺
+
+���ƴ���
+
+```
+    // �����Ҫ����IJ������DZ������õ�����������Ҫ��,������Ȩ��token
+    @PostMapping("/login6")
+    @ApiOperation(value = "��token�Ľӿ�",notes = "��token�Ľӿ�")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "authorization",//��������
+                    value = "��Ȩtoken",//����������
+                    required = true,//�Ƿ���봫��
+                    paramType = "header"
+            )
+            ,
+            @ApiImplicitParam(name = "username",//��������
+                    value = "�û���",//����������
+                    required = true,//�Ƿ���봫��
+                    paramType = "query"
+            )
+    })
+    public String login6(String username){
+        return username;
+    }
+
+```
+
+* * *
+
+# Swagger�İ�ȫ����
+
+1.�����������Ȩ�޹��������Ը�swagger����Ȩ�޹�����Ҫ�����swaggerҳ�������û��������룬��Щ��spring security��shiro�����ˣ����ﲻ����
+
+2.���������Dz�������ʽ�����п��Է��ʣ���������ʽ�����йر�Swagger�Զ����ã���Ͳ�����swaggerҳ���ˡ�ʹ��`@Profile({"dev","test"})`ע��������ֻ��dev����test������Swagger�Զ����á�
+Ȼ����Spring Boot�����ļ����޸ĵ�ǰprofile`spring.profiles.active=release`������֮�󣬴�ʱ�޷�����`http://localhost:8080/swagger-ui.html`
+
+* * *
+
+
+
+���ߣ�[progor](https://www.cnblogs.com/progor/)
+����Ϊ����ԭ����ת����ע������
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/Spring\345\270\270\350\247\201\346\263\250\350\247\243\344\275\277\347\224\250\346\214\207\345\215\227(\345\214\205\345\220\253Spring+SpringMVC+SpringBoot).md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/Spring\345\270\270\350\247\201\346\263\250\350\247\243\344\275\277\347\224\250\346\214\207\345\215\227(\345\214\205\345\220\253Spring+SpringMVC+SpringBoot).md"
new file mode 100644
index 0000000..813fabe
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/Spring\345\270\270\350\247\201\346\263\250\350\247\243\344\275\277\347\224\250\346\214\207\345\215\227(\345\214\205\345\220\253Spring+SpringMVC+SpringBoot).md"
@@ -0,0 +1,1112 @@
+# Springע��
+## 1 ����
+
+���Ƕ�֪��Spring����ĵ����Ծ���IOC+AOP��IOC��ԭ������ʵ����һ��Spring������������������Spring Beanʵ��
+DI��Ҳ��������ע�룬��������Ϊ��������Ҫ���ĵĺ��Ļ��⣬���ע��������ע���ĸ���������������Ҫ��ȷ֪���ġ�
+����ǰ������ϰ������xml�����ļ�������һ��bean�������ڣ����Ǹ����ʹ��ע��ʹ��������DI�Ĺ���
+
+
+���ǿ���ʹ�� org.springframework.beans.factory.annotation �� org.springframework.context.annotation ���е�ע�������� Spring DI ����Ĺ��ܡ�
+
+����ͨ������Щ��Ϊ��Spring ����ע�͡������ǽ��ڱ��̳��ж�����лعˡ�
+
+
+## 2 DI���ע��
+
+### 2.1 @Autowired
+
+���ǿ���ʹ�� @Autowired ����� Spring ��Ҫ������ע��������
+���ǿ��Խ���ע���빹�캯����setter ���ֶ�ע��һ��ʹ�á�
+Constructor injection:
+
+**������ע��**
+
+````
+class Car {
+    Engine engine;
+
+    @Autowired
+    Car(Engine engine) {
+        this.engine = engine;
+    }
+}
+````
+
+**Setterע��**
+````
+class Car {
+    Engine engine;
+
+    @Autowired
+    void setEngine(Engine engine) {
+        this.engine = engine;
+    }
+}
+````
+**����ע��**
+````
+class Car {
+    @Autowired
+    Engine engine;
+}
+````
+
+@Autowired ��һ����Ϊ required �IJ���������Ĭ��ֵΪ true��
+
+�����Ҳ������ʵ� bean ������ʱ��������� Spring ����Ϊ�� ��Ϊ true ʱ�����׳��쳣�����������κ����ݡ�
+
+��ע�⣬�������ʹ�ù��캯��ע�룬�����й��캯����������ǿ���Եġ�
+
+�� 4.3 �汾��ʼ�����Dz���Ҫ��ʽ��ʹ�� @Autowired ע�⹹�캯���������������������������캯����
+
+### 2.2 @Bean
+
+@Bean ���ʵ���� Spring bean �Ĺ���������
+
+```
+@Bean
+Engine engine() {
+    return new Engine();
+}
+````
+
+����Ҫ�������͵���ʵ��ʱ��Spring �������Щ������
+
+���ɵ� bean �빤������ͬ���� ����������Բ�ͬ�ķ�ʽ���������ǿ���ʹ�ô�ע�͵����ƻ�ֵ����������ֵ�Dz������Ƶı�������
+
+````
+@Bean("engine")
+Engine getEngine() {
+    return new Engine();
+}
+````
+����һ�ַdz�������bean������ʽ����Ϊ�ܶ��bean����������һ��ʼ���ڴ����ﶨ��õģ���������Ҫ��������ʱ���������а��蹹����
+
+���ǿ������ɵ������Ͷ���Bean������Ҳ���Ը������Զ����bean���ơ�
+
+ע�⣬������@Bean ע�͵ķ�����������@Configuration ���С�
+
+### 2.3 @Qualifier
+
+����ʹ��@Qualifier ��@Autowired ���ṩ������Ҫ�ڲ���ȷ�����ʹ�õ�bean id ��bean ���ơ�
+
+���磬�������� bean ʵ����ͬ�Ľӿڣ�
+````
+class Bike implements Vehicle {}
+
+class Car implements Vehicle {}
+
+````
+
+��� Spring ��Ҫע��һ�� Vehicle bean�������Զ��ƥ�䶨������� ����������£����ǿ���ʹ�� @Qualifier ע����ʽ�ṩ bean �����ơ�
+
+**������ע��**
+````
+@Autowired
+Biker(@Qualifier("bike") Vehicle vehicle) {
+this.vehicle = vehicle;
+}
+````
+
+**Setterע��**
+
+````
+@Autowired
+void setVehicle(@Qualifier("bike") Vehicle vehicle) {
+this.vehicle = vehicle;
+}
+````
+����:
+
+````
+@Autowired
+@Qualifier("bike")
+void setVehicle(Vehicle vehicle) {
+this.vehicle = vehicle;
+````
+**����ע��**
+
+````
+@Autowired
+@Qualifier("bike")
+Vehicle vehicle;
+````
+���ע�����ǿ���ƽ���õIJ��࣬���ǵ�һ���ӿ��ж��ʵ����ʱ�����ͻᾭ�������ó���
+
+### 2.4 @Required
+
+@Required �� setter �����ϱ��������Ҫͨ�� XML ���������
+````
+@Required
+void setColor(String color) {
+this.color = color;
+}
+````
+xml
+````
+<bean class="com.baeldung.annotations.Bike">
+    <property name="color" value="green" />
+</bean>
+````
+���򣬽��׳� BeanInitializationException��
+�dz��ټ����÷���֪��һ�¾�����
+
+### 2.5 @Value
+���ǿ���ʹ�� @Value ������ֵע�� bean�� ���빹�캯����setter ���ֶ�ע����ݡ�
+
+��Ҳ�Ƿdz����õ�һ��ע�⣬��Ϊ���Ǻܶ�ʱ����Ҫ��application.properties�������������ļ�������ȡ��������ֵ��
+
+**������ע��**
+````
+Engine(@Value("8") int cylinderCount) {
+this.cylinderCount = cylinderCount;
+}
+````
+
+**setterע��**
+
+````
+@Autowired
+void setCylinderCount(@Value("8") int cylinderCount) {
+this.cylinderCount = cylinderCount;
+}
+````
+
+����:
+````
+
+@Value("8")
+void setCylinderCount(int cylinderCount) {
+this.cylinderCount = cylinderCount;
+}
+````
+
+**����ע��**
+````
+@Value("8")
+int cylinderCount;
+````
+
+��Ȼ��ע�뾲ֵ̬��û���õġ� ��ˣ����ǿ����� @Value ��ʹ��ռλ���ַ������������ⲿԴ�ж����ֵ�������� .properties �� .yaml �ļ��С�
+````
+
+engine.fuelType=petrol
+````
+
+���ǿ���ͨ�����·�ʽע�� engine.fuelType ��ֵ��
+
+````
+@Value("${engine.fuelType}")
+String fuelType;
+````
+
+������������ʹ�� SpEL ��ʹ��@Value�� ����߼�ʾ�����������ǹ���@Value ���������ҵ���
+
+### 2.6 @DependsOn
+���ǿ���ʹ�ô�ע���� Spring ��ע��� bean ֮ǰ��ʼ������ bean�� ͨ��������Ϊ���Զ��ģ����� bean ֮�����ʽ������ϵ��
+
+����ֻ������������ʽ��ʱ�����Ҫ���ע�⣬����JDBC�������ػ��߾�̬������ʼ����
+
+���ǿ�����ָ������ bean ���Ƶ���������ʹ�� @DependsOn�� ע�͵�ֵ������Ҫһ���������� bean ���Ƶ����飺
+
+````
+@DependsOn("engine")
+class Car implements Vehicle {}
+````
+Alternatively, if we define a bean with the @Bean annotation, the factory method should be annotated with @DependsOn:
+````
+@Bean
+@DependsOn("fuel")
+Engine engine() {
+return new Engine();
+}
+````
+### 2.7 @Lazy
+������������س�ʼ�����ǵ� bean ʱ������ʹ�� @Lazy�� Ĭ������£�Spring ��Ӧ�ó��������ĵ�����/����ʱ���еش������е��� bean��
+
+���ǣ���Щ�����������Ҫ������ʱ���� bean����������Ӧ�ó�������ʱ������
+
+���ע�����Ϊ��������Ƿ�������ȷ��λ�ö�������ͬ�� ���ǿ��԰������ڣ�
+
+һ�� @Bean ע�͵� bean �������������ӳٷ������ã���˴��� bean��
+@Configuration ������а�����@Bean ���������ܵ�Ӱ��
+
+һ�� @Component �࣬������ @Configuration �࣬��� bean �����ӳٳ�ʼ��
+
+@Autowired ���캯����setter ���ֶΣ������ӳټ������������ͨ��������
+
+````
+@Configuration
+@Lazy
+class VehicleFactoryConfig {
+
+    @Bean
+    @Lazy(false)
+    Engine engine() {
+        return new Engine();
+    }
+}
+````
+��ͬ������һ�����õ�ע�⡣
+
+������ά��һ���д���bean����Ŀʱ���ᷢ���кܶ�bean���ܶ��ǰ���ʹ�õģ���һ����Ҫ��������ʼ��ʱ�ͽ��г�ʼ��������԰����ǽ�ʡ�ܶ�ʱ������ܡ�
+
+
+### 2.8 @Lookup
+ͬ����һ���Ƚ����õ���ע��
+
+@Lookup ����� Spring �����ǵ�����ʱ���ط����������͵�ʵ����
+
+�����ϣ�Spring ���������Ǵ�ע�͵ķ�����ʹ�����Ƿ����ķ������ͺͲ�����Ϊ BeanFactory#getBean �IJ�����
+
+@Lookup �����ڣ�
+
+��ԭ�� bean ע�������Լ���bean�������� Provider��
+
+����������ɾ���ӵ��һ��ԭ�� Spring bean����ô���Ǽ����������������������⣺
+
+���ǵĵ��� Spring bean ����η�����Щԭ�� Spring bean��
+
+���ڣ�Provider �϶���һ�ַ�ʽ������ @Lookup ��ijЩ�������ͨ�á�
+
+Ҫע����ǣ�springĬ��ʹ�õĵ���bean�������������Ҫע��ԭ��bean�����Dz���Ҫ�������Ķ��⹤��
+
+���ȣ������Ǵ���һ��ԭ�� bean���Ժ����ǽ���ע�뵽���� bean �У�
+````
+@Component
+@Scope("prototype")
+public class SchoolNotification {
+// ... prototype-scoped state
+}
+````
+ʹ��@Lookup�����ǿ���ͨ������ bean ��ȡ SchoolNotification ��ʵ����
+
+````
+@Component
+public class StudentServices {
+
+    // ... member variables, etc.
+
+    @Lookup
+    public SchoolNotification getNotification() {
+        return null;
+    }
+
+    // ... getters and setters
+}
+````
+Using @Lookup, we can get an instance of SchoolNotification through our singleton bean:
+````
+@Test
+public void whenLookupMethodCalled_thenNewInstanceReturned() {
+// ... initialize context
+StudentServices first = this.context.getBean(StudentServices.class);
+StudentServices second = this.context.getBean(StudentServices.class);
+
+    assertEquals(first, second); 
+    assertNotEquals(first.getNotification(), second.getNotification()); 
+}
+````
+��ע�⣬�� StudentServices �У����ǽ� getNotification ��������Ϊ�����
+
+������Ϊ Spring ͨ������ beanFactory.getBean(StudentNotification.class) �����˸÷�����������ǿ��Խ������ա�
+
+
+### 2.9 @Primary
+��ʱ������Ҫ��������ͬ���͵�bean�� ����Щ����£�ע�뽫���ɹ�����Ϊ Spring ��֪��������Ҫ�ĸ� bean��
+
+�����Ѿ������˴������������ѡ���@Qualifier ������н��ߵ㲢ָ������ bean �����ơ�
+
+Ȼ���������ʱ��������Ҫһ���ض��� bean��������Ҫ���� bean��
+
+���ǿ���ʹ��@Primary ����������������������@Primary �����õ�bean��������unqualified��ע����ϱ�ѡ��
+
+````
+@Component
+@Primary
+class Car implements Vehicle {}
+
+@Component
+class Bike implements Vehicle {}
+
+@Component
+class Driver {
+@Autowired
+Vehicle vehicle;
+}
+
+@Component
+class Biker {
+@Autowired
+@Qualifier("bike")
+Vehicle vehicle;
+}
+````
+��ǰ���ʾ���У���������Ҫ������ ��ˣ��� Driver ���У�Spring ע����һ�� Car bean�� ��Ȼ���� Biker bean �У��ֶ� vehicle ��ֵ����һ�� Bike ������Ϊ����qualified�ġ�
+
+### 2.10 @Scope
+
+����ͨ����Ӧ����˵������bean��scopeĬ�϶��ǵ����ģ���ʵ����spring bean����֧�ֶ��ֶ��������÷�Χ���������Ų�ͬ���������ڡ�
+
+����ʹ��@Scope ������@Component ���@Bean ����ķ�Χ�� �������ǵ�����ԭ�͡����󡢻Ự��globalSession ��һЩ�Զ��巶Χ��
+
+��Ӧ��ö��ֵΪ
+````
+singleton
+prototype
+request
+session
+application
+websocket
+````
+
+����
+````
+@Component
+@Scope("prototype")
+class Engine {}
+````
+���ǿ�������һЩ����������request��session��websocket�����������bean��ͨ��Ӧ���Ǻ�����������صģ������ô洢�û���Ϣ��session֮���bean��
+
+������ôʹ�ã���Ҫ������ľ��峡����ѡ���ˣ������һ���ܴ�Ļ��⣬������Ȳ�չ���ˣ��Ժ�����ڵ�����������������ܡ�
+
+## 3 ����������ע��
+���ǿ���ʹ�ñ�����������ע��������Ӧ�ó��������ġ�
+
+
+### 3.1 @Profile
+
+�������ϣ�� Spring �����ض������ļ����ڻ״̬ʱʹ��@Component ���@Bean ���������ǿ���ʹ��@Profile ������б�ǡ�
+
+���ǿ���ʹ��ע�͵�ֵ�������������ļ������ƣ�
+
+����ͨ�����ע�������ò�ͬ���������á�
+���������������
+
+````
+public interface DatasourceConfig {
+public void setup();
+}
+````
+
+�����ǿ������������ã�
+
+````
+@Component
+@Profile("dev")
+public class DevDatasourceConfig implements DatasourceConfig {
+@Override
+public void setup() {
+System.out.println("Setting up datasource for DEV environment. ");
+}
+}
+````
+�������������������ã�
+
+````
+@Component
+@Profile("production")
+public class ProductionDatasourceConfig implements DatasourceConfig {
+@Override
+public void setup() {
+System.out.println("Setting up datasource for PRODUCTION environment. ");
+}
+}
+````
+��Ȼ����Ҳ����ʹ��xml�����������͵������ļ��������������bean
+
+xml
+````
+<beans profile="local">
+    <bean id="localDatasourceConfig" 
+      class="org.test.profiles.LocalDatasourceConfig" />
+</beans>
+````
+### 3.2 @Import
+
+���ǿ���ʹ���ض��� @Configuration �࣬������ʹ�ô�ע��������ɨ�衣 ���ǿ���Ϊ��Щ���ṩ@Import ��ֵ����
+
+������˵�����Ҫ�õ�@Configurationע���bean����ôspringӦ�ñ���Ҫɨ�赽��Ŀ¼�����ǡ��û�жԸ�·������ɨ�裬��������ֻ����ʹ��·���µĵ��������࣬��ô���ǾͿ���ʹ��@Import����������������ˡ�
+
+���ע�⻹�Ƿdz����õģ���һ�������������
+
+````
+@Import(VehiclePartSupplier.class)
+class VehicleFactoryConfig {}
+
+@Configuration
+class VehiclePartSupplier{
+}
+````
+
+### 3.3 @ImportResource
+
+����˵��������һ�� bean.xml �������ļ�����Ҫ���� beans.xml �ж���� bean���� �����뵽 Spring Boot �����������У�����β����أ�
+
+1.Spring ��ʽ�������ļ� bean.xml �˴����ٸ�ʾ��������˵ xml ��������һ�� helloService��������ʾ
+````
+<?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">
+
+    <!--�� HelloService ��xml�ķ�ʽ,ע�뵽������-->
+    <bean id="helloService" class="com.demo.springboot.service.HelloService"></bean>
+</beans>
+````
+2.ʹ��@ImportResourceע�⣬���� xml ����
+````
+/**
+ * Spring Boot����û��Spring�������ļ��������Լ���д�������ļ���Ҳ�����Զ�ʶ��
+ * �������Spring�������ļ���Ч�����ص�Spring ����������
+ * ʹ��@ImportResourceע�⣬�����ע��һ����������(�˴�������������)
+ */
+@SpringBootApplication
+@ImportResource(locations = {"classpath:beans.xml"})
+public class BootApplication {
+
+    public static void main(String[] args) {
+        // SpringӦ����������         
+        SpringApplication.run(BootApplication.class,args);
+
+    }
+}
+
+````
+### 3.4 @PropertySource
+ͨ�����ע�⣬���ǿ���ΪӦ�ó������ö��������ļ���
+
+@PropertySource ע���ṩ��һ�ַ���������Ի��ƣ����ڽ� PropertySource ���ӵ� Spring �� Environment �У��� @Configuration ��һ��ʹ�á�
+
+�����ʹ�� @Value ȥ���ö�������ԣ����磺@Value("testbean.name")��Ҳ����ָ��Ĭ��ֵ���磺@Value("testbean.name:defaultValue")��
+
+�÷�ʾ��
+
+����һ�������ļ�app.properties
+````
+testbean.name=myTestBean
+````
+���� @Configuration ��ʹ�� @PropertySource �� app.properties ���ø� Environment �� PropertySources ���ϡ�
+````
+@Configuration
+@PropertySource("classpath:/com/myco/app.properties")
+public class AppConfig {
+
+    @Autowired
+    Environment env;
+ 
+    @Bean
+    public TestBean testBean() {
+        TestBean testBean = new TestBean();
+        testBean.setName(env.getProperty("testbean.name"));
+        return testBean;
+    }
+}
+````
+
+ע�⣺ʹ�� @Autowired �� Environment ����ע�뵽�������У�Ȼ���� testBean() ������ʹ�á�
+���������У����� testBean.getName() ���������ء�myTestBean���ַ�����
+
+@PropertySource ������ Java 8 ���ظ�ע�����ԣ�����ζ�����ǿ���������α��һ���ࣺ
+
+````
+@Configuration
+@PropertySource("classpath:/annotations.properties")
+@PropertySource("classpath:/vehicle-factory.properties")
+class VehicleFactoryConfig {}
+````
+
+### 3.5 @PropertySources
+�÷�ͬ�ϣ�ֻ��������һ�����ǿ���ʹ�����ע��ָ�����@PropertySource ���ã�
+````
+@Configuration
+@PropertySources({
+@PropertySource("classpath:/annotations.properties"),
+@PropertySource("classpath:/vehicle-factory.properties")
+})
+class VehicleFactoryConfig {}
+````
+��ע�⣬�� Java 8 ���������ǿ���ͨ�������ظ�ע�͹���ʵ����ͬ�Ĺ��ܡ�
+
+## 4.����
+
+�ڱ����У����ǿ���������� Spring ����ע�͵ĸ����� ���ǿ������������ bean ���Ӻ�Ӧ�������ģ��Լ����Ϊ���ɨ�����ࡣ
+
+spring��ϵ�еij���ע�⻹�кܶ࣬һƪ���²�����ȫ�����ǣ�������©����ӭ���䡣
+
+# Spring Beanע��
+
+## 1 ����
+�ڱ��̳��У����ǽ��������ڶ��岻ͬ���� bean ������� Spring bean ע�͡�
+
+�м��ַ��������� Spring ���������� bean�� ���ȣ����ǿ���ʹ�� XML �����������ǡ� ���ǻ���������������ʹ��@Bean ע�������� bean��
+
+������ǿ���ʹ�� org.springframework.stereotype ���е�ע��֮һ����Ǹ��࣬�������ಿ���������ɨ�衣
+
+## 2 @ComponentScan
+�������Ǿ�����ʹ�õ�һ��ע�⣬�����ǵ�Ӧ���У���ʱ��һ����ɨ�����еİ����ر��ǵ�����Ҫɨ���ⲿjar���е�beanʱ�����dz����á�
+
+�����Լ���SpringBootApplication�ϣ�Ҳ���Լ���@configurationע���ϵ���������
+
+������������ɨ�裬Spring �����Զ�ɨ����е� bean��
+
+@ComponentScan ����ʹ��ע������ɨ����Щ�����ࡣ
+
+���ǿ���ֱ��ʹ�� basePackages �� value ����֮һָ�����������ƣ�value �� basePackages �ı�����
+
+````
+@Configuration
+@ComponentScan(basePackages = "com.baeldung.annotations")
+class VehicleFactoryConfig {}
+````
+���⣬���ǿ���ʹ�� basePackageClasses ����ָ��������е��ࣺ
+
+````
+@Configuration
+@ComponentScan(basePackageClasses = VehicleFactoryConfig.class)
+class VehicleFactoryConfig {}
+````
+
+�����������������飬������ǿ���Ϊÿ�������ṩ�������
+
+���δָ����������ɨ�跢���ڴ��� @ComponentScan ע�����ͬһ���С�
+
+@ComponentScan ������ Java 8 ���ظ�ע�����ԣ�����ζ�����ǿ���������α��һ���ࣺ
+
+````
+@Configuration
+@ComponentScan(basePackages = "com.baeldung.annotations")
+@ComponentScan(basePackageClasses = VehicleFactoryConfig.class)
+class VehicleFactoryConfig {}
+````
+
+���ߣ����ǿ���ʹ�� @ComponentScans ָ����� @ComponentScan ���ã�
+
+````
+@Configuration
+@ComponentScans({
+@ComponentScan(basePackages = "com.baeldung.annotations"),
+@ComponentScan(basePackageClasses = VehicleFactoryConfig.class)
+})
+````
+````
+class VehicleFactoryConfig {
+}
+````
+ʹ�� XML ����ʱ���������ɨ��ͬ���򵥣�
+
+````
+<context:component-scan base-package="com.baeldung"/>
+````
+
+### 3 @Component
+
+@Component ���༶���ע�⡣ �����ɨ���ڼ䣬Spring Framework ���Զ����ʹ��@Component ע����ࣺ
+````
+@Component
+class CarUtility {
+// ...
+}
+````
+
+Ĭ������£������ bean ʵ��������ͬ��������ĸСд�� ���⣬���ǿ���ʹ�ô�ע�͵Ŀ�ѡֵ����ָ����ͬ�����ơ�
+
+����@Repository��@Service��@Configuration ��@Controller ���Ǵ���@Component ��ע�⣬���ǹ�����ͬ��bean ������Ϊ��
+
+Spring ���������ɨ��������Զ�������ǡ�
+
+ͨ����˵�����ǻ���mvcӦ�������ǻ��õ���������ע�⣬�������ڷ�webӦ���и���ؿ���ʹ��@component��ע��bean
+
+### 4 @Repository
+
+DAO or Repository classes usually represent the database access layer in an application, and should be annotated with @Repository:
+````
+@Repository
+class VehicleRepository {
+// ...
+}
+````
+ʹ�ô�ע�͵�һ���ŵ������������Զ��־����쳣ת���� ��ʹ�ó־��Կ�ܣ��� Hibernate��ʱ����ʹ�� @Repository ע�͵������׳��ı����쳣���Զ�ת��Ϊ Spring �� DataAccessExeption �����ࡣ
+
+Ҫ�����쳣ת����������Ҫ���������Լ��� PersistenceExceptionTranslationPostProcessor bean��
+````
+@Bean
+public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
+return new PersistenceExceptionTranslationPostProcessor();
+}
+````
+��ע�⣬�ڴ��������£�Spring ���Զ�ִ���������衣
+
+����ͨ�� XML ���ã�
+````
+<bean class=
+"org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>
+````
+
+### 5 @Service
+Ӧ�ó����ҵ���߼�ͨ��פ���ڷ�����У�������ǽ�ʹ��@Service ע����ָʾһ�������ڸò㣺
+
+````
+@Service
+public class VehicleService {
+// ...    
+}
+````
+### 6 @Controller
+@Controller ��һ���༶���ע�⣬������ Spring Framework �������Ϊ Spring MVC �еĿ�������
+
+spring���@Controller ע���bean���ܶ����飬�����������ǻ���SpringMVC��ص�����������
+
+````
+@Controller
+public class VehicleController {
+// ...
+}
+
+````
+## 7 @Configuration
+
+��������԰�����@Bean ע�͵� bean ���巽����
+````
+@Configuration
+class VehicleFactoryConfig {
+
+    @Bean
+    Engine engine() {
+        return new Engine();
+    }
+
+}
+````
+## 8 AOPע��
+������ʹ�� Spring ������ע��ʱ�������״���һ������㣬������������о����ض������͵���ΪĿ�ꡣ
+
+���磬������������� DAO �㷽����ִ��ʱ�䡣 ���ǽ��������·��棨ʹ�� AspectJ ע�ͣ������� @Repository �����ͣ�
+
+```
+@Aspect
+@Component
+public class PerformanceAspect {
+@Pointcut("within(@org.springframework.stereotype.Repository *)")
+public void repositoryClassMethods() {};
+
+    @Around("repositoryClassMethods()")
+    public Object measureMethodExecutionTime(ProceedingJoinPoint joinPoint) 
+      throws Throwable {
+        long start = System.nanoTime();
+        Object returnValue = joinPoint.proceed();
+        long end = System.nanoTime();
+        String methodName = joinPoint.getSignature().getName();
+        System.out.println(
+          "Execution of " + methodName + " took " + 
+          TimeUnit.NANOSECONDS.toMillis(end - start) + " ms");
+        return returnValue;
+    }
+}
+````
+
+�ڴ�ʾ���У����Ǵ�����һ������㣬�������ƥ��ʹ��@Repository ע�͵����е����з����� Ȼ������ʹ��@Around ֪ͨ����λ�Ǹ�����㣬��ȷ�����ط������õ�ִ��ʱ�䡣
+
+���⣬ʹ�����ַ��������ǿ���Ϊÿ��Ӧ�ó����������־��¼�����ܹ�������ƺ�������Ϊ��
+
+��Ȼ�ˣ�aspectJ�����ע�⻹�ܶ࣬���������������棬δ������Ҳ�ᵥ��д�Ľ��ܡ�
+
+## 9 ����
+
+�ڱ����У����Ǽ���� Spring ������ע�Ͳ����������Ǹ��Դ������������͡�
+
+���ǻ�ѧϰ�����ʹ�����ɨ����������������������ҵ���ע�͵��ࡣ
+
+��������˽�����Щע����ε��¸ɾ����ֲ������Լ�Ӧ�ó����ע��֮��ķ��롣 ���ǻ�ʹ���ø�С����Ϊ���Dz�����Ҫ�ֶ���ʽ���� bean��
+# SpringMVCע��
+## 1. ����
+�ڱ��̳��У����ǽ�̽�� org.springframework.web.bind.annotation ���е� Spring Web ע�͡�
+
+## 2. @RequestMapping
+
+�򵥵�˵��@RequestMapping ���@Controller ���ڲ������������򷽷��� ������ʹ�����ã�
+
+·����������������ƺ�ֵ������ӳ�䵽�ĸ� URL
+���������ݵ� HTTP ����
+params������ HTTP �����Ĵ��ڡ������ڻ�ֵ��������
+headers������ HTTP ��ͷ�Ĵ��ڡ������ڻ�ֵ��������
+���ģ��÷��������� HTTP ����������������Щý������
+produces���÷��������� HTTP ��Ӧ������������Щý������
+����һ���򵥵�ʾ����
+
+````
+@Controller
+class VehicleController {
+
+    @RequestMapping(value = "/vehicles/home", method = RequestMethod.GET)
+    String home() {
+        return "home";
+    }
+}
+````
+����������༶��Ӧ�ô�ע�ͣ����ǿ���Ϊ @Controller ���е����д������򷽷��ṩĬ�����á� Ψһ�������� Spring ����ʹ�÷����������ø��ǵ��ḽ������·�����ֵ� URL��
+
+���磬��������ú������Ч����һ���ģ�
+
+````
+@Controller
+@RequestMapping(value = "/vehicles", method = RequestMethod.GET)
+class VehicleController {
+
+    @RequestMapping("/home")
+    String home() {
+        return "home";
+    }
+}
+````
+
+���⣬@GetMapping��@PostMapping��@PutMapping��@DeleteMapping ��@PatchMapping ��@RequestMapping �IJ�ͬ���壬��HTTP �����ѷֱ�����ΪGET��POST��PUT��DELETE ��PATCH��
+
+��Щ�� Spring 4.3 �汾��ʼ���á�
+
+## 3 @RequestBody
+
+�����Ǽ���@RequestBody�������� HTTP ���������ӳ�䵽һ������
+
+````
+@PostMapping("/save")
+void saveVehicle(@RequestBody Vehicle vehicle) {
+// ...
+}
+````
+�����л����Զ��ģ�ȡ����������������͡�
+
+## 4 @PathVariable
+������˵˵@PathVariable��
+
+��ע��ָʾ���������󶨵� URI ģ������� ���ǿ���ʹ�� @RequestMapping ע��ָ�� URI ģ�壬��ʹ�� @PathVariable �����������󶨵�ģ�岿��֮һ��
+
+���ǿ���ʹ�����ƻ����������ֵ������ʵ����һ�㣺
+
+````
+@RequestMapping("/{id}")
+Vehicle getVehicle(@PathVariable("id") long id) {
+// ...
+}
+````
+���ģ���в��ֵ������뷽��������������ƥ�䣬���ǾͲ�����ע����ָ������
+
+````
+@RequestMapping("/{id}")
+Vehicle getVehicle(@PathVariable long id) {
+// ...
+}
+````
+���⣬���ǿ���ͨ��������IJ�������Ϊ false ����·���������Ϊ��ѡ��
+
+````
+@RequestMapping("/{id}")
+Vehicle getVehicle(@PathVariable(required = false) long id) {
+// ...
+}
+````
+## 5. @RequestParam
+We use @RequestParam for accessing HTTP request parameters:
+````
+@RequestMapping
+Vehicle getVehicleByParam(@RequestParam("id") long id) {
+// ...
+}
+````
+�������� @PathVariable ע����ͬ������ѡ�
+
+������Щ����֮�⣬�� Spring �������з���û��ֵ��Ϊ��ֵʱ�����ǿ���ʹ�� @RequestParam ָ��ע��ֵ�� Ϊ�ˣ����DZ������� defaultValue ������
+
+�ṩĬ��ֵ��ʽ���� required Ϊ false��
+````
+@RequestMapping("/buy")
+Car buyCar(@RequestParam(defaultValue = "5") int seatCount) {
+// ...
+}
+````
+���˲���֮�⣬���ǻ����Է������� HTTP ���󲿷֣�cookie �ͱ�ͷ��
+
+���ǿ��Էֱ�ʹ��ע��@CookieValue ��@RequestHeader ���������ǡ�
+
+
+## 6. Response Handling Annotations
+�ڽ������IJ����У����ǽ������� Spring MVC �в��� HTTP ��Ӧ�����ע�͡�
+
+### 6.1 @ResponseBody
+���������@ResponseBody ������������򷽷���Spring �Ὣ�����Ľ����Ϊ��Ӧ������
+
+````
+@ResponseBody
+@RequestMapping("/hello")
+String hello() {
+return "Hello World!";
+}
+````
+������������ע����ע�� @Controller �࣬�������������򷽷�����ʹ������
+
+### 6.2 @ExceptionHandler
+
+ʹ�ô�ע�ͣ����ǿ�������һ���Զ�����������򷽷��� �����������򷽷��׳��κ�ָ�����쳣ʱ��Spring ���ô˷�����
+
+������쳣������Ϊ�������ݸ�������
+````
+@ExceptionHandler(IllegalArgumentException.class)
+void onIllegalArgumentException(IllegalArgumentException exception) {
+// ...
+}
+````
+
+### 6.3 @ResponseStatus
+�������ʹ�ô�ע�Ͷ����������򷽷�����ע�ͣ������ָ����Ӧ������ HTTP ״̬�� ���ǿ���ʹ�� code ����������� value ����������״̬���롣
+
+���⣬���ǿ���ʹ�� reason �����ṩԭ��
+
+����Ҳ���Խ�����@ExceptionHandler һ��ʹ�ã�
+
+@ExceptionHandler(IllegalArgumentException.class)
+@ResponseStatus(HttpStatus.BAD_REQUEST)
+void onIllegalArgumentException(IllegalArgumentException exception) {
+// ...
+}
+
+�й� HTTP ��Ӧ״̬�ĸ�����Ϣ������ʱ��ġ�
+
+## 7 ���� Webע��
+һЩע�Ͳ�ֱ�ӹ��� HTTP �������Ӧ�� �ڽ������IJ����У����ǽ���������ġ�
+
+### 7.1 @Controller
+���ǿ���ʹ��@Controller ����һ��Spring MVC �������� �йظ�����Ϣ����������ǹ��� Spring Bean Annotations �����¡�
+
+### 7.2 @RestController
+@RestController �����@Controller ��@ResponseBody��
+
+��ˣ����������ǵ�Ч�ģ�
+
+````
+@Controller
+@ResponseBody
+class VehicleRestController {
+// ...
+}
+````
+
+````
+@RestController
+class VehicleRestController {
+// ...
+}
+````
+### 7.3 @ModelAttribute
+ͨ�����ע�⣬���ǿ���ͨ���ṩģ�ͼ��������Ѿ������� MVC @Controller ģ���е�Ԫ�أ�
+
+````
+@PostMapping("/assemble")
+void assembleVehicle(@ModelAttribute("vehicle") Vehicle vehicleInModel) {
+// ...
+}
+````
+��@PathVariable ��@RequestParam һ�����������������ͬ�����ƣ����Dz���ָ��ģ�ͼ���
+
+````
+@PostMapping("/assemble")
+void assembleVehicle(@ModelAttribute Vehicle vehicle) {
+// ...
+}
+````
+���⣬@ModelAttribute����һ����;�������������ע��һ��������Spring���Զ��������ķ���ֵ���ӵ�ģ���У�
+
+````
+@ModelAttribute("vehicle")
+Vehicle getVehicle() {
+// ...
+}
+````
+����ǰһ�������Dz���ָ��ģ�ͼ���Spring Ĭ��ʹ�÷��������ƣ�
+````
+@ModelAttribute
+Vehicle vehicle() {
+// ...
+}
+````
+�� Spring �������������򷽷�֮ǰ����������������� @ModelAttribute ע�͵ķ�����
+
+�й� @ModelAttribute �ĸ�����Ϣ������ı��ġ�
+
+### 7.4 @CrossOrigin
+@CrossOrigin Ϊ��ע�͵����������򷽷����ÿ���ͨ�ţ�
+
+````
+@CrossOrigin
+@RequestMapping("/hello")
+String hello() {
+return "Hello World!";
+}
+````
+��������������һ���࣬�����������е��������������򷽷���
+
+���ǿ���ʹ�ô�ע�͵IJ���΢�� CORS ��Ϊ��
+
+�й���ϸ��Ϣ������ʱ��ġ�
+
+# SpringBootע��
+## 1 ����
+Spring Boot ͨ�����Զ����ù���ʹ���� Spring ��ø������ס�
+
+�ڱ����ٽ̳��У����ǽ�̽�� org.springframework.boot.autoconfigure �� org.springframework.boot.autoconfigure.condition ���е�ע�⡣
+
+## 2 @SpringBootApplication
+����ʹ�����ע������� Spring Boot Ӧ�ó�������ࣺ
+
+@SpringBootApplication
+����ʹ�����ע������� Spring Boot Ӧ�ó�������ࣺ
+````
+@SpringBootApplication
+class VehicleFactoryApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(VehicleFactoryApplication.class, args);
+    }
+}
+````
+@SpringBootApplication ��װ��@Configuration��@EnableAutoConfiguration ��@ComponentScan ע�⼰��Ĭ�����ԡ�
+
+## 3 @EnableAutoConfiguration
+
+@EnableAutoConfiguration������˼�壬�����Զ����á� ����ζ�� Spring Boot ������·���в����Զ����� bean ���Զ�Ӧ�����ǡ�
+
+��ע�⣬���DZ��뽫��ע����@Configuration һ��ʹ�ã�
+
+````
+@Configuration
+@EnableAutoConfiguration
+class VehicleFactoryConfig {}
+````
+
+## 4 @Configuration�Լ������
+
+@Configuration�����ã���ע�����ϣ�����spring����(Ӧ��������)��
+
+����������spring������bean��ʹ�õ�xml�����ļ�������һ����bean����springboot�У�Ϊ�����������ã�spring����ṩ��@Configuration��һע��
+
+�൱�ڰѸ�����Ϊspring��xml�����ļ��е�<beans>
+
+@Configurationע������У�ʹ��@Beanע���ע�ķ��������ص����Ͷ���ֱ��ע��Ϊbean��
+
+@Configureע��Ķ������£�
+````
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Component
+public @interface Configuration {
+String value() default "";
+}
+````
+�Ӷ����������ײ��Ǻ���@Component ������@Configuration ���к� @Component �����á����context:component-scan/����@ComponentScan���ܴ���@Configurationע����ࡣ
+
+ͨ���������DZ�д�Զ����Զ�����ʱ������ϣ�� Spring ��������ʹ�����ǡ� ���ǿ���ͨ�������е�ע����ʵ����һ�㡣
+
+���ǿ��Խ��˲����е�ע�ͷ���@Configuration ���@Bean �����ϡ�
+
+�ڽ������IJ����У����ǽ�ֻ����ÿ����������Ļ������ ���˽������Ϣ���������ƪ���¡�
+
+### 4.1 @ConditionalOnClass and @ConditionalOnMissingClass
+����������һ�����������жϵ�����ע�⣬Ҫ֪�����ܶ�ʱ�����ǰ������bean�ģ������Ǹ����ⲿjar���Ƿ���������м��غ��жϵġ�
+
+����ʱ�򣬾�Ҫ�����ⲿ���Ƿ�����������Ƿ��Ƿ���ظ�bean
+
+ʹ����Щ���������ע�Ͳ����е������/�����ڣ�Spring ����ʹ�ñ�ǵ��Զ����� bean��
+
+````
+@Configuration
+@ConditionalOnClass(DataSource.class)
+class MySQLAutoconfiguration {
+//...
+}
+````
+
+### 4.2 @ConditionalOnBean and @ConditionalOnMissingBean
+
+��������Ҫ�����ض� bean �Ĵ��ڻ򲻴�������������ʱ�����ǿ���ʹ����Щע�ͣ�
+
+������һ��ע������Щ��ͬ����Ϊ���ǵ��ж����������bean
+
+````
+@Bean
+@ConditionalOnBean(name = "dataSource")
+LocalContainerEntityManagerFactoryBean entityManagerFactory() {
+// ...
+}
+````
+### 4.3 @ConditionalOnProperty
+ͨ�����ע�⣬���ǿ��Զ����Ե�ֵ��������
+
+Ҫע�⣬���������ֵ��Դ��application.properties�ļ��е�����
+
+````
+@Bean
+@ConditionalOnProperty(
+name = "usemysql",
+havingValue = "local"
+)
+DataSource dataSource() {
+// ...
+}
+````
+
+### 4.4 @ConditionalOnResource
+
+���ǿ����� Spring ���ڴ����ض���Դʱʹ�ö��壺
+����˼�壬Ҫ��classpath���������Դ�ļ�ʱ�Ž��м��أ���Ҳ�Ǻܳ��õ�һ��ע�⡣
+
+````
+
+@ConditionalOnResource(resources = "classpath:mysql.properties")
+Properties  ditionalProperties() {
+// ...
+}
+````
+
+### 4.5 @ConditionalOnWebApplication and @ConditionalOnNotWebApplication
+���ע��ͨ�����ں�web��ǿ������������ȫ�޹�����������
+
+ʹ����Щע�ͣ����ǿ��Ը��ݵ�ǰӦ�ó����Ƿ��� Web Ӧ�ó���������������
+````
+
+@ConditionalOnWebApplication
+HealthCheckController healthCheckController() {
+// ...
+}
+````
+
+### 4.6 @ConditionalExpression
+springboot���Ϊ�����뵽�������������������ע�⻹�����������Ҫ����ô�ɴ�������Լ�д������Ӧ��û������ɣ�
+
+���ǿ����ڸ����ӵ������ʹ�����ע�⡣ �� SpEL ����ʽ������Ϊ��ʱ��Spring ��ʹ�ñ�ǵĶ��壺
+
+````
+@Bean
+@ConditionalOnExpression("${usemysql} && ${mysqlserver == 'local'}")
+DataSource dataSource() {
+// ...
+}
+````
+
+### 4.7 @Conditional
+ʲô���������⣿
+��springbootҲ�����ṩʲô����ʽ�����ˣ�ֱ�����û�дһ���ж�������������true����false������
+
+���ڸ����ӵ����������ǿ��Դ���һ�������Զ����������ࡣ ���Ǹ��� Spring ������Զ��������� @Conditional һ��ʹ�ã�
+
+````
+@Conditional(HibernateCondition.class)
+Properties  ditionalProperties() {
+//...
+}
+````
+
+## 5 �ܽ�
+�ڱ����У����Ǹ��������΢���Զ����ù��̲�Ϊ�Զ����Զ����� bean �ṩ������
+
+# �����
+https://www.baeldung.com/spring-annotations
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/\345\237\272\344\272\216SpringBoot\344\270\255\347\232\204\345\274\200\346\272\220\347\233\221\346\216\247\345\267\245\345\205\267SpringBootAdmin.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/\345\237\272\344\272\216SpringBoot\344\270\255\347\232\204\345\274\200\346\272\220\347\233\221\346\216\247\345\267\245\345\205\267SpringBootAdmin.md"
new file mode 100644
index 0000000..fc25a2c
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/\345\237\272\344\272\216SpringBoot\344\270\255\347\232\204\345\274\200\346\272\220\347\233\221\346\216\247\345\267\245\345\205\267SpringBootAdmin.md"
@@ -0,0 +1,294 @@
+Spring Boot Admin(SBA)��һ����Դ��������Ŀ�����ڹ����ͼ�� Spring Boot Ӧ�ó���Ӧ�ó������ͨ�� http �ķ�ʽ���� Spring Cloud �����ֻ���ע�ᵽ SBA �У�Ȼ��Ϳ���ʵ�ֶ� Spring Boot ��Ŀ�Ŀ��ӻ������Ͳ鿴�ˡ�
+
+Spring Boot Admin ���Լ�� Spring Boot ������Ⱥ��Ŀ�����ṩ��ϸ�Ľ��� (Health)��Ϣ���ڴ���Ϣ��JVM ϵͳ�ͻ������ԡ�����������Ϣ����־���úͲ鿴����ʱ����鿴��Spring Boot ����鿴�͹����ȹ��ܡ�����������һ�������ʹ�ðɡ�
+
+�����յ�չʾЧ�����£�
+
+[![](https://s5.51cto.com/oss/202201/14/5d142e8c6b544f7b981b3eff8099b3d8.png)](https://s5.51cto.com/oss/202201/14/5d142e8c6b544f7b981b3eff8099b3d8.png)
+
+## 1.�SBA��ض�
+
+������Ҫ����һ�� Spring Boot Admin ��Ŀ��������غ͹������ǵ� Spring Boot ��Ŀ����ķ�ʽ�ʹ�����ͨ�� Spring Boot ��Ŀ���ƣ����岽�����¡�ʹ�� Idea ����һ�� Spring Boot ��Ŀ��
+
+[![](https://s5.51cto.com/oss/202201/14/d97c492785db6ff2ded49175184ceda9.png)](https://s5.51cto.com/oss/202201/14/d97c492785db6ff2ded49175184ceda9.png)
+
+[![](https://s3.51cto.com/oss/202201/14/8bb1f0389b95e174b56ac01ba313ec7b.png)](https://s3.51cto.com/oss/202201/14/8bb1f0389b95e174b56ac01ba313ec7b.png)
+
+������Ҫע�⣬��Ҫ���� Spring Boot Admin(Server)����˿�ܵ�֧�֣�����ͼ��ʾ��
+
+[![](https://s4.51cto.com/oss/202201/14/122e9f0726fde8ac0c8936c79ef12f5f.png)](https://s4.51cto.com/oss/202201/14/122e9f0726fde8ac0c8936c79ef12f5f.png)
+
+Ҳ���Ǵ����� Spring Boot ��Ŀ��Ҫ��������������Ҫ�Ŀ��֧�֣�
+
+
+
+<button data-clipboard-target="#code_id_0">����</button>
+
+```
+<dependency> 
+   <groupId>org.springframework.boot</groupId> 
+   spring-boot-starter-web 
+</dependency> 
+<dependency> 
+  <groupId>de.codecentric</groupId> 
+  spring-boot-admin-starter-server 
+</dependency> 
+
+```
+
+
+
+
+
+<dependency></dependency>
+
+### 1.1 ����SBA����
+
+��������Ŀ֮����Ҫ���������Ͽ��� SBA ����
+
+
+
+<button data-clipboard-target="#code_id_1">����</button>
+
+```
+import de.codecentric.boot.admin.server.config.EnableAdminServer; 
+import org.springframework.boot.SpringApplication; 
+import org.springframework.boot.autoconfigure.SpringBootApplication; 
+
+@EnableAdminServer // ���Ӵ��д��� 
+@SpringBootApplication  
+public class SbaserverApplication { 
+    public static void main(String[] args) { 
+        SpringApplication.run(SbaserverApplication.class, args); 
+    } 
+} 
+
+```
+
+
+
+
+
+### 1.2 ����SBA�˿ں�
+
+�� application.properties ������һ����Ŀ�Ķ˿ںžͿ���ֱ�������ˣ������õĶ˿ں��� 9001��
+
+
+
+<button data-clipboard-target="#code_id_2">����</button>
+
+```
+server.port=9001 
+
+```
+
+
+
+
+
+PS�����ö˿ںŵ���ҪĿ����Ϊ�˲������� Spring Boot ��Ŀ��ͻ����� SBA �ǵ�������˲�����Ժ��ԡ�
+
+������Ŀ֮�󣬾Ϳ��Կ��� SBA ����ҳ�ˣ�����ͼ��ʾ��
+
+[![](https://s5.51cto.com/oss/202201/14/20418ce88230b20b234f9e9c15e07f47.png)](https://s5.51cto.com/oss/202201/14/20418ce88230b20b234f9e9c15e07f47.png)
+
+��ʱ SBA �л�û�������κ���Ҫ��ص���Ŀ�������������ٴ���һ�� Spring Boot ��Ŀ�����뵽 SBA �������м�غ͹����ɡ�
+
+## 2.����һ����ͨSpringBoot��Ŀ
+
+���ȣ�������Ҫ����һ����ͨ�� Spring Boot ��Ŀ������Ĵ�����������Ͳ���ʾ�ˡ��������� Spring Boot ��Ŀ֮����Ҫ����� Spring Boot ��Ŀ����Ҫ���� SBA �ͻ��˿�ܵ�֧�֣�Ҳ������ pom.xml �������������ݣ�
+
+<dependency></dependency>
+
+
+
+<button data-clipboard-target="#code_id_3">����</button>
+
+```
+<dependency> 
+  <groupId>de.codecentric</groupId> 
+  spring-boot-admin-starter-client 
+</dependency> 
+
+```
+
+
+
+
+
+Ȼ���� application.properties �ļ������� SBA �������˵�ַ��Ҳ�������ǵ�һ������ SBA ��Ŀ�ĵ�ַ�������������£�
+
+
+
+<button data-clipboard-target="#code_id_4">����</button>
+
+```
+# ��ǰ��Ŀ�˿ں� 
+server.port=8080 
+# Spring Boot Admin ��ط������˵�ַ 
+spring.boot.admin.client.url=http://localhost:9001 
+
+```
+
+
+
+
+
+���С�spring.boot.admin.client.url��Ϊ SBA ��ص�ַ��
+
+## 3.SpringBootAdmin�������
+
+������������Ϣ֮�󣬴�ʱ�鿴 Spring Boot Admin ҳ���о��б���ص� Spring Boot ��Ŀ�ˣ�����ͼ��ʾ��
+
+[![](https://s5.51cto.com/oss/202201/14/c010770a5cdfe5fad0ad1e8f0c3b07dc.png)](https://s5.51cto.com/oss/202201/14/c010770a5cdfe5fad0ad1e8f0c3b07dc.png)
+
+Ҳ���Ե����Ӧ��ǽ���鿴 Spring Boot Admin �����б���ص� Spring Boot ��Ŀ������ͼ��ʾ��
+
+[![](https://s4.51cto.com/oss/202201/14/d88e33f87e116000f9717e8c19c43cc4.png)](https://s4.51cto.com/oss/202201/14/d88e33f87e116000f9717e8c19c43cc4.png)
+
+���Ӧ�ý�������ҳ�棬����ͼ��ʾ��
+
+[![](https://s2.51cto.com/oss/202201/14/4c3609840ea5cb45779eafbc2b260324.png)](https://s2.51cto.com/oss/202201/14/4c3609840ea5cb45779eafbc2b260324.png)
+
+[![](https://s4.51cto.com/oss/202201/14/2912ed434d97f8dd49c27ce73252d34c.png)](https://s4.51cto.com/oss/202201/14/2912ed434d97f8dd49c27ce73252d34c.png)
+
+�¼���־�а��� Spring Boot ����״̬��չʾ(UP Ϊ������OFFLINE Ϊ�쳣)�ͷ�����ʱ�䣬����ͼ��ʾ��
+
+[![](https://s5.51cto.com/oss/202201/14/5792a62fbcafe6978bfe3bd26cf1e3ab.png)](https://s5.51cto.com/oss/202201/14/5792a62fbcafe6978bfe3bd26cf1e3ab.png)
+
+## 4.SpringBoot�쳣���
+
+�������ֶ��ѱ���ص� Spring Boot ��Ŀֹ֮ͣ���� Spring Boot Admin �оͿ��Բ鿴��һ��Ӧ���Ѿ���ͣ���ˣ�����ͼ��ʾ��
+
+[![](https://s5.51cto.com/oss/202201/14/47569a3fe09e62b2364c26bdbd7da4bc.png)](https://s5.51cto.com/oss/202201/14/47569a3fe09e62b2364c26bdbd7da4bc.png)
+
+����Ҳ����ͨ���¼���־�鿴 Spring Boot 崻��ľ���ʱ�䣬����ͼ��ʾ��
+
+[![](https://s2.51cto.com/oss/202201/14/b63f631561fa646f85ccf3e1e4321939.png)](https://s2.51cto.com/oss/202201/14/b63f631561fa646f85ccf3e1e4321939.png)
+
+## 5.���ò鿴��������
+
+ͨ��������������ǿ��Կ�������ص� Spring Boot ѡ��DZȽ��ٵģ���ô���ܲ鿴����ļ������?Ҫ���������⣬������Ҫ�ڱ���ص� Spring Boot ��Ŀ������ spring-boot-starter-actuator ��ܵ�֧�֣��������鿴���м��������ò��У�����չʾЧ�����£�
+
+[![](https://s4.51cto.com/oss/202201/14/03938ac0bded4487b6720fc4657f9e99.png)](https://s4.51cto.com/oss/202201/14/03938ac0bded4487b6720fc4657f9e99.png)
+
+����������������һ����Щ����
+
+### 5.1 ����actuator���֧��
+
+�ڱ���ص� Spring Boot ��Ŀ������ actuator ���֧�֣�Ҳ������ pom.xml �������������ã�
+
+<dependency></dependency>
+
+
+
+<button data-clipboard-target="#code_id_5">����</button>
+
+```
+<dependency> 
+    <groupId>org.springframework.boot</groupId> 
+    spring-boot-starter-actuator 
+</dependency> 
+
+```
+
+
+
+
+
+�ֶ���� Maven ����������(����������Զ����룬�˲���ɺ���)��
+
+### 5.2 ���ÿ������м����
+
+�ڱ���ص� Spring Boot ��Ŀ�������������ã�
+
+
+
+<button data-clipboard-target="#code_id_6">����</button>
+
+```
+# ������������� 
+management.endpoints.web.exposure.include=* 
+
+```
+
+
+
+
+
+���ϵ������ǿ��ż������ѡ�������֮�������� Spring Boot ��Ŀ��Ȼ����ˢ�� Spring Boot Admin ����ļ�����չʾ�����ˣ�����ͼ��ʾ��
+
+[![](https://s6.51cto.com/oss/202201/14/2cc24e05bc6185ba1869872db5a864a5.png)](https://s6.51cto.com/oss/202201/14/2cc24e05bc6185ba1869872db5a864a5.png)
+
+### 5.3 �����ĿԤ��
+
+�� Spring Boot �����м�������֮��ͨ�� SBA �Ϳ��Բ鿴���������ˣ�
+
+*   ����ʱ�䡢�ۼ�����ʱ��;
+*   ���̺��߳�������ռ�õ� CPU ��Դ;
+*   ��������������Ϣ�����մ����ͻ���ʱ��;
+*   JVM �߳�ת�����ڴ�ת������Ͷ�Ӧ���ļ�����;
+*   ���Բ鿴������ Spring Boot ��Ŀ�е���־����;
+*   �鿴 Spring Boot ��Ŀ���ܼ��;
+*   �鿴 Spring Boot ���л�����Ϣ;
+*   �鿴 Spring Boot ��������Ϣ;
+*   �鿴 Spring Boot �еĶ�ʱ����;
+*   �鿴�͹��� Spring Boot ��Ŀ�е����л��档
+
+�����Ǽ�����Ҫҳ��Ľ�ͼ������һ��������
+
+### 5.3.1 �鿴���л���
+
+[![](https://s5.51cto.com/oss/202201/14/a9db77b1b0e378450086edd1ab438df5.png)](https://s5.51cto.com/oss/202201/14/a9db77b1b0e378450086edd1ab438df5.png)
+
+[![](https://s2.51cto.com/oss/202201/14/17604f4f5eb388a2a6c08f55e1e050ac.png)](https://s2.51cto.com/oss/202201/14/17604f4f5eb388a2a6c08f55e1e050ac.png)
+
+### 5.3.2 �鿴��ʱ����
+
+[![](https://s5.51cto.com/oss/202201/14/113d94b9bd488e239967915aededc89c.png)](https://s5.51cto.com/oss/202201/14/113d94b9bd488e239967915aededc89c.png)
+
+### 5.3.3 ��Ŀ��־��������
+
+[![](https://s3.51cto.com/oss/202201/14/8da60846eecbdbd9472ae6dbf17d951f.png)](https://s3.51cto.com/oss/202201/14/8da60846eecbdbd9472ae6dbf17d951f.png)
+
+���ǿ���ͨ�� Spring Boot Admin ����̬��������Ŀ�е���־����
+
+### 5.3.4 JVM�̺߳��ڴ�鿴
+
+[![](https://s2.51cto.com/oss/202201/14/d3f98228a8b19675475c863457821034.png)](https://s2.51cto.com/oss/202201/14/d3f98228a8b19675475c863457821034.png)
+
+### 5.3.5 �鿴SpringBoot���л���
+
+[![](https://s5.51cto.com/oss/202201/14/ae811102080c26b11135be50cd889710.png)](https://s5.51cto.com/oss/202201/14/ae811102080c26b11135be50cd889710.png)
+
+��Ȼ���ǻ����Զ���Щ�������ɾ��������
+
+## 6.�鿴��Ŀʵʱ��־
+
+��Ҫ�鿴�����Ŀ�е���־��Ϣ����һ��ǰ��������ǰ���������㱻��ص� Spring Boot ��Ŀ��������������־�ı���·��������־�����ļ�����ֻ�������������е�����һ���� Spring Boot ��Ŀ�ŻὫ��־���浽�����ϣ���������ͨ�� SBA �鿴���������õ�����־·������ Spring Boot �� application.properties �����ļ��������������ã�
+
+
+
+<button data-clipboard-target="#code_id_7">����</button>
+
+```
+# ������־����·�� 
+logging.file.path=C:\\work\\log 
+
+```
+
+
+
+
+
+�������֮��������� Spring Boot ��Ŀ��Ȼ��ˢ�� SBA ҳ�棬����չʾЧ�����£�
+
+[![](https://s6.51cto.com/oss/202201/14/3f03c6402cc8a2532ed45ab43be156ac.png)](https://s6.51cto.com/oss/202201/14/3f03c6402cc8a2532ed45ab43be156ac.png)
+
+��ʱ���ǾͿ��Բ鿴ʵʱ����־��Ϣ�ˣ���Ȼ��Ҳ������ʱ������־�������Ҫ�Ļ���
+
+## �ܽ�
+
+Spring Boot Admin(SBA)��һ��������Դ��Ŀ�����ڹ����ͼ��� Spring Boot Ӧ�ó������ṩ��ϸ�Ľ��� (Health)��Ϣ���ڴ���Ϣ��JVM ϵͳ�ͻ������ԡ�����������Ϣ����־���úͲ鿴����ʱ����鿴��Spring Boot ����鿴�͹����ȹ��ܡ�
+
+������Ҫ����һ�� SBA ���������������һ������ Spring Boot ��Ŀ������ص� Spring Boot ��ĿҪ���� SBA Client ��ܵ�֧�֣������� actuator ��ܺ���Ӧ�����ã��Ϳ���ʵ�ֶ� Spring Boot ��Ŀ����������ˡ�
\ No newline at end of file
diff --git "a/docs/java-web/Spring/\347\273\231\344\275\240\344\270\200\344\273\275Spring Boot\347\237\245\350\257\206\346\270\205\345\215\225.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/\347\273\231\344\275\240\344\270\200\344\273\275SpringBoot\347\237\245\350\257\206\346\270\205\345\215\225.md"
similarity index 68%
rename from "docs/java-web/Spring/\347\273\231\344\275\240\344\270\200\344\273\275Spring Boot\347\237\245\350\257\206\346\270\205\345\215\225.md"
rename to "docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/\347\273\231\344\275\240\344\270\200\344\273\275SpringBoot\347\237\245\350\257\206\346\270\205\345\215\225.md"
index 44c55aa..96260af 100644
--- "a/docs/java-web/Spring/\347\273\231\344\275\240\344\270\200\344\273\275Spring Boot\347\237\245\350\257\206\346\270\205\345\215\225.md"	
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot/\347\273\231\344\275\240\344\270\200\344\273\275SpringBoot\347\237\245\350\257\206\346\270\205\345\215\225.md"
@@ -1,26 +1,21 @@
-# Table of Contents
-
-  * [一、抛砖引玉：探索Spring IoC容器](#一、抛砖引玉：探索spring-ioc容器)
+# 目录
+* [一、抛砖引玉：探索Spring IoC容器](#一、抛砖引玉：探索spring-ioc容器)
     * [1.1、Spring IoC容器](#11、spring-ioc容器)
     * [1.2、Spring容器扩展机制](#12、spring容器扩展机制)
-  * [二、夯实基础：JavaConfig与常见Annotation](#二、夯实基础：javaconfig与常见annotation)
+* [二、夯实基础：JavaConfig与常见Annotation](#二、夯实基础：javaconfig与常见annotation)
     * [2.1、JavaConfig](#21、javaconfig)
     * [2.2、@ComponentScan](#22、componentscan)
     * [2.3、@Import](#23、import)
     * [2.4、@Conditional](#24、conditional)
     * [2.5、@ConfigurationProperties与@EnableConfigurationProperties](#25、configurationproperties与enableconfigurationproperties)
-      * [](#)
-  * [三、削铁如泥：SpringFactoriesLoader详解](#三、削铁如泥：springfactoriesloader详解)
-  * [四、另一件武器：Spring容器的事件监听机制](#四、另一件武器：spring容器的事件监听机制)
-      * [Spring容器内的事件监听机制](#spring容器内的事件监听机制)
-  * [五、出神入化：揭秘自动配置原理](#五、出神入化：揭秘自动配置原理)
-  * [六、启动引导：Spring Boot应用启动的秘密](#六、启动引导：spring-boot应用启动的秘密)
+* [三、削铁如泥：SpringFactoriesLoader详解](#三、削铁如泥：springfactoriesloader详解)
+* [四、另一件武器：Spring容器的事件监听机制](#四、另一件武器：spring容器的事件监听机制)
+    * [Spring容器内的事件监听机制](#spring容器内的事件监听机制)
+* [五、出神入化：揭秘自动配置原理](#五、出神入化：揭秘自动配置原理)
+* [六、启动引导：Spring Boot应用启动的秘密](#六、启动引导：spring-boot应用启动的秘密)
     * [6.1 SpringApplication初始化](#61-springapplication初始化)
     * [6.2 Spring Boot启动流程](#62-spring-boot启动流程)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
+* [参考文章](#参考文章)
 
 
 本文转自互联网，侵删
@@ -43,8 +38,8 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
-<!-- more -->
+<!-- more -->  
+<!-- more -->  
 
 
 > 1.  预警：本文非常长，建议先mark后看，也许是最后一次写这么长的文章
@@ -54,7 +49,7 @@
 
 在过去两三年的Spring生态圈，最让人兴奋的莫过于Spring Boot框架。或许从命名上就能看出这个框架的设计初衷：快速的启动Spring应用。因而Spring Boot应用本质上就是一个基于Spring框架的应用，它是Spring对“约定优先于配置”理念的最佳实践产物，它能够帮助开发者更快速高效地构建基于Spring生态圈的应用。
 
-那Spring Boot有何魔法？**自动配置**、**起步依赖**、**Actuator**、**命令行界面(CLI)** 是Spring Boot最重要的4大核心特性，其中CLI是Spring Boot的可选特性，虽然它功能强大，但也引入了一套不太常规的开发模型，因而这个系列的文章仅关注其它3种特性。如文章标题，本文是这个系列的第一部分，将为你打开Spring Boot的大门，重点为你剖析其启动流程以及自动配置实现原理。要掌握这部分核心内容，理解一些Spring框架的基础知识，将会让你事半功倍。
+那Spring Boot有何魔法？**自动配置**、**起步依赖**、**Actuator**、**命令行界面(CLI)**是Spring Boot最重要的4大核心特性，其中CLI是Spring Boot的可选特性，虽然它功能强大，但也引入了一套不太常规的开发模型，因而这个系列的文章仅关注其它3种特性。如文章标题，本文是这个系列的第一部分，将为你打开Spring Boot的大门，重点为你剖析其启动流程以及自动配置实现原理。要掌握这部分核心内容，理解一些Spring框架的基础知识，将会让你事半功倍。
 
 ## 一、抛砖引玉：探索Spring IoC容器
 
@@ -72,7 +67,7 @@
 
 
 
-![](https://upload-images.jianshu.io/upload_images/175724-911dc459ef9cec28.png?imageMogr2/auto-orient/strip|imageView2/2/w/1200/format/webp)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/175724-911dc459ef9cec28.png)
 
 
 
@@ -84,23 +79,23 @@ BeanFactory、BeanDefinitionRegistry关系图（来自：Spring揭秘）
 
 下面通过一段简单的代码来模拟BeanFactory底层是如何工作的：
 
-```
-// 默认容器实现
-DefaultListableBeanFactory beanRegistry = new DefaultListableBeanFactory();
-// 根据业务对象构造相应的BeanDefinition
-AbstractBeanDefinition definition = new RootBeanDefinition(Business.class,true);
-// 将bean定义注册到容器中
-beanRegistry.registerBeanDefinition("beanName",definition);
-// 如果有多个bean，还可以指定各个bean之间的依赖关系
-// ........
-
-// 然后可以从容器中获取这个bean的实例
-// 注意：这里的beanRegistry其实实现了BeanFactory接口，所以可以强转，
-// 单纯的BeanDefinitionRegistry是无法强制转换到BeanFactory类型的
-BeanFactory container = (BeanFactory)beanRegistry;
-Business business = (Business)container.getBean("beanName");
-
-```
+```  
+// 默认容器实现  
+DefaultListableBeanFactory beanRegistry = new DefaultListableBeanFactory();  
+// 根据业务对象构造相应的BeanDefinition  
+AbstractBeanDefinition definition = new RootBeanDefinition(Business.class,true);  
+// 将bean定义注册到容器中  
+beanRegistry.registerBeanDefinition("beanName",definition);  
+// 如果有多个bean，还可以指定各个bean之间的依赖关系  
+// ........  
+  
+// 然后可以从容器中获取这个bean的实例  
+// 注意：这里的beanRegistry其实实现了BeanFactory接口，所以可以强转，  
+// 单纯的BeanDefinitionRegistry是无法强制转换到BeanFactory类型的  
+BeanFactory container = (BeanFactory)beanRegistry;  
+Business business = (Business)container.getBean("beanName");  
+  
+```  
 
 这段代码仅为了说明BeanFactory底层的大致工作流程，实际情况会更加复杂，比如bean之间的依赖关系可能定义在外部配置文件(XML/Properties)中、也可能是注解方式。Spring IoC容器的整个工作流程大致可以分为两个阶段：
 
@@ -110,19 +105,18 @@ Business business = (Business)container.getBean("beanName");
 
 来看一个简单的例子吧，过往，所有的bean都定义在XML配置文件中，下面的代码将模拟BeanFactory如何从配置文件中加载bean的定义以及依赖关系：
 
-```
-// 通常为BeanDefinitionRegistry的实现类，这里以DeFaultListabeBeanFactory为例
-BeanDefinitionRegistry beanRegistry = new DefaultListableBeanFactory(); 
-// XmlBeanDefinitionReader实现了BeanDefinitionReader接口，用于解析XML文件
-XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReaderImpl(beanRegistry);
-// 加载配置文件
-beanDefinitionReader.loadBeanDefinitions("classpath:spring-bean.xml");
-
-// 从容器中获取bean实例
-BeanFactory container = (BeanFactory)beanRegistry;
-Business business = (Business)container.getBean("beanName");
-
-```
+```  
+// 通常为BeanDefinitionRegistry的实现类，这里以DeFaultListabeBeanFactory为例  
+BeanDefinitionRegistry beanRegistry = new DefaultListableBeanFactory(); // XmlBeanDefinitionReader实现了BeanDefinitionReader接口，用于解析XML文件  
+XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReaderImpl(beanRegistry);  
+// 加载配置文件  
+beanDefinitionReader.loadBeanDefinitions("classpath:spring-bean.xml");  
+  
+// 从容器中获取bean实例  
+BeanFactory container = (BeanFactory)beanRegistry;  
+Business business = (Business)container.getBean("beanName");  
+  
+```  
 
 ②、Bean的实例化阶段
 
@@ -142,15 +136,13 @@ IoC容器负责管理容器中所有bean的生命周期，而在bean生命周期
 
 与之相似的，还有`BeanPostProcessor`，其存在于对象实例化阶段。跟BeanFactoryPostProcessor类似，它会处理容器内所有符合条件并且已经实例化后的对象。简单的对比，BeanFactoryPostProcessor处理bean的定义，而BeanPostProcessor则处理bean完成实例化后的对象。BeanPostProcessor定义了两个接口：
 
-```
-public interface BeanPostProcessor {
-    // 前置处理
-    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
-    // 后置处理
-    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
-}
-
-```
+```  
+public interface BeanPostProcessor {  
+    // 前置处理  
+    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;    // 后置处理  
+    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;}  
+  
+```  
 
 为了理解这两个方法执行的时机，简单的了解下bean的整个生命周期：
 
@@ -158,7 +150,7 @@ public interface BeanPostProcessor {
 
 
 
-![](https://upload-images.jianshu.io/upload_images/175724-0d50d67d980161b4.png?imageMogr2/auto-orient/strip|imageView2/2/w/810/format/webp)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/175724-0d50d67d980161b4.png)
 
 
 
@@ -170,20 +162,13 @@ Bean的实例化过程（来自：Spring揭秘）
 
 再来看一个更常见的例子，在Spring中经常能够看到各种各样的Aware接口，其作用就是在对象实例化完成以后将Aware接口定义中规定的依赖注入到当前实例中。比如最常见的`ApplicationContextAware`接口，实现了这个接口的类都可以获取到一个ApplicationContext对象。当容器中每个对象的实例化过程走到BeanPostProcessor前置处理这一步时，容器会检测到之前注册到容器的ApplicationContextAwareProcessor，然后就会调用其postProcessBeforeInitialization()方法，检查并设置Aware相关依赖。看看代码吧，是不是很简单：
 
-```
-// 代码来自：org.springframework.context.support.ApplicationContextAwareProcessor
-// 其postProcessBeforeInitialization方法调用了invokeAwareInterfaces方法
-private void invokeAwareInterfaces(Object bean) {
-    if (bean instanceof EnvironmentAware) {
-        ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
-    }
-    if (bean instanceof ApplicationContextAware) {
-        ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
-    }
-    // ......
-}
-
-```
+```  
+// 代码来自：org.springframework.context.support.ApplicationContextAwareProcessor  
+// 其postProcessBeforeInitialization方法调用了invokeAwareInterfaces方法  
+private void invokeAwareInterfaces(Object bean) {  
+    if (bean instanceof EnvironmentAware) {        ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());    }    if (bean instanceof ApplicationContextAware) {        ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);    }    // ......}  
+  
+```  
 
 最后总结一下，本小节内容和你一起回顾了Spring容器的部分核心内容，限于篇幅不能写更多，但理解这部分内容，足以让您轻松理解Spring Boot的启动原理，如果在后续的学习过程中遇到一些晦涩难懂的知识，再回过头来看看Spring的核心知识，也许有意想不到的效果。也许Spring Boot的中文资料很少，但Spring的中文资料和书籍有太多太多，总有东西能给你启发。
 
@@ -195,67 +180,49 @@ private void invokeAwareInterfaces(Object bean) {
 
 后来，基于纯Java Annotation依赖注入框架`Guice`出世，其性能明显优于采用XML方式的Spring，甚至有部分人认为，`Guice`可以完全取代Spring（`Guice`仅是一个轻量级IOC框架，取代Spring还差的挺远）。正是这样的危机感，促使Spring及社区推出并持续完善了`JavaConfig`子项目，它基于Java代码和Annotation注解来描述bean之间的依赖绑定关系。比如，下面是使用XML配置方式来描述bean的定义：
 
-```
-<bean id="bookService" class="cn.moondev.service.BookServiceImpl"></bean>
-
-```
+```  
+<bean id="bookService" class="cn.moondev.service.BookServiceImpl"></bean>  
+  
+```  
 
 而基于JavaConfig的配置形式是这样的：
 
-```
-@Configuration
-public class MoonBookConfiguration {
-
-    // 任何标志了@Bean的方法，其返回值将作为一个bean注册到Spring的IOC容器中
-    // 方法名默认成为该bean定义的id
-    @Bean
-    public BookService bookService() {
-        return new BookServiceImpl();
-    }
-}
-
-```
+```  
+@Configuration  
+public class MoonBookConfiguration {  
+  
+    // 任何标志了@Bean的方法，其返回值将作为一个bean注册到Spring的IOC容器中  
+    // 方法名默认成为该bean定义的id  
+    @Bean    public BookService bookService() {        return new BookServiceImpl();    }}  
+  
+```  
 
 如果两个bean之间有依赖关系的话，在XML配置中应该是这样：
 
-```
-<bean id="bookService" class="cn.moondev.service.BookServiceImpl">
-    <property name="dependencyService" ref="dependencyService"/>
-</bean>
-
-<bean id="otherService" class="cn.moondev.service.OtherServiceImpl">
-    <property name="dependencyService" ref="dependencyService"/>
-</bean>
-
-<bean id="dependencyService" class="DependencyServiceImpl"/>
-
-```
+```  
+<bean id="bookService" class="cn.moondev.service.BookServiceImpl">  
+    <property name="dependencyService" ref="dependencyService"/></bean>  
+  
+<bean id="otherService" class="cn.moondev.service.OtherServiceImpl">  
+    <property name="dependencyService" ref="dependencyService"/></bean>  
+  
+<bean id="dependencyService" class="DependencyServiceImpl"/>  
+  
+```  
 
 而在JavaConfig中则是这样：
 
-```
-@Configuration
-public class MoonBookConfiguration {
-
-    // 如果一个bean依赖另一个bean，则直接调用对应JavaConfig类中依赖bean的创建方法即可
-    // 这里直接调用dependencyService()
-    @Bean
-    public BookService bookService() {
-        return new BookServiceImpl(dependencyService());
-    }
-
-    @Bean
-    public OtherService otherService() {
-        return new OtherServiceImpl(dependencyService());
-    }
-
-    @Bean
-    public DependencyService dependencyService() {
-        return new DependencyServiceImpl();
-    }
-}
-
-```
+```  
+@Configuration  
+public class MoonBookConfiguration {  
+  
+    // 如果一个bean依赖另一个bean，则直接调用对应JavaConfig类中依赖bean的创建方法即可  
+    // 这里直接调用dependencyService()  
+    @Bean    public BookService bookService() {        return new BookServiceImpl(dependencyService());    }  
+    @Bean    public OtherService otherService() {        return new OtherServiceImpl(dependencyService());    }  
+    @Bean    public DependencyService dependencyService() {        return new DependencyServiceImpl();    }}  
+  
+```  
 
 你可能注意到这个示例中，有两个bean都依赖于dependencyService，也就是说当初始化bookService时会调用`dependencyService()`，在初始化otherService时也会调用`dependencyService()`，那么问题来了？这时候IOC容器中是有一个dependencyService实例还是两个？这个问题留着大家思考吧，这里不再赘述。
 
@@ -267,31 +234,23 @@ public class MoonBookConfiguration {
 
 `@Import`注解用于导入配置类，举个简单的例子：
 
-```
-@Configuration
-public class MoonBookConfiguration {
-    @Bean
-    public BookService bookService() {
-        return new BookServiceImpl();
-    }
-}
-
-```
+```  
+@Configuration  
+public class MoonBookConfiguration {  
+    @Bean    public BookService bookService() {        return new BookServiceImpl();    }}  
+  
+```  
 
 现在有另外一个配置类，比如：`MoonUserConfiguration`，这个配置类中有一个bean依赖于`MoonBookConfiguration`中的bookService，如何将这两个bean组合在一起？借助`@Import`即可：
 
-```
-@Configuration
-// 可以同时导入多个配置类，比如：@Import({A.class,B.class})
-@Import(MoonBookConfiguration.class)
-public class MoonUserConfiguration {
-    @Bean
-    public UserService userService(BookService bookService) {
-        return new BookServiceImpl(bookService);
-    }
-}
-
-```
+```  
+@Configuration  
+// 可以同时导入多个配置类，比如：@Import({A.class,B.class})  
+@Import(MoonBookConfiguration.class)  
+public class MoonUserConfiguration {  
+    @Bean    public UserService userService(BookService bookService) {        return new BookServiceImpl(bookService);    }}  
+  
+```  
 
 需要注意的是，在4.2之前，`@Import`注解只支持导入配置类，但是在4.2之后，它支持导入普通类，并将这个类作为一个bean的定义注册到IOC容器中。
 
@@ -301,160 +260,110 @@ public class MoonUserConfiguration {
 
 在Spring里可以很方便的编写你自己的条件类，所要做的就是实现`Condition`接口，并覆盖它的`matches()`方法。举个例子，下面的简单条件类表示只有在`Classpath`里存在`JdbcTemplate`类时才生效：
 
-```
-public class JdbcTemplateCondition implements Condition {
-
-    @Override
-    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
-        try {
-        conditionContext.getClassLoader().loadClass("org.springframework.jdbc.core.JdbcTemplate");
-            return true;
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-        return false;
-    }
-}
-
-```
+```  
+public class JdbcTemplateCondition implements Condition {  
+  
+    @Override    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {        try {        conditionContext.getClassLoader().loadClass("org.springframework.jdbc.core.JdbcTemplate");            return true;        } catch (ClassNotFoundException e) {            e.printStackTrace();        }        return false;    }}  
+  
+```  
 
 当你用Java来声明bean的时候，可以使用这个自定义条件类：
 
-```
-@Conditional(JdbcTemplateCondition.class)
-@Service
-public MyService service() {
-    ......
-}
-
-```
+```  
+@Conditional(JdbcTemplateCondition.class)  
+@Service  
+public MyService service() {  
+    ......}  
+  
+```  
 
 这个例子中只有当`JdbcTemplateCondition`类的条件成立时才会创建MyService这个bean。也就是说MyService这bean的创建条件是`classpath`里面包含`JdbcTemplate`，否则这个bean的声明就会被忽略掉。
 
 `Spring Boot`定义了很多有趣的条件，并把他们运用到了配置类上，这些配置类构成了`Spring Boot`的自动配置的基础。`Spring Boot`运用条件化配置的方法是：定义多个特殊的条件化注解，并将它们用到配置类上。下面列出了`Spring Boot`提供的部分条件化注解：
 
-| 条件化注解 | 配置生效条件 |
-| --- | --- |
-| @ConditionalOnBean | 配置了某个特定bean |
-| @ConditionalOnMissingBean | 没有配置特定的bean |
-| @ConditionalOnClass | Classpath里有指定的类 |
-| @ConditionalOnMissingClass | Classpath里没有指定的类 |
-| @ConditionalOnExpression | 给定的Spring Expression Language表达式计算结果为true |
-| @ConditionalOnJava | Java的版本匹配特定指或者一个范围值 |
-| @ConditionalOnProperty | 指定的配置属性要有一个明确的值 |
-| @ConditionalOnResource | Classpath里有指定的资源 |
-| @ConditionalOnWebApplication | 这是一个Web应用程序 |
-| @ConditionalOnNotWebApplication | 这不是一个Web应用程序 |
+| 条件化注解 | 配置生效条件 |  
+| --- | --- |  
+| @ConditionalOnBean | 配置了某个特定bean |  
+| @ConditionalOnMissingBean | 没有配置特定的bean |  
+| @ConditionalOnClass | Classpath里有指定的类 |  
+| @ConditionalOnMissingClass | Classpath里没有指定的类 |  
+| @ConditionalOnExpression | 给定的Spring Expression Language表达式计算结果为true |  
+| @ConditionalOnJava | Java的版本匹配特定指或者一个范围值 |  
+| @ConditionalOnProperty | 指定的配置属性要有一个明确的值 |  
+| @ConditionalOnResource | Classpath里有指定的资源 |  
+| @ConditionalOnWebApplication | 这是一个Web应用程序 |  
+| @ConditionalOnNotWebApplication | 这不是一个Web应用程序 |  
 
 ### 2.5、@ConfigurationProperties与@EnableConfigurationProperties
 
 当某些属性的值需要配置的时候，我们一般会在`application.properties`文件中新建配置项，然后在bean中使用`@Value`注解来获取配置的值，比如下面配置数据源的代码。
 
-```
-// jdbc config
-jdbc.mysql.url=jdbc:mysql://localhost:3306/sampledb
-jdbc.mysql.username=root
-jdbc.mysql.password=123456
-......
-
-// 配置数据源
-@Configuration
-public class HikariDataSourceConfiguration {
-
-    @Value("jdbc.mysql.url")
-    public String url;
-    @Value("jdbc.mysql.username")
-    public String user;
-    @Value("jdbc.mysql.password")
-    public String password;
-
-    @Bean
-    public HikariDataSource dataSource() {
-        HikariConfig hikariConfig = new HikariConfig();
-        hikariConfig.setJdbcUrl(url);
-        hikariConfig.setUsername(user);
-        hikariConfig.setPassword(password);
-        // 省略部分代码
-        return new HikariDataSource(hikariConfig);
-    }
-}
-
-```
+```  
+// jdbc config  
+jdbc.mysql.url=jdbc:mysql://localhost:3306/sampledb  
+jdbc.mysql.username=root  
+jdbc.mysql.password=123456  
+......  
+  
+// 配置数据源  
+@Configuration  
+public class HikariDataSourceConfiguration {  
+  
+    @Value("jdbc.mysql.url")    public String url;    @Value("jdbc.mysql.username")    public String user;    @Value("jdbc.mysql.password")    public String password;  
+    @Bean    public HikariDataSource dataSource() {        HikariConfig hikariConfig = new HikariConfig();        hikariConfig.setJdbcUrl(url);        hikariConfig.setUsername(user);        hikariConfig.setPassword(password);        // 省略部分代码  
+        return new HikariDataSource(hikariConfig);    }}  
+  
+```  
 
 使用`@Value`注解注入的属性通常都比较简单，如果同一个配置在多个地方使用，也存在不方便维护的问题（考虑下，如果有几十个地方在使用某个配置，而现在你想改下名字，你改怎么做？）。对于更为复杂的配置，Spring Boot提供了更优雅的实现方式，那就是`@ConfigurationProperties`注解。我们可以通过下面的方式来改写上面的代码：
 
-```
-@Component
-//  还可以通过@PropertySource("classpath:jdbc.properties")来指定配置文件
-@ConfigurationProperties("jdbc.mysql")
-// 前缀=jdbc.mysql，会在配置文件中寻找jdbc.mysql.*的配置项
-pulic class JdbcConfig {
-    public String url;
-    public String username;
-    public String password;
-}
-
-@Configuration
-public class HikariDataSourceConfiguration {
-
-    @AutoWired
-    public JdbcConfig config;
-
-    @Bean
-    public HikariDataSource dataSource() {
-        HikariConfig hikariConfig = new HikariConfig();
-        hikariConfig.setJdbcUrl(config.url);
-        hikariConfig.setUsername(config.username);
-        hikariConfig.setPassword(config.password);
-        // 省略部分代码
-        return new HikariDataSource(hikariConfig);
-    }
-}
-
-```
+```  
+@Component  
+//  还可以通过@PropertySource("classpath:jdbc.properties")来指定配置文件  
+@ConfigurationProperties("jdbc.mysql")  
+// 前缀=jdbc.mysql，会在配置文件中寻找jdbc.mysql.*的配置项  
+pulic class JdbcConfig {  
+    public String url;    public String username;    public String password;}  
+  
+@Configuration  
+public class HikariDataSourceConfiguration {  
+  
+    @AutoWired    public JdbcConfig config;  
+    @Bean    public HikariDataSource dataSource() {        HikariConfig hikariConfig = new HikariConfig();        hikariConfig.setJdbcUrl(config.url);        hikariConfig.setUsername(config.username);        hikariConfig.setPassword(config.password);        // 省略部分代码  
+        return new HikariDataSource(hikariConfig);    }}  
+  
+```  
 
 `@ConfigurationProperties`对于更为复杂的配置，处理起来也是得心应手，比如有如下配置文件：
 
-```
-#App
-app.menus[0].title=Home
-app.menus[0].name=Home
-app.menus[0].path=/
-app.menus[1].title=Login
-app.menus[1].name=Login
-app.menus[1].path=/login
-
-app.compiler.timeout=5
-app.compiler.output-folder=/temp/
-
-app.error=/error/
-
-```
+```  
+#App  
+app.menus[0].title=Home  
+app.menus[0].name=Home  
+app.menus[0].path=/  
+app.menus[1].title=Login  
+app.menus[1].name=Login  
+app.menus[1].path=/login  
+  
+app.compiler.timeout=5  
+app.compiler.output-folder=/temp/  
+  
+app.error=/error/  
+  
+```  
 
 可以定义如下配置类来接收这些属性
 
-```
-@Component
-@ConfigurationProperties("app")
-public class AppProperties {
-
-    public String error;
-    public List<Menu> menus = new ArrayList<>();
-    public Compiler compiler = new Compiler();
-
-    public static class Menu {
-        public String name;
-        public String path;
-        public String title;
-    }
-
-    public static class Compiler {
-        public String timeout;
-        public String outputFolder;
-    }
-}
-
-```
+```  
+@Component  
+@ConfigurationProperties("app")  
+public class AppProperties {  
+  
+    public String error;    public List<Menu> menus = new ArrayList<>();    public Compiler compiler = new Compiler();  
+    public static class Menu {        public String name;        public String path;        public String title;    }  
+    public static class Compiler {        public String timeout;        public String outputFolder;    }}  
+  
+```  
 
 `@EnableConfigurationProperties`注解表示对`@ConfigurationProperties`的内嵌支持，默认会将对应Properties Class作为bean注入的IOC容器中，即在相应的Properties类上不用加`@Component`注解。
 
@@ -466,137 +375,89 @@ JVM提供了3种类加载器：`BootstrapClassLoader`、`ExtClassLoader`、`AppC
 
 采用双亲委派模型的一个好处是保证使用不同类加载器最终得到的都是同一个对象，这样就可以保证Java 核心库的类型安全，比如，加载位于rt.jar包中的`java.lang.Object`类，不管是哪个加载器加载这个类，最终都是委托给顶层的BootstrapClassLoader来加载的，这样就可以保证任何的类加载器最终得到的都是同样一个Object对象。查看ClassLoader的源码，对双亲委派模型会有更直观的认识：
 
-```
-protected Class<?> loadClass(String name, boolean resolve) {
-    synchronized (getClassLoadingLock(name)) {
-    // 首先，检查该类是否已经被加载，如果从JVM缓存中找到该类，则直接返回
-    Class<?> c = findLoadedClass(name);
-    if (c == null) {
-        try {
-            // 遵循双亲委派的模型，首先会通过递归从父加载器开始找，
-            // 直到父类加载器是BootstrapClassLoader为止
-            if (parent != null) {
-                c = parent.loadClass(name, false);
-            } else {
-                c = findBootstrapClassOrNull(name);
-            }
-        } catch (ClassNotFoundException e) {}
-        if (c == null) {
-            // 如果还找不到，尝试通过findClass方法去寻找
-            // findClass是留给开发者自己实现的，也就是说
-            // 自定义类加载器时，重写此方法即可
-           c = findClass(name);
-        }
-    }
-    if (resolve) {
-        resolveClass(c);
-    }
-    return c;
-    }
-}
-
-```
+```  
+protected Class<?> loadClass(String name, boolean resolve) {  
+    synchronized (getClassLoadingLock(name)) {    // 首先，检查该类是否已经被加载，如果从JVM缓存中找到该类，则直接返回  
+    Class<?> c = findLoadedClass(name);    if (c == null) {        try {            // 遵循双亲委派的模型，首先会通过递归从父加载器开始找，  
+            // 直到父类加载器是BootstrapClassLoader为止  
+            if (parent != null) {                c = parent.loadClass(name, false);            } else {                c = findBootstrapClassOrNull(name);            }        } catch (ClassNotFoundException e) {}        if (c == null) {            // 如果还找不到，尝试通过findClass方法去寻找  
+            // findClass是留给开发者自己实现的，也就是说  
+            // 自定义类加载器时，重写此方法即可  
+           c = findClass(name);        }    }    if (resolve) {        resolveClass(c);    }    return c;    }}  
+  
+```  
 
 但双亲委派模型并不能解决所有的类加载器问题，比如，Java 提供了很多服务提供者接口(`Service Provider Interface`，SPI)，允许第三方为这些接口提供实现。常见的 SPI 有 JDBC、JNDI、JAXP 等，这些SPI的接口由核心类库提供，却由第三方实现，这样就存在一个问题：SPI 的接口是 Java 核心库的一部分，是由BootstrapClassLoader加载的；SPI实现的Java类一般是由AppClassLoader来加载的。BootstrapClassLoader是无法找到 SPI 的实现类的，因为它只加载Java的核心库。它也不能代理给AppClassLoader，因为它是最顶层的类加载器。也就是说，双亲委派模型并不能解决这个问题。
 
 线程上下文类加载器(`ContextClassLoader`)正好解决了这个问题。从名称上看，可能会误解为它是一种新的类加载器，实际上，它仅仅是Thread类的一个变量而已，可以通过`setContextClassLoader(ClassLoader cl)`和`getContextClassLoader()`来设置和获取该对象。如果不做任何的设置，Java应用的线程的上下文类加载器默认就是AppClassLoader。在核心类库使用SPI接口时，传递的类加载器使用线程上下文类加载器，就可以成功的加载到SPI实现的类。线程上下文类加载器在很多SPI的实现中都会用到。但在JDBC中，你可能会看到一种更直接的实现方式，比如，JDBC驱动管理`java.sql.Driver`中的`loadInitialDrivers()`方法中，你可以直接看到JDK是如何加载驱动的：
 
-```
-for (String aDriver : driversList) {
-    try {
-        // 直接使用AppClassLoader
-        Class.forName(aDriver, true, ClassLoader.getSystemClassLoader());
-    } catch (Exception ex) {
-        println("DriverManager.Initialize: load failed: " + ex);
-    }
-}
-
-```
+```  
+for (String aDriver : driversList) {  
+    try {        // 直接使用AppClassLoader  
+        Class.forName(aDriver, true, ClassLoader.getSystemClassLoader());    } catch (Exception ex) {        println("DriverManager.Initialize: load failed: " + ex);    }}  
+  
+```  
 
 其实讲解线程上下文类加载器，最主要是让大家在看到`Thread.currentThread().getClassLoader()`和`Thread.currentThread().getContextClassLoader()`时不会一脸懵逼，这两者除了在许多底层框架中取得的ClassLoader可能会有所不同外，其他大多数业务场景下都是一样的，大家只要知道它是为了解决什么问题而存在的即可。
 
 类加载器除了加载class外，还有一个非常重要功能，就是加载资源，它可以从jar包中读取任何资源文件，比如，`ClassLoader.getResources(String name)`方法就是用于读取jar包中的资源文件，其代码如下：
 
-```
-public Enumeration<URL> getResources(String name) throws IOException {
-    Enumeration<URL>[] tmp = (Enumeration<URL>[]) new Enumeration<?>[2];
-    if (parent != null) {
-        tmp[0] = parent.getResources(name);
-    } else {
-        tmp[0] = getBootstrapResources(name);
-    }
-    tmp[1] = findResources(name);
-    return new CompoundEnumeration<>(tmp);
-}
-
-```
+```  
+public Enumeration<URL> getResources(String name) throws IOException {  
+    Enumeration<URL>[] tmp = (Enumeration<URL>[]) new Enumeration<?>[2];    if (parent != null) {        tmp[0] = parent.getResources(name);    } else {        tmp[0] = getBootstrapResources(name);    }    tmp[1] = findResources(name);    return new CompoundEnumeration<>(tmp);}  
+  
+```  
 
 是不是觉得有点眼熟，不错，它的逻辑其实跟类加载的逻辑是一样的，首先判断父类加载器是否为空，不为空则委托父类加载器执行资源查找任务，直到BootstrapClassLoader，最后才轮到自己查找。而不同的类加载器负责扫描不同路径下的jar包，就如同加载class一样，最后会扫描所有的jar包，找到符合条件的资源文件。
 
 类加载器的`findResources(name)`方法会遍历其负责加载的所有jar包，找到jar包中名称为name的资源文件，这里的资源可以是任何文件，甚至是.class文件，比如下面的示例，用于查找Array.class文件：
 
-```
-// 寻找Array.class文件
-public static void main(String[] args) throws Exception{
-    // Array.class的完整路径
-    String name = "java/sql/Array.class";
-    Enumeration<URL> urls = Thread.currentThread().getContextClassLoader().getResources(name);
-    while (urls.hasMoreElements()) {
-        URL url = urls.nextElement();
-        System.out.println(url.toString());
-    }
-}
-
-```
+```  
+// 寻找Array.class文件  
+public static void main(String[] args) throws Exception{  
+    // Array.class的完整路径  
+    String name = "java/sql/Array.class";    Enumeration<URL> urls = Thread.currentThread().getContextClassLoader().getResources(name);    while (urls.hasMoreElements()) {        URL url = urls.nextElement();        System.out.println(url.toString());    }}  
+  
+```  
 
 运行后可以得到如下结果：
 
-```
-$JAVA_HOME/jre/lib/rt.jar!/java/sql/Array.class
-
-```
+```  
+$JAVA_HOME/jre/lib/rt.jar!/java/sql/Array.class  
+  
+```  
 
 根据资源文件的URL，可以构造相应的文件来读取资源内容。
 
 看到这里，你可能会感到挺奇怪的，你不是要详解`SpringFactoriesLoader`吗？上来讲了一堆ClassLoader是几个意思？看下它的源码你就知道了：
 
-```
-public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
-// spring.factories文件的格式为：key=value1,value2,value3
-// 从所有的jar包中找到META-INF/spring.factories文件
-// 然后从文件中解析出key=factoryClass类名称的所有value值
-public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
-    String factoryClassName = factoryClass.getName();
-    // 取得资源文件的URL
-    Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
-    List<String> result = new ArrayList<String>();
-    // 遍历所有的URL
-    while (urls.hasMoreElements()) {
-        URL url = urls.nextElement();
-        // 根据资源文件URL解析properties文件
-        Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
-        String factoryClassNames = properties.getProperty(factoryClassName);
-        // 组装数据，并返回
-        result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
-    }
-    return result;
-}
-
-```
+```  
+public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";  
+// spring.factories文件的格式为：key=value1,value2,value3  
+// 从所有的jar包中找到META-INF/spring.factories文件  
+// 然后从文件中解析出key=factoryClass类名称的所有value值  
+public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {  
+    String factoryClassName = factoryClass.getName();    // 取得资源文件的URL  
+    Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));    List<String> result = new ArrayList<String>();    // 遍历所有的URL  
+    while (urls.hasMoreElements()) {        URL url = urls.nextElement();        // 根据资源文件URL解析properties文件  
+        Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));        String factoryClassNames = properties.getProperty(factoryClassName);        // 组装数据，并返回  
+        result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));    }    return result;}  
+  
+```  
 
 有了前面关于ClassLoader的知识，再来理解这段代码，是不是感觉豁然开朗：从`CLASSPATH`下的每个Jar包中搜寻所有`META-INF/spring.factories`配置文件，然后将解析properties文件，找到指定名称的配置后返回。需要注意的是，其实这里不仅仅是会去ClassPath路径下查找，会扫描所有路径下的Jar包，只不过这个文件只会在Classpath下的jar包中。来简单看下`spring.factories`文件的内容吧：
 
-```
-// 来自 org.springframework.boot.autoconfigure下的META-INF/spring.factories
-// EnableAutoConfiguration后文会讲到，它用于开启Spring Boot自动配置功能
-org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
-org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
-org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
-org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration\
-
-```
-
-执行`loadFactoryNames(EnableAutoConfiguration.class, classLoader)`后，得到对应的一组`@Configuration`类，
+```  
+// 来自 org.springframework.boot.autoconfigure下的META-INF/spring.factories  
+// EnableAutoConfiguration后文会讲到，它用于开启Spring Boot自动配置功能  
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\  
+org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\  
+org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\  
+org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration\  
+  
+```  
+
+执行`loadFactoryNames(EnableAutoConfiguration.class, classLoader)`后，得到对应的一组`@Configuration`类，  
 我们就可以通过反射实例化这些类然后注入到IOC容器中，最后容器里就有了一系列标注了`@Configuration`的JavaConfig形式的配置类。
 
 这就是`SpringFactoriesLoader`，它本质上属于Spring框架私有的一种扩展方案，类似于SPI，Spring Boot在Spring基础上的很多核心功能都是基于此，希望大家可以理解。
@@ -607,86 +468,47 @@ org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration\
 
 首先定义事件类型，通常的做法是扩展EventObject，随着事件的发生，相应的状态通常都封装在此类中：
 
-```
-public class MethodMonitorEvent extends EventObject {
-    // 时间戳，用于记录方法开始执行的时间
-    public long timestamp;
-
-    public MethodMonitorEvent(Object source) {
-        super(source);
-    }
-}
-
-```
+```  
+public class MethodMonitorEvent extends EventObject {  
+    // 时间戳，用于记录方法开始执行的时间  
+    public long timestamp;  
+    public MethodMonitorEvent(Object source) {        super(source);    }}  
+  
+```  
 
 事件发布之后，相应的监听器即可对该类型的事件进行处理，我们可以在方法开始执行之前发布一个begin事件，在方法执行结束之后发布一个end事件，相应地，事件监听器需要提供方法对这两种情况下接收到的事件进行处理：
 
-```
-// 1、定义事件监听接口
-public interface MethodMonitorEventListener extends EventListener {
-    // 处理方法执行之前发布的事件
-    public void onMethodBegin(MethodMonitorEvent event);
-    // 处理方法结束时发布的事件
-    public void onMethodEnd(MethodMonitorEvent event);
-}
-// 2、事件监听接口的实现：如何处理
-public class AbstractMethodMonitorEventListener implements MethodMonitorEventListener {
-
-    @Override
-    public void onMethodBegin(MethodMonitorEvent event) {
-        // 记录方法开始执行时的时间
-        event.timestamp = System.currentTimeMillis();
-    }
-
-    @Override
-    public void onMethodEnd(MethodMonitorEvent event) {
-        // 计算方法耗时
-        long duration = System.currentTimeMillis() - event.timestamp;
-        System.out.println("耗时：" + duration);
-    }
-}
-
-```
+```  
+// 1、定义事件监听接口  
+public interface MethodMonitorEventListener extends EventListener {  
+    // 处理方法执行之前发布的事件  
+    public void onMethodBegin(MethodMonitorEvent event);    // 处理方法结束时发布的事件  
+    public void onMethodEnd(MethodMonitorEvent event);}  
+// 2、事件监听接口的实现：如何处理  
+public class AbstractMethodMonitorEventListener implements MethodMonitorEventListener {  
+  
+    @Override    public void onMethodBegin(MethodMonitorEvent event) {        // 记录方法开始执行时的时间  
+        event.timestamp = System.currentTimeMillis();    }  
+    @Override    public void onMethodEnd(MethodMonitorEvent event) {        // 计算方法耗时  
+        long duration = System.currentTimeMillis() - event.timestamp;        System.out.println("耗时：" + duration);  
+    }}  
+  
+```  
 
 事件监听器接口针对不同的事件发布实际提供相应的处理方法定义，最重要的是，其方法只接收MethodMonitorEvent参数，说明这个监听器类只负责监听器对应的事件并进行处理。有了事件和监听器，剩下的就是发布事件，然后让相应的监听器监听并处理。通常情况，我们会有一个事件发布者，它本身作为事件源，在合适的时机，将相应的事件发布给对应的事件监听器：
 
-```
-public class MethodMonitorEventPublisher {
-
-    private List<MethodMonitorEventListener> listeners = new ArrayList<MethodMonitorEventListener>();
-
-    public void methodMonitor() {
-        MethodMonitorEvent eventObject = new MethodMonitorEvent(this);
-        publishEvent("begin",eventObject);
-        // 模拟方法执行：休眠5秒钟
-        TimeUnit.SECONDS.sleep(5);
-        publishEvent("end",eventObject);
-
-    }
-
-    private void publishEvent(String status,MethodMonitorEvent event) {
-        // 避免在事件处理期间，监听器被移除，这里为了安全做一个复制操作
-        List<MethodMonitorEventListener> copyListeners = ➥ new ArrayList<MethodMonitorEventListener>(listeners);
-        for (MethodMonitorEventListener listener : copyListeners) {
-            if ("begin".equals(status)) {
-                listener.onMethodBegin(event);
-            } else {
-                listener.onMethodEnd(event);
-            }
-        }
-    }
-
-    public static void main(String[] args) {
-        MethodMonitorEventPublisher publisher = new MethodMonitorEventPublisher();
-        publisher.addEventListener(new AbstractMethodMonitorEventListener());
-        publisher.methodMonitor();
-    }
-    // 省略实现
-    public void addEventListener(MethodMonitorEventListener listener) {}
-    public void removeEventListener(MethodMonitorEventListener listener) {}
-    public void removeAllListeners() {}
-
-```
+```  
+public class MethodMonitorEventPublisher {  
+  
+    private List<MethodMonitorEventListener> listeners = new ArrayList<MethodMonitorEventListener>();  
+    public void methodMonitor() {        MethodMonitorEvent eventObject = new MethodMonitorEvent(this);        publishEvent("begin",eventObject);        // 模拟方法执行：休眠5秒钟  
+        TimeUnit.SECONDS.sleep(5);        publishEvent("end",eventObject);  
+    }  
+    private void publishEvent(String status,MethodMonitorEvent event) {        // 避免在事件处理期间，监听器被移除，这里为了安全做一个复制操作  
+        List<MethodMonitorEventListener> copyListeners = ➥ new ArrayList<MethodMonitorEventListener>(listeners);        for (MethodMonitorEventListener listener : copyListeners) {            if ("begin".equals(status)) {                listener.onMethodBegin(event);            } else {                listener.onMethodEnd(event);            }        }    }  
+    public static void main(String[] args) {        MethodMonitorEventPublisher publisher = new MethodMonitorEventPublisher();        publisher.addEventListener(new AbstractMethodMonitorEventListener());        publisher.methodMonitor();    }    // 省略实现  
+    public void addEventListener(MethodMonitorEventListener listener) {}    public void removeEventListener(MethodMonitorEventListener listener) {}    public void removeAllListeners() {}  
+```  
 
 对于事件发布者（事件源）通常需要关注两点：
 
@@ -711,125 +533,104 @@ ApplicationContext接口继承了ApplicationEventPublisher接口，该接口提
 
 典型的Spring Boot应用的启动类一般均位于`src/main/java`根路径下，比如`MoonApplication`类：
 
-```
-@SpringBootApplication
-public class MoonApplication {
-
-    public static void main(String[] args) {
-        SpringApplication.run(MoonApplication.class, args);
-    }
-}
-
-```
+```  
+@SpringBootApplication  
+public class MoonApplication {  
+  
+    public static void main(String[] args) {        SpringApplication.run(MoonApplication.class, args);    }}  
+  
+```  
 
 其中`@SpringBootApplication`开启组件扫描和自动配置，而`SpringApplication.run`则负责启动引导应用程序。`@SpringBootApplication`是一个复合`Annotation`，它将三个有用的注解组合在一起：
 
-```
-@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 {
-    // ......
-}
-
-```
+```  
+@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`就是`@Configuration`，它是Spring框架的注解，标明该类是一个`JavaConfig`配置类。而`@ComponentScan`启用组件扫描，前文已经详细讲解过，这里着重关注`@EnableAutoConfiguration`。
 
 `@EnableAutoConfiguration`注解表示开启Spring Boot自动配置功能，Spring Boot会根据应用的依赖、自定义的bean、classpath下有没有某个类 等等因素来猜测你需要的bean，然后注册到IOC容器中。那`@EnableAutoConfiguration`是如何推算出你的需求？首先看下它的定义：
 
-```
-@Target(ElementType.TYPE)
-@Retention(RetentionPolicy.RUNTIME)
-@Documented
-@Inherited
-@AutoConfigurationPackage
-@Import(EnableAutoConfigurationImportSelector.class)
-public @interface EnableAutoConfiguration {
-    // ......
-}
-
-```
+```  
+@Target(ElementType.TYPE)  
+@Retention(RetentionPolicy.RUNTIME)  
+@Documented  
+@Inherited  
+@AutoConfigurationPackage  
+@Import(EnableAutoConfigurationImportSelector.class)  
+public @interface EnableAutoConfiguration {  
+    // ......}  
+  
+```  
 
 你的关注点应该在`@Import(EnableAutoConfigurationImportSelector.class)`上了，前文说过，`@Import`注解用于导入类，并将这个类作为一个bean的定义注册到容器中，这里它将把`EnableAutoConfigurationImportSelector`作为bean注入到容器中，而这个类会将所有符合条件的@Configuration配置都加载到容器中，看看它的代码：
 
-```
-public String[] selectImports(AnnotationMetadata annotationMetadata) {
-    // 省略了大部分代码，保留一句核心代码
-    // 注意：SpringBoot最近版本中，这句代码被封装在一个单独的方法中
-    // SpringFactoriesLoader相关知识请参考前文
-    List<String> factories = new ArrayList<String>(new LinkedHashSet<String>(  
-        SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, this.beanClassLoader)));
-}
-
-```
+```  
+public String[] selectImports(AnnotationMetadata annotationMetadata) {  
+    // 省略了大部分代码，保留一句核心代码  
+    // 注意：SpringBoot最近版本中，这句代码被封装在一个单独的方法中  
+    // SpringFactoriesLoader相关知识请参考前文  
+    List<String> factories = new ArrayList<String>(new LinkedHashSet<String>(        SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, this.beanClassLoader)));  
+}  
+  
+```  
 
 这个类会扫描所有的jar包，将所有符合条件的@Configuration配置类注入的容器中，何为符合条件，看看`META-INF/spring.factories`的文件内容：
 
-```
-// 来自 org.springframework.boot.autoconfigure下的META-INF/spring.factories
-// 配置的key = EnableAutoConfiguration，与代码中一致
-org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
-org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
-org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
-org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration\
-.....
-
-```
+```  
+// 来自 org.springframework.boot.autoconfigure下的META-INF/spring.factories  
+// 配置的key = EnableAutoConfiguration，与代码中一致  
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\  
+org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\  
+org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\  
+org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration\  
+.....  
+  
+```  
 
 以`DataSourceAutoConfiguration`为例，看看Spring Boot是如何自动配置的：
 
-```
-@Configuration
-@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
-@EnableConfigurationProperties(DataSourceProperties.class)
-@Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class })
-public class DataSourceAutoConfiguration {
-}
-
-```
+```  
+@Configuration  
+@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })  
+@EnableConfigurationProperties(DataSourceProperties.class)  
+@Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class })  
+public class DataSourceAutoConfiguration {  
+}  
+  
+```  
 
 分别说一说：
 
 *   `@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })`：当Classpath中存在DataSource或者EmbeddedDatabaseType类时才启用这个配置，否则这个配置将被忽略。
 *   `@EnableConfigurationProperties(DataSourceProperties.class)`：将DataSource的默认配置类注入到IOC容器中，DataSourceproperties定义为：
 
-```
-// 提供对datasource配置信息的支持，所有的配置前缀为：spring.datasource
-@ConfigurationProperties(prefix = "spring.datasource")
-public class DataSourceProperties  {
-    private ClassLoader classLoader;
-    private Environment environment;
-    private String name = "testdb";
-    ......
-}
-
-```
+```  
+// 提供对datasource配置信息的支持，所有的配置前缀为：spring.datasource  
+@ConfigurationProperties(prefix = "spring.datasource")  
+public class DataSourceProperties  {  
+    private ClassLoader classLoader;    private Environment environment;    private String name = "testdb";    ......}  
+  
+```  
 
 *   `@Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class })`：导入其他额外的配置，就以`DataSourcePoolMetadataProvidersConfiguration`为例吧。
 
-```
-@Configuration
-public class DataSourcePoolMetadataProvidersConfiguration {
-
-    @Configuration
-    @ConditionalOnClass(org.apache.tomcat.jdbc.pool.DataSource.class)
-    static class TomcatDataSourcePoolMetadataProviderConfiguration {
-        @Bean
-        public DataSourcePoolMetadataProvider tomcatPoolDataSourceMetadataProvider() {
-            .....
-        }
-    }
-  ......
-}
-
-```
+```  
+@Configuration  
+public class DataSourcePoolMetadataProvidersConfiguration {  
+  
+    @Configuration    @ConditionalOnClass(org.apache.tomcat.jdbc.pool.DataSource.class)    static class TomcatDataSourcePoolMetadataProviderConfiguration {        @Bean        public DataSourcePoolMetadataProvider tomcatPoolDataSourceMetadataProvider() {            .....        }    }  ......}  
+  
+```  
 
 DataSourcePoolMetadataProvidersConfiguration是数据库连接池提供者的一个配置类，即Classpath中存在`org.apache.tomcat.jdbc.pool.DataSource.class`，则使用tomcat-jdbc连接池，如果Classpath中存在`HikariDataSource.class`则使用Hikari连接池。
 
@@ -843,20 +644,13 @@ DataSourcePoolMetadataProvidersConfiguration是数据库连接池提供者的一
 
 SpringBoot整个启动流程分为两个步骤：初始化一个SpringApplication对象、执行该对象的run方法。看下SpringApplication的初始化流程，SpringApplication的构造方法中调用initialize(Object[] sources)方法，其代码如下：
 
-```
-private void initialize(Object[] sources) {
-     if (sources != null && sources.length > 0) {
-         this.sources.addAll(Arrays.asList(sources));
-     }
-     // 判断是否是Web项目
-     this.webEnvironment = deduceWebEnvironment();
-     setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
-     setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
-     // 找到入口类
-     this.mainApplicationClass = deduceMainApplicationClass();
-}
-
-```
+```  
+private void initialize(Object[] sources) {  
+     if (sources != null && sources.length > 0) {         this.sources.addAll(Arrays.asList(sources));     }     // 判断是否是Web项目  
+     this.webEnvironment = deduceWebEnvironment();     setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));     setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));     // 找到入口类  
+     this.mainApplicationClass = deduceMainApplicationClass();}  
+  
+```  
 
 初始化流程中最重要的就是通过SpringFactoriesLoader找到`spring.factories`文件中配置的`ApplicationContextInitializer`和`ApplicationListener`两个接口的实现类名称，以便后期构造相应的实例。`ApplicationContextInitializer`的主要目的是在`ConfigurableApplicationContext`做refresh之前，对ConfigurableApplicationContext实例做进一步的设置或处理。ConfigurableApplicationContext继承自ApplicationContext，其主要提供了对ApplicationContext进行设置的能力。
 
@@ -869,11 +663,11 @@ Spring Boot提供两种方式来添加自定义监听器：
 *   通过`SpringApplication.addListeners(ApplicationListener<?>... listeners)`或者`SpringApplication.setListeners(Collection<? extends ApplicationListener<?>> listeners)`两个方法来添加一个或者多个自定义监听器
 *   既然SpringApplication的初始化流程中已经从`spring.factories`中获取到`ApplicationListener`的实现类，那么我们直接在自己的jar包的`META-INF/spring.factories`文件中新增配置即可：
 
-```
-org.springframework.context.ApplicationListener=\
-cn.moondev.listeners.xxxxListener\
-
-```
+```  
+org.springframework.context.ApplicationListener=\  
+cn.moondev.listeners.xxxxListener\  
+  
+```  
 
 关于SpringApplication的初始化，我们就说这么多。
 
@@ -881,80 +675,50 @@ cn.moondev.listeners.xxxxListener\
 
 Spring Boot应用的整个启动流程都封装在SpringApplication.run方法中，其整个流程真的是太长太长了，但本质上就是在Spring容器启动的基础上做了大量的扩展，按照这个思路来看看源码：
 
-```
-public ConfigurableApplicationContext run(String... args) {
-        StopWatch stopWatch = new StopWatch();
-        stopWatch.start();
-        ConfigurableApplicationContext context = null;
-        FailureAnalyzers analyzers = null;
-        configureHeadlessProperty();
-        // ①
-        SpringApplicationRunListeners listeners = getRunListeners(args);
-        listeners.starting();
-        try {
-            // ②
-            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
-            ConfigurableEnvironment environment = prepareEnvironment(listeners,applicationArguments);
-            // ③
-            Banner printedBanner = printBanner(environment);
-            // ④
-            context = createApplicationContext();
-            // ⑤
-            analyzers = new FailureAnalyzers(context);
-            // ⑥
-            prepareContext(context, environment, listeners, applicationArguments,printedBanner);
-            // ⑦ 
-            refreshContext(context);
-            // ⑧
-            afterRefresh(context, applicationArguments);
-            // ⑨
-            listeners.finished(context, null);
-            stopWatch.stop();
-            return context;
-        }
-        catch (Throwable ex) {
-            handleRunFailure(context, listeners, analyzers, ex);
-            throw new IllegalStateException(ex);
-        }
-    }
-
-```
+```  
+public ConfigurableApplicationContext run(String... args) {  
+        StopWatch stopWatch = new StopWatch();        stopWatch.start();        ConfigurableApplicationContext context = null;        FailureAnalyzers analyzers = null;        configureHeadlessProperty();        // ①  
+        SpringApplicationRunListeners listeners = getRunListeners(args);        listeners.starting();        try {            // ②  
+            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);            ConfigurableEnvironment environment = prepareEnvironment(listeners,applicationArguments);            // ③  
+            Banner printedBanner = printBanner(environment);            // ④  
+            context = createApplicationContext();            // ⑤  
+            analyzers = new FailureAnalyzers(context);            // ⑥  
+            prepareContext(context, environment, listeners, applicationArguments,printedBanner);            // ⑦   
+            refreshContext(context);  
+            // ⑧  
+            afterRefresh(context, applicationArguments);            // ⑨  
+            listeners.finished(context, null);            stopWatch.stop();            return context;        }        catch (Throwable ex) {            handleRunFailure(context, listeners, analyzers, ex);            throw new IllegalStateException(ex);        }    }  
+```  
 
 ① 通过SpringFactoriesLoader查找并加载所有的`SpringApplicationRunListeners`，通过调用starting()方法通知所有的SpringApplicationRunListeners：应用开始启动了。SpringApplicationRunListeners其本质上就是一个事件发布者，它在SpringBoot应用启动的不同时间点发布不同应用事件类型(ApplicationEvent)，如果有哪些事件监听者(ApplicationListener)对这些事件感兴趣，则可以接收并且处理。还记得初始化流程中，SpringApplication加载了一系列ApplicationListener吗？这个启动流程中没有发现有发布事件的代码，其实都已经在SpringApplicationRunListeners这儿实现了。
 
 简单的分析一下其实现流程，首先看下SpringApplicationRunListener的源码：
 
-```
-public interface SpringApplicationRunListener {
-
-    // 运行run方法时立即调用此方法，可以用户非常早期的初始化工作
-    void starting();
-
-    // Environment准备好后，并且ApplicationContext创建之前调用
-    void environmentPrepared(ConfigurableEnvironment environment);
-
-    // ApplicationContext创建好后立即调用
-    void contextPrepared(ConfigurableApplicationContext context);
-
-    // ApplicationContext加载完成，在refresh之前调用
-    void contextLoaded(ConfigurableApplicationContext context);
-
-    // 当run方法结束之前调用
-    void finished(ConfigurableApplicationContext context, Throwable exception);
-
-}
-
-```
+```  
+public interface SpringApplicationRunListener {  
+  
+    // 运行run方法时立即调用此方法，可以用户非常早期的初始化工作  
+    void starting();  
+    // Environment准备好后，并且ApplicationContext创建之前调用  
+    void environmentPrepared(ConfigurableEnvironment environment);  
+    // ApplicationContext创建好后立即调用  
+    void contextPrepared(ConfigurableApplicationContext context);  
+    // ApplicationContext加载完成，在refresh之前调用  
+    void contextLoaded(ConfigurableApplicationContext context);  
+    // 当run方法结束之前调用  
+    void finished(ConfigurableApplicationContext context, Throwable exception);  
+}  
+  
+```  
 
 SpringApplicationRunListener只有一个实现类：`EventPublishingRunListener`。①处的代码只会获取到一个EventPublishingRunListener的实例，我们来看看starting()方法的内容：
 
-```
-public void starting() {
-    // 发布一个ApplicationStartedEvent
-    this.initialMulticaster.multicastEvent(new ApplicationStartedEvent(this.application, this.args));
-}
-
-```
+```  
+public void starting() {  
+    // 发布一个ApplicationStartedEvent  
+    this.initialMulticaster.multicastEvent(new ApplicationStartedEvent(this.application, this.args));}  
+  
+```  
 
 顺着这个逻辑，你可以在②处的`prepareEnvironment()`方法的源码中找到`listeners.environmentPrepared(environment);`即SpringApplicationRunListener接口的第二个方法，那不出你所料，`environmentPrepared()`又发布了另外一个事件`ApplicationEnvironmentPreparedEvent`。接下来会发生什么，就不用我多说了吧。
 
@@ -968,16 +732,10 @@ public void starting() {
 
 ③、SpringBoot应用在启动时会输出这样的东西：
 
-```
-  .   ____          _            __ _ _
- /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
-( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
- \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
-  '  |____| .__|_| |_|_| |_\__, | / / / /
- =========|_|==============|___/=/_/_/_/
- :: Spring Boot ::        (v1.5.6.RELEASE)
-
-```
+```  
+  .   ____          _            __ _ _ /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \  
+ \\/  ___)| |_)| | | | | || (_| |  ) ) ) )  '  |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot ::        (v1.5.6.RELEASE)  
+```  
 
 如果想把这个东西改成自己的涂鸦，你可以研究以下Banner的实现，这个任务就留给你们吧。
 
@@ -995,39 +753,36 @@ public void starting() {
 
 ⑦、调用ApplicationContext的`refresh()`方法，完成IoC容器可用的最后一道工序。从名字上理解为刷新容器，那何为刷新？就是插手容器的启动，联系一下第一小节的内容。那如何刷新呢？且看下面代码：
 
-```
-// 摘自refresh()方法中一句代码
-invokeBeanFactoryPostProcessors(beanFactory);
-
-```
+```  
+// 摘自refresh()方法中一句代码  
+invokeBeanFactoryPostProcessors(beanFactory);  
+  
+```  
 
 看看这个方法的实现：
 
-```
-protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
-    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
-    ......
-}
-
-```
+```  
+protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {  
+    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());    ......}  
+  
+```  
 
 获取到所有的`BeanFactoryPostProcessor`来对容器做一些额外的操作。BeanFactoryPostProcessor允许我们在容器实例化相应对象之前，对注册到容器的BeanDefinition所保存的信息做一些额外的操作。这里的getBeanFactoryPostProcessors()方法可以获取到3个Processor：
 
-```
-ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor
-SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor
-ConfigFileApplicationListener$PropertySourceOrderingPostProcessor
-
-```
+```  
+ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor  
+SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor  
+ConfigFileApplicationListener$PropertySourceOrderingPostProcessor  
+  
+```  
 
 不是有那么多BeanFactoryPostProcessor的实现类，为什么这儿只有这3个？因为在初始化流程获取到的各种ApplicationContextInitializer和ApplicationListener中，只有上文3个做了类似于如下操作：
 
-```
-public void initialize(ConfigurableApplicationContext context) {
-    context.addBeanFactoryPostProcessor(new ConfigurationWarningsPostProcessor(getChecks()));
-}
-
-```
+```  
+public void initialize(ConfigurableApplicationContext context) {  
+    context.addBeanFactoryPostProcessor(new ConfigurationWarningsPostProcessor(getChecks()));}  
+  
+```  
 
 然后你就可以进入到`PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()`方法了，这个方法除了会遍历上面的3个BeanFactoryPostProcessor处理外，还会获取类型为`BeanDefinitionRegistryPostProcessor`的bean：`org.springframework.context.annotation.internalConfigurationAnnotationProcessor`，对应的Class为`ConfigurationClassPostProcessor`。`ConfigurationClassPostProcessor`用于解析处理各种注解，包括：@Configuration、@ComponentScan、@Import、@PropertySource、@ImportResource、@Bean。当处理`@import`注解的时候，就会调用<自动配置>这一小节中的`EnableAutoConfigurationImportSelector.selectImports()`来完成自动配置功能。其他的这里不再多讲，如果你有兴趣，可以查阅参考资料6。
 
@@ -1040,43 +795,10 @@ public void initialize(ConfigurableApplicationContext context) {
 整个启动流程确实非常复杂，可以查询参考资料中的部分章节和内容，对照着源码，多看看，我想最终你都能弄清楚的。言而总之，Spring才是核心，理解清楚Spring容器的启动流程，那Spring Boot启动流程就不在话下了。
 
 ## 参考文章
-
-[1] [王福强 著；SpringBoot揭秘：快速构建微服务体系; 机械工业出版社, 2016](https://link.jianshu.com/?t=http%3A%2F%2Funion-click.jd.com%2Fjdc%3Fd%3D4jESQ9)
-[2] [王福强 著；Spring揭秘; 人民邮件出版社, 2009](https://link.jianshu.com/?t=http%3A%2F%2Funion-click.jd.com%2Fjdc%3Fd%3DyzfgeF)
-[3] [Craig Walls 著；丁雪丰 译；Spring Boot实战；中国工信出版集团 人民邮电出版社，2016](https://link.jianshu.com/?t=http%3A%2F%2Funion-click.jd.com%2Fjdc%3Fd%3DAQ6oHO)
-[4] [深入探讨 Java 类加载器](https://link.jianshu.com/?t=https%3A%2F%2Fwww.ibm.com%2Fdeveloperworks%2Fcn%2Fjava%2Fj-lo-classloader%2F) : [https://www.ibm.com/developerworks/cn/java/j-lo-classloader/](https://link.jianshu.com/?t=https%3A%2F%2Fwww.ibm.com%2Fdeveloperworks%2Fcn%2Fjava%2Fj-lo-classloader%2F)
-[5] [spring boot实战：自动配置原理分析](https://link.jianshu.com/?t=http%3A%2F%2Fblog.csdn.net%2Fliaokailin%2Farticle%2Fdetails%2F49559951) : [http://blog.csdn.net/liaokailin/article/details/49559951](https://link.jianshu.com/?t=http%3A%2F%2Fblog.csdn.net%2Fliaokailin%2Farticle%2Fdetails%2F49559951)
+[1][王福强 著；SpringBoot揭秘：快速构建微服务体系; 机械工业出版社, 2016](https://link.jianshu.com/?t=http%3A%2F%2Funion-click.jd.com%2Fjdc%3Fd%3D4jESQ9)  
+[2][王福强 著；Spring揭秘; 人民邮件出版社, 2009](https://link.jianshu.com/?t=http%3A%2F%2Funion-click.jd.com%2Fjdc%3Fd%3DyzfgeF)  
+[3][Craig Walls 著；丁雪丰 译；Spring Boot实战；中国工信出版集团 人民邮电出版社，2016](https://link.jianshu.com/?t=http%3A%2F%2Funion-click.jd.com%2Fjdc%3Fd%3DAQ6oHO)  
+[4][深入探讨 Java 类加载器](https://link.jianshu.com/?t=https%3A%2F%2Fwww.ibm.com%2Fdeveloperworks%2Fcn%2Fjava%2Fj-lo-classloader%2F):[https://www.ibm.com/developerworks/cn/java/j-lo-classloader/](https://link.jianshu.com/?t=https%3A%2F%2Fwww.ibm.com%2Fdeveloperworks%2Fcn%2Fjava%2Fj-lo-classloader%2F)  
+[5][spring boot实战：自动配置原理分析](https://link.jianshu.com/?t=http%3A%2F%2Fblog.csdn.net%2Fliaokailin%2Farticle%2Fdetails%2F49559951):[http://blog.csdn.net/liaokailin/article/details/49559951](https://link.jianshu.com/?t=http%3A%2F%2Fblog.csdn.net%2Fliaokailin%2Farticle%2Fdetails%2F49559951)  
 [6][spring boot实战：Spring boot Bean加载源码分析](https://link.jianshu.com/?t=http%3A%2F%2Fblog.csdn.net%2Fliaokailin%2Farticle%2Fdetails%2F49107209)：[http://blog.csdn.net/liaokailin/article/details/49107209](https://link.jianshu.com/?t=http%3A%2F%2Fblog.csdn.net%2Fliaokailin%2Farticle%2Fdetails%2F49107209)
 
-
-
-## 微信公众号
-
-### 个人公众号：黄小斜
-
-黄小斜是跨考软件工程的 985 硕士，自学 Java 两年，拿到了 BAT 等近十家大厂 offer，从技术小白成长为阿里工程师。
-
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得和程序人生，目前黄小斜的CSDN博客有百万+访问量，知乎粉丝2W+，全网已有10W+读者。
-
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注公众号【黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-**考研复习资料：** 
-计算机考研大礼包，都是我自己考研复习时用的一些复习资料,包括公共课和专业的复习视频，这里也推荐给大家，关注公众号后，后台回复关键字 **“考研”** 即可免费获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-​                     
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/@SpringBootApplication\346\263\250\350\247\243.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/@SpringBootApplication\346\263\250\350\247\243.md"
new file mode 100644
index 0000000..dd72d1f
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/@SpringBootApplication\346\263\250\350\247\243.md"
@@ -0,0 +1,382 @@
+springboot ���������ϻ��עһ��ע�⣺`@SpringBootApplication`�����˽���Դ����������� ��ע������á�
+
+`@SpringBootApplication` �������£�
+
+```
+@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 {
+
+    /**
+     * �Զ�װ��Ҫ�ų����࣬���������� @EnableAutoConfiguration
+     */
+    @AliasFor(annotation = EnableAutoConfiguration.class)
+    Class<?>[] exclude() default {};
+
+    /**
+     *  �Զ�װ��Ҫ�ų������������������� @EnableAutoConfiguration
+     */
+    @AliasFor(annotation = EnableAutoConfiguration.class)
+    String[] excludeName() default {};
+
+    /**
+     * ����ɨ��İ������������� @ComponentScan
+     */
+    @AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
+    String[] scanBasePackages() default {};
+
+    /**
+     * ����ɨ���class����class���ڵİ����ᱻɨ�裬���������� @ComponentScan
+     */
+    @AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
+    Class<?>[] scanBasePackageClasses() default {};
+
+    /**
+     * �Ƿ����� @Bean �������������������� @Configuration
+     */
+    @AliasFor(annotation = Configuration.class)
+    boolean proxyBeanMethods() default true;
+
+}
+
+```
+
+1.  `@SpringBootApplication` ��һ�����ע�⣬������ `@SpringBootConfiguration`��`@EnableAutoConfiguration`��`@ComponentScan` ����ע��Ĺ��ܣ�
+2.  `@SpringBootApplication` ��Ҳ�ṩ��һЩ�������ԣ�����Щ������������������ע�⡣
+
+����������������������ע������÷ֱ���ʲô��
+
+### 1. `@SpringBootConfiguration`
+
+���� `@SpringBootConfiguration`���������£�
+
+```
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Configuration
+public @interface SpringBootConfiguration {
+
+    @AliasFor(annotation = Configuration.class)
+    boolean proxyBeanMethods() default true;
+
+}
+
+```
+
+���ע��Ƚϼ򵥣��������� `@Configuration`��Ȼ����һ������ `proxyBeanMethods()`���������� `@Configuration`����ˣ�`@SpringBootConfiguration` ��û����ʲô������ֻ�ǽ� `@Configuration` ʹ���� `@Configuration` �Ĺ��ܡ�
+
+���� `@Configuration`���������� spring���ܱ� spring ʶ��Ϊ `Component`���� `proxyBeanMethods != false` ʱ���ᱻ spring ���Ϊ `Full` �����࣬�ں��������е� `@Bean` ��������ʱ������� cglib �����������ⷽ������ݣ��ɲο� [ConfigurationClassPostProcessor������������ @Bean ע��](https://my.oschina.net/funcy/blog/4492878).
+
+### 2. `@EnableAutoConfiguration`
+
+`@EnableAutoConfiguration` ��Ҫ ���������Զ�װ�书�ܣ��������£�
+
+```
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+// �Զ�װ��İ�
+@AutoConfigurationPackage
+// ������Զ�װ����
+@Import(AutoConfigurationImportSelector.class)
+public @interface EnableAutoConfiguration {
+
+    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
+
+    /**
+     * �����ж����ų��Զ�װ�����
+     */
+    Class<?>[] exclude() default {};
+
+    /**
+     * �����ж����ų��Զ�װ�������
+     */
+    String[] excludeName() default {};
+
+}
+
+```
+
+�Ӵ����п��Կ�����
+
+1.  ��ע������� `@AutoConfigurationPackage` ע��Ĺ��ܣ���ע������ָ���Զ�װ��İ���
+2.  ��ע��ͨ�� `@Import` ע��������һ���� `AutoConfigurationImportSelector`����������Զ�װ��Ĺؼ���
+3.  ��ע���ṩ���������ã������ų�ָ�����Զ�װ���࣬���Ը��������ų� (`Class` ����)��Ҳ���Ը������� (`����.����`) �ų���
+
+��������������ע `@AutoConfigurationPackage` ������� `AutoConfigurationImportSelector`��
+
+#### 2.1 `@AutoConfigurationPackage`
+
+`@AutoConfigurationPackage` ָ�����Զ�װ��İ����������£�
+
+```
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@Import(AutoConfigurationPackages.Registrar.class)
+public @interface AutoConfigurationPackage {
+
+}
+
+```
+
+���ע������ݷdz��򵥣���ʹ�� `@Import` ע�������� `AutoConfigurationPackages.Registrar`�������������������ݣ�
+
+```
+public abstract class AutoConfigurationPackages {
+
+    private static final String BEAN = AutoConfigurationPackages.class.getName();
+
+    static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
+
+        /**
+         * ���� ImportBeanDefinitionRegistrar �Ĵ�����spring������ registerBeanDefinitions() ע������
+         */
+        @Override
+        public void registerBeanDefinitions(AnnotationMetadata metadata, 
+                    BeanDefinitionRegistry registry) {
+            register(registry, new PackageImport(metadata).getPackageName());
+        }
+
+        @Override
+        public Set<Object> determineImports(AnnotationMetadata metadata) {
+            return Collections.singleton(new PackageImport(metadata));
+        }
+
+    }
+
+    /**
+     * ���������ע�����
+     * 1\. ��� beanFacotry �а��� BEAN���򽫴���İ������ӵ� BEAN ��Ӧ�� BeanDefinition �Ĺ��췽������ֵ�ϣ�
+     * 2\. ��� beanFacotry �в����� BEAN���򴴽� beanDefinition�����ò���ֵ��Ȼ����ע�ᵽ beanFacotry��
+     * ע�ᵽbeanFacotry�е�beanΪBasePackages
+     */
+    public static void register(BeanDefinitionRegistry registry, String... packageNames) {
+        if (registry.containsBeanDefinition(BEAN)) {
+            BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);
+            // bean �� BasePackages�����췽���� BasePackages(String... names)�������ȡԭ���Ĺ��������ֵ
+            ConstructorArgumentValues constructorArguments 
+                    = beanDefinition.getConstructorArgumentValues();
+            // ��ԭ���Ĺ������ֵ���Լ������ packageNames ͳһ���ӵ����췽���ĵ�0������ֵ��
+            constructorArguments.addIndexedArgumentValue(0, 
+                    addBasePackages(constructorArguments, packageNames));
+        }
+        else {
+            GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
+            // ����BeanClassΪBasePackages.class
+            beanDefinition.setBeanClass(BasePackages.class);
+            // ���ù��췽���IJ���ֵ
+            beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0, packageNames);
+            beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
+            registry.registerBeanDefinition(BEAN, beanDefinition);
+        }
+    }
+
+    /**
+     * packageName �İ�װ��
+     * packageName �Ǵ��������ڵİ�������PackageImport�Ĺ��췽���л�ȡ
+     */
+    private static final class PackageImport {
+
+        private final String packageName;
+
+        PackageImport(AnnotationMetadata metadata) {
+            // ��ȡ���������ڰ���
+            this.packageName = ClassUtils.getPackageName(metadata.getClassName());
+        }
+
+        String getPackageName() {
+            return this.packageName;
+        }
+
+        // ʡ�� equals/toString/hashCode ����
+        ...
+
+    }
+
+    /**
+     * ע�⵽ beanFactory �е���
+     * ��������һ��List�ṹ�����������ɨ��·��
+     */
+    static final class BasePackages {
+        // ��ɨ��·�������ﱣ��
+        private final List<String> packages;
+
+        private boolean loggedBasePackageInfo;
+
+        BasePackages(String... names) {
+            List<String> packages = new ArrayList<>();
+            for (String name : names) {
+                if (StringUtils.hasText(name)) {
+                    packages.add(name);
+                }
+            }
+            this.packages = packages;
+        }
+
+        // ʡ����һЩ����
+        ...
+    }
+
+}
+
+```
+
+�����е㳤�����߼��������ӣ��������£�
+
+1.  `AutoConfigurationPackages.Registrar` ʵ���� `ImportBeanDefinitionRegistrar`��`registerBeanDefinitions(...)` ������ spring ��ע���� `BasePackages`��ע���߼��� `AutoConfigurationPackages#register` �����У�
+2.  `AutoConfigurationPackages#register` ������ע���߼�Ϊ�����ж��Ƿ���ע���� `BasePackages`�����ע���ˣ��ͽ���ǰ�����ڵİ����ӵ� `BasePackages` �Ĺ��췽������ֵ�У�����ʹ��� `BeanDefinition`�����ù��췽���IJ���ֵ��Ȼ��ע�ᵽ spring �У�
+
+#### 2.2 `AutoConfigurationImportSelector`
+
+`AutoConfigurationImportSelector` �Ǵ����Զ����õĹؼ����������£�
+
+```
+public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
+
+    ...
+
+}
+
+```
+
+`AutoConfigurationImportSelector` ʵ���� `DeferredImportSelector`������һ�� `ImportSelector` �࣬�����������ȼ���� (�� `@ComponentScan`��`@Component`��`@Bean`��`@Configuration` ������ `@Import` ע�⴦����֮���ٴ���)���� `AutoConfigurationImportSelector` ���лᴦ���Զ�������ļ������̣�����ͨ�����ַ�ʽ�����Զ������������� spring �����С�
+
+���� spring �� `@Import` �Ĵ��������Բο� [ConfigurationClassPostProcessor ֮���� @Import ע��](https://my.oschina.net/funcy/blog/4678152).
+
+���� `AutoConfigurationImportSelector` ��ȡ�Զ�����������̣����ں���������о�����������ľͲ�չ���ˡ�
+
+### 3. `@ComponentScan`
+
+���ע����ش���Ѿ�����Ϥ�ˣ���ָ���˰�ɨ��·���������ָ������ɨ��������İ���������Щ���� [ConfigurationClassPostProcessor ֮���� @ComponentScan ע��](https://my.oschina.net/funcy/blog/4836178)һ�����Ѿ���ϸ�������ˣ��Ͳ��ٷ����ˡ�
+
+�����������������ע��������ʹ�õ� 2 ���ࣺ
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-19d14d3d8262eead434d5ca09369e1789d5.png)
+
+#### 3.1 `TypeExcludeFilter`
+
+������ʾ�ڽ��а�ɨ��ʱ�������ų�һЩ�࣬�������£�
+
+```
+public class TypeExcludeFilter implements TypeFilter, BeanFactoryAware {
+
+    private BeanFactory beanFactory;
+
+    private Collection<TypeExcludeFilter> delegates;
+
+    @Override
+    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+        this.beanFactory = beanFactory;
+    }
+
+    @Override
+    public boolean match(MetadataReader metadataReader, 
+            MetadataReaderFactory metadataReaderFactory) throws IOException {
+        if (this.beanFactory instanceof ListableBeanFactory 
+                && getClass() == TypeExcludeFilter.class) {
+            // getDelegates() ��ȡ��ǰ���������е� TypeExcludeFilter ʵ��
+            // ���������̳� TypeExcludeFilter���Զ���ƥ�����
+            for (TypeExcludeFilter delegate : getDelegates()) {
+                if (delegate.match(metadataReader, metadataReaderFactory)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private Collection<TypeExcludeFilter> getDelegates() {
+        Collection<TypeExcludeFilter> delegates = this.delegates;
+        if (delegates == null) {
+            delegates = ((ListableBeanFactory) this.beanFactory)
+                    .getBeansOfType(TypeExcludeFilter.class).values();
+            this.delegates = delegates;
+        }
+        return delegates;
+    }
+
+    ....
+
+```
+
+�Ӵ��������������Ҫ�ų�һЩ �࣬���ǿ��������̳� `TypeExcludeFilter` �࣬Ȼ����д `match(...)` �����������ж���ƥ���߼���
+
+#### 3.1 `AutoConfigurationExcludeFilter`
+
+`AutoConfigurationExcludeFilter` �����ų��Զ������࣬Ҳ����˵��spring �ڽ��а�ɨ��ʱ������ɨ���Զ������࣬�������£�
+
+```
+public class AutoConfigurationExcludeFilter implements TypeFilter, BeanClassLoaderAware {
+
+    private ClassLoader beanClassLoader;
+
+    private volatile List<String> autoConfigurations;
+
+    @Override
+    public void setBeanClassLoader(ClassLoader beanClassLoader) {
+        this.beanClassLoader = beanClassLoader;
+    }
+
+    @Override
+    public boolean match(MetadataReader metadataReader, 
+            MetadataReaderFactory metadataReaderFactory) throws IOException {
+        // isConfiguration(...)����ǰ���Ƿ� @Configuration ���
+        // isAutoConfiguration(...)����ǰ���Ƿ�Ϊ�Զ�������
+        return isConfiguration(metadataReader) && isAutoConfiguration(metadataReader);
+    }
+
+    private boolean isConfiguration(MetadataReader metadataReader) {
+        return metadataReader.getAnnotationMetadata().isAnnotated(Configuration.class.getName());
+    }
+
+    private boolean isAutoConfiguration(MetadataReader metadataReader) {
+        // ��ȡ���е��Զ������࣬Ȼ���жϵ�ǰ���Ƿ����������
+        return getAutoConfigurations().contains(metadataReader.getClassMetadata().getClassName());
+    }
+
+    protected List<String> getAutoConfigurations() {
+        if (this.autoConfigurations == null) {
+            this.autoConfigurations = SpringFactoriesLoader
+                    .loadFactoryNames(EnableAutoConfiguration.class, this.beanClassLoader);
+        }
+        return this.autoConfigurations;
+    }
+
+}
+
+```
+
+������Ҫ�� `match(...)` ����������ƥ�����Ϊ��
+
+1.  �� `@Configuration` ��ǣ�
+2.  ���Զ������ࡣ
+
+������������������spring �Ͳ���������ɨ�账����
+
+��ʲô���Զ��������أ��� `isAutoConfiguration(...)` ���Կ��������ж��Ƿ�Ϊ�Զ��������ϣ�springboot ��ʹ�� `SpringFactoriesLoader` �������������࣬Ȼ�����жϴ�������Ƿ�Ϊ����֮һ����������Կ������Զ������ಢ�����а�ɨ�������
+
+���� `SpringFactoriesLoader` ��μ��������࣬��������»���ϸ������
+
+### 4\. �ܽ�
+
+������Ҫ���� `@SpringBootApplication` �Ĺ��ܣ��ܽ����£�
+
+1.  `@SpringBootApplication` ��һ�����ע�⣬������ `@SpringBootConfiguration`��`@EnableAutoConfiguration`��`@ComponentScan` ����ע��Ĺ��ܣ�ͬʱ�ṩ��һЩ�������ã�Ҳ������������ 3 ��ע�⣻
+2.  `@SpringBootConfiguration` ������ `Configuration` ע��Ĺ��ܣ�
+3.  `@EnableAutoConfiguration` �ǿ����Զ�װ��Ĺؼ�ע�⣬���б���� `@AutoConfigurationPackage`���Ὣ�� `@SpringBootApplication` ��ǵ������ڵİ�����װ�� `BasePackages`��Ȼ��ע�ᵽ spring �����У�`@EnableAutoConfiguration` ��ͨ�� `@Import` ע���������������� `AutoConfigurationImportSelector`������Ὣ��ǰ��Ŀ֧�ֵ��Զ����������ӵ� spring �����У�
+4.  `@ComponentScan` �����˰�ɨ��·������ `excludeFilters` ֵ���������ų����ɨ�裬springboot ָ���� `TypeExcludeFilter`���������ǿ��Լ̳и��������������ų����� ��ͬʱҲָ���� `AutoConfigurationExcludeFilter` ���� `Filter` ���������ų��Զ������࣬Ҳ����˵���Զ������಻����а�����������
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4870882](https://my.oschina.net/funcy/blog/4870882) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBootWeb\345\272\224\347\224\250\357\274\210\344\270\200\357\274\211\357\274\232servlet\347\273\204\344\273\266\347\232\204\346\263\250\345\206\214\346\265\201\347\250\213.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBootWeb\345\272\224\347\224\250\357\274\210\344\270\200\357\274\211\357\274\232servlet\347\273\204\344\273\266\347\232\204\346\263\250\345\206\214\346\265\201\347\250\213.md"
new file mode 100644
index 0000000..052d637
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBootWeb\345\272\224\347\224\250\357\274\210\344\270\200\357\274\211\357\274\232servlet\347\273\204\344\273\266\347\232\204\346\263\250\345\206\214\346\265\201\347\250\213.md"
@@ -0,0 +1,655 @@
+�� springboot �У����������Ҫע�� servlet ���������`servlet`��`filter`��`listener`������ô���أ�springboot ���ĵ�Ϊ�����ṩ�� 3 �ַ��������ľ��������� 3 �ַ�����Դ��ʵ�֡�
+
+### 1\. ע�᷽ʽ
+
+#### 1.1 ʹ�� `XxxRegistrationBean` ע��
+
+springboot �ṩ���������͵� `RegistrationBean` ������ servlet ���������ע�ᣬ�ֱ��� `ServletRegistrationBean`��`FilterRegistrationBean`��`ServletListenerRegistrationBean`���������Ǽ�ʾ�������ǵ��÷���
+
+```
+/**
+ * ׼����һ��servlet
+ */
+public class MyServlet extends HttpServlet {
+
+    @Override
+    protected void service(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+        // ����һЩ����
+        ...
+    }
+}
+
+/**
+ * ����ע�����
+ */
+@Bean
+public ServletRegistrationBean registerServlet() {
+    ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(
+            new MyServlet(), "/myServlet");
+    // ����һЩ���ò���
+    servletRegistrationBean.setXxx();
+    ...
+    return servletRegistrationBean;
+}
+
+```
+
+�����ṩ�� `servlet` ��ע�᷽ʽ��Ҫע�� `filter`��`listener`��ֻ��ʹ�ö�Ӧ�� `RegistrationBean` ���ɣ�����Ͳ�չʾ�ˡ�
+
+#### 1.2 ʹ�� servlet ע��ע��
+
+�� `Servlet 3.0`��servlet �����ṩ�� 3 ��ע�������� `servlet` ���������ע�᣺
+
+*   `@WebServlet`: ���� `servlet` ע��
+*   `@WebFilter`: ���� `filter` ע��
+*   `@WebListener`: ���� `listener` ע��
+
+������ `servlet` ע��Ϊ������������ `@WebServlet`:
+
+```
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface WebServlet {
+    String name() default "";
+
+    String[] value() default {};
+
+    String[] urlPatterns() default {};
+
+    int loadOnStartup() default -1;
+
+    WebInitParam[] initParams() default {};
+
+    boolean asyncSupported() default false;
+
+    String smallIcon() default "";
+
+    String largeIcon() default "";
+
+    String description() default "";
+
+    String displayName() default "";
+}
+
+```
+
+���Կ�����`@WebServlet` ֧�ֶ���������ã���ָ�� servlet �����ơ�ӳ��� url ������������ָ��������Ҳ�ṩһ��ʾ����
+
+```
+@WebServlet(name = "myServlet", urlPatterns = "/myServlet")
+public class JavaServlet extends HttpServlet {
+
+    @Override
+    protected void service(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+        // ����һЩ����
+        ...
+    }
+
+}
+
+```
+
+���������󣬻�Ҫ��һ����Ҫ�IJ������Ǿ���ʹ�� `@ServletComponentScan` ������ɨ�蹦�ܣ�
+
+```
+// ʹ�� @ServletComponentScan ������ servlet �����ɨ�蹦��
+@ServletComponentScan
+@SpringBootApplication
+public class MyApplication {
+    public static void main(String[] args) {
+        ...
+    }
+}
+
+```
+
+#### 1.3 `ServletContextInitializer` ע��
+
+ʹ�����ַ�ʽע�ᣬ��Ҫʵ�� `ServletContextInitializer` �ӿڣ�
+
+```
+/**
+ * ׼��һ��servlet
+ */
+public class MyServlet extends HttpServlet {
+
+    @Override
+    protected void service(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+        // ����һЩ����
+        ...
+    }
+}
+
+/**
+ * ʵ�� ServletContextInitializer 
+ */
+@Component
+public class ServletConfig implements ServletContextInitializer {
+
+    @Override
+    public void onStartup(ServletContext servletContext) {
+        // ʹ�� servletContext ����ע��
+        ServletRegistration initServlet = servletContext.addServlet("myServlet", MyServlet.class);
+        // ���Խ���һЩ����
+        initServlet.addMapping("/myServlet");
+    }
+
+}
+
+```
+
+ʹ�����ַ�ʽע�ᣬ��Ҫʵ�� `ServletContextInitializer`��Ȼ����д `ServletContextInitializer#onStartup` �������� `ServletContextInitializer#onStartup` ʹ�� `ServletContext` �������ע�ᡣ`ServletContext` ������ servlet �����ṩ������������ע����ռ��࣬������ʹ�� `RegistrationBean` ע�ᣬ����ʹ�� `@ServletComponentScan` ɨ��ע�ᣬ���ն���ͨ�� `ServletContext` ע�ᵽ servlet �����С�
+
+### 2\. Դ��ʵ��
+
+�˽������ʹ�ú󣬽��������Ǿ� ����Դ�뿴����Щ���������ʵ�֡�
+
+#### 2.1 `@ServletComponentScan` ɨ��
+
+����ֱ�ӽ��� `@ServletComponentScan`��
+
+```
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Import(ServletComponentScanRegistrar.class)
+public @interface ServletComponentScan {
+    ...
+}
+
+```
+
+���ע���������� `@Import` ע�⣬������һ���ࣺ`ServletComponentScanRegistrar`�����ǿ�������྿������ɶ��
+
+```
+/**
+ * ʵ����ImportBeanDefinitionRegistrar
+ * ��������ע���� ServletComponentRegisteringPostProcessor
+ */
+class ServletComponentScanRegistrar implements ImportBeanDefinitionRegistrar {
+
+    private static final String BEAN_NAME = "servletComponentRegisteringPostProcessor";
+
+    @Override
+    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, 
+            BeanDefinitionRegistry registry) {
+        Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);
+        if (registry.containsBeanDefinition(BEAN_NAME)) {
+            updatePostProcessor(registry, packagesToScan);
+        }
+        else {
+            // ע�� BeanFactoryPostProcessor
+            addPostProcessor(registry, packagesToScan);
+        }
+    }
+
+    /**
+     * ע�� BeanFactoryPostProcessor
+     * ע���� ServletComponentRegisteringPostProcessor
+     */
+    private void addPostProcessor(BeanDefinitionRegistry registry, Set<String> packagesToScan) {
+        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
+        // ServletComponentRegisteringPostProcessor: ����ɨ��� BeanFactoryPostProcessor
+        beanDefinition.setBeanClass(ServletComponentRegisteringPostProcessor.class);
+        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(packagesToScan);
+        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
+        // ServletComponentScanRegistrar ����Ϊ��ע�� ServletComponentRegisteringPostProcessor
+        registry.registerBeanDefinition(BEAN_NAME, beanDefinition);
+    }
+
+    ...
+
+}
+
+```
+
+���Կ����������ʵ���� `ImportBeanDefinitionRegistrar`����Ҫ���� spring ������ע���� `ServletComponentRegisteringPostProcessor`�����Ǽ�������ȥ������ `ServletComponentRegisteringPostProcessor`��
+
+```
+class ServletComponentRegisteringPostProcessor implements BeanFactoryPostProcessor, 
+        ApplicationContextAware {
+
+    /**
+     * ��Ҫɨ��İ�.
+     */
+    private final Set<String> packagesToScan;
+
+    /**
+     * Ҫɨ��İ��ɹ��췽������
+     */
+    ServletComponentRegisteringPostProcessor(Set<String> packagesToScan) {
+        this.packagesToScan = packagesToScan;
+    }
+
+    /**
+     * ��д��BeanFactoryPostProcessor�ķ���
+     */
+    @Override
+    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 
+            throws BeansException {
+        // �ж��Ƿ���������Ƕ�� web ������
+        if (isRunningInEmbeddedWebServer()) {
+            // ɨ������������ɨ�����
+            ClassPathScanningCandidateComponentProvider componentProvider 
+                    = createComponentProvider();
+            for (String packageToScan : this.packagesToScan) {
+                // ���а�ɨ�����
+                scanPackage(componentProvider, packageToScan);
+            }
+        }
+    }
+
+    ...
+
+}
+
+```
+
+���Կ�����`ServletComponentRegisteringPostProcessor` ʵ���� `BeanFactoryPostProcessor`������д�� `BeanFactoryPostProcessor#postProcessBeanFactory` �����д���ɨ�������ɨ��ǰ�����Ǵ�����ɨ���� `ClassPathScanningCandidateComponentProvider`��Ȼ���ٽ���ɨ�衣
+
+����������ɨ�����Ĵ������� `createComponentProvider()`��
+
+```
+// �������� handler
+private static final List<ServletComponentHandler> HANDLERS;
+
+static {
+    List<ServletComponentHandler> servletComponentHandlers = new ArrayList<>();
+    servletComponentHandlers.add(new WebServletHandler());
+    servletComponentHandlers.add(new WebFilterHandler());
+    servletComponentHandlers.add(new WebListenerHandler());
+    HANDLERS = Collections.unmodifiableList(servletComponentHandlers);
+}
+
+/**
+ * ����ɨ����
+ */
+private ClassPathScanningCandidateComponentProvider createComponentProvider() {
+    // ��������
+    ClassPathScanningCandidateComponentProvider componentProvider 
+            = new ClassPathScanningCandidateComponentProvider(false);
+    componentProvider.setEnvironment(this.applicationContext.getEnvironment());
+    componentProvider.setResourceLoader(this.applicationContext);
+    for (ServletComponentHandler handler : HANDLERS) {
+        // ���ù��˹���
+        componentProvider.addIncludeFilter(handler.getTypeFilter());
+    }
+    return componentProvider;
+}
+
+```
+
+`createComponentProvider()` �����У����Ǵ�����ɨ��������Ȼ��������һЩ���ԣ����ž������ù��˹������������ص������¹��˹�������ã���Щ������ `WebServletHandler`/`WebFilterHandler`/`WebListenerHandler` �� `getTypeFilter()` �����ṩ��
+
+`getTypeFilter()` ����λ��һ�����󷽷��У�
+
+```
+abstract class ServletComponentHandler {
+
+    private final TypeFilter typeFilter;
+
+    /**
+     * ����ע�⣬ת��Ϊ AnnotationTypeFilter ����
+     */
+    protected ServletComponentHandler(Class<? extends Annotation> annotationType) {
+        this.typeFilter = new AnnotationTypeFilter(annotationType);
+        ...
+    }
+
+    /**
+     * ���� TypeFilter
+     */
+    TypeFilter getTypeFilter() {
+        return this.typeFilter;
+    }
+    ...
+}
+
+```
+
+�� `ServletComponentHandler` �У���һ����Ա���� `typeFilter`���ڹ��췽���д���ע��ֵ���ת���� `AnnotationTypeFilter`��Ȼ��ֵ�� `typeFilter`���� `getTypeFilter()` �������صľ������ `typeFilter`��
+
+�˽������ `typeFilter` ����Դ���������������ļ���ʵ���ࣺ
+
+```
+/**
+ * WebFilterHandler ���췽������IJ����� WebFilter
+ */
+class WebFilterHandler extends ServletComponentHandler {
+    WebFilterHandler() {
+        super(WebFilter.class);
+    }
+    ...
+}
+
+/**
+ * WebListenerHandler ���췽������IJ����� WebListener
+ */
+class WebListenerHandler extends ServletComponentHandler {
+    WebListenerHandler() {
+        super(WebListener.class);
+    }
+    ...
+}
+
+/**
+ * WebServletHandler ���췽������IJ����� WebServlet
+ */
+class WebServletHandler extends ServletComponentHandler {
+    WebServletHandler() {
+        super(WebServlet.class);
+    }
+    ...
+}
+
+```
+
+�ɴ˾������ˣ�`createComponentProvider()` �õ��� `ClassPathScanningCandidateComponentProvider` ֻ�������� 3 ��ע����ࣺ
+
+*   `@WebFilter`
+*   `@WebListener`
+*   `@WebServlet`
+
+���Ǽ���������������ɨ�����̣�����Ϊ `ServletComponentRegisteringPostProcessor#scanPackage`:
+
+```
+private void scanPackage(ClassPathScanningCandidateComponentProvider componentProvider, 
+        String packageToScan) {
+    for (BeanDefinition candidate : componentProvider.findCandidateComponents(packageToScan)) {
+        if (candidate instanceof AnnotatedBeanDefinition) {
+            // �����õ��� BeanDefinition
+            for (ServletComponentHandler handler : HANDLERS) {
+                handler.handle(((AnnotatedBeanDefinition) candidate),
+                        (BeanDefinitionRegistry) this.applicationContext);
+            }
+        }
+    }
+}
+
+```
+
+���ھ����ɨ�����̣�`ClassPathScanningCandidateComponentProvider#findCandidateComponents` ��������ͬ spring �İ�ɨ�����̻���һ�£�����Ͳ�չ��ϸ���ˣ����ǰ��ص���� `BeanDefinition` �Ĵ����ϣ�Ҳ���� `ServletComponentHandler#handle` ������
+
+```
+void handle(AnnotatedBeanDefinition beanDefinition, BeanDefinitionRegistry registry) {
+    // ����� annotationType ���ǹ��췽���д����ע�⣬��@WebFilter��@WebListener ��
+    Map<String, Object> attributes = beanDefinition.getMetadata()
+            .getAnnotationAttributes(this.annotationType.getName());
+    // �ж϶�Ӧ��ע���Ƿ���ڣ���������
+    if (attributes != null) {
+        doHandle(attributes, beanDefinition, registry);
+    }
+}
+
+```
+
+�ڴ���ɨ��õ��� `BeanDefinition` ʱ���ȱ������е� `handler`(`WebServletHandler`/`WebFilterHandler`/`WebListenerHandler`)��Ȼ����� `ServletComponentHandler#handle` �������д������� `ServletComponentHandler#handle` �У��ֻ�����Ƿ���ڶ�Ӧ��ע���Ƿ���ڣ�ʹ�� `AnnotatedBeanDefinition#getMetadata` ��ȡ��Ӧע�����Ϣ���������Ƿ��������� `doHandler()` ������
+
+��ô��� `doHandler()` ��������ʲô�أ����ǽ��� `WebServletHandler#doHandle`��
+
+```
+public void doHandle(Map<String, Object> attributes, AnnotatedBeanDefinition beanDefinition,
+        BeanDefinitionRegistry registry) {
+    // ע����� ServletRegistrationBean ��Ӧ�� BeanDefinition
+    BeanDefinitionBuilder builder = BeanDefinitionBuilder
+            .rootBeanDefinition(ServletRegistrationBean.class);
+    builder.addPropertyValue("asyncSupported", attributes.get("asyncSupported"));
+    builder.addPropertyValue("initParameters", extractInitParameters(attributes));
+    builder.addPropertyValue("loadOnStartup", attributes.get("loadOnStartup"));
+    // ��ȡ servlet ���ƣ����ָ�������ƣ���ʹ��ָ�����ƣ����û��ָ������ʹ����bean������
+    String name = determineName(attributes, beanDefinition);
+    builder.addPropertyValue("name", name);
+    builder.addPropertyValue("servlet", beanDefinition);
+    builder.addPropertyValue("urlMappings", extractUrlPatterns(attributes));
+    builder.addPropertyValue("multipartConfig", determineMultipartConfig(beanDefinition));
+    registry.registerBeanDefinition(name, builder.getBeanDefinition());
+}
+
+```
+
+���Կ��������������Ҫ�Ǵ��� `Servlet` �����ã������� spring ������ע����� `ServletRegistrationBean` ��Ӧ�� `beanDefinition`��
+
+�������� `Handler` ��� `doHandle()` ������������Ҳ��࣬���������� spring ������ע��� `beanDefinition` ������ͬ������Ͳ�ϸ���ˡ�
+
+�����ܽ����⼸��ע�������� spring ������ע��� `beanDefinition`��
+
+*   `@WebServlet`: ע���� `ServletRegistrationBean` ��Ӧ�� `beanDefinition`
+*   `@WebFilter`: ע���� `FilterRegistrationBean` ��Ӧ�� `beanDefinition`
+*   `@WebListener`: ע���� `ServletListenerRegistrationBean` ��Ӧ�� `beanDefinition`
+
+��ʹ�� `XxxRegistrationBean` ע��ʱ���������ֶ������� `XxxRegistrationBean`��Ȼ��ͨ�� `@Bean` ע��ע�ᵽ spring �����У���ʹ�� `@WebServlet`/`@WebFilter`/`@WebListener` ����һȦ������Ҳ�ǻص��� `XxxRegistrationBean`��
+
+#### 2.2 `XxxRegistrationBean` ��ע��
+
+������ʹ�� `XxxRegistrationBean` ע�ᣬ����ʹ�� `@ServletComponentScan` ɨ��ע�ᣬ���ն���õ� `XxxRegistrationBean` ��Ӧ�� bean�����������Ǿ���̽������Щ bean �����ע�ᵽ servlet �����еġ�
+
+�Ӵ����Ͽ���`ServletRegistrationBean`��`FilterRegistrationBean` �� `ServletListenerRegistrationBean` ���� `ServletContextInitializer` �ӿڵ�ʵ���࣬`ServletRegistrationBean` �ļ̳нṹ���£�
+
+![ͼƬ��������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-0397d56cfb328683ae349d0822db2320231.png)
+
+`ServletContextInitializer` ��ֻ��һ������ `onStartup(...)`��
+
+```
+@FunctionalInterface
+public interface ServletContextInitializer {
+
+    /**
+     * ������� servletContext�������������ǽ��� Servlet��filter��listener ��ע����
+     */
+    void onStartup(ServletContext servletContext) throws ServletException;
+
+}
+
+```
+
+�����ڽ��� `servlet` ���������ע�᷽ʽʱ�������ᵽ����ͨ��ʵ�� `ServletContextInitializer`����д�� `onStartup()` ��ʵ�� `servlet` �����ע�ᣬ�� `XxxRegistrationBean` �ĵײ�ʵ��Ҳ����ô���ġ�
+
+�� `ServletRegistrationBean`���������������� `onStartup(...)` ��������ɶ��
+
+`ServletRegistrationBean` û����д `onStartup(...)` ������ֱ�Ӽ̳��� `RegistrationBean`:
+
+```
+public final void onStartup(ServletContext servletContext) throws ServletException {
+    // ��ȡ������Ϣ 
+    String description = getDescription();
+    // �Ƿ���ע�ᣬĬ��Ϊtrue
+    if (!isEnabled()) {
+        logger.info(StringUtils.capitalize(description) + " was not registered (disabled)");
+        return;
+    }
+    // ����ע�����
+    register(description, servletContext);
+}
+
+```
+
+��������������ӣ��Ȼ�ȡ��һ��������Ϣ��Ȼ���ж��Ƿ�����ע�ᣬ���ž��ǽ���ע������ˡ�����ֱ�Ӳ鿴ע����������� `DynamicRegistrationBean#register`:
+
+```
+protected final void register(String description, ServletContext servletContext) {
+    D registration = addRegistration(description, servletContext);
+    if (registration == null) {
+        logger.info(...);
+        return;
+    }
+    // ��������
+    configure(registration);
+}
+
+```
+
+���������Ҫ�����������£�ע�� `servlet` �봦�����ã�������������ע����������� `ServletRegistrationBean#addRegistration` ����:
+
+```
+protected ServletRegistration.Dynamic addRegistration(String description, 
+        ServletContext servletContext) {
+    String name = getServletName();
+    // ע��
+    return servletContext.addServlet(name, this.servlet);
+}
+
+```
+
+ע��������DZȽϼ򵥵ģ�ֱ�ӵ��� `ServletContext#addServlet` ���С�
+
+�����鿴���ô��������� `ServletRegistrationBean#configure` ������
+
+```
+protected void configure(ServletRegistration.Dynamic registration) {
+    // ���ø���
+    super.configure(registration);
+    // ����urlMapping
+    String[] urlMapping = StringUtils.toStringArray(this.urlMappings);
+    if (urlMapping.length == 0 && this.alwaysMapUrl) {
+        urlMapping = DEFAULT_MAPPINGS;
+    }
+    if (!ObjectUtils.isEmpty(urlMapping)) {
+        registration.addMapping(urlMapping);
+    }
+    // ����loadOnStartup
+    registration.setLoadOnStartup(this.loadOnStartup);
+    // ��������һЩ��������
+    if (this.multipartConfig != null) {
+        registration.setMultipartConfig(this.multipartConfig);
+    }
+}
+
+```
+
+����������ǵ����˸���ķ�����Ȼ��������ô����ˣ��������������Ҫ�Ǵ����� `urlMapping` �� `loadOnStartup`���Ͳ����������ˡ�
+
+������������ `super.configure(...)` ������ɶ������ `DynamicRegistrationBean#configure`:
+
+```
+/**
+ * Ҳ�Ǵ���һЩ����
+ */
+protected void configure(D registration) {
+    registration.setAsyncSupported(this.asyncSupported);
+    // ���ó�ʼ������
+    if (!this.initParameters.isEmpty()) {
+        registration.setInitParameters(this.initParameters);
+    }
+}
+
+```
+
+���������Ҫ�����˳�ʼ���������á�
+
+������ķ���������`ServletRegistrationBean` �� `onStartup(...)` ������Ҫ����������������
+
+1.  �� `servlet` ���ӵ�������
+2.  ���� `servlet` ��������
+
+`FilterRegistrationBean` �� `ServletListenerRegistrationBean` ��ע��������ƣ�����Ͳ���˵�ˡ�
+
+#### 2.3 `ServletContextInitializer#onStartup` ��ִ��
+
+ע�������Ѿ������ˣ������������� `ServletContextInitializer#onStartup` ��������ִ�еġ�ע����һ�������̱Ƚϸ��ӣ����漰�� tomcat ���������̣�����ⲿ��ֻ��ע�ص���룬���������һ�������̡�
+
+�� tomcat ����Ϊ��������һϵ�еĵ��������׷�٣����������� `TomcatStarter` �����еģ��������£�
+
+```
+class TomcatStarter implements ServletContainerInitializer {
+
+    private final ServletContextInitializer[] initializers;
+
+    TomcatStarter(ServletContextInitializer[] initializers) {
+        this.initializers = initializers;
+    }
+
+    @Override
+    public void onStartup(Set<Class<?>> classes, ServletContext servletContext) 
+            throws ServletException {
+        try {
+            for (ServletContextInitializer initializer : this.initializers) {
+                // ����ִ�� ServletContextInitializer#onStartup����
+                initializer.onStartup(servletContext);
+            }
+        }
+        catch (Exception ex) {
+            this.startUpException = ex;
+            ...
+        }
+    }
+
+    ...
+
+}
+
+```
+
+`TomcatStarter` �� springboot �ṩ���࣬��ʵ���� `ServletContainerInitializer`�������� `ServletContextInitializer`��`ServletContainerInitializer` ���� tomcat �ṩ�ģ��� tomcat ����ʱ����ִ�� `ServletContainerInitializer#onStartup` ������`servlt 3.0` �淶����
+
+��ô `TomcatStarter` ��������ӵ� tomcat �����е��أ���Ȼ `servlt 3.0` �淶����ͨ�� `spi` ����ɨ�赽 `ServletContainerInitializer` ��ʵ�֣������������Բ����������ģ���Ϊ����� tomcat ͨ�� `spi` ɨ��õ� `TomcatStarter` ��ʵ���������ij�Ա���� `initializers` ���޷���ֵ�ˣ����������ӵ� tomcat ǰ��`TomcatStarter` ��Ҫʵ�������� `initializers` ��Ҫ����ֵ��
+
+������ε��ԣ����� `TomcatStarter` ���� `TomcatServletWebServerFactory#configureContext` �����ӵ� tomcat �����ģ��ؼ���������:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-6625407ce4d1dad8de736db00db124a2a99.png)
+
+���Կ�����`initializers` ����������������뵽 `TomcatStarter` �Ĺ��췽���У��õ� `TomcatStarter` ��ʵ�������ֶ����ӵ� tomcat �������ˡ�
+
+��ô����� `initializers` ���������ȡ�����أ���ʵ�ϣ����ǵ� `XxxRegistrationBean` ��Ҫ spring �����У�Ҫ��ȡ�Ļ���ֻҪ���� `beanFactory.getBeansOfType(...)` �Ϳ����ˣ�`ServletContextInitializerBeans#addServletContextInitializerBean(String, ServletContextInitializer, ListableBeanFactory)` ���Ǹ�����µģ�
+
+```
+private void addServletContextInitializerBeans(ListableBeanFactory beanFactory) {
+    for (Class<? extends ServletContextInitializer> initializerType : this.initializerTypes) {
+        // ��ȡ ServletContextInitializer: getOrderedBeansOfType(beanFactory, initializerType)
+        for (Entry<String, ? extends ServletContextInitializer> initializerBean 
+                : getOrderedBeansOfType(beanFactory, initializerType)) {
+            addServletContextInitializerBean(initializerBean.getKey(), 
+                initializerBean.getValue(), beanFactory);
+        }
+    }
+}
+
+/**
+ * �������Ӳ���
+ */
+private void addServletContextInitializerBean(String beanName, 
+        ServletContextInitializer initializer, ListableBeanFactory beanFactory) {
+    // ���� ServletRegistrationBean
+    if (initializer instanceof ServletRegistrationBean) {
+        Servlet source = ((ServletRegistrationBean<?>) initializer).getServlet();
+        addServletContextInitializerBean(Servlet.class, beanName, initializer, 
+                beanFactory, source);
+    }
+    // ���� FilterRegistrationBean
+    else if (initializer instanceof FilterRegistrationBean) {
+        Filter source = ((FilterRegistrationBean<?>) initializer).getFilter();
+        addServletContextInitializerBean(Filter.class, beanName, initializer, 
+                beanFactory, source);
+    }
+    // ���� DelegatingFilterProxyRegistrationBean
+    else if (initializer instanceof DelegatingFilterProxyRegistrationBean) {
+        String source = ((DelegatingFilterProxyRegistrationBean) initializer).getTargetBeanName();
+        addServletContextInitializerBean(Filter.class, beanName, initializer, beanFactory, source);
+    }
+    // ���� ServletListenerRegistrationBean
+    else if (initializer instanceof ServletListenerRegistrationBean) {
+        EventListener source = ((ServletListenerRegistrationBean<?>) initializer).getListener();
+        addServletContextInitializerBean(EventListener.class, beanName, initializer, 
+                beanFactory, source);
+    }
+    else {
+        // ������ ServletContextInitializer Bean
+        addServletContextInitializerBean(ServletContextInitializer.class, beanName, 
+                initializer, beanFactory, initializer);
+    }
+}
+
+```
+
+### 3\. �ܽ�
+
+���ķ����� springboot ע�� servlet ������������̣�
+
+1.  �� `Servlet` Ϊ���������� 3 ��ע�᷽ʽ��ʹ�� `XxxRegistrationBean` ע�ᡢʹ�� `servlet` ע�� (`@WebServlet`/`@WebFilter`/`@WebListener`) ע�ᣬ�Լ�ʵ�� `ServletContextInitializer` �ӿ��ֶ�ע�᣻
+2.  ������ `@ServletComponentScan` ע���ɨ������
+3.  �� `ServletRegistrationBean` Ϊ���������˽� `ServletRegistrationBean` ע�ᵽ servlet ������
+4.  ������ `ServletContainerInitializer#onStartup` ��ִ��
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4951050](https://my.oschina.net/funcy/blog/4951050) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBootWeb\345\272\224\347\224\250\357\274\210\344\272\214\357\274\211\357\274\232WebMvc\350\243\205\351\205\215\350\277\207\347\250\213.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBootWeb\345\272\224\347\224\250\357\274\210\344\272\214\357\274\211\357\274\232WebMvc\350\243\205\351\205\215\350\277\207\347\250\213.md"
new file mode 100644
index 0000000..46adf6d
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBootWeb\345\272\224\347\224\250\357\274\210\344\272\214\357\274\211\357\274\232WebMvc\350\243\205\351\205\215\350\277\207\347\250\213.md"
@@ -0,0 +1,815 @@
+ƽʱ�����У�springboot ���������������е��� web ��Ŀ�����Ľ����� springboot �Զ� springMvc ��Ŀ�����̡�
+
+### 1\. springMvc ���Զ�װ����
+
+springMvc ���Զ�װ����Ϊ
+
+```
+@Configuration(proxyBeanMethods = false)
+// ����װ������
+@ConditionalOnWebApplication(type = Type.SERVLET)
+@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
+// ���û���Զ���WebMvc�������࣬��ʹ�ñ�����
+@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
+// װ��˳��
+@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
+@AutoConfigureAfter({ 
+        // DispatcherServlet ���Զ�װ��
+        DispatcherServletAutoConfiguration.class, 
+        // �̳߳ص��Զ�װ��
+        TaskExecutionAutoConfiguration.class,
+        // jsr 303 ��֤��ܵ��Զ�װ��
+        ValidationAutoConfiguration.class })
+public class WebMvcAutoConfiguration {
+    ...
+}
+
+```
+
+������� `@AutoConfigureAfter` ע���У�`WebMvcAutoConfiguration` ��Ҫ�� `DispatcherServletAutoConfiguration`��`TaskExecutionAutoConfiguration`��`ValidationAutoConfiguration` ����װ�����֮����װ�䣬����Щ��������о����£�
+
+*   `DispatcherServletAutoConfiguration`��`DispatcherServlet` �Զ�װ��
+*   `TaskExecutionAutoConfiguration`������ִ��������ʵ���Ǵ�����һ���̳߳�
+*   `ValidationAutoConfiguration`��jsr 303 ��֤�����Զ�װ�䣬��֤���������� `@NotNull`��`@NotEmpty` ��ע�����֤����
+
+�� 3 �����У��� springMvc �йص�ֻ�� `DispatcherServletAutoConfiguration`����������ʶһ������
+
+```
+@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnWebApplication(type = Type.SERVLET)
+@ConditionalOnClass(DispatcherServlet.class)
+// ��Ҫ�� ServletWebServerFactoryAutoConfiguration �Զ�װ����ɺ���
+@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)
+public class DispatcherServletAutoConfiguration {
+    ...
+}
+
+```
+
+`DispatcherServletAutoConfiguration` ��Ҫ�� `ServletWebServerFactoryAutoConfiguration` �Զ�װ����ɲŽ���װ�䣬���������ʲô���أ���͸�£����Ǵ��� servlet ������`tomcat`, `jetty`, `undertow` �ȣ������ɵģ������������� `ServletWebServerFactoryAutoConfiguration`��
+
+```
+@Configuration(proxyBeanMethods = false)
+@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
+@ConditionalOnClass(ServletRequest.class)
+@ConditionalOnWebApplication(type = Type.SERVLET)
+@EnableConfigurationProperties(ServerProperties.class)
+// ������һЩ��
+@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
+        // 3�� web ����
+        ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
+        ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
+        ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
+public class ServletWebServerFactoryAutoConfiguration {
+    ...
+}
+
+```
+
+���Կ������������������û�� `@AutoConfigureAfter` ע���ˣ��������� springMvc ��������Զ�װ����࣬���ǵķ����ʹ�����࿪ʼ��
+
+�ܽ������ϼ������װ��˳��
+
+1.  `ServletWebServerFactoryAutoConfiguration`
+2.  `DispatcherServletAutoConfiguration`
+3.  `WebMvcAutoConfiguration`
+
+���������ǵķ���Ҳ��������˳����һ������Щ�Զ�װ���ࡣ
+
+### 2. `ServletWebServerFactoryAutoConfiguration` ���Զ�װ��
+
+`ServletWebServerFactoryAutoConfiguration` �����£�
+
+```
+@Configuration(proxyBeanMethods = false)
+@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
+@ConditionalOnClass(ServletRequest.class)
+@ConditionalOnWebApplication(type = Type.SERVLET)
+@EnableConfigurationProperties(ServerProperties.class)
+// ������һЩ��
+@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
+        // 3�� web ����
+        ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
+        ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
+        ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
+public class ServletWebServerFactoryAutoConfiguration {
+    ...
+}
+
+```
+
+����������� `BeanPostProcessorsRegistrar`��`EmbeddedTomcat`��`EmbeddedJetty`��`EmbeddedUndertow`����������һ�����ɣ�
+
+#### 2.1 `BeanPostProcessorsRegistrar`
+
+`BeanPostProcessorsRegistrar` �� `ServletWebServerFactoryAutoConfiguration` ���ڲ��࣬�������£�
+
+```
+public static class BeanPostProcessorsRegistrar 
+        implements ImportBeanDefinitionRegistrar, BeanFactoryAware {
+
+    ...
+
+    /**
+     * ���� ImportBeanDefinitionRegistrar �ķ���
+     */
+    @Override
+    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
+            BeanDefinitionRegistry registry) {
+        if (this.beanFactory == null) {
+            return;
+        }
+        // ע�����
+        registerSyntheticBeanIfMissing(registry, "webServerFactoryCustomizerBeanPostProcessor",
+                WebServerFactoryCustomizerBeanPostProcessor.class);
+        registerSyntheticBeanIfMissing(registry, "errorPageRegistrarBeanPostProcessor",
+                ErrorPageRegistrarBeanPostProcessor.class);
+    }
+
+    /**
+     * �����ע�����
+     */
+    private void registerSyntheticBeanIfMissing(BeanDefinitionRegistry registry, 
+            String name, Class<?> beanClass) {
+        if (ObjectUtils.isEmpty(this.beanFactory.getBeanNamesForType(beanClass, true, false))) {
+            RootBeanDefinition beanDefinition = new RootBeanDefinition(beanClass);
+            beanDefinition.setSynthetic(true);
+            registry.registerBeanDefinition(name, beanDefinition);
+        }
+    }
+}
+
+```
+
+�������Ҫ���� spring ������ע���������ࣺ`WebServerFactoryCustomizerBeanPostProcessor`��`ErrorPageRegistrarBeanPostProcessor`���������������Ƿֱ��Ǹ�ɶ��
+
+##### 1. `WebServerFactoryCustomizerBeanPostProcessor`
+
+`WebServerFactoryCustomizerBeanPostProcessor` �Ĵ������£�
+
+```
+public class WebServerFactoryCustomizerBeanPostProcessor 
+        implements BeanPostProcessor, BeanFactoryAware {
+
+    ...
+
+    @Override
+    public Object postProcessBeforeInitialization(Object bean, String beanName) 
+            throws BeansException {
+        // bean �������� WebServerFactory �Ŵ���
+        if (bean instanceof WebServerFactory) {
+            postProcessBeforeInitialization((WebServerFactory) bean);
+        }
+        return bean;
+    }
+
+    @SuppressWarnings("unchecked")
+    private void postProcessBeforeInitialization(WebServerFactory webServerFactory) {
+        LambdaSafe.callbacks(WebServerFactoryCustomizer.class, getCustomizers(), webServerFactory)
+                .withLogger(WebServerFactoryCustomizerBeanPostProcessor.class)
+                // ��������
+                .invoke((customizer) -> customizer.customize(webServerFactory));
+    }
+
+    /**
+     * ��ȡ WebServerFactoryCustomizer���õ�����һ�����ɱ�� List
+     */
+    private Collection<WebServerFactoryCustomizer<?>> getCustomizers() {
+        if (this.customizers == null) {
+            this.customizers = new ArrayList<>(getWebServerFactoryCustomizerBeans());
+            this.customizers.sort(AnnotationAwareOrderComparator.INSTANCE);
+            this.customizers = Collections.unmodifiableList(this.customizers);
+        }
+        return this.customizers;
+    }
+
+    /**
+     * ��ȡ beanFactory �����е� WebServerFactoryCustomizer
+     */
+    private Collection<WebServerFactoryCustomizer<?>> getWebServerFactoryCustomizerBeans() {
+        return (Collection) this.beanFactory.getBeansOfType(
+                WebServerFactoryCustomizer.class, false, false).values();
+    }
+
+}
+
+```
+
+��������������� `WebServerFactory` ���Զ������õģ���ʵ���� `BeanPostProcessor`�� ������Ҫ��ע���� `postProcessBeforeInitialization(...)` ������
+
+�� `WebServerFactoryCustomizerBeanPostProcessor` �� `postProcessBeforeInitialization(...)` �����У������ǰ bean �������� `WebServerFactory`�����Ȼ�ȡ `beanFactory` ����������Ϊ `WebServerFactoryCustomizer` �� bean��Ȼ����Щ `WebServerFactoryCustomizer` ���õ� `WebServerFactory`bean �С�
+
+�������Ҫ�Զ��� `Tomcat` �����ã���������������
+
+```
+@Component
+public class MyCustomizer implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
+
+    @Override
+    public void customize(TomcatServletWebServerFactory factory) {
+        factory.setPort(8091);
+        factory.setContextPath("/");
+        // ������������
+        ...
+    }
+
+}
+
+```
+
+�� `ServletWebServerFactoryAutoConfiguration` ���ṩ������ `WebServerFactoryCustomizer`:
+
+```
+public class ServletWebServerFactoryAutoConfiguration {
+
+    @Bean
+    public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(
+            ServerProperties serverProperties) {
+        return new ServletWebServerFactoryCustomizer(serverProperties);
+    }
+
+    @Bean
+    @ConditionalOnClass(name = "org.apache.catalina.startup.Tomcat")
+    public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(
+            ServerProperties serverProperties) {
+        return new TomcatServletWebServerFactoryCustomizer(serverProperties);
+    }
+
+    ...
+
+}
+
+```
+
+�ӷ�������������������������ö������� `ServerProperties`��
+
+```
+@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
+public class ServerProperties {
+    ...
+}
+
+```
+
+�������� `ConfigurationProperties` ע�⣬`prefix` Ϊ "server"��������������ö����� `server` ��ͷ��֧�ֵ��������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-586d95875e2eeefd295643c3e6acf0091e1.png)
+
+���磬����Ҫ�������Ķ˿ڣ�ֻ���� `application.properties` ���������ü��ɣ�
+
+```
+server.port=8080
+
+```
+
+�����������ã�����Ͳ����������ˡ�
+
+##### 2. `ErrorPageRegistrarBeanPostProcessor`
+
+`ErrorPageRegistrarBeanPostProcessor` �Ĵ������£�
+
+```
+public class ErrorPageRegistrarBeanPostProcessor implements BeanPostProcessor, BeanFactoryAware {
+
+    /**
+     * ����BeanPostProcessor�ķ�������bean��ʼ��ǰִ��
+     */
+    @Override
+    public Object postProcessBeforeInitialization(Object bean, String beanName) 
+            throws BeansException {
+        if (bean instanceof ErrorPageRegistry) {
+            // ��� bean �� ErrorPageRegistry
+            postProcessBeforeInitialization((ErrorPageRegistry) bean);
+        }
+        return bean;
+    }
+
+    private void postProcessBeforeInitialization(ErrorPageRegistry registry) {
+        for (ErrorPageRegistrar registrar : getRegistrars()) {
+            // ע�����ҳ
+            registrar.registerErrorPages(registry);
+        }
+    }
+
+    private Collection<ErrorPageRegistrar> getRegistrars() {
+        if (this.registrars == null) {
+            // ��ȡ���еĴ���ҳ
+            this.registrars = new ArrayList<>(this.beanFactory.getBeansOfType(
+                    ErrorPageRegistrar.class, false, false).values());
+            this.registrars.sort(AnnotationAwareOrderComparator.INSTANCE);
+            this.registrars = Collections.unmodifiableList(this.registrars);
+        }
+        return this.registrars;
+    }
+
+    ...
+}
+
+```
+
+������Ҫ��ע `postProcessBeforeInitialization` �����̣�
+
+1.  ��� bean �������� `ErrorPageRegistry`�����е� 2 ��
+2.  ��ȡ beanFactory ������ `ErrorPageRegistrar` ���͵� bean���������е� 3 ��
+3.  ���� `registrar.registerErrorPages(registry)` ���д���ҳ����
+
+��������������Ҫ˵����
+
+*   `ErrorPageRegistrar`������ҳע�������� `ErrorPageRegistry` �ɻ���ࣩ
+*   `ErrorPageRegistry`�������ע�����ࣨʵ�ʸɻ���ࣩ
+
+���������Ҫ�Զ������ҳ������ʵ�� `ErrorPageRegistry` �ӿڣ�
+
+```
+@Component
+public class MyErrorPage implements ErrorPageRegistrar {
+
+    /**
+     * ע�����ҳ
+     */
+    @Override
+    public void registerErrorPages(ErrorPageRegistry errorPageRegistry) {
+        // ���յ��õ��� ErrorPageRegistry#addErrorPages ����ע��
+        errorPageRegistry.addErrorPages(new ErrorPage("/error/page"));
+    }
+}
+
+```
+
+#### 2.2 `EmbeddedTomcat`
+
+���� `ServletWebServerFactoryConfiguration.EmbeddedTomcat` �ࣺ
+
+```
+@Configuration(proxyBeanMethods = false)
+class ServletWebServerFactoryConfiguration {
+
+    @Configuration(proxyBeanMethods = false)
+    // ����ע�⣬��������ʱ������
+    @ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
+    // ע�� ServletWebServerFactory�����ǿ�������ʵ�� tomcat ������װ��
+    @ConditionalOnMissingBean(value = ServletWebServerFactory.class, 
+        search = SearchStrategy.CURRENT)
+    public static class EmbeddedTomcat {
+
+        @Bean
+        public TomcatServletWebServerFactory tomcatServletWebServerFactory(
+                ObjectProvider<TomcatConnectorCustomizer> connectorCustomizers,
+                ObjectProvider<TomcatContextCustomizer> contextCustomizers,
+                ObjectProvider<TomcatProtocolHandlerCustomizer<?>> protocolHandlerCustomizers) {
+            TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
+            // ����һЩ����
+            factory.getTomcatConnectorCustomizers()
+                    .addAll(connectorCustomizers.orderedStream().collect(Collectors.toList()));
+            factory.getTomcatContextCustomizers()
+                    .addAll(contextCustomizers.orderedStream().collect(Collectors.toList()));
+            factory.getTomcatProtocolHandlerCustomizers()
+                    .addAll(protocolHandlerCustomizers.orderedStream()
+                    .collect(Collectors.toList()));
+            return factory;
+        }
+
+    }
+
+    ...
+}
+
+```
+
+�������Ҫ���Ƿ��� `TomcatServletWebServerFactory` bean������ע��һЩ `connectorCustomizers`��`contextCustomizers`��`protocolHandlerCustomizers` �Ȳ��������Զ������ã���Щ�������Ǵ� `BeanPostProcessorsRegistrar` �����ġ�
+
+�����и��ط���Ҫ��һ�£��������ʹ�� springboot �ṩ�� `TomcatServletWebServerFactory`�����ǿ����Լ�ʵ�� `TomcatServletWebServerFactory`����������
+
+```
+@Bean
+public ServletWebServerFactory servletWebServerFactory() {
+    TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory();
+    // �����Զ���ĸ�������
+    ...
+    return tomcat;
+}
+
+```
+
+��������֮��springboot �ṩ�� `tomcatServletWebServerFactory` �Ͳ��ᴦ���ˡ�
+
+���������� `EmbeddedJetty`��`EmbeddedUndertow`���� `EmbeddedTomcat` �Ĵ����������ƣ��Ͳ���˵�ˡ�
+
+### 3. `DispatcherServletAutoConfiguration`
+
+������������ `DispatcherServletAutoConfiguration`���ؼ��������£�
+
+```
+public class DispatcherServletAutoConfiguration {
+
+    public static final String DEFAULT_DISPATCHER_SERVLET_BEAN_NAME = "dispatcherServlet";
+
+    public static final String DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME 
+            = "dispatcherServletRegistration";
+
+    @Configuration(proxyBeanMethods = false)
+    @Conditional(DefaultDispatcherServletCondition.class)
+    @ConditionalOnClass(ServletRegistration.class)
+    @EnableConfigurationProperties({ HttpProperties.class, WebMvcProperties.class })
+    protected static class DispatcherServletConfiguration {
+
+        /**
+         * ���������� DispatcherServlet.
+         * @param httpProperties http����.
+         * @param webMvcProperties webMvc ����.
+         * @return ���ض���
+         */
+        @Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
+        public DispatcherServlet dispatcherServlet(HttpProperties httpProperties, 
+                WebMvcProperties webMvcProperties) {
+            DispatcherServlet dispatcherServlet = new DispatcherServlet();
+            dispatcherServlet.setDispatchOptionsRequest(
+                    webMvcProperties.isDispatchOptionsRequest());
+            dispatcherServlet.setDispatchTraceRequest(webMvcProperties.isDispatchTraceRequest());
+            dispatcherServlet.setThrowExceptionIfNoHandlerFound(
+                    webMvcProperties.isThrowExceptionIfNoHandlerFound());
+            dispatcherServlet.setPublishEvents(webMvcProperties.isPublishRequestHandledEvents());
+            dispatcherServlet.setEnableLoggingRequestDetails(httpProperties.isLogRequestDetails());
+            return dispatcherServlet;
+        }
+
+        /**
+         * �ļ��ϴ����.
+         * @param resolver ����.
+         * @return ����ֵ.
+         */
+        @Bean
+        @ConditionalOnBean(MultipartResolver.class)
+        @ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)
+        public MultipartResolver multipartResolver(MultipartResolver resolver) {
+            return resolver;
+        }
+
+    }
+
+    /**
+     * ���� DispatcherServletRegistrationBean
+     * ���ὫdispatcherServletע�ᵽservlet����
+     */
+    @Configuration(proxyBeanMethods = false)
+    @Conditional(DispatcherServletRegistrationCondition.class)
+    @ConditionalOnClass(ServletRegistration.class)
+    @EnableConfigurationProperties(WebMvcProperties.class)
+    @Import(DispatcherServletConfiguration.class)
+    protected static class DispatcherServletRegistrationConfiguration {
+
+        @Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
+        @ConditionalOnBean(value = DispatcherServlet.class, 
+                name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
+        public DispatcherServletRegistrationBean dispatcherServletRegistration(
+                DispatcherServlet dispatcherServlet, WebMvcProperties webMvcProperties, 
+                ObjectProvider<MultipartConfigElement> multipartConfig) {
+            // ���� DispatcherServletRegistrationBean�����ὫdispatcherServletע�ᵽservlet������
+            DispatcherServletRegistrationBean registration = 
+                    new DispatcherServletRegistrationBean(dispatcherServlet, 
+                    webMvcProperties.getServlet().getPath());
+            registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
+            registration.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());
+            multipartConfig.ifAvailable(registration::setMultipartConfig);
+            return registration;
+        }
+
+    }
+
+    ...
+
+}
+
+```
+
+����Ҫ��ע���� 3 �� bean��
+
+*   `dispatcherServlet`��springMvc ��������ڣ�url �����ɴ˽��룬Ȼ��ת���� `requestMapping`
+*   `multipartResolver`�������ļ��ϴ�
+*   `dispatcherServletRegistration`������ `dispatcherServlet` ��ע�ᣬ���Ὣ `dispatcherServlet` ע�ᵽ servlet �����У����� springboot ע�� servlet ��������ݣ����Բο� [springboot web Ӧ��֮ servlet �����ע������](https://my.oschina.net/funcy/blog/4951050)��
+
+### 4. `WebMvcAutoConfiguration`
+
+������ `WebMvcAutoConfiguration`:
+
+```
+@Configuration(proxyBeanMethods = false)
+...
+// ���û���Զ���WebMvc�������࣬��ʹ�ñ�����
+@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
+...
+public class WebMvcAutoConfiguration {
+    ...
+}
+
+```
+
+`WebMvcAutoConfiguration` ���и�ע����Ҫע���£�
+
+```
+@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
+
+```
+
+���д�������� `WebMvcAutoConfiguration` ֻ���� `WebMvcConfigurationSupport` ���͵� bean ������ʱ�����Ż�����Զ�װ�䡣
+
+`WebMvcConfigurationSupport` �Ǹ�ɶ�أ��� [springmvc demo �� @EnableWebMvc ע��](https://my.oschina.net/funcy/blog/4696657)һ���У������ᵽ���� springMvc ��������ַ�ʽ��
+
+*   ʹ�� `@EnableWebMvc` ע��
+*   �̳� `WebMvcConfigurationSupport` ��
+
+�����ַ������ն����� spring ��������������Ϊ `WebMvcConfigurationSupport` �� bean������� `springboot` ��Ŀ�У�������ǽ������������ֲ���֮һ����ô�������� `WebMvcConfigurationSupport`��`WebMvcAutoConfiguration` ���Զ�װ��Ͳ�ִ���ˡ�
+
+������������ `WebMvcAutoConfiguration` װ��� bean��
+
+#### 4.1 `WebMvcAutoConfigurationAdapter`
+
+`WebMvcAutoConfigurationAdapter` �� `WebMvcAutoConfiguration` ���ڲ��࣬�������£�
+
+```
+@Configuration(proxyBeanMethods = false)
+// ������ EnableWebMvcConfiguration
+@Import(EnableWebMvcConfiguration.class)
+@EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })
+@Order(0)
+public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer {
+    ...
+}
+
+```
+
+��ʵ���� `WebMvcConfigurer`���������� `EnableWebMvcConfiguration`��`WebMvcConfigurer` ������������ springMvc �����ã�ֻ��Ҫ��д���ж�Ӧ�ķ������ɣ�`EnableWebMvcConfiguration` �������������� ������ webMvc ���á�����Ҳ�� `WebMvcAutoConfiguration` ���ڲ��࣬����������������ɶ��
+
+```
+@Configuration(proxyBeanMethods = false)
+public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration 
+        implements ResourceLoaderAware {
+    ...
+}
+
+```
+
+���Կ��������� `DelegatingWebMvcConfiguration` �����࣬�� `DelegatingWebMvcConfiguration` ���Ǹ�ɶ�أ�����Ҳ���������Ķ��壺
+
+```
+@Configuration(proxyBeanMethods = false)
+public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
+    ...
+}
+
+```
+
+`DelegatingWebMvcConfiguration` ���� springMvc �ṩ�ģ����Կ�������ʵ���� `WebMvcConfigurationSupport`����ˣ�springboot ͨ�� `@Import(EnableWebMvcConfiguration.class)` �ķ�ʽ�� spring ������������ `WebMvcConfigurationSupport` ���͵� bean��
+
+��ʵ�ϣ�`DelegatingWebMvcConfiguration` ���� `@EnableWebMvc` ����� bean��
+
+```
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Documented
+// ������ DelegatingWebMvcConfiguration
+@Import(DelegatingWebMvcConfiguration.class)
+public @interface EnableWebMvc {
+    ...
+}
+
+```
+
+springbot ��ֱ������ `DelegatingWebMvcConfiguration` ���������������� `EnableWebMvcConfiguration`����Ȼ��������һЩ�Զ������õġ�
+
+���� `EnableWebMvcConfiguration` ������Щɶ������һ���ٷ������������� `WebMvcAutoConfigurationAdapter` ������ bean��
+
+```
+/**
+ * http ��Ϣת����.
+ */
+@Override
+public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
+    this.messageConvertersProvider.ifAvailable(
+            (customConverters) -> converters.addAll(customConverters.getConverters()));
+}
+
+/**
+ * ��ͼ������.
+ */
+@Bean
+@ConditionalOnMissingBean
+public InternalResourceViewResolver defaultViewResolver() {
+    InternalResourceViewResolver resolver = new InternalResourceViewResolver();
+    resolver.setPrefix(this.mvcProperties.getView().getPrefix());
+    resolver.setSuffix(this.mvcProperties.getView().getSuffix());
+    return resolver;
+}
+
+@Bean
+@ConditionalOnBean(View.class)
+@ConditionalOnMissingBean
+public BeanNameViewResolver beanNameViewResolver() {
+    BeanNameViewResolver resolver = new BeanNameViewResolver();
+    resolver.setOrder(Ordered.LOWEST_PRECEDENCE - 10);
+    return resolver;
+}
+
+@Bean
+@ConditionalOnBean(ViewResolver.class)
+@ConditionalOnMissingBean(name = "viewResolver", value = ContentNegotiatingViewResolver.class)
+public ContentNegotiatingViewResolver viewResolver(BeanFactory beanFactory) {
+    ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver();
+    resolver.setContentNegotiationManager(beanFactory.getBean(ContentNegotiationManager.class));
+    resolver.setOrder(Ordered.HIGHEST_PRECEDENCE);
+    return resolver;
+}
+
+/**
+ * ������ʻ�����.
+ */
+@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;
+}
+
+/**
+ * ��̬��Դӳ��
+ */
+@Override
+public void addResourceHandlers(ResourceHandlerRegistry registry) {
+    if (!this.resourceProperties.isAddMappings()) {
+        logger.debug("Default resource handling disabled");
+        return;
+    }
+    // ӳ��webjars
+    Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
+    CacheControl cacheControl = this.resourceProperties.getCache()
+            .getCachecontrol().toHttpCacheControl();
+    if (!registry.hasMappingForPattern("/webjars/**")) {
+        customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
+                .addResourceLocations("classpath:/META-INF/resources/webjars/")
+                .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
+    }
+    // ӳ�侲̬��Դ·��
+    String staticPathPattern = this.mvcProperties.getStaticPathPattern();
+    if (!registry.hasMappingForPattern(staticPathPattern)) {
+        customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
+                // staticLocations Ĭ��Ϊ classpath:[/META-INF/resources/,
+                // /resources/, /static/, /public/]
+                .addResourceLocations(getResourceLocations(
+                    this.resourceProperties.getStaticLocations()))
+                .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
+    }
+}
+
+```
+
+���Կ�����`WebMvcAutoConfigurationAdapter` ���������� bean:
+
+1.  http ��Ϣת����
+2.  ��ͼ������
+3.  ���ʻ�����
+
+���������ص������� `http��Ϣת����`����ʹ�� springMvc ʱ��ͨ���� `Controller` ������еķ����ϱ�� `@ResponseBody`�����ز����ͻ�ת��Ϊ json������� `http��Ϣת����`�����Ĺ����ˡ�springboot Ĭ�ϵ� jaon ������ `jackson`������ʵ������ `JacksonAutoConfiguration` �У�װ��Ϊ `HttpMessageConverter` �Ĵ����� `JacksonHttpMessageConvertersConfiguration`������Ͳ�չ���ˡ�
+
+������ �ķ����У���γ����� `WebMvcProperties` ���ã��������������Ǹ�ɶ��
+
+```
+@ConfigurationProperties(prefix = "spring.mvc")
+public class WebMvcProperties {
+    ...
+}
+
+```
+
+�����ԣ����Ǹ������� �����Կ�������������ǰ׺Ϊ `spring.mvc`��֧�ֵ��������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-062f490afbb74e496f50f4cad4bd13ede82.png)
+
+#### 4.2 `EnableWebMvcConfiguration`
+
+���������� `EnableWebMvcConfiguration` �Զ�������ã�
+
+```
+public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration 
+        implements ResourceLoaderAware {
+
+    /**
+     * ����������
+     */
+    @Bean
+    @Override
+    public RequestMappingHandlerAdapter requestMappingHandlerAdapter(
+            @Qualifier("mvcContentNegotiationManager") 
+                ContentNegotiationManager contentNegotiationManager,
+            @Qualifier("mvcConversionService") FormattingConversionService conversionService,
+            @Qualifier("mvcValidator") Validator validator) {
+        RequestMappingHandlerAdapter adapter = super.requestMappingHandlerAdapter(
+                contentNegotiationManager, conversionService, validator);
+        adapter.setIgnoreDefaultModelOnRedirect(this.mvcProperties == null 
+                || this.mvcProperties.isIgnoreDefaultModelOnRedirect());
+        return adapter;
+    }
+
+    /**
+     * ·��ӳ��
+     */
+    @Bean
+    @Primary
+    @Override
+    public RequestMappingHandlerMapping requestMappingHandlerMapping(
+            @Qualifier("mvcContentNegotiationManager") 
+                    ContentNegotiationManager contentNegotiationManager,
+            @Qualifier("mvcConversionService") FormattingConversionService conversionService,
+            @Qualifier("mvcResourceUrlProvider") ResourceUrlProvider resourceUrlProvider) {
+        // Must be @Primary for MvcUriComponentsBuilder to work
+        return super.requestMappingHandlerMapping(contentNegotiationManager, conversionService,
+                resourceUrlProvider);
+    }
+
+    /**
+     * ��ӭҳ
+     */
+    @Bean
+    public WelcomePageHandlerMapping welcomePageHandlerMapping(
+            ApplicationContext applicationContext, 
+            FormattingConversionService mvcConversionService, 
+            ResourceUrlProvider mvcResourceUrlProvider) {
+        WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(
+                new TemplateAvailabilityProviders(applicationContext), applicationContext, 
+                getWelcomePage(), this.mvcProperties.getStaticPathPattern());
+        welcomePageHandlerMapping.setInterceptors(getInterceptors(
+                mvcConversionService, mvcResourceUrlProvider));
+        return welcomePageHandlerMapping;
+    }
+
+    /**
+     * mvc���ã����������ڸ�ʽ�Ĵ���
+     */
+    @Bean
+    @Override
+    public FormattingConversionService mvcConversionService() {
+        WebConversionService conversionService 
+            = new WebConversionService(this.mvcProperties.getDateFormat());
+        addFormatters(conversionService);
+        return conversionService;
+    }
+
+    /**
+     * ��������
+     */
+    @Bean
+    @Override
+    public Validator mvcValidator() {
+        if (!ClassUtils.isPresent("javax.validation.Validator", getClass().getClassLoader())) {
+            return super.mvcValidator();
+        }
+        return ValidatorAdapter.get(getApplicationContext(), getValidator());
+    }
+
+    /**
+     * �쳣����
+     */
+    @Override
+    protected ExceptionHandlerExceptionResolver createExceptionHandlerExceptionResolver() {
+        if (this.mvcRegistrations != null 
+                && this.mvcRegistrations.getExceptionHandlerExceptionResolver() != null) {
+            return this.mvcRegistrations.getExceptionHandlerExceptionResolver();
+        }
+        return super.createExceptionHandlerExceptionResolver();
+    }
+
+    @Override
+    protected void extendHandlerExceptionResolvers(
+                List<HandlerExceptionResolver> exceptionResolvers) {
+        super.extendHandlerExceptionResolvers(exceptionResolvers);
+        if (this.mvcProperties.isLogResolvedException()) {
+            for (HandlerExceptionResolver resolver : exceptionResolvers) {
+                if (resolver instanceof AbstractHandlerExceptionResolver) {
+                    ((AbstractHandlerExceptionResolver) resolver).setWarnLogCategory(
+                            resolver.getClass().getName());
+                }
+            }
+        }
+    }
+    ...
+}
+
+```
+
+�����ԭ���� springMvc����������������������·��ӳ�䡢����У�顢�쳣�����ȡ�
+
+### 5\. �ܽ�
+
+1.  `webMvc` ��װ��ʱ����װ�� `ServletWebServerFactoryAutoConfiguration`����װ�� `DispatcherServletAutoConfiguration`�����װ�� `WebMvcAutoConfiguration`
+2.  `ServletWebServerFactoryAutoConfiguration` ���� servlet ������װ�䣬`DispatcherServletAutoConfiguration` ���� `DispatcherServlet` ��װ�䣬`WebMvcAutoConfiguration` ���� `webMvc` �������Ϣת��������ͼ����������̬��Դӳ��ȣ���װ��
+3.  ����� spring ������������ `WebMvcConfigurationSupport`�� `WebMvcAutoConfiguration` ��װ�����������ִ��
+4.  `servlet` ����������� `servlet` Ϊǰ׺��`webMvc` �������� `spring.mvc` Ϊǰ׺�����ǿ����������ļ���һ��Ϊ `application.properties/application.yml`���н�������
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4921595](https://my.oschina.net/funcy/blog/4921595) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\200\357\274\211\357\274\232\345\207\206\345\244\207SpringApplication.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\200\357\274\211\357\274\232\345\207\206\345\244\207SpringApplication.md"
new file mode 100644
index 0000000..ece7a22
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\200\357\274\211\357\274\232\345\207\206\345\244\207SpringApplication.md"
@@ -0,0 +1,318 @@
+������̽�� springboot ����������ģ�����ʹ�õ��� demo λ��?[gitee/funcy](https://gitee.com/funcy/spring-boot/tree/v2.2.2.RELEASE_learn/spring-boot-project/spring-boot-learn/src/main/java/org/springframework/boot/learn/autoconfigure/demo01).
+
+## 1\. ��?`Demo01Application#main(...)`?��ʼ
+
+springboot ��������ʽ�dz��򵥣���һ�У�
+
+```
+@SpringBootApplication
+public class Demo01Application {
+
+    public static void main(String[] args) {
+        // ��һ�о�����������springboot��
+        SpringApplication.run(Demo01Application.class, args);
+    }
+}
+
+```
+
+Ȼ�����Ǿͽ����������������������ʲô��
+
+```
+public class SpringApplication {
+    ...
+    // primarySource �������Ǵ���� Demo01Application.class��
+    // args ���� main() �����IJ���
+    public static ConfigurableApplicationContext run(
+            Class<?> primarySource, String... args) {
+        // �� primarySource ��װ�����飬�������� run(...) ����
+        return run(new Class<?>[] { primarySource }, args);
+    }
+
+    // primarySources �������Ǵ���� Demo01Application.class ��װ�ɵ����飬
+    // args ���� main() �����IJ���
+    public static ConfigurableApplicationContext run(
+            Class<?>[] primarySources, String[] args) {
+        // ���￪ʼ��������
+        return new SpringApplication(primarySources).run(args);
+    }
+    ...
+}
+
+```
+
+ͨ������һ����׷����ȥ�������?`SpringApplication#run(Class<?>[], String[])`?�������ؼ��������£�
+
+```
+return new SpringApplication(primarySources).run(args);
+
+```
+
+��������Ҫ�����������Բ�����������֣�
+
+*   ���췽����`SpringApplication#SpringApplication(Class<?>...)`
+*   ʵ��������`SpringApplication#run(String...)`
+
+�������������������� springboot ���������������ˣ����������Ǿ�������������������
+
+## 2\. ����?`SpringApplication`��`SpringApplication#SpringApplication(Class<?>...)`
+
+```
+public class SpringApplication {
+    public SpringApplication(Class<?>... primarySources) {
+        // ��������
+        this(null, primarySources);
+    }
+
+    /**
+     * ��������յ��õĹ��췽����
+     * resourceLoader Ϊ null
+     * primarySources Ϊ Demo01Application.class
+     */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
+        // 1\. �������resourceLoader���õ���Ա�����������ֵΪnull
+        this.resourceLoader = resourceLoader;
+        Assert.notNull(primarySources, "PrimarySources must not be null");
+        // 2\. �������primarySources���õ���Ա�����������ֵΪ Demo01Application.class
+        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
+        // 3\. ��ǰ�� web Ӧ�����ͣ�REACTIVE��NONE��SERVLET
+        this.webApplicationType = WebApplicationType.deduceFromClasspath();
+        // 4\. ���ó�ʼ������getSpringFactoriesInstances���� META-INF/spring.factories �л�ȡ����
+        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
+        // 5\. ���ü�������getSpringFactoriesInstances���� META-INF/spring.factories �л�ȡ����
+        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
+        // 6\. ���ذ���main()������class
+        this.mainApplicationClass = deduceMainApplicationClass();
+    }
+}
+
+```
+
+��������������»��DZȽ������ģ�������ݶ����ڴ�����ע���ˣ�������Щ��������Ҫչ�������������Ǿ���������
+
+### 2.1 ��ȡ��ǰ web Ӧ�����ͣ�`WebApplicationType.deduceFromClasspath()`
+
+`WebApplicationType.deduceFromClasspath()`?�����������ƶϵ�ǰ��Ŀ��ʲô���͵ģ��������£�
+
+```
+public enum WebApplicationType {
+    // ���� web Ӧ��
+    NONE,
+
+    // servlet ���͵� web Ӧ��
+    SERVLET,
+
+    // reactive ���͵� web Ӧ��
+    REACTIVE;
+
+    ...
+
+    private static final String[] SERVLET_INDICATOR_CLASSES = { 
+            "javax.servlet.Servlet",
+            "org.springframework.web.context.ConfigurableWebApplicationContext" };
+
+    private static final String WEBMVC_INDICATOR_CLASS 
+            = "org.springframework.web.servlet.DispatcherServlet";
+
+    private static final String WEBFLUX_INDICATOR_CLASS 
+            = "org.springframework.web.reactive.DispatcherHandler";
+
+    private static final String JERSEY_INDICATOR_CLASS 
+            = "org.glassfish.jersey.servlet.ServletContainer";
+
+    static WebApplicationType deduceFromClasspath() {
+        // classpath ����� WEBFLUX �����
+        if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) 
+                && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
+                && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
+            return WebApplicationType.REACTIVE;
+        }
+        // classpath ������ SERVLET �����
+        for (String className : SERVLET_INDICATOR_CLASSES) {
+            if (!ClassUtils.isPresent(className, null)) {
+                return WebApplicationType.NONE;
+            }
+        }
+        // Ĭ�� web ����Ϊ SERVLET
+        // Ҳ����˵��ͬʱ���� WEBFLUX �� SERVLET ����࣬���շ��ص��� SERVLET
+        return WebApplicationType.SERVLET;
+    }
+
+    ...
+}
+
+```
+
+���Կ�����springboot ������������Ŀ���ͣ�`NONE`(���� web Ӧ��)��`SERVLET`(`servlet`?���͵� web Ӧ��)��`REACTIVE`(`reactive`?���͵� web Ӧ��)��`WebApplicationType.deduceFromClasspath()`?��ִ���������£�
+
+1.  ���?`classpath`?�н�����?`WEBFLUX`?����࣬�������ǰ��Ŀ��?`reactive`?���͵� web Ӧ�ã����أ�
+2.  ���?`classpath`?�в�����?`SERVLET`?����࣬�������ǰ��Ŀ���� web Ӧ�ã����أ�
+3.  ������������������㣬�������ǰ��Ŀ��?`servlet`?���͵� web Ӧ�á�
+
+���� demo ������?`spring-boot-starter-web`?�����������˵�ǰ��Ŀ��?`servlet`?���͵� web Ӧ�á�
+
+### 2.2 ���ó�ʼ������`setInitializers(...)`
+
+���������£�
+
+```
+setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
+
+```
+
+���д����Ϊ������:
+
+*   ��ȡ?`ApplicationContextInitializer`��`getSpringFactoriesInstances(ApplicationContextInitializer.class)`
+*   ���ó�ʼ������`setInitializers(...)`
+
+��������������ȡ?`ApplicationContextInitializer`?�����̣��������£�
+
+```
+public class SpringApplication {
+    ...
+
+    // type Ϊ ApplicationContextInitializer.class
+    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
+        return getSpringFactoriesInstances(type, new Class<?>[] {});
+    }
+
+    /**
+     * type Ϊ ApplicationContextInitializer.class
+     * parameterTypes Ϊ ew Class<?>[] {}
+     * args Ϊ null
+     */
+    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, 
+            Class<?>[] parameterTypes, Object... args) {
+        ClassLoader classLoader = getClassLoader();
+        // �� META-INF/spring.factories ��������
+        Set<String> names = new LinkedHashSet<>(
+                SpringFactoriesLoader.loadFactoryNames(type, classLoader));
+        // ʵ������ʹ�õķ������
+        List<T> instances = createSpringFactoriesInstances(
+                type, parameterTypes, classLoader, args, names);
+        // ���򣬱Ƚϵ��� @Order ע�⣬��ʵ�ֵ� Orderd �ӿ�
+        AnnotationAwareOrderComparator.sort(instances);
+        return instances;
+    }
+    ...
+}
+
+```
+
+���ϴ���Ƚϼ򵥣��ȴ�?`META-INF/spring.factories`?��ȡ���ݣ�Ȼ��ʹ�÷������ʵ����������������ٷ��ء�
+
+����?`SpringFactoriesLoader.loadFactoryNames(...)`�������ջ��?`META-INF/spring.factories`?�������ݣ�`META-INF/spring.factories`?��������Ϊһ�������ļ���key Ϊ����� type���÷�������ϸ���������Բο�?[springboot �Զ�װ��֮�����Զ�װ����](https://my.oschina.net/funcy/blog/4870868)��
+
+���ջ��ж��ٸ�?`ApplicationContextInitializer`?���ؽ����أ�ͨ�����ԣ�����һ���� 7 ����
+
+![](https://oscimg.oschina.net/oscnet/up-53f764fefeb0c55fcfef6e34634805162f5.png)
+
+���� 7 ��?`ApplicationContextInitializer`��˵�����£�
+
+*   `ConfigurationWarningsApplicationContextInitializer`������ IOC ������һЩ�����Ĵ�������
+*   `ContextIdApplicationContextInitializer`������ Spring Ӧ�������ĵ� ID
+*   `DelegatingApplicationContextInitializer`������?`application.properties`?��?`context.initializer.classes`?���õ���
+*   `RSocketPortInfoApplicationContextInitializer`����?`RSocketServer`?ʵ��ʹ�õļ����˿�д�뵽?`Environment`?����������
+*   `ServerPortInfoApplicationContextInitializer`�������� servlet ����ʵ��ʹ�õļ����˿�д�뵽?`Environment`?����������
+*   `SharedMetadataReaderFactoryContextInitializer`������һ��?`SpringBoot`?��?`ConfigurationClassPostProcessor`?���õ�?`CachingMetadataReaderFactory`?����
+*   `ConditionEvaluationReportLoggingListener`����?`ConditionEvaluationReport`?д����־
+
+��ȡ��?`ApplicationContextInitializer`��������������?`setInitializers(...)`?������
+
+```
+public class SpringApplication {
+    ...
+    public void setInitializers(
+            Collection<? extends ApplicationContextInitializer<?>> initializers) {
+        this.initializers = new ArrayList<>(initializers);
+    }
+    ...
+}
+
+```
+
+����һ����׼��?`setter`?�����������ľ�ֻ�����ó�Ա������
+
+### 2.3 ���ü�������`setListeners(...)`
+
+���ü������Ĵ������£�
+
+```
+setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
+
+```
+
+����ʽ�Ͽ���ͬ?`Initializer`?һ����Ҳ���ȴ�?`META-INF/spring.factories`?�м���?`ApplicationListener`��Ȼ�����ӵ���Ա�����У���������ֱ�ӿ��ܻ�ȡ����Щ?`listener`��
+
+![](https://oscimg.oschina.net/oscnet/up-0440eb21c69a75686850a1b44eb9f1287c8.png)
+
+���Կ�����һ�����Ի�ȡ�� 11 ��?`listener`����Щ?`listener`?���������£�
+
+*   `ClearCachesApplicationListener`��Ӧ�������ļ�����ɺ�Ի������������
+*   `ParentContextCloserApplicationListener`������˫��Ӧ�������ĵĹر��¼������Լ�����Ӧ���������д���
+*   `CloudFoundryVcapEnvironmentPostProcessor`����?`CloudFoundry`?�ṩ֧��
+*   `FileEncodingApplicationListener`�����ϵͳ�ļ�������Ӧ�û��������Ƿ�һ�£����ϵͳ�ļ������Ӧ�û����ı��벻ͬ����ֹӦ������
+*   `AnsiOutputApplicationListener`������?`spring.output.ansi.enabled`?��������?`AnsiOutput`
+*   `ConfigFileApplicationListener`���ӳ�������ЩԼ����λ�ö�ȡ�����ļ�
+*   `DelegatingApplicationListener`���������¼���ת����?`application.properties`?�����õ�?`context.listener.classes`?�ļ�����
+*   `ClasspathLoggingApplicationListener`���Ի��������¼�?`ApplicationEnvironmentPreparedEvent`?��Ӧ��ʧ���¼�?`ApplicationFailedEvent`?������Ӧ
+*   `LoggingApplicationListener`������?`LoggingSystem`��ʹ��?`logging.config`?��������ָ�������û���ȱʡ����
+*   `LiquibaseServiceLocatorApplicationListener`��ʹ��һ�����Ժ�?`SpringBoot`?��ִ�� jar ����Ϲ����İ汾�滻?`LiquibaseServiceLocator`
+*   `BackgroundPreinitializer`��ʹ��һ����̨�߳̾��紥��һЩ��ʱ�ij�ʼ������
+
+��������?`SpringApplication#setListeners`��
+
+```
+public void setListeners(Collection<? extends ApplicationListener<?>> listeners) {
+    this.listeners = new ArrayList<>(listeners);
+}
+
+```
+
+��Ҳ��һ����׼��?`setter`?������
+
+### 2.4 �ƶ����ࣺ`deduceMainApplicationClass()`
+
+��ν���࣬���ǰ���?`main(String[])`��Ҳ���ǵ�ǰ spring Ӧ�õ������࣬`SpringApplication#deduceMainApplicationClass`?�������£�
+
+```
+private Class<?> deduceMainApplicationClass() {
+    try {
+        // ��ȡ����ջ
+        StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
+        // ��������ջ���� ��main����
+        for (StackTraceElement stackTraceElement : stackTrace) {
+            if ("main".equals(stackTraceElement.getMethodName())) {
+                return Class.forName(stackTraceElement.getClassName());
+            }
+        }
+    }
+    catch (ClassNotFoundException ex) {
+        // Swallow and continue
+    }
+    return null;
+}
+
+```
+
+������Ҫ��ͨ��?`new RuntimeException().getStackTrace()`?��ȡ����ջ��Ȼ��������õ�����?`main`?�������࣬�õ��ĵ���ջ���£�
+
+![](https://oscimg.oschina.net/oscnet/up-8c04487e6b05f583e7d45b83c293634f42a.png)
+
+���Կ�����`main()`?�Ͱ����ڵ���ջ���ˡ�
+
+### 2.5 �ܽ�
+
+������Ҫ�ǽ���?`SpringApplication`?�Ĵ������̣������ص���������¼��㣺
+
+1.  �ƶϵ�ǰ web Ӧ�����ͣ�NONE, SERVLET,REACTIVE��
+2.  ���ó�ʼ������`ApplicationContextInitializer`��
+3.  ���ü�������`ApplicationListener`��
+4.  �ƶ����ࡣ
+
+![](https://oscimg.oschina.net/oscnet/up-e9a43f1c523c0f19d37e4741580ed32ca08.png)
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4877610](https://my.oschina.net/funcy/blog/4877610)?���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\211\357\274\211\357\274\232\345\207\206\345\244\207IOC\345\256\271\345\231\250.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\211\357\274\211\357\274\232\345\207\206\345\244\207IOC\345\256\271\345\231\250.md"
new file mode 100644
index 0000000..f916074
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\211\357\274\211\357\274\232\345\207\206\345\244\207IOC\345\256\271\345\231\250.md"
@@ -0,0 +1,535 @@
+��һƪ�����ܽ� springboot �����������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-07a6b491fbe69b8dcbd41e59a8543f06671.png)
+
+�����ģ����Ǽ��������������IJ��衣
+
+### 3.8 ���� ioc ����
+
+���� ioc �����Ĵ������£�
+
+```
+ConfigurableApplicationContext context = null;
+....
+// ����applicationContext
+context = createApplicationContext();
+
+```
+
+���ǽ��� `SpringApplication#createApplicationContext` ������
+
+```
+/** Ĭ�ϵ� ApplicationContext */
+public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."
+        + "annotation.AnnotationConfigApplicationContext";
+
+/** servlet Ӧ�õĵ� ApplicationContext */
+public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot."
+        + "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";
+
+/** Reactive Ӧ�õ� ApplicationContext */
+public static final String DEFAULT_REACTIVE_WEB_CONTEXT_CLASS = "org.springframework."
+        + "boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext";
+
+protected ConfigurableApplicationContext createApplicationContext() {
+    Class<?> contextClass = this.applicationContextClass;
+    if (contextClass == null) {
+        try {
+            // ����Ӧ��������������ͬ������
+            switch (this.webApplicationType) {
+            case SERVLET:
+                // ʹ�õ��� AnnotationConfigServletWebServerApplicationContext
+                contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
+                break;
+            case REACTIVE:
+                contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
+                break;
+            default:
+                // Ĭ��ʹ�õ��� AnnotationConfigApplicationContext
+                contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
+            }
+        }
+        catch (ClassNotFoundException ex) {
+            throw new IllegalStateException(...);
+        }
+    }
+    // ʹ�÷������ʵ����
+    return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
+}
+
+```
+
+���������Ҫ���Ǹ���Ӧ��������������ͬ `ApplicationContext`��ʹ�÷���ķ�������ʵ��������Ӧ�����Ͷ�Ӧ�� `ApplicationContext` ���£�
+
+1.  `servlet` Ӧ�ã�`AnnotationConfigServletWebServerApplicationContext`
+2.  `reactive` Ӧ�ã�`AnnotationConfigReactiveWebServerApplicationContext`
+3.  ���϶����ǣ�`AnnotationConfigApplicationContext`
+
+��ǰӦ�õ������� `servlet`����˴����� `ApplicationContext` �� `AnnotationConfigReactiveWebServerApplicationContext`�����������Ĺ��췽����
+
+```
+public class AnnotationConfigServletWebServerApplicationContext 
+        extends ServletWebServerApplicationContext implements AnnotationConfigRegistry {
+
+    // �������� BeanDefinition ��ע��
+    private final AnnotatedBeanDefinitionReader reader;
+
+    // ������������ɨ��
+    private final ClassPathBeanDefinitionScanner scanner;
+
+    ...
+
+    public AnnotationConfigServletWebServerApplicationContext() {
+        this.reader = new AnnotatedBeanDefinitionReader(this);
+        this.scanner = new ClassPathBeanDefinitionScanner(this);
+    }
+
+    ...
+}
+
+```
+
+`AnnotationConfigServletWebServerApplicationContext` �Ĺ��췽�����DZȽϼ򵥵ģ�ֻ���������������ԣ��Ͳ���˵�ˡ�����������ҲҪ��Ŀ���Զһ�㣬�����丸��Ĺ��췽���������� `GenericApplicationContext` �Ĺ��췽�����ҵ���ôһ�䣺
+
+```
+public GenericApplicationContext() {
+    this.beanFactory = new DefaultListableBeanFactory();
+}
+
+```
+
+���д��봴���� `DefaultListableBeanFactory` �����丳ֵ���� `beanFactory`������������� `ApplicationContext` ʹ�õ� `beanFactory` ���� `DefaultListableBeanFactory`��
+
+### 3.9 ׼�� ioc ����
+
+������ ioc �����󣬽��ž��Ƕ���������һЩ׼���������������£�
+
+```
+public class SpringApplication {
+
+    ...
+
+    private void prepareContext(ConfigurableApplicationContext context, 
+            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, 
+            ApplicationArguments applicationArguments, Banner printedBanner) {
+        // �������õ�Ӧ�û������õ�IOC������
+        context.setEnvironment(environment);
+        // ����������һЩ����
+        postProcessApplicationContext(context);
+        // Ӧ��Initializer���г�ʼ������
+        applyInitializers(context);
+        //  ��������SpringApplicationRunListeners��contextPrepared����
+        // ���ڴ�����׼��ApplicationContext֮�󣬵��ڼ���֮ǰ��
+        listeners.contextPrepared(context);
+        // ��ӡ����־
+        if (this.logStartupInfo) {
+            logStartupInfo(context.getParent() == null);
+            logStartupProfileInfo(context);
+        }
+        // ��ȡbeanFactory
+        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
+        // �����в�����Ϊbeanע�ᵽbeanFactory��
+        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
+        // �� banner ��Ϊbeanע�ᵽbeanFactory��
+        if (printedBanner != null) {
+            beanFactory.registerSingleton("springBootBanner", printedBanner);
+        }
+        if (beanFactory instanceof DefaultListableBeanFactory) {
+            // �Ƿ�����bean����Ϣ������
+            ((DefaultListableBeanFactory) beanFactory)
+                    .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
+        }
+        // ����������
+        if (this.lazyInitialization) {
+            context.addBeanFactoryPostProcessor(
+                    new LazyInitializationBeanFactoryPostProcessor());
+        }
+        // ��ȡ������Դ
+        Set<Object> sources = getAllSources();
+        Assert.notEmpty(sources, "Sources must not be empty");
+        // ���� class
+        load(context, sources.toArray(new Object[0]));
+        // �����¼�
+        listeners.contextLoaded(context);
+    }
+}
+
+```
+
+׼�������IJ��軹�Ǻ������ģ���Ҫ���ݶ����ڴ����н�����ע�ͣ������һЩ����������΢չ���¡�
+
+#### 1\. ���� `Environment`
+
+�ò����Ĵ���Ϊ
+
+```
+private void prepareContext(ConfigurableApplicationContext context, 
+        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, 
+        ApplicationArguments applicationArguments, Banner printedBanner) {
+    // �������õ�Ӧ�û������õ�IOC������
+    context.setEnvironment(environment);
+    ...
+}
+
+```
+
+��� `environment` ����ǰ�洴���� `environment`��ioc ����Ҳ��ʹ��������������������ò�����
+
+```
+public class AnnotationConfigServletWebServerApplicationContext extends ... {
+
+    ...
+
+    @Override
+    public void setEnvironment(ConfigurableEnvironment environment) {
+        // ���ø���ķ�����������
+        super.setEnvironment(environment);
+        // Ҳ��environment���õ�������������
+        this.reader.setEnvironment(environment);
+        this.scanner.setEnvironment(environment);
+    }
+
+    ....
+}
+
+```
+
+#### 2\. ���� ioc �IJ�������
+
+���������� `postProcessApplicationContext(context);` ����������
+
+```
+public class SpringApplication {
+
+    ...
+
+    protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
+        // ���� beanNameGenerator���������� bean �����ƣ����ﴫ�����null
+        if (this.beanNameGenerator != null) {
+            context.getBeanFactory().registerSingleton(
+                    AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
+                    this.beanNameGenerator);
+        }
+        // ���� resourceLoader����ز���������Ϊnull��if��Ĵ��벻��ִ��
+        if (this.resourceLoader != null) {
+            if (context instanceof GenericApplicationContext) {
+                ((GenericApplicationContext) context).setResourceLoader(this.resourceLoader);
+            }
+            if (context instanceof DefaultResourceLoader) {
+                ((DefaultResourceLoader) context).setClassLoader(
+                        this.resourceLoader.getClassLoader());
+            }
+        }
+        // �����ִ��
+        if (this.addConversionService) {
+            // ��������ת���������StringתNumber��
+            context.getBeanFactory().setConversionService(
+                    ApplicationConversionService.getSharedInstance());
+        }
+    }
+
+    ...
+
+}
+
+```
+
+�ⲿ�־������� `ApplicationContext` �ļ������ԣ������ǵ� demo �У�`beanNameGenerator` �� `resourceLoader` ���� `null`����������鶼�������У������еľ�ֻ�������룺
+
+```
+ context.getBeanFactory().setConversionService(
+        ApplicationConversionService.getSharedInstance());
+
+```
+
+`ConversionService` ��ǰ��Ҳ�ᵽ��������Ҫ���������в�������ת���ġ�
+
+#### 3\. Ӧ�ó�ʼ������`applyInitializers(context)`
+
+`SpringApplication#applyInitializers` �������£�
+
+```
+public class SpringApplication {
+
+    ...
+
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    protected void applyInitializers(ConfigurableApplicationContext context) {
+        // getInitializers()����ȡ���еij�ʼ����
+        for (ApplicationContextInitializer initializer : getInitializers()) {
+            Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(),
+                    ApplicationContextInitializer.class);
+            Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
+            // ��һ����initializer��initialize(...)����
+            initializer.initialize(context);
+        }
+    }
+
+}
+
+```
+
+���������Ǻ������ģ����ǻ�ȡ���е� `Initializer`��Ȼ���������������� `initialize(...)` ������
+
+���ﻹ��Ҫ���£�`getInitializers()` ����ô��ȡ `Initializer` ���أ���ش������£�
+
+```
+public class SpringApplication {
+
+    private List<ApplicationContextInitializer<?>> initializers;
+
+    ...
+
+    // �ڹ��췽�������õ� initializers
+    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
+        ...
+
+        // ���ó�ʼ������getSpringFactoriesInstances���� META-INF/spring.factories �л�ȡ����
+        setInitializers((Collection) getSpringFactoriesInstances(
+                ApplicationContextInitializer.class));
+
+        ...
+    }
+
+    // ��ȡ Initializer �IJ������������л�ȡ
+    public Set<ApplicationContextInitializer<?>> getInitializers() {
+        return asUnmodifiableOrderedSet(this.initializers);
+    }
+
+    ...
+
+```
+
+���˴���������ˣ���ǰ����� `SpringApplication` �Ĺ��췽��ʱ�������ᵽ springboot ��� `META-INF/spring.factories` ��ȡ���õ� `Initializer`���������õ� `initializers` ���ԣ����������ʹ�� `Initializer` �ĵط��ˡ�
+
+#### 4\. ��ȡ������Դ
+
+�������£�
+
+```
+private void prepareContext(ConfigurableApplicationContext context, 
+        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, 
+        ApplicationArguments applicationArguments, Banner printedBanner) {
+    ...
+    // ��ȡ������Դ
+    Set<Object> sources = getAllSources();
+    ...
+}
+
+```
+
+���� `getAllSources()` ������
+
+```
+// �� primarySources ����set�У�Ȼ��setת��Ϊ���ɱ��set������
+public Set<Object> getAllSources() {
+    Set<Object> allSources = new LinkedHashSet<>();
+    if (!CollectionUtils.isEmpty(this.primarySources)) {
+        allSources.addAll(this.primarySources);
+    }
+    // sources Ϊ�գ�if��ִ��
+    if (!CollectionUtils.isEmpty(this.sources)) {
+        allSources.addAll(this.sources);
+    }
+    return Collections.unmodifiableSet(allSources);
+}
+
+```
+
+��������ܼ򵥣���һ�������� `primarySources` ���� `set` �У�Ȼ�� `set` ת��Ϊ���ɱ�� `set`�����ء�
+
+����� `primarySources` ��ɶ�أ������Ҫ�ص� `SpringApplication` �Ĺ��췽���ˣ�
+
+```
+public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
+    ...
+    // ���������� primarySources
+    Assert.notNull(primarySources, "PrimarySources must not be null");
+    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
+    ...
+}
+
+```
+
+Ȼ��������ϣ������ `primarySources` �������� `main` �����д���ģ�
+
+```
+@SpringBootApplication
+public class Demo01Application {
+
+    public static void main(String[] args) {
+        // Demo01Application.class ���� primarySources
+        SpringApplication.run(Demo01Application.class, args);
+    }
+
+}
+
+```
+
+���Ǵ���� `Demo01Application.class` ���� `primarySources`��
+
+��ˣ�`getAllSources()` ������һ�� set��set ��ֻ��һ��Ԫ�أ�`Demo01Application.class`������Ҳ����ͨ����������֤��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-29dd8056dc457c56e6fe41020516d02fe80.png)
+
+#### 5\. ������Դ
+
+��������Ĵ������£�
+
+```
+private void prepareContext(ConfigurableApplicationContext context, 
+        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, 
+        ApplicationArguments applicationArguments, Banner printedBanner) {
+    ...
+    // ���� class
+    load(context, sources.toArray(new Object[0]));
+    ...
+}
+
+```
+
+���� `SpringApplication#load` ������
+
+```
+public class SpringApplication {
+    ...
+
+    protected void load(ApplicationContext context, Object[] sources) {
+        // ����һ��BeanDefinition�ļ�����
+        BeanDefinitionLoader loader = createBeanDefinitionLoader(
+                getBeanDefinitionRegistry(context), sources);
+        // ��ǰ beanNameGenerator Ϊ null��������
+        if (this.beanNameGenerator != null) {
+            loader.setBeanNameGenerator(this.beanNameGenerator);
+        }
+        // ��ǰ resourceLoader Ϊ null��������
+        if (this.resourceLoader != null) {
+            loader.setResourceLoader(this.resourceLoader);
+        }
+        // ��ǰ environment Ϊ null��������
+        // ǰ�洴����environment��û�и�ֵ����Ա����
+        if (this.environment != null) {
+            loader.setEnvironment(this.environment);
+        }
+        loader.load();
+    }
+    ...
+}
+
+```
+
+����������Ǵ�����һ�� `BeanDefinitionLoader` ʵ���������ȡ�� `source` ���� `BeanDefinitionLoader` �Ĺ��췽���д��뵽ʵ���У�Ȼ��Ը� `loader` ����һϵ�е��������ã�����ٵ����� `load()` ������������Ҫ˵�����ǣ���Ȼǰ�洴���� `environment`���� `this.environment` ����Ϊ `null`��ԭ����ǰ�洴���� `environment` ��û�и�ֵ�� `this.environment`��
+
+���Ǽ��������� `BeanDefinitionLoader#load()`��
+
+```
+class BeanDefinitionLoader {
+
+    ...
+
+    int load() {
+        int count = 0;
+        // ����� sources �о�ֻ��һ��Ԫ�أ�Demo01Application.class
+        for (Object source : this.sources) {
+            count += load(source);
+        }
+        return count;
+    }
+
+    // �������ز���
+    private int load(Object source) {
+        Assert.notNull(source, "Source must not be null");
+        // Class �������������
+        if (source instanceof Class<?>) {
+            // source Ϊ Demo01Application.class��������Ҫ��ע�������
+            return load((Class<?>) source);
+        }
+        if (source instanceof Resource) {
+            return load((Resource) source);
+        }
+        if (source instanceof Package) {
+            return load((Package) source);
+        }
+        if (source instanceof CharSequence) {
+            return load((CharSequence) source);
+        }
+        throw new IllegalArgumentException("Invalid source type " + source.getClass());
+    }
+
+    // Class ���͵ļ��ز���
+    private int load(Class<?> source) {
+        // ���� grouovy ���Եģ����ù�
+        if (isGroovyPresent() && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
+            GroovyBeanDefinitionSource loader 
+                    = BeanUtils.instantiateClass(source, GroovyBeanDefinitionSource.class);
+            load(loader);
+        }
+        // �Ƿ��� @Component ע��
+        if (isComponent(source)) {
+            // ���������� BeanDefinition ���󣬲�ע�ᵽspring��
+            this.annotatedReader.register(source);
+            return 1;
+        }
+        return 0;
+    }
+    ...
+
+```
+
+�ڴ��� `BeanDefinitionLoader` ʵ��ʱ��ͨ���乹�췽���� `sources` ������ `BeanDefinitionLoader` ��ʵ���У�`sources` �о�ֻ��һ��Ԫ�أ�`Demo01Application.class`���������ֻ���ע `Class` ������Դ�ļ��ؾͿ����ˣ����յ��� `BeanDefinitionLoader#load(java.lang.Class<?>)` �������÷��������IJ���Ϊ���жϴ���� `Class` �Ƿ��� `@Component`������оͽ���ע�ᵽ ioc �����С�
+
+��ô `Demo01Application.class` �Ƿ��� `@Component` ע���أ��еģ��������صñȽ����ע��㼶���£�
+
+```
+@SpringBootApplication
+public class Demo01Application {
+    ...
+}
+
+```
+
+���� `@SpringBootApplication`��
+
+```
+...
+@SpringBootConfiguration
+...
+public @interface SpringBootApplication {
+    ...
+}
+
+```
+
+�������� `@SpringBootApplication`��
+
+```
+...
+@Configuration
+public @interface SpringBootConfiguration {
+    ...
+}
+
+```
+
+�������� `@Configuration`��
+
+```
+...
+@Component
+public @interface Configuration {
+    ...
+}
+
+```
+
+�������ز��ۣ������� `@Configuration` ע�����ҵ��� `@Component`.
+
+���� `this.annotatedReader.register(source)` ע��ľ������������� [spring ����](https://my.oschina.net/funcy/blog/4527454)�У��Ѿ��������ˣ�����Ͳ��ٷ����ˡ�
+
+����ƪ�������ľ͵������ˣ���ƪ��������ʣ�µ����̡�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-fba95ddd84c68cdd1757f060ab131478a3c.png)
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4884127](https://my.oschina.net/funcy/blog/4884127) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\272\214\357\274\211\357\274\232\345\207\206\345\244\207\350\277\220\350\241\214\347\216\257\345\242\203.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\272\214\357\274\211\357\274\232\345\207\206\345\244\207\350\277\220\350\241\214\347\216\257\345\242\203.md"
new file mode 100644
index 0000000..4fceb03
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\272\214\357\274\211\357\274\232\345\207\206\345\244\207\350\277\220\350\241\214\347\216\257\345\242\203.md"
@@ -0,0 +1,508 @@
+�����ģ����Ǽ������������Ľ�����`SpringApplication#run(String...)`������
+
+## 3.`springboot`������`SpringApplication#run(String...)`
+
+�����������£�
+
+```
+public ConfigurableApplicationContext run(String... args) {
+    // 1\. ���� StopWatch ʵ������ʵ���Ǹ���ʱ��������ͳ��springboot������ʱ
+    StopWatch stopWatch = new StopWatch();
+    stopWatch.start();
+    // ׼���յ�ApplicationContext���Լ�һ���쳣������
+    ConfigurableApplicationContext context = null;
+    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
+    // 2\. ����һ��ϵͳ���ԣ�java.awt.headless��java.awt.headlessģʽ��ϵͳ��һ������ģʽ��
+    // ��ϵͳ����ȱ����ʾ�豸�����̻������Щ���������¿���ʹ�ø�ģʽ
+    configureHeadlessProperty();
+    // 3\. ��ȡ��������Ҳ�Ǵ� META-INF/spring.factories �л�ȡ
+    SpringApplicationRunListeners listeners = getRunListeners(args);
+    // starting()���״�����run����ʱ�������á������ڷdz����ڵij�ʼ����׼������ʱ����֮ǰ����
+    // 4\. �����¼�
+    listeners.starting();
+    try {
+        // ��װ����IJ���
+        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
+        // 5\. ������������
+        ConfigurableEnvironment environment 
+                = prepareEnvironment(listeners, applicationArguments);
+        // 6\. ��������� spring.beaninfo.ignore���򽫸��������ý�ϵͳ����
+        configureIgnoreBeanInfo(environment);
+        // 7\. ���banner
+        Banner printedBanner = printBanner(environment);
+        // 8\. ����applicationContext
+        context = createApplicationContext();
+        // �������󱨸���Զ���ص��ӿ�
+        exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
+                new Class[] { ConfigurableApplicationContext.class }, context);
+        // 9\. ׼�������ģ�������һϵ�е�����ֵ
+        prepareContext(context, environment, listeners, applicationArguments, printedBanner);
+        // 10\. ���� AbstractApplicationContext.refresh������spring����
+        refreshContext(context);
+        // 11\. ˢ�º�Ĵ���
+        afterRefresh(context, applicationArguments);
+        stopWatch.stop();
+        if (this.logStartupInfo) {
+            new StartupInfoLogger(this.mainApplicationClass)
+                .logStarted(getApplicationLog(), stopWatch);
+        }
+        // 12\. �����¼�
+        listeners.started(context);
+        // 13\. ���� runner��ʵ���� ApplicationRunner��CommandLineRunner �Ľӿ�
+        callRunners(context, applicationArguments);
+    }
+    catch (Throwable ex) {
+        handleRunFailure(context, ex, exceptionReporters, listeners);
+        throw new IllegalStateException(ex);
+    }
+    try {
+        // 14\. �����¼�
+        listeners.running(context);
+    }
+    catch (Throwable ex) {
+        handleRunFailure(context, ex, exceptionReporters, null);
+        throw new IllegalStateException(ex);
+    }
+    return context;
+}
+
+```
+
+���������������£�
+
+![](https://oscimg.oschina.net/oscnet/up-07a6b491fbe69b8dcbd41e59a8543f06671.png)
+
+�������������ص������ 13 ���������̡�
+
+### 3.1`stopWatch`��������ʱ��������
+
+һ��ʼ��springboot �ʹ�����`stopWatch`ʵ����Ȼ�����`StopWatch#start()`������ʱ���ܣ����������ûɶ��˵�ģ������Ǹ���ʱ������������������ springboot ������ʱ��������־�е�ʱ������������ʱ���õ��ģ�
+
+![](https://oscimg.oschina.net/oscnet/up-70a9e95e6c1208288334341bdb54bd59c17.png)
+
+### 3.2 ����`java.awt.headless`����ֵ
+
+`SpringApplication#configureHeadlessProperty`��������ش������£�
+
+```
+public class SpringApplication {
+
+    private static final String SYSTEM_PROPERTY_JAVA_AWT_HEADLESS = "java.awt.headless";
+
+    ...
+
+    private boolean headless = true;
+
+    public void setHeadless(boolean headless) {
+        this.headless = headless;
+    }
+    ...
+
+    private void configureHeadlessProperty() {
+        // �� java.awt.headless ��ֵ���õ�ϵͳ����
+        System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,
+                System.getProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, 
+                Boolean.toString(this.headless)));
+    }
+    ...
+}
+
+```
+
+������������ǽ�`java.awt.headless`��ֵ���õ���ϵͳ���������ó�`true`����ʾ����`java.awt.headless`ģʽ����ô���Ǹ�ɶģʽ�أ�����˵����ģʽ����ϵͳȱ������ʾ�豸�����̻����������ģʽ��������һ�㶼������������¹����ġ�
+
+### 3.3 ��ȡ���м�����
+
+��������һ���ǻ�ȡ���м����������Լ��������ڼ��һЩ״̬�������룺
+
+```
+// ��ȡ��������Ҳ�Ǵ� META-INF/spring.factories �л�ȡ
+SpringApplicationRunListeners listeners = getRunListeners(args);
+
+```
+
+����`SpringApplication#getRunListeners`��
+
+```
+public class SpringApplication {
+    ...
+
+    private SpringApplicationRunListeners getRunListeners(String[] args) {
+        Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
+        return new SpringApplicationRunListeners(logger,
+                // ��Ȼ�Ǵ�META-INF/spring.factories �л�ȡ��key �� SpringApplicationRunListener
+                getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));
+    }
+    ...
+}
+
+```
+
+���Կ�����`SpringApplicationRunListener`��Ȼ�Ǵ�`META-INF/spring.factories`�л�ȡ����`SpringApplicationRunListener`�Ǹ�ɶ�أ������������룺
+
+```
+public interface SpringApplicationRunListener {
+
+    /**
+     * �״�����run����ʱ�������á������ڷdz����ڵij�ʼ����
+     */
+    default void starting() {
+    }
+
+    /**
+     * ׼���û�����Environment������ɣ������ڴ���ApplicationContext֮ǰ���á�
+     */
+    default void environmentPrepared(ConfigurableEnvironment environment) {
+    }
+
+    /**
+     * �ڴ����͹���ApplicationContext֮�󣬵��ڼ���֮ǰ���á�
+     */
+    default void contextPrepared(ConfigurableApplicationContext context) {
+    }
+
+    /**
+     * ApplicationContext�Ѽ��ص���ˢ��֮ǰ���á�
+     */
+    default void contextLoaded(ConfigurableApplicationContext context) {
+    }
+
+    /**
+     * ApplicationContext��ˢ�£�Ӧ�ó�����������
+     * �������CommandLineRunners��ApplicationRunners��
+     */
+    default void started(ConfigurableApplicationContext context) {
+    }
+
+    /**
+     * �����з����������֮ǰ�������ã�
+     * ˢ��ApplicationContext����������CommandLineRunners��ApplicationRunner��
+     */
+    default void running(ConfigurableApplicationContext context) {
+    }
+
+    /**
+     * ������Ӧ�ó���ʱʧ��ʱ���á�
+     */
+    default void failed(ConfigurableApplicationContext context, Throwable exception) {
+    }
+}
+
+```
+
+`SpringApplicationRunListener`��һ���ӿڣ�������һϵ�еķ��������� springboot ���������̣�������˵���Ѿ����ĵ�������ϸ���壬���������Ҫ�� springboot �������е�ij��������һЩ���飬�Ϳ���ʵ��`SpringApplicationRunListener`Ȼ����д��Ӧ�ķ�����
+
+ͨ�����ԣ����� springboot ��õ����м��������£�
+
+![](https://oscimg.oschina.net/oscnet/up-3ed62d827b3bf1989af74f9c4db1fc0b9ce.png)
+
+### 3.4 �������������`listeners.starting()`
+
+�ص�`SpringApplication#run(java.lang.String...)`����ȡ�����м������󣬻���������`starting()`���������������¼���
+
+```
+// ��ȡ������
+SpringApplicationRunListeners listeners = getRunListeners(args);
+// starting()���״�����run����ʱ�������á������ڷdz����ڵij�ʼ����׼������ʱ����֮ǰ����
+listeners.starting();
+
+```
+
+����`SpringApplicationRunListeners#starting`������
+
+```
+void starting() {
+    for (SpringApplicationRunListener listener : this.listeners) {
+        listener.starting();
+    }
+}
+
+```
+
+���Կ�������ν�ķ����¼������DZ������еļ���������һ������`starting()`���ˣ�`this.listeners`���������ȡ�������е����м�������������ˣ�`SpringApplicationRunListener`������������`environmentPrepared(...)`��`contextPrepared(...)`�ȶ��������ĵ�����·�����濴���˾Ͳ��ظ������ˡ�
+
+### 3.5 ׼������ʱ����
+
+�����������������������Ĵ������������£�
+
+```
+// ��װ����IJ���
+ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
+// ������������
+ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
+
+```
+
+����`SpringApplication#prepareEnvironment`��
+
+```
+private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
+        ApplicationArguments applicationArguments) {
+    // ��ȡ����������������򴴽�
+    ConfigurableEnvironment environment = getOrCreateEnvironment();
+    // ��������ʱ����
+    configureEnvironment(environment, applicationArguments.getSourceArgs());
+    ConfigurationPropertySources.attach(environment);
+    //  SpringApplicationRunListener �� environmentPrepared ����
+    // ��Environment������ɣ����ڴ���ApplicationContext֮ǰ��
+    listeners.environmentPrepared(environment);
+    // ������Ӧ�ð�
+    bindToSpringApplication(environment);
+    if (!this.isCustomEnvironment) {
+        environment = new EnvironmentConverter(getClassLoader())
+                .convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
+    }
+    ConfigurationPropertySources.attach(environment);
+    return environment;
+}
+
+```
+
+���Կ������ֻ���׼�����������ص㽲��
+
+#### 1\. ��ȡ�򴴽�`Environment`
+
+ֱ�ӽ���`SpringApplication#getOrCreateEnvironment`��
+
+```
+private ConfigurableEnvironment getOrCreateEnvironment() {
+    if (this.environment != null) {
+        return this.environment;
+    }
+    switch (this.webApplicationType) {
+    case SERVLET:
+        return new StandardServletEnvironment();
+    case REACTIVE:
+        return new StandardReactiveWebEnvironment();
+    default:
+        return new StandardEnvironment();
+    }
+}
+
+```
+
+�Ӵ�����������������Ǹ���Ӧ��������������Ӧ��`Environment`ʵ������ǰӦ��������`SERVLET`������ֱ�ӿ�`StandardServletEnvironment`����δ����ġ�
+
+����֪������ java �У�������ʱ�����ȵ��ø���Ĺ��췽������������ֱ�ӽ���`AbstractEnvironment`���췽����
+
+```
+
+public abstract class AbstractEnvironment implements ConfigurableEnvironment {
+
+    ...
+
+    public AbstractEnvironment() {
+        customizePropertySources(this.propertySources);
+    }
+
+    ...
+}
+
+```
+
+������`AbstractEnvironment`�Ĺ��췽���У�������`customizePropertySources()`�������������`StandardServletEnvironment`ʵ�֣�
+
+```
+public class StandardServletEnvironment extends StandardEnvironment 
+        implements ConfigurableWebEnvironment {
+    public static final String SERVLET_CONTEXT_PROPERTY_SOURCE_NAME = "servletContextInitParams";
+    public static final String SERVLET_CONFIG_PROPERTY_SOURCE_NAME = "servletConfigInitParams";
+    public static final String JNDI_PROPERTY_SOURCE_NAME = "jndiProperties";
+
+    @Override
+    protected void customizePropertySources(MutablePropertySources propertySources) {
+        // ���� servletConfigInitParams
+        propertySources.addLast(new StubPropertySource(SERVLET_CONFIG_PROPERTY_SOURCE_NAME));
+        // ���� servletContextInitParams
+        propertySources.addLast(new StubPropertySource(SERVLET_CONTEXT_PROPERTY_SOURCE_NAME));
+        if (JndiLocatorDelegate.isDefaultJndiEnvironmentAvailable()) {
+            propertySources.addLast(new JndiPropertySource(JNDI_PROPERTY_SOURCE_NAME));
+        }
+        // ���ø���ķ���
+        super.customizePropertySources(propertySources);
+    }
+
+    @Override
+    public void initPropertySources(@Nullable ServletContext servletContext, 
+            @Nullable ServletConfig servletConfig) {
+        // �滻�������õ� servletContextInitParams Ϊ servletContext
+        // �滻�������õ� servletConfigInitParams Ϊ servletConfig
+        WebApplicationContextUtils.initServletPropertySources(
+                getPropertySources(), servletContext, servletConfig);
+    }
+
+}
+
+```
+
+���Կ�����`StandardServletEnvironment`��`customizePropertySources()`����ֻ�������˼��� servlet ��صIJ�����Ȼ���ȥ���ø���Ĺ��췽���ˣ����Ǽ�������`StandardEnvironment`��
+
+������ƺ���û����ʲô�����Ǽ���׷�٣���������Ĺ��췽����
+
+```
+public class StandardEnvironment extends AbstractEnvironment {
+
+    /** ϵͳ���� */
+    public static final String SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME = "systemEnvironment";
+
+    /** ϵͳ���� */
+    public static final String SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME = "systemProperties";
+
+    @Override
+    protected void customizePropertySources(MutablePropertySources propertySources) {
+        // ��ȡϵͳ���ԣ����õ��� System.getenv()
+        propertySources.addLast(new PropertiesPropertySource(
+                SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
+        // ��ȡϵͳ���������õ��� System.getProperties()
+        propertySources.addLast(new SystemEnvironmentPropertySource(
+                SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
+    }
+
+}
+
+```
+
+���Կ�����`StandardEnvironment`��`customizePropertySources()`������Ҫ�ǽ�ϵͳ������ϵͳ�������ӵ�`Environment`�С���ʵ���ϣ�`Environment`�а����������ϵͳ�뻷����صIJ���������Ҳ�ṩ��һЩ`getter`�������Ժܷ���ػ�ȡ��Щ������
+
+![](https://oscimg.oschina.net/oscnet/up-d2d69692db15146f2981db94633e7c575d5.png)
+
+��������Ǿ������ˣ�`StandardServletEnvironment`�а������������ݣ�
+
+*   ϵͳ���ԣ�����ƽʱ����`System.getenv()`�õ��IJ�����
+*   ϵͳ����������ƽʱ����`System.getProperties()`�õ��IJ�����
+*   `servlet`��`servletContext`��`servletConfig`.
+
+#### 2\. ���û���
+
+���Ǽ������������ſ������û��������̣�Ҳ����`SpringApplication#configureEnvironment`������
+
+```
+protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
+    if (this.addConversionService) {
+        // ����ת������������������ת������ StringתNumber��IntegerתEnum��
+        ConversionService conversionService = ApplicationConversionService.getSharedInstance();
+        environment.setConversionService((ConfigurableConversionService) conversionService);
+    }
+    // �������������ӵ� environment ��
+    configurePropertySources(environment, args);
+    // ���� ActiveProfiles ֵ
+    configureProfiles(environment, args);
+}
+
+```
+
+����������벻�࣬�ؼ��㶼���ڴ�����ע������ˣ�������Ҫ��΢����`SpringApplication#configurePropertySources`��
+
+```
+protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {
+    MutablePropertySources sources = environment.getPropertySources();
+    // ����Ĭ�����ԣ����ָ����Ĭ�����ԣ�������������
+    if (this.defaultProperties != null && !this.defaultProperties.isEmpty()) {
+        sources.addLast(new MapPropertySource("defaultProperties", this.defaultProperties));
+    }
+    if (this.addCommandLineProperties && args.length > 0) {
+        String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
+        if (sources.contains(name)) {
+            PropertySource<?> source = sources.get(name);
+            CompositePropertySource composite = new CompositePropertySource(name);
+            composite.addPropertySource(
+                    // ��������ʱ����IJ���
+                    new SimpleCommandLinePropertySource("springApplicationCommandLineArgs", args));
+            composite.addPropertySource(source);
+            sources.replace(name, composite);
+        }
+        else {
+            sources.addFirst(new SimpleCommandLinePropertySource(args));
+        }
+    }
+}
+
+```
+
+������������Դ���IJ������н���������`SimpleCommandLinePropertySource`��
+
+```
+public class SimpleCommandLinePropertySource 
+        extends CommandLinePropertySource<CommandLineArgs> {
+
+    public SimpleCommandLinePropertySource(String... args) {
+        super(new SimpleCommandLineArgsParser().parse(args));
+    }
+    ...
+}
+
+```
+
+���ս����ķ�����`SimpleCommandLineArgsParser#parse`��
+
+```
+public class SimpleCommandLineArgsParser {
+    public CommandLineArgs parse(String... args) {
+        CommandLineArgs commandLineArgs = new CommandLineArgs();
+        for (String arg : args) {
+            if (arg.startsWith("--")) {
+                String optionText = arg.substring(2, arg.length());
+                String optionName;
+                String optionValue = null;
+                if (optionText.contains("=")) {
+                    // -- ��ͷ�Ұ��� = �IJ������ᱻ������ key/value
+                    optionName = optionText.substring(0, optionText.indexOf('='));
+                    optionValue = optionText.substring(optionText.indexOf('=')+1, optionText.length());
+                }
+                else {
+                    optionName = optionText;
+                }
+                if (optionName.isEmpty() || (optionValue != null && optionValue.isEmpty())) {
+                    throw new IllegalArgumentException("Invalid argument syntax: " + arg);
+                }
+                commandLineArgs.addOptionArg(optionName, optionValue);
+            }
+            else {
+                commandLineArgs.addNonOptionArg(arg);
+            }
+        }
+        return commandLineArgs;
+    }
+
+    ...
+}
+
+```
+
+�����������DZȽϼ򵥵ģ������ַ����Ĵ������ѡ�
+
+springboot ������������ɶ�ý������أ������� spring ��Ŀʱ�����ǿ�������ָ��������
+
+```
+java -jar xxx.jar --a1=aaa --b1=bbb
+
+```
+
+Ȼ�����Ǿ���ͨ��`@Value("${a1}")`��ȡ�����ؼ�������������Կ�����springboot ��Ѵ����`--a1=aaa`��`--b1=bbb`������`a1/aaa`��`b1/bbb`��ֵ�Ե���ʽ�����浽`Environment`������Ҫ�õ�ʱ���Ϳɺܷ���ش�`Environment`�л�ȡ�ˡ�
+
+���ˣ�׼�������ķ����͵������ˡ�
+
+### 3.6 ����ϵͳ����
+
+�����Ҫ��������һ��������`spring.beaninfo.ignore`�����������Ƿ�����`BeanInfo`���������`������Դ���֪Ĭ��ֵ��true`���о��õIJ��࣬�Ͳ������ˡ�
+
+### 3.7 ��ӡ`banner`
+
+`banner`���������ӡ���ģ�
+
+```
+Banner printedBanner = printBanner(environment);
+
+```
+
+����Ҳ�����Լ����� banner��������Ͻ̳�һ��ѣ�demo �Ͳ��ṩ�ˡ�
+
+����`banner`���� springboot ���������̹�ϵ���󣬾Ͳ������ˣ�С�����ֻ���˽���ô���ü��ɡ�
+
+���ˣ�����ƪ�������ľ͵������ˣ���ƪ���Ǽ�����
+
+![](https://oscimg.oschina.net/oscnet/up-38d3824690292937a6b0cba5b081c8f8fec.png)
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4882417](https://my.oschina.net/funcy/blog/4882417)���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\272\224\357\274\211\357\274\232\345\256\214\346\210\220\345\220\257\345\212\250.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\272\224\357\274\211\357\274\232\345\256\214\346\210\220\345\220\257\345\212\250.md"
new file mode 100644
index 0000000..8e6b041
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\272\224\357\274\211\357\274\232\345\256\214\346\210\220\345\220\257\345\212\250.md"
@@ -0,0 +1,108 @@
+��һƪ�����ܽ� springboot �����������£�
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-07a6b491fbe69b8dcbd41e59a8543f06671.png)
+
+�����ģ����Ǽ��������������IJ��衣
+
+### 3.11 ˢ�º�Ĵ���
+
+ˢ�º�Ĵ�������Ϊ `SpringApplication#afterRefresh`���������£�
+
+```
+protected void afterRefresh(ConfigurableApplicationContext context, ApplicationArguments args) {
+}
+```
+
+���Կ���������һ���շ�����springboot �ṩ����չ��
+
+### 3.12 ���� `started` �¼�
+
+�ò����ķ���Ϊ `listeners.started(context)`�������߼�ǰ���Ѿ�������������Ͳ��ٷ����ˡ�
+
+### 3.13 �������ص�
+
+�����������ķ����� `SpringApplication#callRunners`���������£�
+
+```
+private void callRunners(ApplicationContext context, ApplicationArguments args) {
+    List<Object> runners = new ArrayList<>();
+    // ��ȡ���е� ApplicationRunner �� CommandLineRunner
+    runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
+    runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
+    // ����
+    AnnotationAwareOrderComparator.sort(runners);
+    // ��������
+    for (Object runner : new LinkedHashSet<>(runners)) {
+        // ���� ApplicationRunner#run ����
+        if (runner instanceof ApplicationRunner) {
+            callRunner((ApplicationRunner) runner, args);
+        }
+        // ���� CommandLineRunner#run ����
+        if (runner instanceof CommandLineRunner) {
+            callRunner((CommandLineRunner) runner, args);
+        }
+    }
+}
+
+/**
+ * ���� ApplicationRunner#run ����
+ */
+private void callRunner(ApplicationRunner runner, ApplicationArguments args) {
+    try {
+        (runner).run(args);
+    }
+    catch (Exception ex) {
+        throw new IllegalStateException("Failed to execute ApplicationRunner", ex);
+    }
+}
+
+/**
+ * ���� CommandLineRunner#run ����
+ */
+private void callRunner(CommandLineRunner runner, ApplicationArguments args) {
+    try {
+        (runner).run(args.getSourceArgs());
+    }
+    catch (Exception ex) {
+        throw new IllegalStateException("Failed to execute CommandLineRunner", ex);
+    }
+}
+```
+
+������������ʾ��springboot Ϊ�����ṩ�������ӿڣ�`ApplicationRunner` �� `CommandLineRunner`�����ǿ���ʵ���������һЩ������Ӧ��ʾ�����£�
+
+```
+/**
+ * ApplicationRunner ʾ��
+ */
+@Component
+public class MyApplicationRunner implements ApplicationRunner {
+    @Override
+    public void run(ApplicationArguments args) throws Exception {
+        System.out.println("MyApplicationRunner: hello world");
+    }
+}
+
+/**
+ * CommandLineRunner ʾ��
+ */
+@Component
+public class MyCommandLineRunner implements CommandLineRunner {
+    @Override
+    public void run(String... args) throws Exception {
+        System.out.println("MyCommandLineRunner: hello world!");
+    }
+}
+```
+
+### 3.14 ������������� `listeners.running(...)`
+
+�������������ͬǰ������� `listeners.starting()` ��·һ��������Ͳ������ˡ�
+
+���ˣ����ĵķ����͵������ˣ����� springboot ���������̵ķ���Ҳ�������ˡ�
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-9b539b547c6004c40d2b6f8bd59481b8e34.png)
+
+------
+
+*����ԭ�����ӣ�https://my.oschina.net/funcy/blog/4906553 ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������*
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\205\255\357\274\211\357\274\232\345\220\257\345\212\250\346\265\201\347\250\213\346\200\273\347\273\223.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\205\255\357\274\211\357\274\232\345\220\257\345\212\250\346\265\201\347\250\213\346\200\273\347\273\223.md"
new file mode 100644
index 0000000..8b2d0ee
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\205\255\357\274\211\357\274\232\345\220\257\345\212\250\346\265\201\347\250\213\346\200\273\347\273\223.md"
@@ -0,0 +1,41 @@
+ǰ�漸ƪ���·��� springboot ���������̣��������ܽ��¡�
+
+����һ��ʼ���� `SpringApplication.run(Demo01Application.class, args);` �������֣����ط���������������
+
+*   `SpringApplication#SpringApplication(...)`
+*   `SpringApplication#run(...)`
+
+���������������� springboot �������������̣�����������һ�ܽ��� ��
+
+### `SpringApplication#SpringApplication(...)`
+
+����������������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-e9a43f1c523c0f19d37e4741580ed32ca08.png)
+
+����
+
+*   `webApplicationType` ���ں����������ʲô���͵� `applicationContext`��
+*   `Initialzers` ������ `META-INF/spring.factories`������ springboot ����ʱ��һЩ��ʼ��������
+*   `Listteners` ͬ�������� `META-INF/spring.factories`���ṩ�˶�����������Է���ؼ��� springboot ��ִ�й��̡�
+
+### `SpringApplication#run(...)`
+
+�ⲿ�ֵ��������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-07a6b491fbe69b8dcbd41e59a8543f06671.png)
+
+����
+
+*   `getRunListener()` ���ȡ���е� `Listeners`��Ҳ������ `SpringApplication#SpringApplication(...)` �� ��ȡ�� `Listeners`��`Listeners` ���ṩ���ڶ෽�����ɼ��� springboot ���������̣�
+*   ׼�����л���ʱ������� `webApplicationType` �����������������ã��õ���Ӧ���͵� `Environment` ������ �������������õ� spring �����У�spring ������ʹ�õ� `Environment` ���������ﴴ�������õģ�
+*   ���� ioc ����ʱ��Ҳ�Ǹ��� `webApplicationType` ��������������Ӧ�� `ApplicationContext`��
+*   ��׼�� ioc �����ķ����У���� `ApplicationContext` ��һ������ ��`Initializers` Ҳ�����������У�
+*   ���� ioc ����ʱ��springboot ��ע��һ�� shutdownhook����������Ŀ�ر�ʱ�����رղ��������⣬���� ioc ���������̣�springboot ������չ�лᴴ�������� web ������
+*   springboot �ṩ���������͵���������`ApplicationRunner`��`CommandLineRunner`�����������������ߵķ�����
+
+�������ݽ��ıȽϼ��ԣ����Ҫ��ϸ�˽⣬�������Ķ�ǰ������¡�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4906588](https://my.oschina.net/funcy/blog/4906588) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\233\233\357\274\211\357\274\232\345\220\257\345\212\250IOC\345\256\271\345\231\250.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\233\233\357\274\211\357\274\232\345\220\257\345\212\250IOC\345\256\271\345\231\250.md"
new file mode 100644
index 0000000..507a1a5
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\233\233\357\274\211\357\274\232\345\220\257\345\212\250IOC\345\256\271\345\231\250.md"
@@ -0,0 +1,389 @@
+��һƪ�����ܽ� springboot �����������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-07a6b491fbe69b8dcbd41e59a8543f06671.png)
+
+�����ģ����Ǽ��������������IJ��衣
+
+### 3.10 ˢ�� ioc ����
+
+���������������� `SpringApplication#refreshContext` ������
+
+```
+private void refreshContext(ConfigurableApplicationContext context) {
+    // ����spring����
+    refresh(context);
+    if (this.registerShutdownHook) {
+        try {
+            // ע�� ShutdownHook
+            context.registerShutdownHook();
+        }
+        catch (AccessControlException ex) {
+            // Not allowed in some environments.
+        }
+    }
+}
+
+```
+
+�������������������
+
+1.  `refresh(context)`������ spring ������Ҳ���ǵ��� `AbstractApplicationContext#refresh` ������
+2.  `context.registerShutdownHook()`��ע�� `ShutdownHook`�������� jvm ���̹ر�ʱ����һЩ�ض��IJ�����
+
+#### 3.10.1 ���� spring ����
+
+���� `SpringApplication#refresh`��
+
+```
+protected void refresh(ApplicationContext applicationContext) {
+    Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
+    // spring ����������������
+    ((AbstractApplicationContext) applicationContext).refresh();
+}
+
+```
+
+��������ܼ򵥣����ж� `applicationContext` �������Ƿ�Ϊ `AbstractApplicationContext`��Ȼ���ٵ��� `AbstractApplicationContext#refresh()`��
+
+���� `AbstractApplicationContext#refresh()`���ǿ��Ǵ������������÷��������� spring �������������̡����ڱ��IJ��Ƿ��� spring �����£�������Ͳ�չ�������ˣ���Ҫ�˽���������̵�С�����Բο��������£�
+
+*   [��spring Դ�������spring �������̣��ģ�������ǰ��׼������](https://my.oschina.net/funcy/blog/4633169)
+*   [��spring Դ�������spring �������̣��壩��ִ�� BeanFactoryPostProcessor](https://my.oschina.net/funcy/blog/4641114)
+*   [��spring Դ�������spring �������̣�������ע�� BeanPostProcessor](https://my.oschina.net/funcy/blog/4657181)
+*   [��spring Դ�������spring �������̣��ߣ������ʻ����¼�����](https://my.oschina.net/funcy/blog/4892120)
+*   [��spring Դ�������spring �������̣��ˣ������ BeanFactory �ij�ʼ��](https://my.oschina.net/funcy/blog/4658230)
+*   [��spring Դ�������spring �������̣��ţ������� bean �Ĵ���](https://my.oschina.net/funcy/blog/4659524)
+*   [��spring Դ�������spring �������̣�ʮ����������ɵĴ���](https://my.oschina.net/funcy/blog/4892555)
+
+�� `AbstractApplicationContext#refresh()` �У�spring �ṩ�˼�����չ�㣺
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-b86d0fb2e3790f63b5c6590884be9401354.png)
+
+���ǵ�ǰʹ�õ� `applicationContext` Ϊ `AnnotationConfigServletWebServerApplicationContext`������Ҳʹ������Щ��չ�㣬������Ҫ��ע��Щ��չ���Ӧ�á�
+
+##### 1\. ����ǰ׼����`prepareRefresh()`
+
+�������Է��֣�`initPropertySources()` ���������е������������£�
+
+```
+AbstractApplicationContext#refresh
+ |- AnnotationConfigServletWebServerApplicationContext#prepareRefresh
+  |- AbstractApplicationContext#prepareRefresh
+   |- GenericWebApplicationContext#initPropertySources
+
+```
+
+���յ��õ��� `GenericWebApplicationContext#initPropertySources`��
+
+```
+protected void initPropertySources() {
+    ConfigurableEnvironment env = getEnvironment();
+    if (env instanceof ConfigurableWebEnvironment) {
+        ((ConfigurableWebEnvironment) env).initPropertySources(this.servletContext, null);
+    }
+}
+
+```
+
+����������Ȼ�ȡ `Environment`��Ȼ���ж��Ƿ�Ϊ `ConfigurableWebEnvironment` ��ʵ������ǰ�����**׼������ʱ����**ʱ�����ǵõ��� `Environment` Ϊ `StandardServletEnvironment`���� `ConfigurableWebEnvironment` �ķ��ϣ�Ȼ����� `ConfigurableWebEnvironment#initPropertySources` ������������� `StandardServletEnvironment#initPropertySources`��
+
+```
+public void initPropertySources(@Nullable ServletContext servletContext, 
+        @Nullable ServletConfigservletConfig) {
+    // �滻�������õ� servletContextInitParams Ϊ servletContext
+    // �滻�������õ� servletConfigInitParams Ϊ servletConfig
+    WebApplicationContextUtils.initServletPropertySources(getPropertySources(), 
+        servletContext, servletConfig);
+}
+
+```
+
+����������Ǻܼ򵥣�ֻ�ǽ� `servletContext` �� `servletConfig` ���õ��� `Environment` �С�
+
+##### 2\. ��ȡ `beanFactory`: `obtainFreshBeanFactory()`
+
+��ǰ `applicationContext` �Ը÷�������չ����������
+
+##### 3\. ׼�� `beanFactory`: `prepareBeanFactory(beanFactory)`
+
+��ǰ `applicationContext` �Ը÷�������չ����������
+
+##### 4\. ��չ�㣺`postProcessBeanFactory(beanFactory)`
+
+`AnnotationConfigServletWebServerApplicationContext` ������������
+
+```
+@Override
+protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
+    // ���ø���ķ���
+    super.postProcessBeanFactory(beanFactory);
+    // ���а�ɨ�裬����İ���������
+    if (this.basePackages != null && this.basePackages.length > 0) {
+        this.scanner.scan(this.basePackages);
+    }
+    // ע��bean��Ϊ��
+    if (!this.annotatedClasses.isEmpty()) {
+        this.reader.register(ClassUtils.toClassArray(this.annotatedClasses));
+    }
+}
+
+```
+
+���������ִ�й������£�
+
+1.  �����˸���ķ��� `super.postProcessBeanFactory(beanFactory)`
+2.  ���а�ɨ�裬ͨ�����Է��֣������ `basePackages` Ϊ nul
+3.  ע�� `annotatedClasses`������� `annotatedClasses` Ϊ��
+
+������Ҫ������ `super.postProcessBeanFactory(beanFactory)`���÷����� `ServletWebServerApplicationContext` �У�
+
+```
+@Override
+protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
+    // ����һ�� BeanPostProcessor
+    beanFactory.addBeanPostProcessor(
+            new WebApplicationContextServletContextAwareProcessor(this));
+    // ���� ServletContextAware ���Զ�ע��
+    beanFactory.ignoreDependencyInterface(ServletContextAware.class);
+    // ע�� web bean �ķ�Χ�������ע��request��session��globalSession��������
+    registerWebApplicationScopes();
+}
+
+```
+
+����������ݱȽϼ򵥣���Ҫ��ע�� `BeanPostProcessor` �Լ�ע�� `web bean` �����÷�Χ������������Ҫ���� `WebApplicationContextServletContextAwareProcessor` �����ã��������£�
+
+```
+public class WebApplicationContextServletContextAwareProcessor 
+        extends ServletContextAwareProcessor {
+
+    private final ConfigurableWebApplicationContext webApplicationContext;
+
+    public WebApplicationContextServletContextAwareProcessor(
+            ConfigurableWebApplicationContext webApplicationContext) {
+        Assert.notNull(webApplicationContext, "WebApplicationContext must not be null");
+        this.webApplicationContext = webApplicationContext;
+    }
+
+    /**
+     * ��ȡ ServletContext
+     */
+    @Override
+    protected ServletContext getServletContext() {
+        ServletContext servletContext = this.webApplicationContext.getServletContext();
+        return (servletContext != null) ? servletContext : super.getServletContext();
+    }
+
+    /**
+     * ��ȡ ServletConfig
+     */
+    @Override
+    protected ServletConfig getServletConfig() {
+        ServletConfig servletConfig = this.webApplicationContext.getServletConfig();
+        return (servletConfig != null) ? servletConfig : super.getServletConfig();
+    }
+
+}
+
+```
+
+������ƺ���û����ʲô�������ٸ������࣬�������Ǹ� `BeanPostProcessor`��������Ҫ��ע���� `postProcessBeforeInitialization()` �� `postProcessAfterInitialization()` ����������
+
+```
+public class ServletContextAwareProcessor implements BeanPostProcessor {
+
+    ...
+
+    public Object postProcessBeforeInitialization(Object bean, 
+            String beanName) throws BeansException {
+        // ���� ServletContext
+        if (getServletContext() != null && bean instanceof ServletContextAware) {
+            ((ServletContextAware) bean).setServletContext(getServletContext());
+        }
+        // ���� ServletConfig
+        if (getServletConfig() != null && bean instanceof ServletConfigAware) {
+            ((ServletConfigAware) bean).setServletConfig(getServletConfig());
+        }
+        return bean;
+    }
+
+    @Override
+    public Object postProcessAfterInitialization(Object bean, String beanName) {
+        return bean;
+    }
+
+}
+
+```
+
+���Կ�������� `BeanPostProcessor` ���������� `ServletContextAware` �� `ServletConfigAware` ���� `Aware` �ӿڵģ���·ͬ���� `ApplicationAware`��`BeanFactoryAware` ��һ����
+
+##### 5\. ִ�� `BeanFactoryPostProcessors`: `invokeBeanFactoryPostProcessors(beanFactory)`
+
+��ǰ `applicationContext` �Ը÷�������չ����������
+
+ֵ��һ����ǣ�����������У��и��ص� `BeanFactoryPostProcessor` �ᱻִ�У�`ConfigurationClassPostProcessor`��springboot ���Զ�װ�������ע�� `@EnableAutoConfiguration` �������ﴦ�����Զ�װ����ļ��ء�����ע��Ҳ���� `ConfigurationClassPostProcessor` �С�
+
+##### 6\. ע�� `BeanPostProcessor`: `registerBeanPostProcessors(beanFactory)`
+
+��ǰ `applicationContext` �Ը÷�������չ����������
+
+##### 7\. ��ʼ��` MessageSource`(���ڹ��ʻ�����): `initMessageSource()`
+
+��ǰ `applicationContext` �Ը÷�������չ����������
+
+##### 8\. ��ʼ���¼��㲥����`initApplicationEventMulticaster()`
+
+��ǰ `applicationContext` �Ը÷�������չ����������
+
+##### 9\. ��չ�㣺`onRefresh()`
+
+��ǰ `applicationContext` �Ը÷�������չΪ `ServletWebServerApplicationContext#onRefresh` �������������£�
+
+```
+@Override
+protected void onRefresh() {
+    // ���ø��෽��
+    super.onRefresh();
+    try {
+        // ����web����������tomcat,jetty��
+        createWebServer();
+    }
+    catch (Throwable ex) {
+        throw new ApplicationContextException(...);
+    }
+}
+
+```
+
+���� ������web ������������������д����ġ����� web �������Ĵ��������򵥣���Ҫ�������������жϣ�����������Ǻ�������ϸ˵����
+
+##### 10\. ע���¼���������`registerListeners()`
+
+��ǰ `applicationContext` �Ը÷�������չ����������
+
+##### 11\. ��ʼ������ `bean`: `finishBeanFactoryInitialization(beanFactory)`
+
+��ǰ `applicationContext` �Ը÷�������չ����������
+
+##### 12\. �����������: `finishRefresh()`
+
+��ǰ `applicationContext` �Ը÷�������չΪ `ServletWebServerApplicationContext#finishRefresh` �������������£�
+
+```
+@Override
+protected void finishRefresh() {
+    super.finishRefresh();
+    // ����web����
+    WebServer webServer = startWebServer();
+    if (webServer != null) {
+        // ���� ServletWebServerInitializedEvent �¼�
+        publishEvent(new ServletWebServerInitializedEvent(webServer, this));
+    }
+}
+
+/**
+ * ����web����
+ */
+private WebServer startWebServer() {
+    WebServer webServer = this.webServer;
+    if (webServer != null) {
+        webServer.start();
+    }
+    return webServer;
+}
+
+```
+
+���Կ�������������������� web ������
+
+##### 13\. �������: `resetCommonCaches()`
+
+��ǰ `applicationContext` �Ը÷�������չ����������
+
+#### 3.10.2 ע�� `ShutdownHook`
+
+���������� `context.registerShutdownHook()`���÷����� `AbstractApplicationContext#registerShutdownHook` �ṩ��
+
+```
+public abstract class AbstractApplicationContext extends DefaultResourceLoader
+        implements ConfigurableApplicationContext {
+    ...
+    @Override
+    public void registerShutdownHook() {
+        if (this.shutdownHook == null) {
+            // ָ���̵߳�����
+            this.shutdownHook = new Thread(SHUTDOWN_HOOK_THREAD_NAME) {
+                @Override
+                public void run() {
+                    synchronized (startupShutdownMonitor) {
+                        // ������� ShutdownHook ������
+                        doClose();
+                    }
+                }
+            };
+            Runtime.getRuntime().addShutdownHook(this.shutdownHook);
+        }
+    }
+
+    /**
+     * ���������Ĺرղ���
+     */
+    protected void doClose() {
+        // Check whether an actual close attempt is necessary...
+        if (this.active.get() && this.closed.compareAndSet(false, true)) {
+            LiveBeansView.unregisterApplicationContext(this);
+
+            try {
+                // �����ر��¼�
+                publishEvent(new ContextClosedEvent(this));
+            }
+            catch (Throwable ex) {
+                logger.warn(...);
+            }
+
+            // ���� lifecycle �� onClose() ����
+            if (this.lifecycleProcessor != null) {
+                try {
+                    this.lifecycleProcessor.onClose();
+                }
+                catch (Throwable ex) {
+                    logger.warn(...);
+                }
+            }
+
+            // ���� bean
+            destroyBeans();
+
+            // �ر�����
+            closeBeanFactory();
+
+            // ��չ�㣬������ʵ��
+            onClose();
+
+            // ���������
+            if (this.earlyApplicationListeners != null) {
+                this.applicationListeners.clear();
+                this.applicationListeners.addAll(this.earlyApplicationListeners);
+            }
+
+            // ���� active ��ʶ
+            this.active.set(false);
+        }
+    }
+
+    ...
+
+}
+
+```
+
+���Կ�����`context.registerShutdownHook()` ʵ������������ `doClose()` �������������������Ĺرղ������ر� spring �����Ĺرգ�ע���Ѿ��൱����ˣ�����Ͳ������ˡ�
+
+���ˣ������������ͷ����������ˣ����������������� spring ���������������չ���� `onRefresh()` �� `finishRefresh()`��ǰ�ߴ����� `webServer` ���������������� `webServer` ������
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-81033ec78641ad875623cf452ef9cd62eb6.png)
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4888129](https://my.oschina.net/funcy/blog/4888129) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\350\207\252\345\212\250\350\243\205\351\205\215\357\274\210\344\270\200\357\274\211\357\274\232\345\212\240\350\275\275\350\207\252\345\212\250\350\243\205\351\205\215\347\261\273.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\350\207\252\345\212\250\350\243\205\351\205\215\357\274\210\344\270\200\357\274\211\357\274\232\345\212\240\350\275\275\350\207\252\345\212\250\350\243\205\351\205\215\347\261\273.md"
new file mode 100644
index 0000000..2dbdfc7
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\350\207\252\345\212\250\350\243\205\351\205\215\357\274\210\344\270\200\357\274\211\357\274\232\345\212\240\350\275\275\350\207\252\345\212\250\350\243\205\351\205\215\347\261\273.md"
@@ -0,0 +1,456 @@
+�Զ�װ���� springboot �ĺ���֮һ�����Ľ���̽�� springboot ����μ����Զ�װ����ġ�
+
+�� [@SpringBootApplication ע��](https://my.oschina.net/funcy/blog/4870882)һ���У������ᵽ springboot �����Զ�װ���ע���� `@EnableAutoConfiguration`���������£�
+
+```
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+// �Զ�װ��İ�
+@AutoConfigurationPackage
+// ������Զ�װ����
+@Import(AutoConfigurationImportSelector.class)
+public @interface EnableAutoConfiguration {
+
+    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
+
+    /**
+     * �����ж����ų��Զ�װ�����
+     */
+    Class<?>[] exclude() default {};
+
+    /**
+     * �����ж����ų��Զ�װ�������
+     */
+    String[] excludeName() default {};
+
+}
+
+```
+
+���ϴ�������������֣�
+
+1.  `@AutoConfigurationPackage`��ָ���Զ�װ��İ���
+2.  `@Import(AutoConfigurationImportSelector.class)`�������Զ�װ��Ĵ����� `AutoConfigurationImportSelector`����������Զ�װ��Ĺؼ����ڣ�
+3.  `@EnableAutoConfiguration` �����ԣ�`@EnableAutoConfiguration` �ṩ���������ԣ�`exclude` �� `excludeName`�����������ų�����Ҫ�Զ�װ����ࡣ
+
+�����ص������� `AutoConfigurationImportSelector` �ࡣ
+
+### 1. `AutoConfigurationImportSelector.AutoConfigurationGroup`
+
+`AutoConfigurationImportSelector` ʵ���� `DeferredImportSelector`������ `DeferredImportSelector` �ķ��������Բο� [ConfigurationClassPostProcessor ֮���� @Import ע��](https://my.oschina.net/funcy/blog/4678152)����������ֱ�Ӹ������ۣ�
+
+* `DeferredImportSelector` �� `ImportSelector` ���ӽӿڣ����ڲ���һ���ӿ� `Group`���ýӿڶ���������������
+
+  ```
+  public interface DeferredImportSelector extends ImportSelector {
+      ...
+  
+      interface Group {
+  
+          /**
+           * �����������
+           */
+          void process(AnnotationMetadata metadata, DeferredImportSelector selector);
+  
+          /**
+           * ���ص�����
+           */
+          Iterable<Entry> selectImports()
+      }
+  }
+  
+  ```
+
+  �ڴ��� `DeferredImportSelector` �ĵ�����ʱ��`DeferredImportSelector.Group#process` �������ȵ��ã�Ȼ���ٵ��� `DeferredImportSelector.Group#selectImports` ���ص����ࣻ
+
+* `DeferredImportSelector` ����ָ��������ķ��飬�ڴ���ʱ�����԰����鴦�������ࣻ
+
+* `DeferredImportSelector` �ڴ���������ʱ���Ƚ������ఴ�������һ�� `map` �У��ڴ��������������ࣨspring ��������Ϊ `@Component`��`@ComponentScan`��`@Import`��`@Configuration`��`@Bean` ��ǵ��ࣩ���������������еĵ����࣬Ҳ����˵��`DeferredImportSelector` ������࣬����������ע�ᵽ `beanFactory` �к��ٽ���ע�ᣨע��ǰ�����ж��ܷ�ע�ᵽ `beanFactory`�����ܲ�ע�ᣩ��
+
+���������� `AutoConfigurationImportSelector` �Ĵ��룺
+
+```
+// ʵ���� DeferredImportSelector
+public class AutoConfigurationImportSelector implements DeferredImportSelector, 
+        BeanClassLoaderAware,ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
+
+    ...
+
+    /**
+     * ����ʵ���� DeferredImportSelector.Group
+     */
+    private static class AutoConfigurationGroup implements DeferredImportSelector.Group, 
+            BeanClassLoaderAware, BeanFactoryAware, ResourceLoaderAware {
+
+        /**
+         * ���浼�����
+         */
+        private final List<AutoConfigurationEntry> autoConfigurationEntries = new ArrayList<>();
+
+        /**
+         * ����������
+         */
+        @Override
+        public void process(AnnotationMetadata annotationMetadata, 
+                DeferredImportSelector deferredImportSelector) {
+            Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
+                    () -> String.format("Only %s implementations are supported, got %s",
+                            AutoConfigurationImportSelector.class.getSimpleName(),
+                            deferredImportSelector.getClass().getName()));
+            // 1\. ���� AutoConfigurationImportSelector#getAutoConfigurationEntry(...) ������
+            // ����������������Զ�װ����
+            AutoConfigurationEntry autoConfigurationEntry = 
+                ((AutoConfigurationImportSelector) deferredImportSelector)
+                    .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
+            // 2\. ����ȡ���� autoConfigurationEntry ��������
+            this.autoConfigurationEntries.add(autoConfigurationEntry);
+            for (String importClassName : autoConfigurationEntry.getConfigurations()) {
+                this.entries.putIfAbsent(importClassName, annotationMetadata);
+            }
+        }
+
+        /**
+         * ���ص�����
+         */
+        @Override
+        public Iterable<Entry> selectImports() {
+            if (this.autoConfigurationEntries.isEmpty()) {
+                return Collections.emptyList();
+            }
+            // 3\. �õ�������
+            Set<String> allExclusions = this.autoConfigurationEntries.stream()
+                    .map(AutoConfigurationEntry::getExclusions).flatMap(Collection::stream)
+                    .collect(Collectors.toSet());
+            // 4\. �� autoConfigurationEntries ת��Ϊ LinkedHashSet
+            Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
+                    .map(AutoConfigurationEntry::getConfigurations).flatMap(Collection::stream)
+                    .collect(Collectors.toCollection(LinkedHashSet::new));
+            // 5\. ȥ����Ҫ���˵���
+            processedConfigurations.removeAll(allExclusions);
+            // 6\. ��������
+            return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata())
+                    .stream().map((importClassName) -> new Entry(
+                        this.entries.get(importClassName), importClassName))
+                    .collect(Collectors.toList());
+        }
+
+        ...
+    }
+
+}
+
+```
+
+�������ǽ� `DeferredImportSelector.Group#process` �� `DeferredImportSelector.Group#selectImports` ����������������������������ܽ�����:
+
+1.  ���� `AutoConfigurationImportSelector#getAutoConfigurationEntry(...)` ���������Զ�װ���ࣻ
+2.  ���õ����Զ�װ���ౣ�浽 `autoConfigurationEntries` �У�
+3.  �õ������࣬��Щ����������� `@EnableAutoConfiguration` �� `exclude` �� `excludeName` ָ���ģ�
+4.  �� `autoConfigurationEntries` ת��Ϊ `LinkedHashSet`�����Ϊ `processedConfigurations`��
+5.  ȥ�� `processedConfigurations` ��Ҫ���˵��ࣻ
+6.  ���� 5 ���õ���������󣬷��ء�
+
+���������Ƕ���Щ�ؼ�������з�����
+
+> �ر�˵����`DeferredImportSelector` �� `ImportSelector` ���ӽӿڣ�`ImportSelector` ����������ķ����� `selectImports(...)`���� `DeferredImportSelector` ��Ҳ��д�˸÷�����
+>
+> ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-75a2839c622af2d0f374189b2e2765a64d7.png)
+>
+> �������������Ҳ�Ǽ����Զ�װ���࣬�������յ�����࣬����Ҫע����ǣ�springboot ���Զ�������**����**�����ﴦ���ģ�������㣬�����ڷ����ڴ���ϵ㣬Ȼ��ͻᷢ�����������û�����е���
+>
+> ����������£�springboot ���Զ�������**����**�� `AutoConfigurationImportSelector#selectImports` �����д����ģ������� `AutoConfigurationImportSelector.AutoConfigurationGroup#selectImports` �����д����ġ�
+
+### 2\. ��ȡװ���ࣺ`AutoConfigurationImportSelector#getAutoConfigurationEntry`
+
+�Զ����� ��ļ��ش���Ϊ��
+
+```
+AutoConfigurationEntry autoConfigurationEntry = 
+    ((AutoConfigurationImportSelector) deferredImportSelector)
+        .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
+
+```
+
+�ô���������������Զ�װ����ģ�����ֱ�ӽ��� `AutoConfigurationImportSelector#getAutoConfigurationEntry` ������
+
+```
+protected AutoConfigurationEntry getAutoConfigurationEntry(
+        AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
+    // ��һ���ж��Ƿ����Զ�װ��
+    if (!isEnabled(annotationMetadata)) {
+        return EMPTY_ENTRY;
+    }
+    // ��ȡע�������
+    AnnotationAttributes attributes = getAttributes(annotationMetadata);
+    // 1\. ���غ�ѡ���Զ�������
+    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
+    // 2\. ȥ�أ�ת����set����ת����list
+    configurations = removeDuplicates(configurations);
+    // 3\. ȥ����Ҫ�ų����࣬��ʵ���Ǵ���@EnableAutoConfiguration��exclude��excludeName
+    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
+    checkExcludedClasses(configurations, exclusions);
+    configurations.removeAll(exclusions);
+    // 4\. ���˲���Ҫ�Զ�װ�����
+    configurations = filter(configurations, autoConfigurationMetadata);
+    // 5\. ���� AutoConfigurationImportEvent �¼�
+    fireAutoConfigurationImportEvents(configurations, exclusions);
+    // 6\. ���շ��ص�ֵ
+    return new AutoConfigurationEntry(configurations, exclusions);
+}
+
+```
+
+��������dz���Ҫ�������˻�ȡ�Զ�װ�����ȫ���������ò����������£�
+
+1. ���غ�ѡ���Զ�װ���࣬springboot �Զ�װ�����λ�� `classpath` �µ� `META-INF/spring.factories` �ļ��У�key Ϊ `org.springframework.boot.autoconfigure.EnableAutoConfiguration`��������Ǻ�������ϸ������
+
+2. ȥ���ظ����Զ�װ���࣬��һ�����صõ����Զ�װ������ܻ����ظ����������ȥ���ظ����࣬ȥ����ʽҲ�dz��򵥣�springboot ��ֻ����ת���� `Set`����ת���� `List`��
+
+3. ȥ���ų����࣬ǰ���ᵽ `@EnableAutoConfiguration` ����ͨ�� `exclude` �� `excludeName` ָ����Ҫ�ų����࣬��һ���������������������Եģ�
+
+4. ���˲���Ҫ�Զ�װ����࣬���ݱ��˵��ԣ����ֲ�û����ɹ��ˣ�
+
+   ����ǰ�� 124 ����
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-773695c0161c8126f239c2e66529fc8a394.png)
+
+   ���˺��� 124 ����
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-7144d971f729b5dfbddfeff2d3319c7705c.png)
+
+5. ���� `AutoConfigurationImportEvent` �¼���
+
+6. ���� 3 ���õ����ų������ 4 ���õ����Զ�װ�����װ�� `AutoConfigurationEntry` ���ء�
+
+ע�����һ�д��룺
+
+```
+// 6\. ���շ��ص�ֵ
+return new AutoConfigurationEntry(configurations, exclusions);
+
+```
+
+����� `configurations` �� `exclusions` �������� `AutoConfigurationEntry` �Ĺ��췽�������������� `AutoConfigurationEntry`��
+
+```
+protected static class AutoConfigurationEntry {
+    // �Զ�װ����
+    private final List<String> configurations;
+
+    // ��Ҫ�ų����Զ�װ����
+    private final Set<String> exclusions;
+
+    /**
+     * ���췽���������߽��и�ֵ
+     */
+    AutoConfigurationEntry(Collection<String> configurations, Collection<String> exclusions) {
+        this.configurations = new ArrayList<>(configurations);
+        this.exclusions = new HashSet<>(exclusions);
+    }
+
+    ...
+}
+
+```
+
+��Щ�ɼ������շ��ص� `AutoConfigurationEntry` �����������ݣ�
+
+*   `configurations`���Զ�װ���࣬�Ѿ�ȥ������Ҫ�ų�����
+*   `exclusions`��ͨ�� `@EnableAutoConfiguration` ָ������Ҫ�ų�����
+
+�����Զ�װ����Ļ�ȡ���������ˣ������������������غ�ѡ���Զ�װ��������̡�
+
+### 3\. ���غ�ѡ���Զ�װ����
+
+�Զ�װ����ļ���λ�� `AutoConfigurationImportSelector#getCandidateConfigurations`���������£�
+
+```
+protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, 
+        AnnotationAttributes attributes) {
+    // ���õ��� spring �ṩ�ķ�����SpringFactoriesLoader.loadFactoryNames(...)
+    // getSpringFactoriesLoaderFactoryClass() ���ص���EnableAutoConfiguration
+    List<String> configurations = SpringFactoriesLoader
+            .loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
+    Assert.notEmpty(configurations, "...");
+    return configurations;
+}
+
+protected Class<?> getSpringFactoriesLoaderFactoryClass() {
+    return EnableAutoConfiguration.class;
+}
+
+```
+
+�������� `SpringFactoriesLoader#loadFactoryNames`��
+
+```
+public final class SpringFactoriesLoader {
+
+    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
+
+    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
+        // �õ��� factoryTypeName �� org.springframework.boot.autoconfigure.EnableAutoConfiguration
+        String factoryTypeName = factoryType.getName();
+        return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
+    }
+
+    /**
+     * ��������м��أ����ص��� META-INF/spring.factories �е�����
+     */
+    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
+        MultiValueMap<String, String> result = cache.get(classLoader);
+        if (result != null) {
+            return result;
+        }
+
+        try {
+            // ���� META-INF/spring.factories ������
+            Enumeration<URL> urls = (classLoader != null ?
+                    classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
+                    ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
+            result = new LinkedMultiValueMap<>();
+            while (urls.hasMoreElements()) {
+                URL url = urls.nextElement();
+                UrlResource resource = new UrlResource(url);
+                // �� META-INF/spring.factories ������ת��Ϊ Properties ����
+                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
+                for (Map.Entry<?, ?> entry : properties.entrySet()) {
+                    String factoryTypeName = ((String) entry.getKey()).trim();
+                    // StringUtils.commaDelimitedListToStringArray(...) ���ŷָ�Ϊ����
+                    for (String factoryImplementationName : 
+                                StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
+                        result.add(factoryTypeName, factoryImplementationName.trim());
+                    }
+                }
+            }
+            cache.put(classLoader, result);
+            return result;
+        }
+        catch (IOException ex) {
+            throw new IllegalArgumentException("Unable to load factories from location [" +
+                    FACTORIES_RESOURCE_LOCATION + "]", ex);
+        }
+    }
+    ...
+}
+
+```
+
+���Կ�����������ص��� `classpath` �µ� `META-INF/spring.factories` �ļ���ע�⣺����ļ����ܻ��ж����λ�ڲ�ͬ�� jar ���С�
+
+springboot �Դ��� `META-INF/spring.factories` λ�� `spring-boot-autoconfigure` ģ���£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-ace5e83645626966eae1e62a50752f2417d.png)
+
+��������һ�� `spring.factories`��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-d7de9ecd19345f0dc77cc304843c588fe4d.png)
+
+����ļ�����������������࣬�� `key-value` ����ʽ���棬���ֵ֮��ʹ�� ��,�� �ֿ��������ᵽ���Զ�װ����� key �� `org.springframework.boot.autoconfigure.EnableAutoConfiguration`����Ӧ�� `value` �dz��࣬����Ͳ�չʾ�ˡ�
+
+��һ��֮���Զ�װ����ͱ�ע�ᵽ spring �������ˡ�ע����ʱ���ص� spring �����еĻ��� `BeanDefinition`��Ҫ���Ϊ spring bean�����þ��� `ConditionalOnBean`��`ConditionalOnClass` ��ע��Ŀ��飬��Щ���Ǻ����ٷ�����
+
+### 4\. ��ȡ�Զ�װ�����Ĵ���
+
+�������ٻص� `AutoConfigurationImportSelector.AutoConfigurationGroup`���ڵ� 1 �������ܽ���������£�
+
+1.  ���� `AutoConfigurationImportSelector#getAutoConfigurationEntry(...)` ���������Զ�װ���ࣻ
+2.  ���õ����Զ�װ���ౣ�浽 `autoConfigurationEntries` �У�
+3.  �õ������࣬��Щ����������� `@EnableAutoConfiguration` �� `exclude` �� `excludeName` ָ���ģ�
+4.  �� `autoConfigurationEntries` ת��Ϊ `LinkedHashSet`�����Ϊ `processedConfigurations`��
+5.  ȥ�� `processedConfigurations` ��Ҫ���˵��ࣻ
+6.  ���� 5 ���õ���������󣬷��ء�
+
+���ϵ� 2 ����� 3 �ڣ����������Զ�������ļ��ع��̣��������������������IJ��衣
+
+�����Ŵ��룬���ǻᷢ�ֽ������IJ��趼�Ƚϼ򵥣�����Ҳ��һ˵���°ɡ�
+
+*   �� 2 ��������õ����Զ�װ���࣬�����������ֻ�ǵ����� `List#add(...)` ���������õ��� `autoConfigurationEntry` ���浽 `autoConfigurationEntries`������ṹ�� `AutoConfigurationGroup` �ij�Ա�������� `AutoConfigurationImportSelector.AutoConfigurationGroup#selectImports` �����л��õ���
+
+*   �� 3 �����õ��������еĹ����࣬�ù������DZ��� `autoConfigurationEntries`��Ȼ��ͨ�� `autoConfigurationEntry#getExclusions` �����õ��� ��ǰ������Ҳ�ᵽ����`autoConfigurationEntry` ֻ����������Ա������`configurations`(ȥ���ų������Զ�װ����) �� `exclusions`(ͨ�� `@EnableAutoConfiguration` ָ�����ų���)��
+
+*   �� 4 ������ `List` ת��Ϊ `LinkedHashSet`����������
+
+*   �� 5 ���������е��Զ�װ�����ٽ���һ��ȥ���ų���IJ������ų��Ķ��������е��ų��࣬�������Ӧ���ǻ��ͬһ��Ŀ���ж�� `@EnableAutoConfiguration` ������������һ�� `@EnableAutoConfiguration` ע���ų� `A`��`B` �����࣬�ڶ��� `@EnableAutoConfiguration` ע���ų� `C`��`D` �����࣬�������ų����� `A`��`B`��`C`��`D` �ĸ��ࣻ
+
+*   �� 6 ������һ������Ҫ�������������˳��������Զ�װ����ע�ᵽ `beanFactory` �е�˳��`AutoConfigureOrder`��`@AutoConfigureAfter` �� `@AutoConfigureBefore` ���������ﴦ���ģ�����������ݣ����Բο� [springboot �Զ�װ��֮�Զ�װ��˳��](https://my.oschina.net/funcy/blog/4921594).
+
+������Щ������Զ�װ��Ļ�ȡ������ˡ�
+
+### 5\. �Զ����Զ�װ����
+
+�˽����Զ�װ����ļ��ع��̺�����Ҳ�����Զ���һ���Զ�װ���ࡣ
+
+1.  ׼��һ���Զ�װ����
+
+```
+@Configuration
+public class MyAutoConfiguration {
+
+    @Bean
+    public Object object() {
+        System.out.println("create object");
+        return new Object();
+    }
+}
+
+```
+
+�����ܼ򵥣�����һ������� `@Configuration` ���࣬����ʹ�� `@Bean` ע�ⴴ����һ�� bean���ڴ��� bean �Ĺ����л� ��ӡ "create object"��
+
+1.  ׼�� `META-INF/spring.factories` �������£�
+
+```
+# Auto Configure
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+org.springframework.boot.learn.autoconfigure.demo01.configure.MyAutoConfiguration
+
+```
+
+1.  ����
+
+```
+@SpringBootApplication
+public class AutoconfigureDemo01Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(AutoconfigureDemo01Application.class, args);
+    }
+
+}
+
+```
+
+���н�����£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-9337a7ac4ce4ff7d71e69bc952bfac30b12.png)
+
+���Կ�����`create object` �ɹ���ӡ�ˡ�
+
+����� `bean` ��ͨ����ɨ�贴���ģ������Զ�װ�䵼����أ�����ͨ�����Եķ�ʽ�������Զ�װ��õ����ࣺ
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-27bea49ddeae2f0f720ea338914cc443aec.png)
+
+���Կ�����`MyAutoConfiguration` �����Զ�װ������б����ˡ�
+
+ע�⵽��`MyAutoConfiguration` ���� `@Configuration` ע�⣬ ��ô���������� sping ����ɨ�赽�ģ��������Զ�װ��õ����أ�
+
+��[��springboot Դ�������@SpringBootApplication ע��](https://my.oschina.net/funcy/blog/4870882)һ���У������ᵽ `SpringBootApplication` ע���е� `@ComponentScan` ��ָ��һ����������`AutoConfigurationExcludeFilter`�����������������Զ�װ���࣬�������ǿ���ĿǰΪֹ `beanFactory` ������Щ `beanName`��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-1725008451f5516ab540bcc3ae13d1f37ee.png)
+
+���Կ�������û�� `MyAutoConfiguration`����˴�ʱ����û��ɨ��� `beanFactory` �С�
+
+��Ȼ������Ҳ���԰� `MyAutoConfiguration` ����� `@Configuration` ע��ȥ���������Ͳ�������������ˡ�
+
+### 6\. �ܽ�
+
+���Ĵ� `@EnableAutoConfiguration` ע��������������Զ�װ����ļ������̣����������� `AutoConfigurationImportSelector#getAutoConfigurationEntry` �����У����ռ��ص��� `META-INF/spring.factories` �ļ��� key �� `org.springframework.boot.autoconfigure.EnableAutoConfiguration` ���ࡣ
+
+�õ��Զ�װ�����spring �Ὣ��ע�ᵽ�����У���ʱ���ǻ���һ���� `BeanDefinition`��Ҫ���Ϊ spring bean�����þ��� `ConditionalOnBean`��`ConditionalOnClass` ��ע��Ŀ��飬��Щ���Ǻ����ٷ�����
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4870868](https://my.oschina.net/funcy/blog/4870868) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\350\207\252\345\212\250\350\243\205\351\205\215\357\274\210\344\270\211\357\274\211\357\274\232\350\207\252\345\212\250\350\243\205\351\205\215\351\241\272\345\272\217.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\350\207\252\345\212\250\350\243\205\351\205\215\357\274\210\344\270\211\357\274\211\357\274\232\350\207\252\345\212\250\350\243\205\351\205\215\351\241\272\345\272\217.md"
new file mode 100644
index 0000000..03744e2
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\350\207\252\345\212\250\350\243\205\351\205\215\357\274\210\344\270\211\357\274\211\357\274\232\350\207\252\345\212\250\350\243\205\351\205\215\351\241\272\345\272\217.md"
@@ -0,0 +1,568 @@
+�� [springboot �Զ�װ��֮����ע�⣨һ��](https://my.oschina.net/funcy/blog/4918863)һ���У��ڷ��� `@ConditionalOnBean/@ConditionalOnMissingBean` ע��������ж�ʱ���ٷ�ǿ�ҽ����������Զ�װ������ʹ��������ע�⣬���� `@ConditionalOnBean/@ConditionalOnMissingBean` ��ǵ���Ҫ��ָ������֮���ʼ������ springboot ����������Զ�װ��˳���أ����Ľ����о��¡�
+
+### 1\. springboot �����Զ�װ����Ĺ���
+
+��Ҫ��ȷ���ǣ�����̽�ֵ�`�Զ�װ��˳��`��ָ�� `class` ע�ᵽ `beanFactory` ��˳��springboot �����Զ�װ����Ĵ��¹������£�
+
+1.  �����Զ�װ���࣬�� [springboot �Զ�װ��֮�����Զ�װ����](https://my.oschina.net/funcy/blog/4870868) һ�����ѷ�������
+2.  ���Զ�װ��������������DZ��Ľ�Ҫ���������ݣ�
+3.  �����Զ�װ���࣬��ÿ���Զ�װ������һ�������²�����
+    1.  ��������ע���жϵ�ǰ�Զ�װ�����Ƿ�����װ��������
+    2.  �����ǰ�Զ�װ��������װ��������ע�ᵽ `beanFactory` �С�
+
+�ٻص� `@ConditionalOnBean/@ConditionalOnMissingBean`�������������Զ�װ���ࣺ
+
+```
+// A���Զ�װ����
+@Configuration
+public class A {
+    @Bean
+    @ConditionalOnMissingBean("b1")
+    public A1 a1() {
+        return new A1();
+    }
+}
+
+// B���Զ�װ����
+@Configuration
+public class B {
+    @Bean
+    public B1 b1() {
+        return new b1();
+    }
+}
+
+```
+
+`a1` �� `b1` ��������ͬ���Զ�װ�����г�ʼ������ `a1` ֻ���� `b1` ������ʱ���Ż��ʼ�������������ܽ�� springboot �����Զ�װ����IJ��裬����ֻҪָ�� `b1` �� `a1` ֮ǰ��ʼ���Ͳ�������쳣�ˡ�
+
+��ô���Զ�װ�����˳�����ָ���أ�
+
+### 2\. �Զ�װ�����˳�����ע��
+
+springboot Ϊ�����ṩ�������Զ�װ����������ֶΣ�
+
+*   �����Զ�װ��˳�� ����`@AutoConfigOrder`
+*   ����Զ�װ��˳�� ����`@AutoConfigureBefore` �� `@AutoConfigureAfter`
+
+������ע��������������Զ�װ�����������ˣ�`@AutoConfigOrder` ָ����װ��˳��ͬ spring �ṩ�� `@Order` ���ƣ�`@AutoConfigureBefore` �� `@AutoConfigureAfter` ����ָ�� `class`����ʾ���ĸ� `class` ֮ǰ��֮��װ�䡣
+
+�ص�ʾ�������ǿ�������ָ��װ��˳��
+
+```
+// A���Զ�װ����
+@Configuration
+// ��B.class֮���Զ�װ��
+@AutoConfigureAfter(B.class)
+public class A {
+    @Bean
+    @ConditionalOnMissingBean("b1")
+    public A1 a1() {
+    ...
+    }
+}
+
+// B���Զ�װ����
+@Configuration
+public class B {
+    ...
+}
+
+```
+
+### 3\. �Զ�װ���������
+
+ǰ�������ᵽ��`@AutoConfigOrder`��`@AutoConfigureBefore` �� `@AutoConfigureAfter` ���Կ����Զ�װ�����װ��˳����ô���������������������أ��� [springboot �Զ�װ��֮�����Զ�װ����](https://my.oschina.net/funcy/blog/4870868) һ���У��������ܽ��˻�ȡ�Զ�װ����IJ����� 6 ����
+
+1.  ���� `AutoConfigurationImportSelector#getAutoConfigurationEntry(...)` ���������Զ�װ���ࣻ
+2.  ���õ����Զ�װ���ౣ�浽 `autoConfigurationEntries` �У�
+3.  �õ������࣬��Щ����������� `@EnableAutoConfiguration` �� `exclude` �� `excludeName` ָ���ģ�
+4.  �� `autoConfigurationEntries` ת��Ϊ `LinkedHashSet`�����Ϊ `processedConfigurations`��
+5.  ȥ�� `processedConfigurations` ��Ҫ���˵��ࣻ
+6.  ���� 5 ���õ���������󣬷��ء�
+
+�����Զ�װ��������������ڵ� 6 ������Ӧ�ķ����� `AutoConfigurationImportSelector.AutoConfigurationGroup#sortAutoConfigurations`���������£�
+
+```
+private List<String> sortAutoConfigurations(Set<String> configurations,
+        AutoConfigurationMetadata autoConfigurationMetadata) {
+    // �ȴ����� AutoConfigurationSorter ����
+    // Ȼ����� AutoConfigurationSorter.getInPriorityOrder ��������
+    return new AutoConfigurationSorter(getMetadataReaderFactory(), autoConfigurationMetadata)
+            .getInPriorityOrder(configurations);
+}
+
+```
+
+��������Ĵ�����Ϊ������
+
+1.  ������ `AutoConfigurationSorter` ����
+2.  ���� `AutoConfigurationSorter.getInPriorityOrder` ��������
+
+������������ `AutoConfigurationSorter` �Ĵ���������
+
+```
+class AutoConfigurationSorter {
+
+    private final MetadataReaderFactory metadataReaderFactory;
+
+    private final AutoConfigurationMetadata autoConfigurationMetadata;
+
+    /**
+     * ���췽��
+     * ����ֻ�ǶԴ���IJ������и�ֵ�������Ǹ�ֵΪ��Ա����
+     */
+    AutoConfigurationSorter(MetadataReaderFactory metadataReaderFactory,
+            AutoConfigurationMetadata autoConfigurationMetadata) {
+        Assert.notNull(metadataReaderFactory, "MetadataReaderFactory must not be null");
+        this.metadataReaderFactory = metadataReaderFactory;
+        this.autoConfigurationMetadata = autoConfigurationMetadata;
+    }
+
+    ...
+
+}
+
+```
+
+���Կ�����`AutoConfigurationSorter` �Ĺ��췽����û����ʲôʵ���ԵIJ�������������Ĺؼ����ÿ� `AutoConfigurationSorter.getInPriorityOrder` �������÷����Ĵ������£�
+
+```
+List<String> getInPriorityOrder(Collection<String> classNames) {
+    // 1\. �� classNames ��װ�� AutoConfigurationClasses
+    AutoConfigurationClasses classes = new AutoConfigurationClasses(this.metadataReaderFactory,
+            this.autoConfigurationMetadata, classNames);
+    List<String> orderedClassNames = new ArrayList<>(classNames);
+    // 2\. ����������
+    Collections.sort(orderedClassNames);
+    // 3\. ʹ�� @AutoConfigureOrder ����
+    orderedClassNames.sort((o1, o2) -> {
+        int i1 = classes.get(o1).getOrder();
+        int i2 = classes.get(o2).getOrder();
+        return Integer.compare(i1, i2);
+    });
+    // 4\. ʹ�� @AutoConfigureBefore��@AutoConfigureAfter ����
+    orderedClassNames = sortByAnnotation(classes, orderedClassNames);
+    return orderedClassNames;
+}
+
+```
+
+�Ӵ����� �������������ִ�в������£�
+
+1.  �� `classNames` ��װ�� `AutoConfigurationClasses`
+2.  ����������
+3.  ʹ�� `@AutoConfigureOrder` ����
+4.  ʹ�� `@AutoConfigureBefore`��`@AutoConfigureAfter` ����
+
+����������򹲽����� 3 �Σ����Ƕ� `orderedClassNames` ������������һ�����������������ǰ����������ȵ������ǰ���������Ҳ����˵�����û��ָ�� `@AutoConfigureOrder`��`@AutoConfigureBefore` ��ע�⣬�ͻ�ʹ��������������
+
+���������Ǿ�������⼸�������ɡ�
+
+### 4\. �� `classNames` ��װ�� `AutoConfigurationClasses`
+
+�ò���λ�� `AutoConfigurationSorter.AutoConfigurationClasses#AutoConfigurationClasses` �������������£�
+
+```
+private static class AutoConfigurationClasses {
+
+    // ������
+    private final Map<String, AutoConfigurationClass> classes = new HashMap<>();
+
+    /**
+     * ���췽��
+     */
+    AutoConfigurationClasses(MetadataReaderFactory metadataReaderFactory,
+            AutoConfigurationMetadata autoConfigurationMetadata, Collection<String> classNames) {
+        // ���������
+        addToClasses(metadataReaderFactory, autoConfigurationMetadata, classNames, true);
+    }
+
+    /**
+     * �����࣬���ǽ����װ�� AutoConfigurationClass�����ӵ���Ϊ classes �� Map ��
+     * classNames ����ȥ�����ų���������Զ�װ����
+     */
+    private void addToClasses(MetadataReaderFactory metadataReaderFactory,
+            AutoConfigurationMetadata autoConfigurationMetadata, Collection<String> classNames, 
+            boolean required) {
+        for (String className : classNames) {
+            if (!this.classes.containsKey(className)) {
+                // �� className ��װ�� AutoConfigurationClass
+                AutoConfigurationClass autoConfigurationClass = new AutoConfigurationClass(
+                        className, metadataReaderFactory, autoConfigurationMetadata);
+                boolean available = autoConfigurationClass.isAvailable();
+                // @AutoConfigureBefore �� @AutoConfigureAfter ��ǵ���� required Ϊ false
+                if (required || available) {
+                    this.classes.put(className, autoConfigurationClass);
+                }
+                if (available) {
+                    // �ݹ����
+                    addToClasses(metadataReaderFactory, autoConfigurationMetadata,
+                            autoConfigurationClass.getBefore(), false);
+                    addToClasses(metadataReaderFactory, autoConfigurationMetadata,
+                            autoConfigurationClass.getAfter(), false);
+                }
+            }
+        }
+    }
+    ...
+}
+
+```
+
+�����ϴ���������
+
+*   `AutoConfigurationClasses` ����һ����Ա������`classes`�������� `Map`��`key` �� `String`��Ҳ���� `className`����`value` �� `AutoConfigurationClass`��Ҳ���� `className` �İ����ࣩ;
+*   `AutoConfigurationClasses` �Ĺ��췽������� `addToClasses(...)` �÷������������� `classNames`�������װ�� `AutoConfigurationClass` ���ٱ��浽 `classes` �С�
+
+�ڷ��� `addToClasses(...)` �ľ����߼�ǰ�������������� `AutoConfigurationClass` �Ǹ�ɶ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-fd9c1a4c335951391a33f86a86fe89ff496.png)
+
+���Կ��� ��`AutoConfigurationClass` �������İ�װ�����һ������� `@AutoConfigureBefore` �� `@AutoConfigureAfter` ָ�����࣬�Լ��ṩ�˸� `@AutoConfigureOrder`�� `@AutoConfigureBefore`��`@AutoConfigureAfter` ��ص�һЩ������
+
+�����ٻع�ͷ�� `addToClasses(...)` ��ִ�����̣��÷�����ִ���������£�
+
+1.  ��������� `classNames`��������ÿһ�� `className`����������IJ�����
+2.  ���� `AutoConfigurationClass`������ `className`��
+3.  ���� `AutoConfigurationSorter.AutoConfigurationClass#isAvailable` �������õ� `available`��
+4.  �ж� `available` �� `required` ��ֵ�������һΪ ture���ͽ������ӵ� `classes`��
+5.  ��� `available` Ϊ `true`���ݹ鴦�� `className` �� `@AutoConfigureBefore` �� `@AutoConfigureAfter` ָ�����ࡣ
+
+���̿��Ų����ӣ������м�����ȥ��Ҫ������ ��
+
+1.  `AutoConfigurationSorter.AutoConfigurationClass#isAvailable`���жϵ�ǰ `class` �Ƿ����
+2.  `AutoConfigurationSorter.AutoConfigurationClass#getBefore`����ȡ `class`����ǰ `class` ��Ҫ����Щ `class` ֮ǰ����
+3.  `AutoConfigurationSorter.AutoConfigurationClass#getAfter`����ȡ `class`����ǰ `class` ��Ҫ����Щ `class` ֮����
+
+����������һһ���������⼸��������
+
+#### 4.1 `AutoConfigurationSorter.AutoConfigurationClass#isAvailable`
+
+��������������жϵ�ǰ `class` �Ƿ��ڵ�ǰ��Ŀ�� `classpath` �У������룺
+
+```
+boolean isAvailable() {
+    try {
+        if (!wasProcessed()) {
+            getAnnotationMetadata();
+        }
+        return true;
+    }
+    catch (Exception ex) {
+        return false;
+    }
+}
+
+```
+
+����������벻�࣬���ǵ��� `wasProcessed()` �������ٵ��� `getAnnotationMetadata()`����Ҫע����ǣ�`getAnnotationMetadata()` ���ܻ��׳��쳣����Ƹ�쳣Ҳ�᷵�� `false`.
+
+���Ǽ������� `AutoConfigurationSorter.AutoConfigurationClass#wasProcessed` ������
+
+```
+private boolean wasProcessed() {
+    return (this.autoConfigurationMetadata != null
+        // �ж� META-INF/spring-autoconfigure-metadata.properties �ļ����Ƿ���ڸ�����
+        && this.autoConfigurationMetadata.wasProcessed(this.className));
+}
+
+```
+
+�����������Ҫ������ `AutoConfigurationMetadataLoader.PropertiesAutoConfigurationMetadata#wasProcessed` �������жϣ�
+
+```
+@Override
+public boolean wasProcessed(String className) {
+    // �ж� properties �Ƿ���ڶ�Ӧ�� className
+    return this.properties.containsKey(className);
+}
+
+```
+
+���Կ�����������������ж� `properties` ���Ƿ��������� `className`��`properties` ������������ `META-INF/spring-autoconfigure-metadata.properties`������ʾ�����£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-069444fdaa952c6fa8c39576e776275982b.png)
+
+��Ҫע����ǣ����ļ���Դ�����Dz����ڵģ������ڱ���ʱд��ģ����ڸ��ļ���д�롢���ص� `properties` �����̣����ľͲ�չ�������ˣ������ṩ�����˼·��
+
+*   �ļ���д�룺�ڴ������ʱ��springboot �Ὣ�Զ�װ�����һЩ��Ϣ (���磬`@ConditionalOnClass` ָ���� `class`��`@ConditionalOnBean` ָ���� `bean`��`@AutoConfigureBefore` �� `@AutoConfigureAfter` ��ָ���� `class` ��) д�뵽 `META-INF/spring-autoconfigure-metadata.properties` �ļ��У�������Ϊ `AutoConfigureAnnotationProcessor`��������� `javax.annotation.processing.AbstractProcessor` �����࣬�� `AbstractProcessor` �� jdk �ṩ�������ڱ����ڶ�ע����д�����
+
+*   �ļ��ļ��أ��� `AutoConfigurationImportSelector.AutoConfigurationGroup#process` �����е��� `AutoConfigurationImportSelector#getAutoConfigurationEntry` ʱ���ᴫ�� `AutoConfigurationMetadata`���ļ� `META-INF/spring-autoconfigure-metadata.properties` �е����ݾ��Ǵ�������ص� `AutoConfigurationMetadataLoader.PropertiesAutoConfigurationMetadata#properties` �еģ�
+
+��Щ�ɼ���`AutoConfigurationMetadataLoader.PropertiesAutoConfigurationMetadata#wasProcessed` ����ʵ���Ͼ����ж� `META-INF/spring-autoconfigure-metadata.properties` �ļ����Ƿ��� `className` �����á�
+
+�����ǻص� `AutoConfigurationSorter.AutoConfigurationClass#isAvailable`������������һ��������`getAnnotationMetadata()`���÷���λ�� `AutoConfigurationSorter.AutoConfigurationClass` �У��������£�
+
+```
+private AnnotationMetadata getAnnotationMetadata() {
+    if (this.annotationMetadata == null) {
+        try {
+            // ����`className`��Ӧ����Դ���� className ��Ӧ����Դ������ʱ�����׳��쳣
+            MetadataReader metadataReader = this.metadataReaderFactory
+                    .getMetadataReader(this.className);
+            this.annotationMetadata = metadataReader.getAnnotationMetadata();
+        }
+        catch (IOException ex) {
+            throw new IllegalStateException(...);
+        }
+    }
+    return this.annotationMetadata;
+}
+
+```
+
+�������� `SimpleMetadataReaderFactory#getMetadataReader(String)`��
+
+```
+@Override
+/**
+ * ����������ȡ className ��Ӧ�� .class �ļ�
+ * ��� .class �ļ������ڣ��ͱ��쳣�ˣ�IOException
+ */
+public MetadataReader getMetadataReader(String className) throws IOException {
+    try {
+        // ת�����ƣ�"classpath:xxx/xxx/Xxx.class"
+        String resourcePath = ResourceLoader.CLASSPATH_URL_PREFIX 
+                + lassUtils.convertClassNameToResourcePath(className) 
+                + ClassUtils.CLASS_FILE_SUFFIX;
+        // ��ȡ��Դ��Ĭ�ϵ� resourceLoader Ϊ classLoader
+        Resource resource = this.resourceLoader.getResource(resourcePath);
+        // �� resource ת���� MetadataReader ���󣬲����ھͻ��׳��쳣��IOException
+        return getMetadataReader(resource);
+    }
+    catch (FileNotFoundException ex) {
+        // �п������ڲ��࣬�ٰ��ڲ����������ʽ����һ��
+        int lastDotIndex = className.lastIndexOf('.');
+        if (lastDotIndex != -1) {
+            String innerClassName = className.substring(0, lastDotIndex) + '$' 
+                    + className.substring(lastDotIndex + 1);
+            // ת�����ƣ�"classpath:xxx/Xxx$Xxx.class"
+            String innerClassResourcePath = ResourceLoader.CLASSPATH_URL_PREFIX 
+                    + ClassUtils.convertClassNameToResourcePath(innerClassName) 
+                    + ClassUtils.CLASS_FILE_SUFFIX;
+            Resource innerClassResource = this.resourceLoader.getResource(innerClassResourcePath);
+            // �ж��Ƿ���ڣ������ڻ��ǻᱨ�쳣�ģ�IOException
+            if (innerClassResource.exists()) {
+                return getMetadataReader(innerClassResource);
+            }
+        }
+        throw ex;
+    }
+}
+
+```
+
+��������Ĵ����������£�
+
+1.  ������� `className` ת��Ϊ `classpath:xxx/xxx/Xxx.class` ����ʽ��Ȼ��ȥ���ض�Ӧ����Դ�������Դ�����ڼ� `className` ��Ӧ��`.class` �ļ������ڣ����׳��쳣��
+2.  ���쳣�� `catch` ���У�Ϊ�˷�ֹ `className` ���ڲ��࣬�Ὣ `className` ת��Ϊ `classpath:xxx/Xxx$Xxx.class` ����ʽ��Ȼ���ټ���һ����Դ�������Դ���ڣ�ֱ�ӷ��أ������쳣�����ף�
+
+����������Ǿ������ˣ�`getAnnotationMetadata()` ���������жϵ�ǰ `className` ��Ӧ��`.class` ����Ŀ�� `classpath` ·�����Ƿ���ڡ�
+
+�������������������ܽ����£�
+
+*   `AutoConfigurationSorter.AutoConfigurationClass#wasProcessed`����ǰ `className` �Ƿ��� `META-INF/spring-autoconfigure-metadata.properties` �ļ���
+*   `AutoConfigurationSorter.AutoConfigurationClass#isAvailable`����ǰ `className` ��Ӧ��`.class` �ļ��Ƿ����
+
+���յĽ��ۣ�`AutoConfigurationSorter.AutoConfigurationClass#isAvailable` ���������жϵ�ǰ `className` ��Ӧ��`.class` �ļ�����Ŀ�� `classpath` ·����.
+
+#### 4.2 `AutoConfigurationSorter.AutoConfigurationClass#getBefore/getAfter`
+
+���������������� `AutoConfigurationSorter.AutoConfigurationClass` �������������`getAfter()` �� `getBefore()`��
+
+```
+Set<String> getBefore() {
+    if (this.before == null) {
+        this.before = (wasProcessed() 
+            // ��������� `META-INF/spring-autoconfigure-metadata.properties` �ļ��У�ֱ�ӻ�ȡֵ
+            ? this.autoConfigurationMetadata.getSet(this.className, "AutoConfigureBefore", 
+                    Collections.emptySet()) 
+            // ����� @AutoConfigureBefore ע���ϻ�ȡ
+            : getAnnotationValue(AutoConfigureBefore.class));
+    }
+    return this.before;
+}
+
+Set<String> getAfter() {
+    if (this.after == null) {
+        this.after = (wasProcessed() 
+            // ��������� `META-INF/spring-autoconfigure-metadata.properties` �ļ��У�ֱ�ӻ�ȡֵ
+            ? this.autoConfigurationMetadata.getSet(this.className, "AutoConfigureAfter", 
+                    Collections.emptySet()) 
+            // ����� @AutoConfigureAfter ע���ϻ�ȡ
+            : getAnnotationValue(AutoConfigureAfter.class));
+    }
+    return this.after;
+}
+
+/**
+ * �� @AutoConfigureBefore/@AutoConfigureAfter ע���л�ȡֵ��value �� name ָ����ֵ
+ */
+private Set<String> getAnnotationValue(Class<?> annotation) {
+    Map<String, Object> attributes = getAnnotationMetadata()
+            .getAnnotationAttributes(annotation.getName(), true);
+    if (attributes == null) {
+        return Collections.emptySet();
+    }
+    Set<String> value = new LinkedHashSet<>();
+    Collections.addAll(value, (String[]) attributes.get("value"));
+    Collections.addAll(value, (String[]) attributes.get("name"));
+    return value;
+}
+
+```
+
+�����������ڴ�����ʽ����һ�£��ȿ� `getBefore()` �����̣�
+
+1.  �����ǰ `className` ������ `META-INF/spring-autoconfigure-metadata.properties` �ļ��У�ֱ��ȡֵ��ǰ�����Ҳ�ᵽ��springboot �ڱ���ʱ�����һЩע�����Ϣд�뵽 `META-INF/spring-autoconfigure-metadata.properties` �ļ��У�
+
+2.  ����� 1 �����ɹ�����ӵ�ǰ `class` �� `@AutoConfigureBefore` ȡֵ��
+
+`getAfter()` ������������ `getBefore()` �����̻���һ�£��Ͳ������ˡ�
+
+### 5\. ʹ�� `@AutoConfigureOrder` ����
+
+�����ǻص� `AutoConfigurationSorter#getInPriorityOrder` ���������������� `@AutoConfigureOrder` ��������̣�
+
+```
+List<String> getInPriorityOrder(Collection<String> classNames) {
+    ...
+    orderedClassNames.sort((o1, o2) -> {
+        int i1 = classes.get(o1).getOrder();
+        int i2 = classes.get(o2).getOrder();
+        return Integer.compare(i1, i2);
+    });
+    ...
+}
+
+```
+
+����������ʹ�õ��� `List#sort`��`sort(...)` ��IJ���Ϊ `Comparator`��ָ����������򡣴Ӵ���������ͨ�� `getOrder()` ��ȡ����ǰ���˳�����ʹ�õ��� `Integer` �ıȽϹ������������� `getOrder()` ������Ĺؼ��������Ծ͵ķ����� `AutoConfigurationSorter.AutoConfigurationClass#getOrder`���������£�
+
+```
+private int getOrder() {
+    // �ж� META-INF/spring-autoconfigure-metadata.properties �ļ����Ƿ���ڵ�ǰ className
+    if (wasProcessed()) {
+        // ������ڣ���ʹ���ļ���ָ����˳�򣬷����ʹ��Ĭ��˳��
+        return this.autoConfigurationMetadata.getInteger(this.className, 
+                "AutoConfigureOrder", AutoConfigureOrder.DEFAULT_ORDER);
+    }
+    // ���������ڵ��������ȡ @AutoConfigureOrder ע��ָ����˳��
+    Map<String, Object> attributes = getAnnotationMetadata()
+            .getAnnotationAttributes(AutoConfigureOrder.class.getName());
+    // ��� @AutoConfigureOrder δ���ã���ʹ��Ĭ��˳��
+    return (attributes != null) ? (Integer) attributes.get("value") 
+            : AutoConfigureOrder.DEFAULT_ORDER;
+}
+
+```
+
+����������DZȽϼ򵥵ģ����ǻ�ȡ `@AutoConfigureOrder` ע��ָ����˳�����û�� `@AutoConfigureOrder` ע�⣬��ʹ��Ĭ��˳��Ĭ��˳�� `AutoConfigureOrder.DEFAULT_ORDER` ��ֵΪ 0��
+
+### 6\. ʹ�� `@AutoConfigureBefore`��`@AutoConfigureAfter` ����
+
+����������������ĵ� `@AutoConfigureBefore` �� `@AutoConfigureAfter` ע��������ˣ���Ӧ�ķ���Ϊ `AutoConfigurationSorter#sortByAnnotation`���������£�
+
+```
+/**
+ * ��������
+ * ʵ�������������ֻ��׼����һЩ���ݣ������ɻ���� doSortByAfterAnnotation(...)
+ */
+private List<String> sortByAnnotation(AutoConfigurationClasses classes, List<String> classNames) {
+    // ��Ҫ����� className
+    List<String> toSort = new ArrayList<>(classNames);
+    toSort.addAll(classes.getAllNames());
+    // ����õ� className
+    Set<String> sorted = new LinkedHashSet<>();
+    // ���������е� className
+    Set<String> processing = new LinkedHashSet<>();
+    while (!toSort.isEmpty()) {
+        // ������������ķ���
+        doSortByAfterAnnotation(classes, toSort, sorted, processing, null);
+    }
+    // �����ڼ��� sorted �У����������� classNames �е�Ԫ�ؽ��ᱻ�Ƴ�
+    sorted.retainAll(classNames);
+    return new ArrayList<>(sorted);
+}
+
+/**
+ * �����������ķ���
+ */
+private void doSortByAfterAnnotation(AutoConfigurationClasses classes, List<String> toSort, 
+        Set<String> sorted, Set<String> processing, String current) {
+    if (current == null) {
+        current = toSort.remove(0);
+    }
+    // ʹ�� processing ���ж��Ƿ����ѭ���Ƚϣ����磬��A after ��B���� ��B �� after ��A
+    processing.add(current);
+    // classes.getClassesRequestedAfter����ǰ className ��Ҫ����Щ className ֮��ִ��
+    for (String after : classes.getClassesRequestedAfter(current)) {
+        Assert.state(!processing.contains(after),
+                "AutoConfigure cycle detected between " + current + " and " + after);
+        if (!sorted.contains(after) && toSort.contains(after)) {
+            // �ݹ����
+            doSortByAfterAnnotation(classes, toSort, sorted, processing, after);
+        }
+    }
+    processing.remove(current);
+    // ���ӵ�����������
+    sorted.add(current);
+}
+
+```
+
+`AutoConfigurationSorter#sortByAnnotation` �ṩ�˱������ݵĽṹ���� `AutoConfigurationSorter#doSortByAfterAnnotation` ����������������ķ��������������̫�ö��������������£�
+
+1.  ���ҵ�ǰ `className` ��Ҫ����Щ `className` ֮��װ�䣬���䱣��Ϊ `afterClasses`��Ҳ����˵��`afterClasses` �е�ÿһ�� `className` ��Ҫ�ڵ�ǰ `className` ֮ǰװ�䣻
+
+2.  ���� `afterClasses`��������ÿһ�� `className`������������ `afterClasses`�������ݹ���ȥ��������ѭ���Ƚϵ�����£����ձ�Ȼ�����һ�� `className`������ `afterClasses` Ϊ�գ�����Ͱ� `className` ���뵽���������Ľṹ�С�
+
+��������������ȡ `afterClasses` �IJ���������Ϊ `AutoConfigurationSorter.AutoConfigurationClasses#getClassesRequestedAfter`���������£�
+
+```
+Set<String> getClassesRequestedAfter(String className) {
+    // ��ǰ�ࣺ��ȡ����Щ��֮��ִ�У����ǻ�ȡ @AutoConfigureAfter ע��ָ������
+    Set<String> classesRequestedAfter = new LinkedHashSet<>(get(className).getAfter());
+    // �����ࣺ��Ҫǰ��ִ�е�����
+    this.classes.forEach((name, autoConfigurationClass) -> {
+        if (autoConfigurationClass.getBefore().contains(className)) {
+            classesRequestedAfter.add(name);
+        }
+    });
+    return classesRequestedAfter;
+}
+
+```
+
+�Ӵ���������������� `afterClasses` �����������ݣ�
+
+*   ��ȡ����Щ��װ�����֮��װ�䣬���ǻ�ȡ `@AutoConfigureAfter` ע��ָ������
+*   ��ȡ��Щ����Ҫ�ڵ�ǰ��װ��֮ǰ����װ��
+
+### 7\. ��������`@ConditionalOnBean/@ConditionalOnMissingBean`
+
+ǰ���ᵽ�� `@ConditionalOnBean/@ConditionalOnMissingBean` �Ŀӣ��˽����Զ�װ���˳��󣬾��ܺܺù����Щ���ˣ�
+
+1.  ���� `bean` �����Զ�װ���ࣺ�ܿӷ�ʽ�ǣ�ʹ�� `@AutoConfigureBefore` / `@AutoConfigureAfter` �� `@AutoConfigureOrder` ָ������˳�򣬱�֤����ע���е� `bean` ��װ�伴�ɣ�
+2.  һ������ͨ `spring bean`��һ�����Զ�װ���ࣺ�������ע���е� `bean` ����ͨ spring bean����һ�����Զ�װ���࣬��������²��ô������Զ�װ��Ĵ������� `DeferredImportSelector` �����࣬��������Զ�װ��������ͨ `spring bean` ֮��������֮ ������ע���е� `bean` ���Զ�װ���࣬��һ������ͨ `spring bean`������һ�����������Ҫʹ�ã�
+3.  ����������ͨ `spring bean`���ޱܿӷ�����`spring bean` ע�ᵽ `beanFactory` ��˳�򲻿ɿأ������������������ʹ�ã�
+
+### 8\. �ܽ�
+
+�����ܽ����Զ�װ�����װ��˳����Ҫ�������������ݣ�
+
+1.  ���Զ�װ��������`AutoConfigurationImportSelector.AutoConfigurationGroup#sortAutoConfigurations`
+2.  ָ���Զ�װ�����װ��˳��ʹ�� `@AutoConfigureBefore` / `@AutoConfigureAfter` �� `@AutoConfigureOrder`
+3.  ����ʽ�����֣������ǣ�
+    1.  �� className ������ `String` �ṩ�������
+    2.  ���� `@AutoConfigureOrder` ָ����ֵ���������� `Integer` �ṩ�������
+    3.  ���� `@AutoConfigureBefore` / `@AutoConfigureAfter` �������� ��Ҫע����ǣ�������������ʽ�Ⱥ���У������������Ľ��Ϊ����˳��
+4.  ���� `@ConditionalOnBean/@ConditionalOnMissingBean` �ܿ�ָ�ϣ�
+    1.  ���� `bean` �����Զ�װ���ࣺ�ܿӷ�ʽ�ǣ�ʹ�� `@AutoConfigureBefore` / `@AutoConfigureAfter` �� `@AutoConfigureOrder` ָ������˳�򣬱�֤����ע���е� `bean` ��װ�伴�ɣ�
+    2.  һ������ͨ `spring bean`��һ�����Զ�װ���ࣺ����ע���е� `bean` ����Ϊ��ͨ�� `spring bean`��
+    3.  ����������ɿأ�������ʹ�á�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4921594](https://my.oschina.net/funcy/blog/4921594) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\350\207\252\345\212\250\350\243\205\351\205\215\357\274\210\344\272\214\357\274\211\357\274\232\346\235\241\344\273\266\346\263\250\350\247\243.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\350\207\252\345\212\250\350\243\205\351\205\215\357\274\210\344\272\214\357\274\211\357\274\232\346\235\241\344\273\266\346\263\250\350\247\243.md"
new file mode 100644
index 0000000..31d27a9
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringBoot\346\272\220\347\240\201\350\247\243\346\236\220/SpringBoot\350\207\252\345\212\250\350\243\205\351\205\215\357\274\210\344\272\214\357\274\211\357\274\232\346\235\241\344\273\266\346\263\250\350\247\243.md"
@@ -0,0 +1,961 @@
+### 1\. ����ע�⼰���ж���
+
+�� [springboot �Զ�װ��֮�����Զ�װ����](https://my.oschina.net/funcy/blog/4870868)һ���У����Ƿ����� springboot ����� `META-INF/spring.factories` �ļ��ж�����Զ�װ���࣬���ص���Щ�Զ�װ�������Щ���е� bean ��һ�����ʼ���𣿲����ǣ����ǿ����ڶ�Ӧ�� Bean ���ɷ�����ʹ��**����ע��**���������Ƿ���г�ʼ����
+
+springboot �ṩ������ע�����£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-0e8d27c887fb6ca142672cad1c60e9de207.png)
+
+�����оٲ������£�
+
+| ע������              | ע������                                                     | ����˵��                                      |
+| --------------------- | ------------------------------------------------------------ | --------------------------------------------- |
+| class ����ע��        | `@ConditionalOnClass`/`@ConditionalOnMissingClass`           | ��ָ������**���� / ȱʧ**ʱ��ʼ���� bean      |
+| bean ����ע��         | `@ConditionalOnBean`/`@ConditionalOnMissingBean`             | ��ָ���� bean **���� / ȱʧ**ʱ��ʼ���� bean  |
+| ��������ע��          | `@ConditionalOnProperty`                                     | ��ָ�������Դ��ڳ�ʼ���� bean                 |
+| Resource ����ע��     | `@ConditionalOnResource`                                     | ��ָ������Դ���ڳ�ʼ���� bean                 |
+| Web Ӧ������ע��      | `@ConditionalOnWebApplication` / `@ConditionalOnNotWebApplication` | ��ǰӦ��**Ϊ / ��Ϊ** web Ӧ��ʱ��ʼ���� bean |
+| spring ����ʽ����ע�� | `@ConditionalOnExpression`                                   | ������ʽ���Ϊ true ʱ��ʼ���� bean           |
+
+���ǽ��� `@ConditionalOnClass` ������ע������ݣ�
+
+```
+...
+@Conditional(OnClassCondition.class)
+public @interface ConditionalOnClass {
+    ...
+}
+
+```
+
+���Կ�����`ConditionalOnClass` ����� `@Conditional` ע��Ĺ��ܣ��������� `OnClassCondition.class`��
+
+���� `@Conditional` ע����Բο� [ConfigurationClassPostProcessor ֮���� @Conditional ע��](https://my.oschina.net/funcy/blog/4873444)����������ֱ��˵ `@Conditional` ��ʹ�÷�ʽ��
+
+1. `@Conditional` �� spring ����������ע�⣻
+
+2. `@Conditional` �ṩ��һ������ `value`������Ϊ `Class`��������� `Condition` �����ࣺ
+
+   ```
+   Class<? extends Condition>[] value();
+   
+   ```
+
+3. `Condition` ��һ���ӿڣ�������һ�� `matches(...)` ������
+
+   ```
+   public interface Condition {
+   
+       boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
+   
+   }
+   
+   ```
+
+   ֻ���� `matches(...)` �������� `true` ʱ��`ConfigurationClassPostProcessor` �ŻὫ���Ӧ�� bean ע�ᵽ `beanFactory` �� `beanDefinitionMap` ��.
+
+�ܽ��� `@Conditional` ��ʹ�÷�ʽ�����Ǿ������ˣ�`OnClassCondition.class` �� `Condition` �����࣬�� `matches(...)` ��������������Ҫ��������ͬ������������ע��Ĵ�����ʽҲ���ƣ������ܽ�������ע����ж��ࣺ
+
+| ע������              | ע������                                                     | �����ж���                  |
+| --------------------- | ------------------------------------------------------------ | --------------------------- |
+| class ����ע��        | `@ConditionalOnClass`/`@ConditionalOnMissingClass`           | `OnClassCondition`          |
+| bean ����ע��         | `@ConditionalOnBean`/`@ConditionalOnMissingBean`             | `OnBeanCondition`           |
+| ��������ע��          | `@ConditionalOnProperty`                                     | `OnPropertyCondition`       |
+| Resource ����ע��     | `@ConditionalOnResource`                                     | `OnResourceCondition`       |
+| Web Ӧ������ע��      | `@ConditionalOnWebApplication` / `@ConditionalOnNotWebApplication` | `OnWebApplicationCondition` |
+| spring ����ʽ����ע�� | `@ConditionalOnExpression`                                   | `OnExpressionCondition`     |
+
+������������Ŀ�ľͺ���ȷ�ˣ�Ҫ������Щ����ע����ж��߼���ֻ��Ҫ������Ӧ�����ж���� `matches(...)` �����Ϳ����ˡ�
+
+### 2. `SpringBootCondition#matches`
+
+���� `OnClassCondition#matches` ������������������ `SpringBootCondition`����ط������£�
+
+```
+public abstract class SpringBootCondition implements Condition {
+
+    private final Log logger = LogFactory.getLog(getClass());
+
+    @Override
+    public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
+        String classOrMethodName = getClassOrMethodName(metadata);
+        try {
+            // ��ȡ����ƥ����
+            ConditionOutcome outcome = getMatchOutcome(context, metadata);
+            // ��ӡһ����־
+            logOutcome(classOrMethodName, outcome);
+            // ��¼���������ķ�����������Ϊ��¼һ�������жϼ�¼��
+            recordEvaluation(context, classOrMethodName, outcome);
+            // ���ﷵ�����ս����true �� false
+            return outcome.isMatch();
+        }
+        catch (NoClassDefFoundError ex) {
+            throw new IllegalStateException(...);
+        }
+        catch (RuntimeException ex) {
+            throw new IllegalStateException(...);
+        }
+    }
+
+    /**
+     * ���Ǹ�����ʽ����������������ʵ��
+     */
+    public abstract ConditionOutcome getMatchOutcome(
+        ConditionContext context, AnnotatedTypeMetadata metadata);
+
+    ...
+
+}
+
+```
+
+`SpringBootCondition` �� `matches(...)` �ؼ������У�
+
+```
+...
+ConditionOutcome outcome = getMatchOutcome(context, metadata);
+...
+return outcome.isMatch();
+
+```
+
+�� `SpringBootCondition` �� `getMatchOutcome(...)` ���Ǹ����󷽷���������߼��������ṩ��`OnClassCondition` ����ʵ��֮һ��ʵ���ϣ����������ж��඼�� `SpringBootCondition` �����࣬�������Ǿ�ֱ�ӽ��������� `getMatchOutcome(...)` ���������ˡ�
+
+`getMatchOutcome(...)` �������صĽ���� `ConditionOutcome`������������������ `ConditionOutcome` �Ǹ�ɶ��
+
+```
+public class ConditionOutcome {
+
+    private final boolean match;
+
+    private final ConditionMessage message;
+
+    /**
+     * ���췽��
+     */
+    public ConditionOutcome(boolean match, String message) {
+        this(match, ConditionMessage.of(message));
+    }
+
+    /**
+     * ���췽��
+     */
+    public ConditionOutcome(boolean match, ConditionMessage message) {
+        Assert.notNull(message, "ConditionMessage must not be null");
+        this.match = match;
+        this.message = message;
+    }
+
+    /**
+     * ����ƥ��Ľ��
+     */
+    public boolean isMatch() {
+        return this.match;
+    }
+
+    ...
+}
+
+```
+
+�Ӵ�����������������������װ�ȽϽ���ģ��ڲ����������ԣ�`match` �� `message`:
+
+*   `match` �������� `boolean`�������������ƥ��ɹ�����ʧ�ܵı�ʶ
+*   `message` �������� `ConditionMessage`������ʾƥ������˵��
+
+������������ `ConditionMessage`:
+
+```
+public final class ConditionMessage {
+
+    private String message;
+
+    private ConditionMessage() {
+        this(null);
+    }
+
+    private ConditionMessage(String message) {
+        this.message = message;
+    }
+
+    ...
+}
+
+```
+
+������һ�����ԣ�`message`������������Ƕ�˵����Ϣ�İ�װ��
+
+### 3. `@ConditionalOnClass`: `OnClassCondition#getMatchOutcome`
+
+���������������� `OnClassCondition` ��ƥ���߼���ֱ�ӽ��� `getMatchOutcome` ������
+
+```
+public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
+    ClassLoader classLoader = context.getClassLoader();
+    ConditionMessage matchMessage = ConditionMessage.empty();
+    // 1\. ���� @ConditionalOnClass ע��
+    List<String> onClasses = getCandidates(metadata, ConditionalOnClass.class);
+    if (onClasses != null) {
+        // 1.1 ���������ж�
+        List<String> missing = filter(onClasses, ClassNameFilter.MISSING, classLoader);
+        if (!missing.isEmpty()) {
+            // 1.2 �������ؽ������ƥ������
+            return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnClass.class)
+                    .didNotFind("required class", "required classes").items(Style.QUOTE, missing));
+        }
+        matchMessage = matchMessage.andCondition(ConditionalOnClass.class)
+                .found("required class", "required classes")
+                .items(Style.QUOTE, filter(onClasses, ClassNameFilter.PRESENT, classLoader));
+    }
+
+    // 2\. ���� @ConditionalOnMissingClass ע��
+    List<String> onMissingClasses = getCandidates(metadata, ConditionalOnMissingClass.class);
+    if (onMissingClasses != null) {
+        // 2.1 ���������ж�
+        List<String> present = filter(onMissingClasses, ClassNameFilter.PRESENT, classLoader);
+        if (!present.isEmpty()) {
+            // 2.2 �������ؽ������ƥ������
+            return ConditionOutcome.noMatch(ConditionMessage
+                    .forCondition(ConditionalOnMissingClass.class)
+                    .found("unwanted class", "unwanted classes").items(Style.QUOTE, present));
+        }
+        matchMessage = matchMessage.andCondition(ConditionalOnMissingClass.class)
+                .didNotFind("unwanted class", "unwanted classes")
+                .items(Style.QUOTE, filter(onMissingClasses, ClassNameFilter.MISSING, classLoader));
+    }
+    // ��󷵻�ƥ��Ľ��
+    return ConditionOutcome.match(matchMessage);
+}
+
+```
+
+�������ͬʱ������ `@ConditionalOnClass` �� `@ConditionalOnMissingClass` ����ע�⣬�������̼������ƣ�����ע��������ж϶���ͨ�� `FilteringSpringBootCondition#filter` �������£�
+
+```
+protected final List<String> filter(Collection<String> classNames, ClassNameFilter classNameFilter,
+        ClassLoader classLoader) {
+    if (CollectionUtils.isEmpty(classNames)) {
+        return Collections.emptyList();
+    }
+    List<String> matches = new ArrayList<>(classNames.size());
+    for (String candidate : classNames) {
+        // ��������ƥ��
+        if (classNameFilter.matches(candidate, classLoader)) {
+            matches.add(candidate);
+        }
+    }
+    return matches;
+}
+
+```
+
+�ɴ˿ɼ�������� `classNameFilter` ���˹ؼ���
+
+*   ���� `@ConditionalOnClass` ʱ��`classNameFilter` Ϊ `ClassNameFilter.MISSING`
+*   ���� `@ConditionalOnMissingClass` ʱ��`classNameFilter` Ϊ `ClassNameFilter.PRESENT`
+
+�����ǽ��� `ClassNameFilter` һ̽���������� `FilteringSpringBootCondition` �����࣬�������£�
+
+```
+abstract class FilteringSpringBootCondition extends SpringBootCondition
+        implements AutoConfigurationImportFilter, BeanFactoryAware, BeanClassLoaderAware {
+    ...
+    /**
+     * ��� classLoader ���ڣ������ ClassLoader#loadClass ����
+     * ������� Class#forName ����
+     */
+    protected static Class<?> resolve(String className, ClassLoader classLoader) 
+            throws ClassNotFoundException {
+        if (classLoader != null) {
+            return classLoader.loadClass(className);
+        }
+        return Class.forName(className);
+    }
+
+    /**
+     * ��������ƥ��
+     */
+    protected enum ClassNameFilter {
+
+        PRESENT {
+
+            @Override
+            public boolean matches(String className, ClassLoader classLoader) {
+                return isPresent(className, classLoader);
+            }
+
+        },
+
+        MISSING {
+
+            @Override
+            public boolean matches(String className, ClassLoader classLoader) {
+                return !isPresent(className, classLoader);
+            }
+
+        };
+
+        abstract boolean matches(String className, ClassLoader classLoader);
+
+        /**
+         * Class �Ƿ����
+         * ͨ�����������ʱ���쳣���ж����Ƿ���ڣ�δ�׳��쳣���ʾ�����
+         */
+        static boolean isPresent(String className, ClassLoader classLoader) {
+            if (classLoader == null) {
+                classLoader = ClassUtils.getDefaultClassLoader();
+            }
+            try {
+                // ͨ���쳣�������ж��Ƿ���ڸ�class
+                resolve(className, classLoader);
+                return true;
+            }
+            catch (Throwable ex) {
+                return false;
+            }
+        }
+    }
+    ...
+}
+
+```
+
+�����������Ǿ������ˣ��ж� `Class` �Ƿ���ڣ�spring ��ͨ������ `ClassLoader.load(String)` �� `Class.forName(String)` �������쳣�������ģ�����׳����쳣�ͱ��� `Class` �����ڡ�
+
+�����ܽ��� `@ConditionalOnClass`/`@ConditionalOnMissingClass` �Ĵ�����ʽ��**���ߵĴ����඼Ϊ `OnClassCondition`��ͨ������ `ClassLoader.load(String)` �� `Class.forName(String)` �������쳣���ж� `Class` �Ƿ���ڣ�����׳����쳣�ͱ��� `Class` ������**��
+
+### 4. `@ConditionalOnBean`: `OnBeanCondition#getMatchOutcome`
+
+�������� `@ConditionalOnBean` �� ������ֱ�ӽ��� `OnBeanCondition#getMatchOutcome`��
+
+```
+public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
+    ConditionMessage matchMessage = ConditionMessage.empty();
+    MergedAnnotations annotations = metadata.getAnnotations();
+    // ���� @ConditionalOnBean
+    if (annotations.isPresent(ConditionalOnBean.class)) {
+        Spec<ConditionalOnBean> spec = new Spec<>(context, metadata, 
+                annotations, ConditionalOnBean.class);
+        // ����ƥ��
+        MatchResult matchResult = getMatchingBeans(context, spec);
+        // ע���ж�����
+        if (!matchResult.isAllMatched()) {
+            String reason = createOnBeanNoMatchReason(matchResult);
+            return ConditionOutcome.noMatch(spec.message().because(reason));
+        }
+        matchMessage = spec.message(matchMessage).found("bean", "beans").items(Style.QUOTE,
+                matchResult.getNamesOfAllMatches());
+    }
+
+    // ���� @ConditionalOnSingleCandidate
+    if (metadata.isAnnotated(ConditionalOnSingleCandidate.class.getName())) {
+        Spec<ConditionalOnSingleCandidate> spec 
+                = new SingleCandidateSpec(context, metadata, annotations);
+        // ����ƥ��
+        MatchResult matchResult = getMatchingBeans(context, spec);
+        // ע���ж�����
+        if (!matchResult.isAllMatched()) {
+            return ConditionOutcome.noMatch(spec.message().didNotFind("any beans").atAll());
+        }
+        else if (!hasSingleAutowireCandidate(context.getBeanFactory(), 
+                matchResult.getNamesOfAllMatches(), spec.getStrategy() == SearchStrategy.ALL)) {
+            return ConditionOutcome.noMatch(spec.message().didNotFind("a primary bean from beans")
+                    .items(Style.QUOTE, matchResult.getNamesOfAllMatches()));
+        }
+        matchMessage = spec.message(matchMessage).found("a primary bean from beans")
+                .items(Style.QUOTE, matchResult.getNamesOfAllMatches());
+    }
+
+    // ���� @ConditionalOnMissingBean
+    if (metadata.isAnnotated(ConditionalOnMissingBean.class.getName())) {
+        Spec<ConditionalOnMissingBean> spec = new Spec<>(context, metadata, annotations,
+                ConditionalOnMissingBean.class);
+        // ����ƥ��
+        MatchResult matchResult = getMatchingBeans(context, spec);
+        // ע���ж�����
+        if (matchResult.isAnyMatched()) {
+            String reason = createOnMissingBeanNoMatchReason(matchResult);
+            return ConditionOutcome.noMatch(spec.message().because(reason));
+        }
+        matchMessage = spec.message(matchMessage).didNotFind("any beans").atAll();
+    }
+    return ConditionOutcome.match(matchMessage);
+}
+
+```
+
+���Կ������������һ������������ע�������ƥ�䣺`@ConditionalOnBean`��`@ConditionalOnSingleCandidate` �� `@ConditionalOnMissingBean`�����߶�������ͬһ������ `getMatchingBeans(...)` ����ȡƥ������Ȼ��ʹ�� `matchResult.isAllMatched()` �� `matchResult.isAnyMatched()` �������յĽ���жϡ�
+
+#### `OnBeanCondition#getMatchingBeans`
+
+`getMatchingBeans(...)` �Ĵ������£�
+
+```
+protected final MatchResult getMatchingBeans(ConditionContext context, Spec<?> spec) {
+    ClassLoader classLoader = context.getClassLoader();
+    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
+    boolean considerHierarchy = spec.getStrategy() != SearchStrategy.CURRENT;
+    Set<Class<?>> parameterizedContainers = spec.getParameterizedContainers();
+    if (spec.getStrategy() == SearchStrategy.ANCESTORS) {
+        BeanFactory parent = beanFactory.getParentBeanFactory();
+        Assert.isInstanceOf(ConfigurableListableBeanFactory.class, parent,
+                "Unable to use SearchStrategy.ANCESTORS");
+        beanFactory = (ConfigurableListableBeanFactory) parent;
+    }
+    MatchResult result = new MatchResult();
+    // 1\. ��ȡ ignoreType��ֻ�� @ConditionalOnMissingBean ���������
+    Set<String> beansIgnoredByType = getNamesOfBeansIgnoredByType(classLoader, beanFactory, 
+            considerHierarchy, spec.getIgnoredTypes(), parameterizedContainers);
+
+    // 2\. ���� types
+    for (String type : spec.getTypes()) {
+        Collection<String> typeMatches = getBeanNamesForType(classLoader, considerHierarchy, 
+                beanFactory, type, parameterizedContainers);
+        typeMatches.removeAll(beansIgnoredByType);
+        if (typeMatches.isEmpty()) {
+            result.recordUnmatchedType(type);
+        }
+        else {
+            result.recordMatchedType(type, typeMatches);
+        }
+    }
+
+    // 3\. �������ϵ�ע�� @ConditionalOnMissingBean ���������
+    for (String annotation : spec.getAnnotations()) {
+        Set<String> annotationMatches = getBeanNamesForAnnotation(classLoader, beanFactory, 
+                annotation, considerHierarchy);
+        annotationMatches.removeAll(beansIgnoredByType);
+        if (annotationMatches.isEmpty()) {
+            result.recordUnmatchedAnnotation(annotation);
+        }
+        else {
+            result.recordMatchedAnnotation(annotation, annotationMatches);
+        }
+    }
+
+    // 4\. ���� beanName
+    for (String beanName : spec.getNames()) {
+        if (!beansIgnoredByType.contains(beanName) && containsBean(beanFactory, beanName, 
+                considerHierarchy)) {
+            result.recordMatchedName(beanName);
+        }
+        else {
+            result.recordUnmatchedName(beanName);
+        }
+    }
+    return result;
+}
+
+```
+
+��Ҫ˵�����ǣ���������ᴦ�� 3 ��ע���ƥ�����`@ConditionalOnBean`��`@ConditionalOnSingleCandidate` �� `@ConditionalOnMissingBean`�������������£�
+
+1.  ��ȡ `ignoreType`��ֻ�� `@ConditionalOnMissingBean` ���������
+2.  ���� `types` ��ƥ�����
+3.  ����ע�⣨���ϵ�ע�⣩��ƥ����� ֻ�� `@ConditionalOnMissingBean` ���������
+4.  ���� `beanName` ��ƥ�����
+
+�������ϲ���ľ���ϸ�ڣ����ľͲ�����չ���ˣ�������ṩ���̣�
+
+1.  ��ȡ `ignoreType`��
+    1.  ʹ�� `ListableBeanFactory#getBeanNamesForType(Class, boolean, boolean)` ������ȡ���������е� `ignoreType` �� `beanName`
+    2.  ���Ϊ `beansIgnoredByType`(������ `Set<String>`)
+2.  ���� `types` ��ƥ�����
+    1.  ʹ�� `ListableBeanFactory#getBeanNamesForType(Class, boolean, boolean)` ������ȡ���������е� `type` ��Ӧ�� `beanName`�����Ϊ `typeMatches`
+    2.  �� `typeMatches` �е�ֵȥ�� `ignoreType`
+    3.  �жϵڶ����õ��� `typeMatches`���������Ϊ�գ�����ǰ `Type` ���浽 `unmatchedTypes` �У����򱣴浽 `matchedTypes` �� `namesOfAllMatches` ��
+3.  ����ע���ƥ�����
+    1.  ʹ�� `ListableBeanFactory#getBeanNamesForAnnotation` ������ȡ���������е� `annotation` ��Ӧ�� `beanName`�����Ϊ `annotationMatches`
+    2.  �� `annotationMatches` �е�ֵȥ�� `ignoreType`
+    3.  �жϵڶ����õ��� `annotationMatches`���������Ϊ�գ�����ǰ `Annotation` ���浽 `unmatchedAnnotations` �У����򱣴浽 `matchedAnnotations` �� `namesOfAllMatches` ��
+4.  ���� `beanName` ��ƥ�����
+    1.  �ж� `beansIgnoredByType` �Ƿ���� `beanName`
+    2.  ʹ�� `BeanFactory#containsBean` �����ж��������и� `beanName`
+    3.  ����� 2 �����Ϊ `false`���ڶ������Ϊ `true`���򽫵�ǰ `beanName` ���뵽 `matchedNames` �� `namesOfAllMatches`�����򱣴浽 `unmatchedNames` ��
+
+�õ� `matchedTypes`��`unmatchedNames` �����ݺ�`matchResult.isAllMatched()` �� `matchResult.isAnyMatched()` ���յ��жϽ�������ж���Щ�ṹ�Ƿ�գ�
+
+```
+boolean isAllMatched() {
+    return this.unmatchedAnnotations.isEmpty() && this.unmatchedNames.isEmpty()
+            && this.unmatchedTypes.isEmpty();
+}
+
+boolean isAnyMatched() {
+    return (!this.matchedAnnotations.isEmpty()) || (!this.matchedNames.isEmpty())
+            || (!this.matchedTypes.isEmpty());
+}
+
+```
+
+������`@ConditionalOnBean`/`@ConditionalOnMissingBean` �Ĺؼ�������ʹ�� `ListableBeanFactory#getBeanNamesForType` �� `BeanFactory#containsBean` ���ж� `beanName`��`beanType` �Ƿ�����ˡ�
+
+��ʹ�� `@ConditionalOnBean`/`@ConditionalOnMissingBean` ʱ����һ������Ҫ�ر�ע�⣺����ע���ִ��ʱ������ spring �� `ConfigurationClassPostProcessor` �еģ�ȷ�е�˵�����ڽ� `bean` ���뵽 `beanFactory` �� `beanDefinitionMap` ֮ǰ�жϵģ�����������������ӵ� `beanDefinitionMap` �У�����Ͳ����ӡ������͵�����һ�����⣺����� `@ConditionalOnBean`/`@ConditionalOnMissingBean` �� `bean` �ڸ� `bean` ֮����뵽 `beanDefinitionMap` �У����п��ܳ������У�����˵����
+
+�����������ࣺ
+
+```
+@Component
+@ConditionalOnMissingBean("b")
+public class A {
+
+}
+
+@Component
+public class B {
+
+}
+
+```
+
+���� `A` �� `B` �������� `@Component`���������� spring bean��Ȼ���� `A` ��������ע�� `@ConditionalOnMissingBean("b")`�������� `b` ������ʱ��`A` �Ž��г�ʼ����������Щǰ�ᣬ���������������������
+
+1.  ��� `b` �����ӵ� `beanDefinitionMap` �У��ڽ� `a` ���ӵ� `beanDefinitionMap` ʱ������ `b` �Ѿ������ˣ����ǾͲ������ˣ��������ǵ�Ԥ�ڣ�
+2.  ��� `a` �ȱ�������������ʱ������ `beanDefinitionMap` �в�û�� `b`������ `a` �����ӵ� `beanDefinitionMap` �У��ٴ��� `b`��`b` Ҳ�ᱻ���ӵ� `beanDefinitionMap`������һ����`a` �� `b` ͬʱ������ `beanDefinitionMap` �У����ն��ᱻ��ʼ���� spring bean���������ǵ�Ԥ�ڲ�����
+
+��ô springboot ��ν�����������أ����������� `@ConditionalOnBean`/`@ConditionalOnMissingBean` ��˵����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-30df67cb01c73a6b201695298aad14fd0a5.png)
+
+��΢�������£�
+
+������ֻ��ƥ�䵽ĿǰΪֹ��Ӧ�ó����������е� bean �����������ˣ�ǿ�ҽ�������Զ���������ʹ�á������ѡ bean Ҫ����һ���Զ������´�������ȷ��ʹ�ô������������ڴ�֮�����С�
+
+���������ݣ��ҵĽ�����£�
+
+*   �� `@ConditionalOnBean`/`@ConditionalOnMissingBean` ��� `bean` ���뵽 `beanDefinitionMap` ��һ�̣���ƥ��ĿǰΪֹ `beanDefinitionMap` ���Ѵ��ڵ� bean����֮������ bean �����ǣ�����п���������У����Բο�����ٵ� `a` �� `b` ������
+*   ǿ�ҽ�������Զ���������ʹ�� `@ConditionalOnBean`/`@ConditionalOnMissingBean` ������ע�⣬Ҳ����˵���Զ���������ʹ�õĻ�������ȷ����ƥ��
+*   ����������� `a` �� `b` ��������� `a` �� `b` �ֱ�λ�ڲ�ͬ���Զ��������У���ô `a` ��Ҫ�� `b` ֮����ص� `beanDefinitionMap` �У��������ͨ�� `@AutoConfigureAfter`��`@AutoConfigureBefore`��`@AutoConfigureOrder` ��ע����ָ��
+
+�����Զ�������ļ���˳�򣬺������������ɡ�
+
+����ƪ�������ľ��ȵ������ˣ���ƪ��������ʣ�µ�����ע�⡣
+
+* * *
+
+������ springboot ����ע������ĵڶ�ƪ�����������ܽ��� springboot �ļ��������ܽ᣺
+
+| ע������              | ע������                                                     | �����ж���                  |
+| --------------------- | ------------------------------------------------------------ | --------------------------- |
+| class ����ע��        | `@ConditionalOnClass`/`@ConditionalOnMissingClass`           | `OnClassCondition`          |
+| bean ����ע��         | `@ConditionalOnBean`/`@ConditionalOnMissingBean`             | `OnBeanCondition`           |
+| ��������ע��          | `@ConditionalOnProperty`                                     | `OnPropertyCondition`       |
+| Resource ����ע��     | `@ConditionalOnResource`                                     | `OnResourceCondition`       |
+| Web Ӧ������ע��      | `@ConditionalOnWebApplication` / `@ConditionalOnNotWebApplication` | `OnWebApplicationCondition` |
+| spring ����ʽ����ע�� | `@ConditionalOnExpression`                                   | `OnExpressionCondition`     |
+
+���ļ������������жϡ�
+
+### 5. `@ConditionalOnProperty`��`OnPropertyCondition#getMatchOutcome`
+
+������������ `@ConditionalOnProperty` �Ĵ��������� `OnPropertyCondition#getMatchOutcome` ������
+
+```
+class OnPropertyCondition extends SpringBootCondition {
+
+    @Override
+    public ConditionOutcome getMatchOutcome(ConditionContext context, 
+            AnnotatedTypeMetadata metadata) {
+        // ��ȡ @ConditionalOnProperty ������ֵ
+        List<AnnotationAttributes> allAnnotationAttributes = annotationAttributesFromMultiValueMap(
+                metadata.getAllAnnotationAttributes(ConditionalOnProperty.class.getName()));
+        List<ConditionMessage> noMatch = new ArrayList<>();
+        List<ConditionMessage> match = new ArrayList<>();
+        for (AnnotationAttributes annotationAttributes : allAnnotationAttributes) {
+            // �� determineOutcome(...) �����н����жϣ�ע�������context.getEnvironment()
+            ConditionOutcome outcome = determineOutcome(annotationAttributes, 
+                    context.getEnvironment());
+            (outcome.isMatch() ? match : noMatch).add(outcome.getConditionMessage());
+        }
+        if (!noMatch.isEmpty()) {
+            return ConditionOutcome.noMatch(ConditionMessage.of(noMatch));
+        }
+        return ConditionOutcome.match(ConditionMessage.of(match));
+    }
+
+    ...
+
+}
+
+```
+
+����������DZȽϼ򵥵ģ����ǻ�ȡ `@ConditionalOnProperty` ������ֵ���ٵ��� `determineOutcome(...)` �������д������������ٽ��� `OnPropertyCondition#determineOutcome` ������
+
+```
+/**
+ * �������
+ * ע�⣺resolver ����ĵ��� Environment������� applicationContext �е� Environment
+ */
+private ConditionOutcome determineOutcome(AnnotationAttributes annotationAttributes, 
+        PropertyResolver resolver) {
+    Spec spec = new Spec(annotationAttributes);
+    List<String> missingProperties = new ArrayList<>();
+    List<String> nonMatchingProperties = new ArrayList<>();
+    // ��������
+    spec.collectProperties(resolver, missingProperties, nonMatchingProperties);
+    // �жϽ��
+    if (!missingProperties.isEmpty()) {
+        return ConditionOutcome.noMatch(ConditionMessage
+            .forCondition(ConditionalOnProperty.class, spec)
+            .didNotFind("property", "properties").items(Style.QUOTE, missingProperties));
+    }
+    // �жϽ��
+    if (!nonMatchingProperties.isEmpty()) {
+        return ConditionOutcome.noMatch(ConditionMessage
+            .forCondition(ConditionalOnProperty.class, spec)
+            .found("different value in property", "different value in properties")
+            .items(Style.QUOTE, nonMatchingProperties));
+    }
+    // �жϽ��
+    return ConditionOutcome.match(ConditionMessage
+        .forCondition(ConditionalOnProperty.class, spec).because("matched"));
+}
+
+/**
+ * ��������
+ */
+private void collectProperties(PropertyResolver resolver, List<String> missing, 
+        List<String> nonMatching) {
+    for (String name : this.names) {
+        String key = this.prefix + name;
+        // resolver ����� environment
+        // properties �����жϾ����ж� environment ����û����Ӧ����
+        if (resolver.containsProperty(key)) {
+            if (!isMatch(resolver.getProperty(key), this.havingValue)) {
+                nonMatching.add(name);
+            }
+        }
+        else {
+            if (!this.matchIfMissing) {
+                missing.add(name);
+            }
+        }
+    }
+}
+
+```
+
+���Կ�����`@ConditionalOnProperty` ������ͨ���ж� `environment` ���Ƿ��и����������������жϵġ�
+
+### 6. `@ConditionalOnResource`��`OnResourceCondition#getMatchOutcome`
+
+������������ `@ConditionalOnResource` �Ĵ�����һ����������ʹ�ã�
+
+```
+@Bean
+@ConditionalOnResource(resources = "classpath:config.properties")
+public Config config() {
+    return config;
+}
+
+```
+
+��ʾ�� `classpath` �д��� `config.properties` ʱ��`config` �Żᱻ��ʼ�� springbean��
+
+�ٽ��� `OnResourceCondition#getOutcomes` ������
+
+```
+@Override
+public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
+    MultiValueMap<String, Object> attributes = metadata
+            .getAllAnnotationAttributes(ConditionalOnResource.class.getName(), true);
+    // ��ȡ ResourceLoader
+    ResourceLoader loader = context.getResourceLoader();
+    List<String> locations = new ArrayList<>();
+    collectValues(locations, attributes.get("resources"));
+    Assert.isTrue(!locations.isEmpty(),
+            "@ConditionalOnResource annotations must specify at least one resource location");
+    List<String> missing = new ArrayList<>();
+    // �����ж���Դ�Ƿ����
+    for (String location : locations) {
+        // location �п�����ռλ���������ﴦ��
+        String resource = context.getEnvironment().resolvePlaceholders(location);
+        // �ж� resource �Ƿ����
+        if (!loader.getResource(resource).exists()) {
+            missing.add(location);
+        }
+    }
+    // �������
+    if (!missing.isEmpty()) {
+        return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnResource.class)
+                .didNotFind("resource", "resources").items(Style.QUOTE, missing));
+    }
+    return ConditionOutcome.match(ConditionMessage.forCondition(ConditionalOnResource.class)
+            .found("location", "locations").items(locations));
+}
+
+```
+
+����ͨ�� `OnResourceCondition#getOutcomes` ��������ȡ `ResourceLoader`��ͨ�����Է�ʽ���ֵ�ǰ�� `ResourceLoader` Ϊ `AnnotationConfigServletWebServerApplicationContext`��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-8f1de99f757eca7aeb0307b06b28d1020d2.png)
+
+��ȡ�� `ResourceLoader` �󣬵��� `ResourceLoader#getResource(String)` ����ȡ��Դ��Ȼ����� `Resource#exists` ���ж���Դ�Ƿ���ڣ������ƥ������
+
+�������̵Ĺؼ����� `ResourceLoader#getResource(String)`�������������÷����Ĵ��������뵽 `GenericApplicationContext#getResource` ������
+
+```
+@Override
+public Resource getResource(String location) {
+    if (this.resourceLoader != null) {
+        return this.resourceLoader.getResource(location);
+    }
+    return super.getResource(location);
+}
+
+```
+
+����� `this.resourceLoader` Ϊ `null`�����븸��ķ��� `DefaultResourceLoader#getResource`��
+
+```
+public Resource getResource(String location) {
+    Assert.notNull(location, "Location must not be null");
+    for (ProtocolResolver protocolResolver : getProtocolResolvers()) {
+        Resource resource = protocolResolver.resolve(location, this);
+        if (resource != null) {
+            return resource;
+        }
+    }
+    // ����/��ͷ����Դ
+    if (location.startsWith("/")) {
+        return getResourceByPath(location);
+    }
+    else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
+        // ����classpath��ͷ����Դ
+        return new ClassPathResource(
+            location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
+    }
+    else {
+        try {
+            // ���϶������㣬ʹ�� url ������
+            URL url = new URL(location);
+            return (ResourceUtils.isFileURL(url) 
+                ? new FileUrlResource(url) : new UrlResource(url));
+        }
+        catch (MalformedURLException ex) {
+            // url�����������⣬���ջ����� getResourceByPath(...) ������
+            return getResourceByPath(location);
+        }
+    }
+}
+
+/**
+ * ͨ��·���õ� Resource
+ */
+protected Resource getResourceByPath(String path) {
+    return new ClassPathContextResource(path, getClassLoader());
+}
+
+```
+
+���Կ�����`DefaultResourceLoader#getResource` ͨ���ж� `location` ��ǰ׺���õ��� 4 �� `Resource`��
+
+*   `ClassPathContextResource`
+*   `FileUrlResource`
+*   `UrlResource`
+
+�õ� `Resource` �󣬽��ž����жϸ� `Resource` �Ƿ�����ˣ������������� `ClassPathContextResource#exist` �������÷����� `ClassPathResource#exists`��
+
+```
+/**
+ * �ж� Resource �Ƿ����
+ */
+@Override
+public boolean exists() {
+    return (resolveURL() != null);
+}
+
+/**
+ * ��Դ�ܻ�ȡ�����򷵻���Դ��Ӧ��url�����򷵻�null
+ */
+@Nullable
+protected URL resolveURL() {
+    if (this.clazz != null) {
+        // ʹ�õ�ǰ�� class ��Ӧ�� classLoader ����ȡ
+        return this.clazz.getResource(this.path);
+    }
+    else if (this.classLoader != null) {
+        // ʹ��ָ���� classLoader ����ȡ
+        return this.classLoader.getResource(this.path);
+    }
+    else {
+        // ��ȡϵͳ���������ȡ
+        return ClassLoader.getSystemResource(this.path);
+    }
+}
+
+```
+
+�Ӵ�����Կ�����������ͨ�� `classLoader` ��ȡ�ļ��� `url`��ͨ���ж��ļ� `url` �Ƿ�Ϊ `null` ���ж� `resource` �Ƿ���ڡ�
+
+�������� `FileUrlResource` ���жϣ�ʵ���� `FileUrlResource` �� `UrlResource` �� `exist()` �������� `AbstractFileResolvingResource#exists`������ͳһ�����Ϳ����ˣ��÷����������£�
+
+```
+public boolean exists() {
+    try {
+        URL url = getURL();
+        if (ResourceUtils.isFileURL(url)) {
+            // ������ļ���ֱ���ж��ļ��Ƿ����
+            return getFile().exists();
+        }
+        else {
+            // ����ʹ�������ļ�������
+            URLConnection con = url.openConnection();
+            customizeConnection(con);
+            HttpURLConnection httpCon =
+                    (con instanceof HttpURLConnection ? (HttpURLConnection) con : null);
+            // �����http�����жϿ������ӷ��ص�״̬��
+            if (httpCon != null) {
+                int code = httpCon.getResponseCode();
+                if (code == HttpURLConnection.HTTP_OK) {
+                    return true;
+                }
+                else if (code == HttpURLConnection.HTTP_NOT_FOUND) {
+                    return false;
+                }
+            }
+            // ���� contentLengthLong ����0��Ҳ������true
+            if (con.getContentLengthLong() > 0) {
+                return true;
+            }
+            if (httpCon != null) {
+                httpCon.disconnect();
+                return false;
+            }
+            else {
+                getInputStream().close();
+                return true;
+            }
+        }
+    }
+    catch (IOException ex) {
+        return false;
+    }
+}
+
+```
+
+����DZ����ļ���ֱ��ʹ�� `File#exists()` �����ж��ļ��Ƿ���ڣ�������ж������ļ��Ƿ���ڣ��жϷ�ʽ����Ͳ�ϸ˵�ˡ�
+
+�ܵ���˵��springboot �� `@ConditionalOnResource` ���жϻ�����Щ���ӵģ������ܽ����£�
+
+1.  ����� `classpath` �ļ���ͨ�� `classloader` ��ȡ�ļ���Ӧ�� `url` �Ƿ�Ϊ `null` ���ж��ļ��Ƿ���ڣ�
+2.  �������ͨ�ļ�����ֱ�� `File#exists()` �����ж��ļ��Ƿ���ڣ�
+3.  ����������ļ����ȴ�һ���������ӣ��ж��ļ��Ƿ���ڡ�
+
+### 7. `@ConditionalOnWebApplication`��`OnWebApplicationCondition#getMatchOutcome`
+
+������������ `@ConditionalOnWebApplication` �Ĵ��������� `OnWebApplicationCondition#getOutcomes` ������
+
+```
+@Override
+protected ConditionOutcome[] getOutcomes(String[] autoConfigurationClasses,
+        AutoConfigurationMetadata autoConfigurationMetadata) {
+    ConditionOutcome[] outcomes = new ConditionOutcome[autoConfigurationClasses.length];
+    for (int i = 0; i < outcomes.length; i++) {
+        String autoConfigurationClass = autoConfigurationClasses[i];
+        if (autoConfigurationClass != null) {
+            // �������
+            outcomes[i] = getOutcome(autoConfigurationMetadata.get(autoConfigurationClass, 
+                "ConditionalOnWebApplication"));
+        }
+    }
+    return outcomes;
+}
+
+/**
+ * �������
+ * springboot֧�ֵ�web���������֣�SERVLET��REACTIVE
+ */
+private ConditionOutcome getOutcome(String type) {
+    if (type == null) {
+        return null;
+    }
+    ConditionMessage.Builder message = ConditionMessage
+            .forCondition(ConditionalOnWebApplication.class);
+    // ���ָ���������� SERVLET
+    if (ConditionalOnWebApplication.Type.SERVLET.name().equals(type)) {
+        if (!ClassNameFilter.isPresent(SERVLET_WEB_APPLICATION_CLASS, getBeanClassLoader())) {
+            return ConditionOutcome.noMatch(
+                message.didNotFind("servlet web application classes").atAll());
+        }
+    }
+    // ���ָ���������� REACTIVE
+    if (ConditionalOnWebApplication.Type.REACTIVE.name().equals(type)) {
+        if (!ClassNameFilter.isPresent(REACTIVE_WEB_APPLICATION_CLASS, getBeanClassLoader())) {
+            return ConditionOutcome.noMatch(
+                message.didNotFind("reactive web application classes").atAll());
+        }
+    }
+    // ���û��ָ��web����
+    if (!ClassNameFilter.isPresent(SERVLET_WEB_APPLICATION_CLASS, getBeanClassLoader())
+            && !ClassUtils.isPresent(REACTIVE_WEB_APPLICATION_CLASS, getBeanClassLoader())) {
+        return ConditionOutcome.noMatch(
+            message.didNotFind("reactive or servlet web application classes").atAll());
+    }
+    return null;
+}
+
+```
+
+��������ܼ򵥣������߼�Ϊ������ `@ConditionalOnWebApplication` ��ָ�������ͣ��ж϶�Ӧ�����Ƿ���ڣ��жϷ�ʽ�� `@ConditionalOnClass` �ж����Ƿ����һ�£����������Ͷ�Ӧ�������£�
+
+*   Servlet��`org.springframework.web.context.support.GenericWebApplicationContext`
+*   Reactive��`org.springframework.web.reactive.HandlerResult`
+
+### 8. `@ConditionalOnExpression`��`OnExpressionCondition#getMatchOutcome`
+
+������������ `@ConditionalOnExpression` �Ĵ��������� `OnExpressionCondition#getOutcomes` ������
+
+```
+/**
+ * ����ƥ����
+ */
+@Override
+public ConditionOutcome getMatchOutcome(ConditionContext context, 
+        AnnotatedTypeMetadata metadata) {
+    // ��ȡ����ʽ
+    String expression = (String) metadata.getAnnotationAttributes(
+            ConditionalOnExpression.class.getName()).get("value");
+    expression = wrapIfNecessary(expression);
+    ConditionMessage.Builder messageBuilder = ConditionMessage
+            .forCondition(ConditionalOnExpression.class, "(" + expression + ")");
+    // ����ռλ��
+    expression = context.getEnvironment().resolvePlaceholders(expression);
+    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
+    if (beanFactory != null) {
+        // �������ʽ��ֵ
+        boolean result = evaluateExpression(beanFactory, expression);
+        return new ConditionOutcome(result, messageBuilder.resultedIn(result));
+    }
+    return ConditionOutcome.noMatch(messageBuilder.because("no BeanFactory available."));
+}
+
+/**
+ * �������ʽ��ֵ
+ */
+private Boolean evaluateExpression(ConfigurableListableBeanFactory beanFactory, 
+        String expression) {
+    BeanExpressionResolver resolver = beanFactory.getBeanExpressionResolver();
+    if (resolver == null) {
+        resolver = new StandardBeanExpressionResolver();
+    }
+    // �������������ʽ��ֵ
+    BeanExpressionContext expressionContext = new BeanExpressionContext(beanFactory, null);
+    Object result = resolver.evaluate(expression, expressionContext);
+    return (result != null && (boolean) result);
+}
+
+```
+
+���Կ�����springboot ������ͨ�� `BeanExpressionResolver#evaluate` �������������ʽ��������� spring ����ʽ�����ľͲ�չ�������ˡ�
+
+���ˣ�spring ����ע��ķ����͵������ˣ���Ҫ˵�����ǣ�springboot �� ����������ע�⣺
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-0e8d27c887fb6ca142672cad1c60e9de207.png)
+
+��Щע����жϷ�ʽ�뱾�ĵķ�ʽ�����ƣ��Ͳ�һһ���з����ˡ�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4921590](https://my.oschina.net/funcy/blog/4921590) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudConfig.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudConfig.md"
new file mode 100644
index 0000000..cb6a94c
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudConfig.md"
@@ -0,0 +1,833 @@
+�ڷֲ�ʽ΢����ϵͳ�У��������з�������ж��벻�������ļ���֧�֣���Щ�����ļ�ͨ���ɸ����������й������� properties �� yml ��ʽ�����ڸ���΢�������·���£����� application.properties �� application.yml �ȡ�
+
+���ֽ������ļ�ɢ���ڸ��������еĹ�����ʽ�������������⣺
+
+*   **�����Ѷȴ�**�������ļ�ɢ���ڸ���΢�����У����Թ�����
+*   **��ȫ�Ե�**�����ø���Դ���뱣���ڴ�����У������������й©��
+*   **ʱЧ�Բ�**��΢�����е������޸ĺ󣬱����������񣬷����޷���Ч��
+*   **����������**���޷�֧�ֶ�̬������������־���ء����ܿ��ء�
+
+Ϊ�˽����Щ���⣬ͨ�����Ƕ���ʹ���������Ķ����ý���ͳһ�����������Ͽ�Դ�����������кܶ࣬����ٶȵ� Disconf���Ա��� diamond��360 �� QConf��Я�̵� Apollo �ȶ��ǽ����������ġ�Spring Cloud Ҳ���Լ��ķֲ�ʽ�������ģ��Ǿ��� Spring Cloud Config��
+
+## Spring Cloud Config
+
+Spring Cloud Config ���� Spring Cloud �Ŷӿ�������Ŀ��������Ϊ΢����ܹ��и���΢�����ṩ���л����ⲿ����֧�֡�
+
+�򵥵�˵���ǣ�Spring Cloud Config ���Խ�����΢����������ļ����д洢��һ���ⲿ�Ĵ洢�ֿ��ϵͳ������ Git ��SVN �ȣ��У������õ�ͳһ��������֧�ָ���΢��������С�
+Spring Cloud Config ���������������֣�
+
+*   Config Server��Ҳ����Ϊ�ֲ�ʽ�������ģ�����һ���������е�΢����Ӧ�ã������������òֿⲢΪ�ͻ����ṩ��ȡ������Ϣ��������Ϣ�ͽ�����Ϣ�ķ��ʽӿڡ�
+*   Config Client��ָ����΢����ܹ��еĸ���΢��������ͨ�� Config Server �����ý��й��������� Config Sever �л�ȡ�ͼ���������Ϣ��
+
+Spring Cloud Config Ĭ��ʹ�� Git �洢������Ϣ�����ʹ�� Spirng Cloud Config ���������÷�������Ȼ��֧�ֶ�΢�������õİ汾���������ǿ���ʹ�� Git �ͻ��˹��߷���ض��������ݽ��й����ͷ��ʡ����� Git �⣬Spring Cloud Config ���ṩ�˶������洢��ʽ��֧�֣����� SVN�����ػ��ļ�ϵͳ�ȡ�
+
+## Spring Cloud Config ����ԭ��
+
+Spring Cloud Config ����ԭ������ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1019425240-0.png)
+ͼ1��Spring Cloud Config ����ԭ��
+
+Spring Cloud Config �����������£�
+
+1.  ��������ά��Ա�ύ�����ļ���Զ�̵� Git �ֿ⡣
+2.  Config ����ˣ��ֲ�ʽ�������ģ������������òֿ� Git������ Config �ͻ��˱�¶��ȡ���õĽӿڡ�
+3.  Config �ͻ���ͨ�� Config ����˱�¶�����Ľӿڣ���ȡ���òֿ��е����á�
+4.  Config �ͻ��˻�ȡ��������Ϣ����֧�ַ�������С�
+
+## Spring Cloud Config ���ص�
+
+Spring Cloud Config ���������ص㣺
+
+*   Spring Cloud Config �� Spring Cloud �Ŷӿ���������˵�� Spring ���׶��ӣ��ܹ��� Spring ����̬��ϵ�޷켯�ɡ�
+*   Spring Cloud Config ������΢����������ļ����д洢��һ���ⲿ�Ĵ洢�ֿ��ϵͳ������ Git���У�ͳһ������
+*   Spring Cloud Config �������Ľ������� REST �ӿڵ���ʽ��¶������΢�����Է������΢�����ȡ��
+*   ΢�������ͨ�� Spring Cloud Config ����������ͳһ��ȡ���������Լ���������Ϣ��
+*   �����÷����仯ʱ��΢������Ҫ�������ɸ�֪�����õı仯�����Զ���ȡ��Ӧ���������á�
+*   һ��Ӧ�ÿ����ж�����������翪����dev�����������ԣ�test��������������prod�������ȵȣ�������Ա����ͨ�� Spring Cloud Config �Բ�ͬ�����ĸ����ý��й��������ܹ�ȷ��Ӧ���ڻ���Ǩ�ƺ���Ȼ������������֧�����������С�
+
+�������Ǿ�ͨ������ʵ������ʾ Spring Cloud Config ��ʹ�á�
+
+## � Config �����
+
+1\. �� Github �ϴ���һ����Ϊ springcloud-config �IJֿ⣨Repository������ȡ�òֿ�ĵ�ַ������ Github վ����ڹ����û���˵�����ȶ����ܿ��ܴ��ڼ��ػ��������⣬������ǿ�����[����](https://gitee.com/)��ִ�иò�����
+
+2\. �ڸ����� spring-cloud-demo2 �£�����һ����Ϊ micro-service-cloud-config-center-3344 �� Spring Boot ģ�飬���� pom.xml ������ Spring Cloud Config ������������������¡�
+
+
+
+
+
+```
+<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>spring-cloud-demo2</artifactId>
+        <groupId>net.biancheng.c</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+    <groupId>net.biancheng.c</groupId>
+    <artifactId>micro-service-cloud-config-center-3344</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>micro-service-cloud-config-center-3344</name>
+    <description>Demo project for Spring Boot</description>
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!--�������ķ���������-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-config-server</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>
+
+```
+
+
+
+
+
+3\. �� micro-service-cloud-config-center-3344 ��·����/resources Ŀ¼���£�����һ����Ϊ application.yml �������ļ����������¡�
+
+
+
+
+
+```
+
+server:
+  port: 3344 #�˿ں�
+spring:
+  application:
+    name: spring-cloud-config-center #������
+  cloud:
+    config:
+      server:
+        git:
+          # Git ��ַ��https://gitee.com/java-mohan/springcloud-config.git
+          # ���ƣ�gitee����ַ uri: https://github.com/javmohan/springcloud-config.git  (github վ����ʽ����������������ʹ�� gitee)
+          uri: https://gitee.com/java-mohan/springcloud-config.git
+          #�ֿ���
+          search-paths:
+            - springcloud-config
+          force-pull: true
+          # ���Git�ֿ�Ϊ�����ֿ⣬���Բ���д�û��������룬�����˽�вֿ���Ҫ��д
+          # username: ********
+          # password: ********
+      #��֧��
+      label: master
+
+eureka:                                            
+  client: #���ͻ���ע�ᵽ eureka �����б���
+    service-url: 
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/  #������ע�ᵽ Eureka ��Ⱥ
+```
+
+
+
+
+
+4\. �� micro-service-cloud-config-center-3344 �����������ϣ�ʹ�� @EnableConfigServer ע�⿪�� Spring Cloud Config �������Ĺ��ܣ��������¡�
+
+
+
+
+
+```
+package net.biancheng.c;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.config.server.EnableConfigServer;
+import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
+
+@SpringBootApplication
+@EnableEurekaClient
+@EnableConfigServer
+public class MicroServiceCloudConfigCenter3344Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(MicroServiceCloudConfigCenter3344Application.class, args);
+    }
+
+}
+
+```
+
+
+
+
+
+5\. �½�һ����Ϊ config-dev.yml ���ļ����������ϴ��� springcloud-config �ֿ� master ��֧�£�config-dev.yml ���������¡�
+
+```
+config:
+  info: c.biancheng.net
+  version: 1.0
+```
+
+
+6\. ������������ע�����ģ���Ⱥ���� micro-service-cloud-config-center-3344��ʹ����������ʡ�http://localhost:3344/master/config-dev.yml�����������ͼ��
+
+![Spring Cloud Config ���������ļ�](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1019423313-2.png)
+ͼ2�����������ļ�
+
+Spring Cloud Config �涨��һ�������ļ����ʹ������±���
+
+| ���ʹ���                                  | ʾ��                   |
+| ----------------------------------------- | ---------------------- |
+| /{application}/{profile}[/{label}]        | /config/dev/master     |
+| /{application}-{profile}.{suffix}         | /config-dev.yml        |
+| /{label}/{application}-{profile}.{suffix} | /master/config-dev.yml |
+
+���ʹ����ڸ�����˵�����¡�
+
+*   {application}��Ӧ�����ƣ��������ļ������ƣ����� config-dev��
+*   {profile}����������һ����Ŀͨ�����п�����dev���汾�����ԣ�test�������汾��������prod�������汾�������ļ����� application-{profile}.yml ����ʽ�������֣����� application-dev.yml��application-test.yml��application-prod.yml �ȡ�
+*   {label}��Git ��֧����Ĭ���� master ��֧��������Ĭ�Ϸ�֧�µ������ļ�ʱ���ò�������ʡ�ԣ����ڶ��ַ��ʷ�ʽ��
+*   {suffix}�������ļ��ĺ�׺������ config-dev.yml �ĺ�׺Ϊ yml��
+
+ͨ�����׹���������������Ͼ�ֱ�Ӷ������ļ����з��ʡ�
+
+7\. ��������Ϸ��ʡ�http://localhost:3344/config-dev.yml�����������ͼ��
+
+![Spring Cloud Config ���������ļ�2](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1019422606-3.png)
+ͼ3��Spring Cloud Config ���������ļ�
+
+8\. ��������Ϸ��ʡ�http://localhost:3344/config/dev/master����������¡�
+
+```
+{"name":"config","profiles":["dev"],"label":"master","version":"9caafcc3498e04147463482f8b29e925e8afcc3a","state":null,"propertySources":[{"name":"https://gitee.com/java-mohan/springcloud-config.git/config-dev.yml","source":{"config.info":"c.biancheng.net","config.version":1.0}}]}
+```
+
+�Դ����Ǿ�����˶� Spring Cloud Config ����˵Ĵ�Ͳ��ԡ�
+
+## � Config �ͻ���
+
+1\. �ڸ����� spring-cloud-demo2 �£�����һ����Ϊ micro-service-cloud-config-client-3355 �� Spring Boot ģ�飬������ pom.xml ������ Spring Cloud Config �ͻ��˵������������������¡�
+
+
+
+
+
+```
+
+<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>spring-cloud-demo2</artifactId>
+        <groupId>net.biancheng.c</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+    <groupId>net.biancheng.c</groupId>
+    <artifactId>micro-service-cloud-config-client-3355</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>micro-service-cloud-config-client-3355</name>
+    <description>Demo project for Spring Boot</description>
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-devtools</artifactId>
+            <scope>runtime</scope>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <!--Spring Cloud Config �ͻ�������-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-config</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
+```
+
+
+
+
+
+2\. �� micro-service-cloud-config-client-3355 ����·����/resources Ŀ¼���£�����һ����Ϊ bootstrap.yml �������ļ����������¡�
+
+
+
+
+
+```
+#bootstrap.yml ��ϵͳ����ģ��������ȼ����� application.yml ��������ⲿ�������ò�����
+server:
+  port: 3355 #�˿ں�
+spring:
+  application:
+    name: spring-cloud-config-client #������
+  cloud:
+    config:
+      label: master #��֧����
+      name: config  #�����ļ����ƣ�config-dev.yml �е� config
+      profile: dev  #������  config-dev.yml �е� dev
+      #���ﲻҪ�������� http:// �����޷���ȡ
+      uri: http://localhost:3344 #Spring Cloud Config ����ˣ��������ģ���ַ
+
+eureka:
+  client: #���ͻ���ע�ᵽ eureka �����б���
+    service-url:
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/  #������ע�ᵽ Eureka ��Ⱥ
+```
+
+
+
+
+
+3\. �� net.biancheng.c.controller ���£�����һ����Ϊ ConfigClientController ���࣬ͨ�������ȡ�����ļ��е����ã��������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c.controller;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+//��ȡ��������ָ�������ļ������ݣ���չʾ��ҳ��
+@RestController
+public class ConfigClientController {
+    @Value("${server.port}")
+    private String serverPort;
+
+    @Value("${config.info}")
+    private String configInfo;
+
+    @Value("${config.version}")
+    private String configVersion;
+
+    @GetMapping(value = "/getConfig")
+    public String getConfig() {
+        return "info��" + configInfo + "<br/>version��" + configVersion + "<br/>port��" + serverPort;
+    }
+}
+```
+
+
+
+
+
+4\. �� micro-service-cloud-config-client-3355 �����������ϣ�ʹ�� @EnableEurekaClient ע�⿪�� Eureka �ͻ��˹��ܣ��������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
+
+@SpringBootApplication
+@EnableEurekaClient
+public class MicroServiceCloudConfigClient3355Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(MicroServiceCloudConfigClient3355Application.class, args);
+    }
+
+}
+
+```
+
+
+
+
+
+5\. ���� micro-service-cloud-config-client-3355��ʹ����������ʡ�http://localhost:3355/getConfig��,�������ͼ��
+
+![Config �ͻ��˻�ȡ������Ϣ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1019422604-4.png)
+ͼ4��Spring Cloud Config �ͻ��˻�ȡ������Ϣ
+
+6\. �������ļ� config-dev.yml �� config.version ��ֵ�޸�Ϊ 2.0���������¡�
+
+```
+config:
+  info: c.biancheng.net
+  version: 2.0
+```
+
+
+7\. �������� Eureka ����ע�����ģ���Ⱥ���� micro-service-cloud-config-center-3344�� ʹ����������ʡ�http://localhost:3344/master/config-dev.yml�����������ͼ��
+
+![�������Ļ�ȡ�޸ĺ�������ļ�](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10194255O-5.png)
+ͼ5���������Ļ�ȡ�޸ĺ�������ļ�
+
+��ͼ 6 ���Կ��������������Ѿ��ɹ��ػ�ȡ�����޸ĺ�����á�
+
+8\. �ٴη��ʡ�http://localhost:3355/getConfig��������ͨ�� Spring Cloud Config �ͻ��˻�ȡ�޸ĺ��������Ϣ���������ͼ��
+
+![Config �ͻ��˻�ȡ������Ϣ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1019422604-4.png)
+ͼ6��Spring Cloud Config �ͻ��˻�ȡ�޸ĺ��������Ϣ
+
+9\. ���� micro-service-cloud-config-client-3355���ٴ�ʹ�÷��ʡ�http://localhost:3355/getConfig�����������ͼ��
+
+![����Config �ͻ���](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1019425023-7.png)
+ͼ7������ Spring Cloud Config �ͻ��˻�ȡ����
+
+ͨ����ʵ�������ǿ��Եõ����� 2 ����ۣ�
+
+*   ���ø��º�Spring Cloud Config ����ˣ�Server������ֱ�Ӵ� Git �ֿ��л�ȡ���µ����á�
+*   �������� Spring Cloud Config �ͻ��ˣ�Client���������޷�ͨ�� Spring Cloud Config ����˻�ȡ���µ�������Ϣ��
+
+## �ֶ�ˢ������
+
+Ϊ�˽�������� Config �ͻ����޷���ȡ�������õ����⣬�����������ǾͶ� micro-service-cloud-config-client-3355 ���и��죬���첽�����¡�
+
+1\. �� micro-service-cloud-config-client-3355 �� pom.xml �������������������� Spring Boot actuator ���ģ�顣
+
+
+
+
+
+```
+
+
+<dependency>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-actuator</artifactId>
+</dependency>
+
+```
+
+
+
+
+
+2\. �������ļ� bootstrap.yml �������������ã����Ⱪ¶ Spring Boot actuator �ļ�ؽڵ㡣
+
+
+
+
+
+```
+
+# Spring Boot 2.50�� actuator ��������˴�����Ľڵ㣬ֻ��¶�� health �ڵ㣬�������ã�*������Ϊ�˿������еĽڵ�
+management:
+  endpoints:
+    web:
+      exposure:
+        include: "*"   # * ��yaml �ļ����ڹؼ��֣�������Ҫ������
+
+```
+
+
+
+
+
+
+3\. �� ConfigClientController ����ʹ�� @RefreshScope ע�⿪������ˢ�£��������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c.controller;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.cloud.context.config.annotation.RefreshScope;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+// ��ȡ��������ָ�������ļ������ݣ���չʾ��ҳ��
+@RefreshScope //Ϊ���ö�̬���ֶ����Ļ�ȡ���µ�git ���ã������� actuator ��ؼ��� RefreshScope��
+@RestController
+public class ConfigClientController {
+    @Value("${server.port}")
+    private String serverPort;
+
+    @Value("${config.info}")
+    private String configInfo;
+
+    @Value("${config.version}")
+    private String configVersion;
+
+    @GetMapping(value = "/getConfig")
+    public String getConfig() {
+        return "info��" + configInfo + "<br/> version��" + configVersion + "<br/>port��" + serverPort;
+    }
+}
+```
+
+
+
+
+
+4\. ���� micro-service-cloud-config-client-3355��Ȼ�������ļ� config-dev.yml �е� config.version �޸�Ϊ 3.0���������¡�
+
+```
+config:
+  info: c.biancheng.net
+  version: 3.0
+```
+
+
+5\. ʹ��������ٴη��ʡ�http://localhost:3355/getConfig�����������ͼ��
+
+![����Config �ͻ���](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1019425023-7.png)
+ͼ8������ Spring Cloud Config �ͻ��˺��ȡ����
+
+��ͼ 9 ���Կ�������ʹ���Ƕ� Spring Cloud Config �ͻ��˽����˸��죬Ҳ��Ȼ�޷�ֱ�ӻ�ȡ���������á�
+
+6\. �������д��ڣ�ʹ�����������һ�� POST ����ˢ�� Spring Cloud Config 3355 �ͻ��ˣ�֪ͨ�ͻ��������ļ��Ѿ��޸ģ���Ҫ������ȥ���á�
+
+```curl -X POST "http://localhost:3355/actuator/refresh"```
+
+7. ʹ��������ٴη��ʡ�http://localhost:3355/getConfig�����������ͼ��
+
+![�ֶ�ˢ��](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101942C62-9.png)
+ͼ9���ֶ�ˢ�¿ͻ���
+
+#### �ֶ�ˢ�����õ�����
+
+�������ʵ���У�����ͨ���� Config �ͻ��ˣ��˿ںţ�3355�������� Spring Boot actuator ��������������õı仯��ʹ���ǿ����ڲ����� Config �ͻ��˵�����»�ȡ�����������ã�ԭ������ͼ��
+
+![Spring Cloud Config �ֶ�ˢ��](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1019424S8-10.png)
+ͼ10��Spring Cloud Congfig �ֶ�ˢ��
+
+���ַ�ʽ��Ȼ��������� Config �ͻ��˲��ܻ�ȡ�������õ����⣬����һ������ȴҲ����������Ǿ���ֻҪ���òֿ��е����÷����ı䣬����Ҫ���ǰ����� Config �ͻ����ֶ����� POST ����֪ͨ����������ȡ���á�
+
+����֪������ν�� Config �ͻ�����ʵ����һ��һ���ķ�����΢����ܹ��У�һ��ϵͳ��������ʮ��������ʮ�����������Ϊijһ�������ļ����޸Ķ���ʮ��΢������ POST ��������Ȼ�Dz������ġ�
+
+��ô��û�С�һ��֪ͨ��������Ч���ķ�ʽ�أ����ǿ϶��ġ�Spring Cloud Config ��� Bus �Ϳ���ʵ�����õĶ�̬ˢ�¡�
+
+## Config+Bus ʵ�����õĶ�̬ˢ��
+
+Spring Cloud Bus �ֱ���Ϊ��Ϣ���ߣ����ܹ�ͨ������������Ϣ���������� RabbitMQ��Kafka �ȣ���΢����ܹ��еĸ�����������������ʵ�ֹ㲥״̬���ġ��¼����͵ȹ��ܣ�������ʵ��΢����֮���ͨ�Ź��ܡ�
+
+Ŀǰ Spring Cloud Bus ֧��������Ϣ������RabbitMQ �� Kafka��
+
+#### Spring Cloud Bus �Ļ���ԭ��
+
+Spring Cloud Bus ��ʹ��һ������������Ϣ����������һ����������Ϣ���� Topic��Ĭ��Ϊ��springCloudBus��������� Topic �е���Ϣ�ᱻ���з���ʵ�����������ѡ������е�һ������ˢ������ʱ��Spring Cloud Bus �����Ϣ���浽 Topic �У������������ Topic �ķ�����յ���Ϣ���Զ����ѡ�
+
+#### Spring Cloud Bus ��̬ˢ�����õ�ԭ��
+
+���� Spring Cloud Bus ��������ƿ���ʵ�ֺܶ๦�ܣ�������� Spring Cloud Config ʵ�����õĶ�̬ˢ�¾�������͵�Ӧ�ó���֮һ��
+
+�� Git �ֿ��е����÷����˸ı䣬����ֻ��Ҫ��ijһ�����񣨼ȿ����� Config ����ˣ�Ҳ������ Config �ͻ��ˣ�����һ�� POST ����Spring Cloud Bus �Ϳ���ͨ����Ϣ����֪ͨ��������������ȡ�������ã���ʵ�����õĶ�̬ˢ�¡�
+
+Spring Cloud Bus ��̬ˢ�����õĹ���ԭ��������ͼ��ʾ��
+
+![bus+config ��̬ˢ������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101942GY-11.png)
+ͼ11��Bus+Config ʵ�����õĶ�̬ˢ��
+
+����ͼ 12������ Spring Cloud Bus ʵ�����õĶ�̬ˢ����Ҫ���²���:
+
+1.  �� Git �ֿ��е����÷����ı����ά��Ա�� Config ����˷���һ�� POST ��������·��Ϊ��/actuator/refresh����
+2.  Config ����˽��յ�����󣬻Ὣ������ת������������ Spring Cloud Bus��
+3.  Spring Cloud Bus �ӵ���Ϣ�󣬻�֪ͨ������ Config �ͻ��ˡ�
+4.  Config �ͻ��˽��յ�֪ͨ������ Config �������ȡ�������á�
+5.  ���� Config �ͻ��˶���ȡ�����µ����á�
+
+#### Spring Cloud Bus ��̬ˢ�����ã�ȫ�ֹ㲥��
+
+���������� RabbitMQ Ϊ��������ʾ���ʹ�� Config+Bus ʵ�����õĶ�̬ˢ�¡�
+
+1\. �� micro-service-cloud-config-center-3344 �� pom.xml �У����� Spring Boot actuator ���ģ��� Spring Cloud Bus ���������������¡�
+
+
+
+
+
+```
+
+<!--������Ϣ���ߣ�Bus���� RabbitMQ ��֧��-->
+<dependency>
+    <groupId>org.springframework.cloud</groupId>
+    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
+</dependency>
+<!--����Spring Boot actuator ���ģ�������-->
+<dependency>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-actuator</artifactId>
+</dependency>
+
+```
+
+
+
+
+
+2\. �� micro-service-cloud-config-center-3344 �������ļ� application.yml �У����� RabbitMQ �� Spring Boot actuator ��������ã������������¡�
+
+
+
+
+
+```
+##### RabbitMQ ������ã�15672 ��web ��������Ķ˿ڣ�5672 �� MQ �ķ��ʶ˿�###########
+spring:
+  rabbitmq:
+    host: 127.0.0.1
+    port: 5672
+    username: guest
+    password: guest
+
+# Spring Boot 2.50�� actuator ��������˴�����Ľڵ㣬ֻ��¶�� heath �ڵ㣬�������ã�*������Ϊ�˿������еĽڵ�
+management:
+  endpoints:
+    web:
+      exposure:
+        include: 'bus-refresh'
+
+```
+
+
+
+
+
+3\. �� micro-service-cloud-config-client-3355 �� pom.xml �У����� Spring Cloud Bus ������������������¡�
+
+
+
+
+
+```
+
+
+1.  <!--������Ϣ���ߣ�Bus���� RabbitMQ ��֧��-->
+2.  <dependency>
+3.  <groupId>org.springframework.cloud</groupId>
+4.  spring-cloud-starter-bus-amqp
+5.  </dependency>
+
+```
+
+
+
+
+
+4. �� micro-service-cloud-config-client-3355 �������ļ� bootstrap.yml �������������á�
+
+
+
+
+
+```
+
+<!--������Ϣ���ߣ�Bus���� RabbitMQ ��֧��-->
+<dependency>
+    <groupId>org.springframework.cloud</groupId>
+    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
+</dependency>
+
+```
+
+
+
+
+
+5\. ���� micro-service-cloud-config-client-3355���½�һ����Ϊ micro-service-cloud-config-client-bus-3366 �� Spring Boot ģ�飨�˿ں�Ϊ 3366���������������ļ� bootstrap.yml �������������á�
+
+
+
+
+
+```
+
+#bootstrap.yml ��ϵͳ����ģ��������ȼ����� application.yml ��������ⲿ�������ò�����
+server:
+  port: 3366  #�˿ں�Ϊ 3366
+spring:
+  application:
+    name: spring-cloud-config-client-bus
+
+  cloud:
+    config:
+      label: master #��֧����
+      name: config  #�����ļ����ƣ�config-dev.yml �е� config
+      profile: dev  #�����ļ��ĺ�׺��  config-dev.yml �е� dev
+      #���ﲻҪ�������� http:// �����޷���ȡ
+      uri: http://localhost:3344 #spring cloud �������ĵ�ַ
+
+##### RabbitMQ ������ã�15672 ��web ��������Ķ˿ڣ�5672 �� MQ �ķ��ʶ˿�###########
+  rabbitmq:
+    host: 127.0.0.1
+    port: 5672
+    username: guest
+    password: guest
+###################### eureka ���� ####################
+eureka:
+  client: #���ͻ���ע�ᵽ eureka �����б���
+    service-url:
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/  #������ע�ᵽ Eureka ��Ⱥ
+
+# Spring Boot 2.50�� actuator ��������˴�����Ľڵ㣬ֻ��¶�� heath �ڵ㣬�������ã�*������Ϊ�˿������еĽڵ�
+management:
+  endpoints:
+    web:
+      exposure:
+        include: "*"   # * ��yaml �ļ����ڹؼ��֣�������Ҫ������
+
+```
+
+
+
+
+
+6\. �������� micro-service-cloud-config-center-3344��micro-service-cloud-config-client-3355��ʹ����������ʡ�http://localhost:3355/getConfig�����������ͼ��
+
+![Bus ��̬���ø���](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1019422S4-12.png)
+ͼ12��Spring Cloud Bus ��̬ˢ������
+
+7\. ���� micro-service-cloud-config-client-bus-3366��ʹ����������ʡ�http://localhost:3366/getConfig�����������ͼ��
+
+![Bus ��̬����](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10194254S-13.png)
+ͼ13��Spring Cloud Bus ��̬ˢ������
+
+8.  �������ļ� config-dev.yml �е� config.version �޸�Ϊ 4.0���������¡�
+
+```
+config:
+  info: c.biancheng.net
+  version: 4.0
+```
+
+
+9\. �������д��ڣ�ʹ������������ micro-service-cloud-config-center-3344��Config Server������һ�� POST ����ˢ�����á�
+
+```curl -X POST "http://localhost:3344/actuator/bus-refresh"```
+
+10. ʹ��������ٴη��ʡ�http://localhost:3355/getConfig�����������ͼ��
+
+![bus ��̬ˢ������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1019423453-14.png)
+ͼ14��Spring Cloud Bus ��̬ˢ��
+
+11. ʹ��������ٴη��ʡ�http://localhost:3366/getConfig�����������ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10194222Y-15.png)
+ͼ15��Spring Cloud Bus ��̬ˢ��
+
+> ע�⣺��ʹ�� Spring Cloud Bus ʱ�����뱣֤ Bus �����ӵ���Ϣ�������������� RabbitMQ���Ѿ���ȷ��װ������������
+
+#### Spring Cloud Bus ��̬ˢ�����ã�����֪ͨ��
+
+��ν����֪ͨ�����Dz���֪ͨ���е� Config �ͻ��ˣ����Ǹ�������ֻ֪ͨ����ijһ�� Config �ͻ��ˡ�
+
+ʹ�� Spring Cloud Bus ʵ�ֶ���֪ͨ�ķ���ʮ�ּ򵥣�ֻҪ�����ڷ��� POST ����ʱʹ�����¸�ʽ���ɡ�
+
+```http://{hostname}:{port}/actuator/bus-refresh/{destination}```
+
+����˵�����£�
+
+*   {hostname}�� ��ʾ Config ����˵�������ַ���ȿ�����������Ҳ������ IP ��ַ��
+*   {port}����ʾ Config ����˵Ķ˿ں�.
+*   {destination}����ʾ��Ҫ����֪ͨ�� Config �ͻ��ˣ�΢���񣩣��� Config �ͻ��˵ķ�������spring.application.name��+�˿ںţ�server.port����ɣ�����ֻ֪ͨ micro-service-cloud-config-client-3355 ˢ�����ã���ȡֵΪ spring-cloud-config-client:3355��
+
+�������Ǿ�ͨ��һ���򵥵�ʵ��������ʾ�� Spring Cloud Bus ��̬ˢ�µĶ���֪ͨ��
+
+1\. �������ļ� config-dev.yml �е� config.version �޸�Ϊ 5.0���������¡�
+
+```
+config:
+  info: c.biancheng.net
+  version: 5.0
+```
+
+
+2\. �������д��ڣ�ʹ������������ micro-service-cloud-config-center-3344 ����һ�� POST ����
+
+```curl -X POST "http://localhost:3344/actuator/bus-refresh/spring-cloud-config-client:3355"```
+
+3\. ʹ����������ʡ�http://localhost:3355/getConfig�����������ͼ��
+
+![Bus ����֪ͨ 3355](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10194233O-16.png)
+ͼ16��Spring Cloud Bus ����֪ͨ
+
+4\. ʹ��������ٴη��ʡ�http://localhost:3366/getConfig�����������ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10194222Y-15.png)
+ͼ17��Spring Cloud Bus ����֪ͨ
+
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudConsul.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudConsul.md"
new file mode 100644
index 0000000..85fcf19
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudConsul.md"
@@ -0,0 +1,248 @@
+Spring Cloud Consul Ϊ SpringBoot Ӧ���ṩ�� Consul��֧�֣�Consul�ȿ�����Ϊע������ʹ�ã�Ҳ������Ϊ��������ʹ�ã����Ľ������÷�������ϸ���ܡ�
+
+# Consul ���
+
+Consul��HashiCorp��˾�Ƴ��Ŀ�Դ�������ṩ��΢����ϵͳ�еķ����������������ġ��������ߵȹ��ܡ���Щ�����е�ÿһ�������Ը�����Ҫ����ʹ�ã�Ҳ����һ��ʹ���Թ���ȫ��λ�ķ���������֮Consul�ṩ��һ�������ķ���������������
+
+Spring Cloud Consul �����������ԣ�
+
+- ֧�ַ���������Consul��Ϊע������ʱ��΢�����е�Ӧ�ÿ�����Consulע���Լ������ҿ��Դ�Consul��ȡ����Ӧ����Ϣ��
+- ֧�ֿͻ��˸�����⣺����Ribbon��Spring Cloud LoadBalancer��
+- ֧��Zuul����Zuul��Ϊ����ʱ�����Դ�Consul��ע��ͷ���Ӧ�ã�
+- ֧�ֲַ�ʽ���ù�����Consul��Ϊ��������ʱ��ʹ�ü�ֵ�����洢������Ϣ��
+- ֧�ֿ������ߣ�����������΢����ϵͳ��ͨ�� Control Bus �ַ��¼���Ϣ��
+
+# ʹ��Consul��Ϊע������
+
+# ��װ������Consul
+
+- �������Ǵӹ�������Consul����ַ��https://www.consul.io/downloads.html
+
+
+
+- ������ɺ�ֻ��һ��exe�ļ���˫�����У�
+- ������������������������Բ鿴�汾�ţ�
+
+
+
+    consul --version
+
+
+
+- �鿴�汾����Ϣ���£�
+
+
+
+    Consul v1.6.1
+    Protocol 2 spoken by default, understands 2 to 3 (agent will automatically use protocol >2 when speaking to compatible agents)
+
+
+- ʹ�ÿ���ģʽ������
+
+
+
+    consul agent -dev 
+
+
+
+
+
+
+- ͨ�����µ�ַ���Է���Consul����ҳ��http://localhost:8500
+
+
+
+# ����Ӧ��ע�ᵽConsul
+
+����ͨ������user-service��ribbon-service����ʾ�·���ע���뷢�ֵĹ��ܣ���Ҫ�ǽ�Ӧ��ԭ����Eurekaע������֧�ָ�ΪConsulע������֧�֡�
+
+- ����consul-user-serviceģ���consul-ribbon-serviceģ�飻
+- �޸������������ԭ����Eurekaע�ᷢ�ֵ�������ΪConsul�ģ�������SpringBoot Actuator��������
+
+
+
+    <dependency>
+        <groupId>org.springframework.cloud</groupId>
+        spring-cloud-starter-consul-discovery
+    </dependency>
+    <dependency>
+        <groupId>org.springframework.boot</groupId>
+        spring-boot-starter-actuator
+    </dependency>
+
+
+
+
+- �޸������ļ�application.yml����Eureka��ע�ᷢ�����ø�ΪConsul�ģ�
+
+
+
+    server:
+      port: 8206
+    spring:
+      application:
+        name: consul-user-service
+      cloud:
+        consul: #Consul����ע�ᷢ������
+          host: localhost
+          port: 8500
+          discovery:
+            service-name: ${spring.application.name}
+
+
+
+
+- ��������consul-user-service��һ��consul-ribbon-service����Consulҳ���Ͽ��Կ���������Ϣ��
+
+
+
+# ���ؾ��⹦��
+
+������������������consul-user-service����consul-ribbon-serviceĬ�ϻ�ȥ�������Ľӿڣ����ǵ���consul-ribbon-service�Ľӿ�����ʾ�¸��ؾ��⹦�ܡ�
+
+��ε��ýӿڣ�http://localhost:8308/user/1 �����Է�������consul-user-service�Ŀ���̨�����ӡ������Ϣ��
+
+
+
+    2019-10-20 10:39:32.580  INFO 12428 --- [io-8206-exec-10] c.macro.cloud.controller.UserController  : ����id��ȡ�û���Ϣ���û�����Ϊ��macro
+
+
+
+
+# ʹ��Consul��Ϊ��������
+
+����ͨ������consul-config-clientģ�飬����Consul������������Ϣ����ʾ�����ù����Ĺ��ܡ�
+
+# ����consul-config-clientģ��
+
+- ��pom.xml���������������
+
+
+
+    <dependency>
+        <groupId>org.springframework.cloud</groupId>
+        spring-cloud-starter-consul-config
+    </dependency>
+    <dependency>
+        <groupId>org.springframework.cloud</groupId>
+        spring-cloud-starter-consul-discovery
+    </dependency>
+
+
+
+- ���������ļ�application.yml�����õ���dev���������ã�
+
+
+
+    spring:
+      profiles:
+        active: dev
+
+
+
+
+- ���������ļ�bootstrap.yml����Ҫ�Ƕ�Consul�����ù��ܽ������ã�
+
+
+
+    server:
+      port: 9101
+    spring:
+      application:
+        name: consul-config-client
+      cloud:
+        consul:
+          host: localhost
+          port: 8500
+          discovery:
+            serviceName: consul-config-client
+          config:
+            enabled: true #�Ƿ������������Ĺ���
+            format: yaml #��������ֵ�ĸ�ʽ
+            prefix: config #������������Ŀ¼
+            profile-separator: ':' #�������õķָ���
+            data-key: data #����key�����֣�����Consul��K/V�洢�����ô洢�ڶ�ӦK��V��
+
+
+- ����ConfigClientController����Consul���������л�ȡ������Ϣ��
+
+
+
+    /**
+     * Created by macro on 2019/9/11.
+     */
+    @RestController
+    @RefreshScope
+    public class ConfigClientController {
+    
+        @Value("${config.info}")
+        private String configInfo;
+    
+        @GetMapping("/configInfo")
+        public String getConfigInfo() {
+            return configInfo;
+        }
+    }
+
+
+# ��Consul����������
+
+- ��consul���������ô洢��keyΪ:
+
+
+
+    config/consul-config-client:dev/data
+
+
+
+
+
+- ��consul���������ô洢��valueΪ��
+
+
+
+    config:
+      info: "config info for dev"
+
+
+
+
+- �洢��Ϣ��ͼ���£�
+
+
+
+- ����consul-config-client�����ýӿڲ鿴������Ϣ��http://localhost:9101/configInfo
+
+
+
+    config info for dev
+
+
+
+
+# Consul�Ķ�̬ˢ������
+
+����ֻҪ�޸���Consul�е�������Ϣ���ٴε��ò鿴���õĽӿڣ��ͻᷢ�������Ѿ�ˢ�¡���������ʹ��Spring Cloud Config��ʱ��������Ҫ���ýӿڣ�ͨ��Spring Cloud Bus����ˢ�����á�Consulʹ�����Դ���Control Bus ʵ����һ���¼����ݻ��ƣ��Ӷ�ʵ���˶�̬ˢ�¹��ܡ�
+
+# ʹ�õ���ģ��
+
+
+
+    springcloud-learning
+    ������ consul-config-client -- ������ʾconsul��Ϊ�������ĵ�consul�ͻ���
+    ������ consul-user-service -- ע�ᵽconsul���ṩUser����CRUD�ӿڵķ���
+    ������ consul-service -- ע�ᵽconsul��ribbon������ò��Է���
+
+
+
+
+# ��ĿԴ���ַ
+
+https://github.com/macrozheng/springcloud-learning
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudEureka.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudEureka.md"
new file mode 100644
index 0000000..960e5c7
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudEureka.md"
@@ -0,0 +1,1052 @@
+Eureka һ����Դ�ڹ�ϣ���ʻ㣬�ǡ������ˡ�����˼������������Eureka �� Netflix ��˾������һ�Դ�ķ���ע���뷢�������
+
+Spring Cloud �� Eureka �� Netflix �е�������Դ������������� Ribbon��Feign �Լ� Hystrix �ȣ�һ�����Ͻ� Spring Cloud Netflix ģ���У����Ϻ�����ȫ��Ϊ Spring Cloud Netflix Eureka��
+
+Eureka �� Spring Cloud Netflix ģ�����ģ�飬���� Spring Cloud �� Netflix Eureka �Ķ��η�װ����Ҫ���� Spring Cloud �ķ���ע���뷢�ֹ��ܡ�
+
+Spring Cloud ʹ�� Spring Boot ˼��Ϊ Eureka �������Զ������ã�������Աֻ��Ҫ�������������ע�⣬���ܽ� Spring Boot ������΢�������ɵ��� Eureka �������ϡ�
+
+## Eureka �������
+
+Eureka ���� CS��Client/Server���ͻ���/�������� �ܹ����������������������
+
+*   **Eureka Server**��Eureka ����ע�����ģ���Ҫ�����ṩ����ע�Ṧ�ܡ���΢��������ʱ���Ὣ�Լ��ķ���ע�ᵽ Eureka Server��Eureka Server ά����һ�����÷����б����洢������ע�ᵽ Eureka Server �Ŀ��÷������Ϣ����Щ���÷�������� Eureka Server �Ĺ���������ֱ�ۿ�����
+*   **Eureka Client**��Eureka �ͻ��ˣ�ͨ��ָ����΢����ϵͳ�и���΢������Ҫ���ں� Eureka Server ���н�������΢����Ӧ��������Eureka Client ���� Eureka Server ����������Ĭ������Ϊ 30 �룩���� Eureka Server �ڶ������������û�н��յ�ij�� Eureka Client ��������Eureka Server �����ӿ��÷����б����Ƴ���Ĭ�� 90 �룩��
+
+> ע����������ָ����һ�ζ�ʱ���͵��Զ�����Ϣ���öԷ�֪���Լ���������ȷ�����ӵ���Ч�ԡ��󲿷� CS �ܹ���Ӧ�ó��򶼲������������ƣ�����˺Ϳͻ��˶����Է�������ͨ��������ǿͻ�����������˷���������������������жϿͻ����Ƿ����ߡ�
+
+## Eureka ����ע���뷢��
+
+Eureka ʵ�ַ���ע���뷢�ֵ�ԭ��������ͼ��ʾ��
+
+![Eureka ����ע���뷢��](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1010305209-0.png)
+ͼ1��Eureka ԭ��ͼ
+
+��ͼ�й��漰������ 3 ����ɫ��
+
+*   **����ע�����ģ�Register Service��**������һ�� Eureka Server�������ṩ����ע��ͷ��ֹ��ܡ�
+*   **�����ṩ�ߣ�Provider Service��**������һ�� Eureka Client�������ṩ���������Լ��ṩ�ķ���ע�ᵽ����ע�����ģ��Թ����������߷��֡�
+*   **���������ߣ�Consumer Service��**������һ�� Eureka Client���������ѷ��������Դӷ���ע�����Ļ�ȡ�����б�����������ķ���
+
+Eureka ʵ�ַ���ע���뷢�ֵ��������£�
+
+1.  �һ�� Eureka Server ��Ϊ����ע�����ģ�
+2.  �����ṩ�� Eureka Client ����ʱ����ѵ�ǰ����������Ϣ�Է�������spring.application.name���ķ�ʽע�ᵽ����ע�����ģ�
+3.  ���������� Eureka Client ����ʱ��Ҳ�������ע������ע�᣻
+4.  ���������߻����ȡһ�ݿ��÷����б������б��а���������ע�ᵽ����ע�����ĵķ�����Ϣ�����������ṩ�ߺ���������Ϣ����
+5.  �ڻ���˿��÷����б��󣬷���������ͨ�� HTTP ����Ϣ�м��Զ�̵��÷����ṩ���ṩ�ķ���
+
+����ע�����ģ�Eureka Server�������ݵĽ�ɫʮ����Ҫ�����Ƿ����ṩ�ߺͷ���������֮��������������ṩ��ֻ�н��Լ��ķ���ע�ᵽ����ע�����IJſ��ܱ����������ߵ��ã�������������Ҳֻ��ͨ������ע�����Ļ�ȡ���÷����б��󣬲��ܵ�������ķ���
+
+## ʾ�� 1
+
+���棬����ͨ��һ��������չʾ�� Eureka �����ʵ�ַ���ע���뷢�ֵġ�
+
+#### 1\. ���������̣�Maven Project��
+
+���ڱ������У����漰������� Spring Boot ������΢����Ϊ�˷���������������Dz��� Maven �Ķ� Module �ṹ����һ�� Project ������� Module�����������̡�
+
+����һ����Ϊ spring-cloud-demo2 �� Maven ������ ��Ȼ���ڸ������̵� pom.xml ��ʹ�� dependencyManagement ������ Spring Cloud �İ汾���������¡�
+
+
+
+
+
+```
+
+<?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>
+    <packaging>pom</packaging>
+    <modules>
+        <module>micro-service-cloud-api</module>
+    </modules>
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>2.3.6.RELEASE</version>
+        <relativePath/> <!-- lookup parent from repository -->
+    </parent>
+    <groupId>net.biancheng.c</groupId>
+    <artifactId>spring-cloud-demo2</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <junit.version>4.12</junit.version>
+        <log4j.version>1.2.17</log4j.version>
+        <lombok.version>1.16.18</lombok.version>
+    </properties>
+    <dependencyManagement>
+        <dependencies>
+            <!--����������ʹ�� dependencyManagement ���� Spring Cloud �İ汾��
+            ���������ڵ� Module ������ Spring Cloud �������ʱ���Ͳ�������������İ汾��Ϣ
+            ��֤ Spring Cloud �������һ����-->
+            <dependency>
+                <groupId>org.springframework.cloud</groupId>
+                <artifactId>spring-cloud-dependencies</artifactId>
+                <version>Hoxton.SR12</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+    <build>
+        <finalName>microservicecloud</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-resources-plugin</artifactId>
+                <configuration>
+                    <delimiters>
+                        <delimit>$</delimit>
+                    </delimiters>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
+
+```
+
+
+
+
+
+#### 2\. ����������ģ�飨Maven Module��
+
+1) ���������£�����һ����Ϊ micro-service-cloud-api �� Maven Module��micro-service-cloud-api���� pom.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">
+    <parent>
+        <artifactId>spring-cloud-demo2</artifactId>
+        <groupId>net.biancheng.c</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>micro-service-cloud-api</artifactId>
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+        </dependency>
+    </dependencies>
+</project>
+
+```
+
+
+
+
+
+> ע��micro-service-cloud-api ���������̵Ĺ�����ģ�飬��������һЩ������ģ�鹲�е����ݣ�����ʵ���ࡢ���������ࡢ����������ȡ���������ģ����Ҫʹ�ù�����ģ���е�����ʱ��ֻ��Ҫ���� pom.xml ���빫����ģ����������ɡ�
+
+2) �� micro-service-cloud-api �� net.biancheng.c.entity ���£�����һ����Ϊ Dept ��ʵ���࣬�������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c.entity;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+@NoArgsConstructor //�޲ι��캯��
+@Data // �ṩ���get��set��equals��hashCode��canEqual��toString ����
+@Accessors(chain = true)
+public class Dept implements Serializable {
+    private Integer deptNo;
+    private String deptName;
+    private String dbSource;
+}
+
+```
+
+
+
+
+
+#### 3\. �����ע������
+
+1) ���������´���һ����Ϊ micro-service-cloud-eureka-7001 �� Spring Boot Module ��Ϊ����ע�����ģ������� pom.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <!--�̳������̵� POM-->
+    <parent>
+        <artifactId>spring-cloud-demo2</artifactId>
+        <groupId>net.biancheng.c</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+    <groupId>net.biancheng.c</groupId>
+    <artifactId>micro-service-cloud-eureka-7001</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>micro-service-cloud-eureka-7001</name>
+    <description>Demo project for Spring Boot</description>
+
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <!--Ϊ����ע���������� Eureka Server ������-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
+        </dependency>
+        <!--devtools �� lombok ��Ϊ��������ģ�飬���������ʵ�ѡ��-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-devtools</artifactId>
+            <scope>runtime</scope>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
+```
+
+
+
+
+
+2) �� micro-service-cloud-eureka-7001 ����·����/resouces Ŀ¼���£�����һ�������ļ� application.yml�������������¡�
+
+
+
+
+
+```
+server:
+  port: 7001  #�� Module �Ķ˿ں�
+
+eureka:
+  instance:
+    hostname: localhost #eureka����˵�ʵ�����ƣ�
+
+  client:
+    register-with-eureka: false #false��ʾ����ע������ע���Լ���
+    fetch-registry: false #false��ʾ�Լ��˾���ע�����ģ��ҵ�ְ�����ά������ʵ����������Ҫȥ��������
+    service-url:
+      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #���������ע������
+```
+
+
+
+
+
+3) �� micro-service-cloud-eureka-7001 ������������ʹ�� @EnableEurekaServer ע�⿪������ע�����Ĺ��ܣ��������������ע�ᣬ�������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
+@SpringBootApplication
+@EnableEurekaServer //���� Eureka server,��������΢�����ע��
+public class MicroServiceCloudEureka7001Application {
+    public static void main(String[] args) {
+        SpringApplication.run(MicroServiceCloudEureka7001Application.class, args);
+    }
+}
+
+```
+
+
+
+
+
+4) ���� micro-service-cloud-eureka-7001��ʹ����������� Eureka ����ע��������ҳ����ַΪ��http://localhost:7001/�����������ͼ��
+
+![Eureka Server 7001 ����ע������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1010306360-1.png)
+
+ͼ2��Eureka 7001 ����ע������
+
+#### 4\. ������ṩ��
+
+1) ���������´���һ����Ϊ micro-service-cloud-provider-dept-8001 �� Spring Boot Module�������� pom.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <!--���븸����pom-->
+    <parent>
+        <artifactId>spring-cloud-demo2</artifactId>
+        <groupId>net.biancheng.c</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <groupId>net.biancheng.c</groupId>
+    <artifactId>micro-service-cloud-provider-dept-8001</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>micro-service-cloud-provider-dept-8001</name>
+    <description>Demo project for Spring Boot</description>
+
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+    <dependencies>
+        <!--Spring Boot Web-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <!--devtools ��������-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-devtools</artifactId>
+            <scope>runtime</scope>
+            <optional>true</optional>
+        </dependency>
+        <!--Spring Boot ����-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!--���빫����ģ��-->
+        <dependency>
+            <groupId>net.biancheng.c</groupId>
+            <artifactId>micro-service-cloud-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <!--junit ����-->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+        </dependency>
+        <!--mysql ����-->
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>5.1.49</version>
+        </dependency>
+        <!--logback ��־-->
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-core</artifactId>
+        </dependency>
+        <!--���� mybatis -->
+        <dependency>
+            <groupId>org.mybatis.spring.boot</groupId>
+            <artifactId>mybatis-spring-boot-starter</artifactId>
+            <version>2.2.0</version>
+        </dependency>
+        <!-- �޸ĺ�������Ч���Ȳ��� -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>springloaded</artifactId>
+            <version>1.2.8.RELEASE</version>
+        </dependency>
+        <!--���� Eureka Client ��������������ע�ᵽ Eureka Server-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
+        </dependency>
+        <!-- Spring Boot ���ģ��-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <!--mybatis�Զ����ɴ�����-->
+            <plugin>
+                <groupId>org.mybatis.generator</groupId>
+                <artifactId>mybatis-generator-maven-plugin</artifactId>
+                <version>1.4.0</version>
+                <configuration>
+                    <configurationFile>src/main/resources/mybatis-generator/generatorConfig.xml</configurationFile>
+                    <verbose>true</verbose>
+                    <!-- �Ƿ񸲸ǣ�true��ʾ���滻���ɵ�JAVA�ļ���false�򲻸��� -->
+                    <overwrite>true</overwrite>
+                </configuration>
+                <dependencies>
+                    <!--mysql������-->
+                    <dependency>
+                        <groupId>mysql</groupId>
+                        <artifactId>mysql-connector-java</artifactId>
+                        <version>5.1.49</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>org.mybatis.generator</groupId>
+                        <artifactId>mybatis-generator-core</artifactId>
+                        <version>1.4.0</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>
+
+```
+
+
+
+
+
+2) �� micro-service-cloud-provider-dept-8001 ��·����/resources Ŀ¼���£����������ļ� application.yml�������������¡�
+
+
+
+
+
+```
+
+server:
+  port: 8001 #����˿ں�
+spring:
+  application:
+    name: microServiceCloudProviderDept  #΢�������ƣ����Ⱪ©��΢�������ƣ�ʮ����Ҫ
+################################################## JDBC ͨ������  ##########################################
+  datasource:
+    username: root        #���ݿ��½�û���
+    password: root        #���ݿ��½����
+    url: jdbc:mysql://127.0.0.1:3306/bianchengbang_jdbc       #���ݿ�url
+    driver-class-name: com.mysql.jdbc.Driver                  #���ݿ�����
+
+############################### ����� spring.config.import=configserver:##################
+#  cloud:
+#    config:
+#      enabled: false
+###################################### MyBatis ���� ######################################
+mybatis:
+  # ָ�� mapper.xml ��λ��
+  mapper-locations: classpath:mybatis/mapper/*.xml
+  #ɨ��ʵ�����λ��,�ڴ˴�ָ��ɨ��ʵ����İ����� mapper.xml �оͿ��Բ�дʵ�����ȫ·����
+  type-aliases-package: net.biancheng.c.entity
+  configuration:
+    #Ĭ�Ͽ����շ������������Բ������ø�����
+    map-underscore-to-camel-case: true
+########################################### Spring cloud �Զ���������ƺ� ip ��ַ###############################################
+eureka:
+  client: #���ͻ���ע�ᵽ eureka �����б���
+    service-url:
+      defaultZone: http://eureka7001.com:7001/eureka  #�����ַ�� 7001ע�������� application.yml �б�¶������ע���ַ �������棩
+
+  instance:
+    instance-id: spring-cloud-provider-8001 #�Զ������������Ϣ
+    prefer-ip-address: true  #��ʾ����·���� ip ��ַ
+########################################## spring cloud ʹ�� Spring Boot actuator ���������Ϣ###################################
+# Spring Boot 2.50�� actuator ��������˴�����Ľڵ㣬ֻ��¶�� heath �ڵ㣬�������ã�*������Ϊ�˿������еĽڵ�
+management:
+  endpoints:
+    web:
+      exposure:
+        include: "*"   # * ��yaml �ļ����ڹؼ��֣�������Ҫ������
+info:
+  app.name: micro-service-cloud-provider-dept
+  company.name: c.biancheng.net
+  build.aetifactId: @project.artifactId@
+  build.version: @project.version@
+```
+
+
+
+
+
+3) �� net.biancheng.c.mapper ���´���һ����Ϊ DeptMapper �Ľӿڣ��������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c.mapper;
+import net.biancheng.c.entity.Dept;
+import org.apache.ibatis.annotations.Mapper;
+import java.util.List;
+@Mapper
+public interface DeptMapper {
+    //����������ȡ����
+    Dept selectByPrimaryKey(Integer deptNo);
+    //��ȡ���е�ȫ������
+    List<Dept> GetAll();
+}
+
+```
+
+
+
+
+
+4) �� resources/mybatis/mapper/ Ŀ¼�£�����һ����Ϊ DeptMapper.xml �� MyBatis ӳ���ļ��������������¡�
+
+
+
+
+
+```
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="net.biancheng.c.mapper.DeptMapper">
+    <resultMap id="BaseResultMap" type="net.biancheng.c.entity.Dept">
+        <id column="dept_no" jdbcType="INTEGER" property="deptNo"/>
+        <result column="dept_name" jdbcType="VARCHAR" property="deptName"/>
+        <result column="db_source" jdbcType="VARCHAR" property="dbSource"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        dept_no
+        , dept_name, db_source
+    </sql>
+
+    <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
+        select
+        <include refid="Base_Column_List"/>
+        from dept
+        where dept_no = #{deptNo,jdbcType=INTEGER}
+    </select>
+    <select id="GetAll" resultType="net.biancheng.c.entity.Dept">
+        select *
+        from dept;
+    </select>
+</mapper>
+
+```
+
+
+
+
+
+5) �� net.biancheng.c.service ���´���һ����Ϊ DeptService �Ľӿڣ��������¡�
+
+
+
+
+
+```
+
+
+package net.biancheng.c.service;
+import net.biancheng.c.entity.Dept;
+import java.util.List;
+public interface DeptService {
+    Dept get(Integer deptNo);
+    List<Dept> selectAll();
+}
+
+```
+
+
+
+
+
+6) �� net.biancheng.c.service.impl ���´��� DeptService �ӿڵ�ʵ���� DeptServiceImpl���������¡�
+
+
+
+
+
+```
+package net.biancheng.c.service.impl;
+
+import net.biancheng.c.entity.Dept;
+import net.biancheng.c.mapper.DeptMapper;
+import net.biancheng.c.service.DeptService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service("deptService")
+public class DeptServiceImpl implements DeptService {
+    @Autowired
+    private DeptMapper deptMapper;
+
+    @Override
+    public Dept get(Integer deptNo) {
+        return deptMapper.selectByPrimaryKey(deptNo);
+    }
+
+    @Override
+    public List<Dept> selectAll() {
+        return deptMapper.GetAll();
+    }
+}
+
+```
+
+
+
+
+
+7) �� net.biancheng.c.controller ���´���һ����Ϊ DeptController �� Controller �࣬�������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c.controller;
+
+import lombok.extern.slf4j.Slf4j;
+import net.biancheng.c.entity.Dept;
+import net.biancheng.c.service.DeptService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+* �����ṩ�ߵĿ��Ʋ�
+* author:c���������� c.biancheng.net
+*/
+@RestController
+@Slf4j
+public class DeptController {
+    @Autowired
+    private DeptService deptService;
+  
+    @Value("${server.port}")
+    private String serverPort;
+
+    @RequestMapping(value = "/dept/get/{id}", method = RequestMethod.GET)
+    public Dept get(@PathVariable("id") int id) {
+        return deptService.get(id);
+    }
+
+    @RequestMapping(value = "/dept/list", method = RequestMethod.GET)
+    public List<Dept> list() {
+        return deptService.selectAll();
+    }
+}
+```
+
+
+
+
+
+8) �� micro-service-cloud-provider-dept-8001 �����������ϣ�ʹ�� @EnableEurekaClient ע�⿪�� Eureka �ͻ��˹��ܣ�������ע�ᵽ����ע�����ģ�Eureka Server�����������¡�
+
+
+
+
+
+```
+
+
+package net.biancheng.c;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
+
+@SpringBootApplication
+@EnableEurekaClient // Spring cloud Eureka �ͻ��ˣ��Զ���������ע�ᵽ Eureka Server ע��������
+public class MicroServiceCloudProviderDept8001Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(MicroServiceCloudProviderDept8001Application.class, args);
+    }
+}
+
+```
+
+
+
+
+
+9) �������� micro-service-cloud-eureka-7001 �� micro-service-cloud-provider-dept-8001��ʹ����������ٴ��� Eureka ����ע��������ҳ��http://localhost:7001/��������ͼ��
+
+![Eureka Client ע�ᵽ����ע������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1010304436-2.png)
+ͼ3�������ṩ��ע�ᵽ����ע������
+
+��ͼ 3 ���Կ����� Instances currently registered with Eureka ��ע�ᵽ Eureka Server ��ʵ����ѡ�����Ѿ�������һ��������Ϣ�����Ѿ��з���ע�ᵽ Eureka Server ���ˡ�
+
+Instances currently registered with Eureka ѡ���а����������ݣ�
+
+*   Application��MICROSERVICECLOUDPROVIDERDEPT����ȡֵΪ micro-service-cloud-provider-dept-8001 �����ļ� application.yml �� spring.application.name ��ȡֵ��
+*   Status�� UP (1) - spring-cloud-provider-8001��UP ��ʾ�������ߣ� (1) ��ʾ�м�Ⱥ�з����������spring-cloud-provider-8001 ���� micro-service-cloud-provider-dept-8001 �����ļ� application.yml �� eureka.instance.instance-id ��ȡֵ��
+
+10) �� MySQL �� bianchengbang_jdbc ���ݿ���ִ������ SQL��׼���������ݡ�
+
+```
+DROP TABLE IF EXISTS `dept`;
+CREATE TABLE `dept` (
+  `dept_no` int NOT NULL AUTO_INCREMENT,
+  `dept_name` varchar(255) DEFAULT NULL,
+  `db_source` varchar(255) DEFAULT NULL,
+  PRIMARY KEY (`dept_no`)
+) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+
+
+INSERT INTO `dept` VALUES ('1', '������', 'bianchengbang_jdbc');
+INSERT INTO `dept` VALUES ('2', '���²�', 'bianchengbang_jdbc');
+INSERT INTO `dept` VALUES ('3', '����', 'bianchengbang_jdbc');
+INSERT INTO `dept` VALUES ('4', '���', 'bianchengbang_jdbc');
+INSERT INTO `dept` VALUES ('5', '����', 'bianchengbang_jdbc');
+```
+
+11) ʹ����������ʡ�http://localhost:8001/dept/list�����������ͼ��
+
+![Eureka Client 8001 �������ݿ�](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1010301b2-3.png)
+ͼ4�������ṩ���ṩ����������ݿ�
+
+## Eureka Server ��Ⱥ
+
+��΢����ܹ��У�һ��ϵͳ������ʮ��������ʮ��������ɣ�������Щ����ȫ��ע�ᵽͬһ�� Eureka Server �У��ͼ��п��ܵ��� Eureka Server �򲻿��ظ������������յ�������ϵͳ̱����������������ֱ�ӵİ취���Dz��� Eureka Server ��Ⱥ��
+
+����֪������ Eureka ʵ�ַ���ע���뷢��ʱһ���漰�� 3 ����ɫ������ע�����ġ������ṩ���Լ����������ߣ���������ɫ�ֹ���ȷ����˾��ְ��������ʵ�� Eureka �У����з��񶼼��Ƿ���������Ҳ�Ƿ����ṩ�ߣ�����ע������ Eureka Server Ҳ�����⡣
+
+�����ڴ����ע������ʱ���� application.yml ���漰�����������ã�
+
+
+
+
+
+```
+
+
+eureka:
+  client:
+    register-with-eureka: false  #false ��ʾ����ע������ע���Լ���
+    fetch-registry: false  #false��ʾ�Լ��˾���ע�����ģ�ְ�����ά������ʵ����������Ҫȥ��������
+```
+
+
+
+
+
+�������õ�ԭ���� micro-service-cloud-eureka-7001 �����Լ����Ƿ���ע�����ģ�����ע�������Dz��ܽ��Լ�ע�ᵽ�Լ����ϵģ�������ע�������ǿ��Խ��Լ���Ϊ�����������ķ���ע������ע���Լ��ġ�
+
+�ٸ����ӣ������� Eureka Server �ֱ�Ϊ A �� B����Ȼ A ���ܽ��Լ�ע�ᵽ A �ϣ�B Ҳ���ܽ��Լ�ע�ᵽ B �ϣ��� A �ǿ�����Ϊһ��������Լ�ע�ᵽ B �ϵģ�ͬ�� B Ҳ���Խ��Լ�ע�ᵽ A �ϡ�
+
+�����Ϳ����γ�һ�黥��ע��� Eureka Server ��Ⱥ���������ṩ�߷���ע������ Eureka Server ʱ��Eureka Server �Ὣ����ת������Ⱥ��������֮������ Eureka Server �ϣ���ʵ�� Eureka Server ֮��ķ���ͬ����
+
+ͨ������ͬ�������������߿����ڼ�Ⱥ�е�����һ̨ Eureka Server �ϻ�ȡ�����ṩ���ṩ�ķ�����������ʹ��Ⱥ�е�ij������ע�����ķ������ϣ�������������Ȼ���ԴӼ�Ⱥ�е����� Eureka Server �л�ȡ������Ϣ�����ã������ᵼ��ϵͳ������̱��������� Eureka Server ��Ⱥ�ĸ߿����ԡ�
+
+## ʾ�� 2
+
+����������ʾ�� 1 �Ļ����Ͻ�����չ������һ��ӵ�� 3 �� Eureka Server ʵ���ļ�Ⱥ��
+
+1\. ���� micro-service-cloud-eureka-7001 �Ĵ���̣����������������ٴ������� Eureka Server��micro-service-cloud-eureka-7002 �� micro-service-cloud-eureka-7003����ʱ�� 3 �� Eureka Server ������ Maven ���������뻹�����ö���һģһ���ġ�
+
+2\. �޸� micro-service-cloud-eureka-7001��micro-service-cloud-eureka-7002��micro-service-cloud-eureka-7003 �� application.yml �����ã������������� ��
+
+micro-service-cloud-eureka-7001 �� application.yml ���������¡�
+
+
+
+
+
+```
+server:
+  port: 7001  #�˿ں�
+eureka:
+  instance:
+    hostname: eureka7001.com #eureka����˵�ʵ������
+  client:
+    register-with-eureka: false #false ��ʾ����ע������ע���Լ���
+    fetch-registry: false #false ��ʾ�Լ��˾���ע�����ģ��ҵ�ְ�����ά������ʵ����������Ҫȥ��������
+    service-url:
+      #defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #������
+      defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/ #��Ⱥ�� ����ǰ�� Eureka Server ע�ᵽ 7003 �� 7003 �ϣ��γ�һ�黥��ע��� Eureka Server ��Ⱥ
+```
+
+
+
+
+
+micro-service-cloud-eureka-7002 �� application.yml ���������¡�
+
+
+
+
+
+```
+
+server:
+  port: 7002 #�˿ں�
+
+eureka:
+  instance:
+    hostname: eureka7002.com #Eureka Server ʵ������
+
+  client:
+    register-with-eureka: false #false ��ʾ����ע������ע���Լ���
+    fetch-registry: false  #false ��ʾ�Լ��˾���ע�����ģ��ҵ�ְ�����ά������ʵ����������Ҫȥ��������
+    service-url:
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7003.com:7003/eureka/ #����� Eureka Server ע�ᵽ 7001 �� 7003 ��
+```
+
+
+
+
+
+micro-service-cloud-eureka-7003 �� application.yml ���������¡�
+
+
+
+
+
+```
+
+server:
+  port: 7003 #�˿ں�
+
+eureka:
+  instance:
+    hostname: eureka7003.com #Eureka Server ʵ������
+
+  client:
+    register-with-eureka: false #false ��ʾ����ע������ע���Լ���
+    fetch-registry: false  #false ��ʾ�Լ��˾���ע�����ģ��ҵ�ְ�����ά������ʵ����������Ҫȥ��������
+    service-url:
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/ #����� Eureka Server ע�ᵽ 7001 �� 7002 ��
+```
+
+
+
+
+
+3\. �����������ڱ��ش�� Eureka Server ��Ⱥ�����������Ҫ�޸ı��ص� host �ļ���Windows ����ϵͳ�ĵ����� C:/Windows/System/drivers/etc/hosts ���޸ģ�Mac ϵͳ�ĵ�������Ҫ�� vim/etc/hosts ���޸ģ��޸��������¡�
+
+```
+#Spring Cloud eureka ��Ⱥ
+127.0.0.1 eureka7001.com
+127.0.0.1 eureka7002.com
+127.0.0.1 eureka7003.com
+```
+
+
+4\. �޸� micro-service-cloud-provider-dept-8001�������ṩ�ߣ������ļ� application.yml �� eureka.client.service-url.defaultZone ��ȡֵ��������ע�ᵽ Eureka Server ��Ⱥ�ϣ������������¡�
+
+
+
+
+
+```
+
+eureka:
+  client: #���ͻ���ע�ᵽ eureka �����б���
+    service-url:
+      #defaultZone: http://eureka7001.com:7001/eureka  #�����ַ�� 7001 ע�������� application.yml �б�¶������ע���ַ �������棩
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/  #������ע�ᵽ Eureka Server ��Ⱥ
+```
+
+
+
+
+
+5\. ���� micro-service-cloud-eureka-7001��ʹ����������ʡ�http://eureka7001.com:7001/�����������ͼ��
+
+![Eureka ��Ⱥ 7001](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1010302b3-4.png)
+
+ͼ5��Eureka Server ��Ⱥ -7001
+
+����ͼ���Կ����� �����ṩ�ߣ�micro-service-cloud-provider-dept-8001���ķ����Ѿ�ע�ᵽ�� Eureka Server 7001�������� DS Replicas ѡ����Ҳ��ʾ�˼�Ⱥ�е��������� Eureka Server��Eureka Server 7002 �� Eureka Server 7003��
+
+6\. ���� micro-service-cloud-eureka-7002��ʹ����������ʡ�http://eureka7002.com:7002/�����������ͼ��
+
+![Eureka ��Ⱥ 7002](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101030E36-5.png)
+ͼ6��Eureka Server ��Ⱥ -7002
+
+
+����ͼ���Կ����� �����ṩ�ߣ�micro-service-cloud-provider-dept-8001�����ṩ�ķ����Ѿ�ע�ᵽ�� Eureka Server 7002�������� DS Replicas ѡ����Ҳ��ʾ�˼�Ⱥ�е��������� Eureka Server��Eureka Server 7001 �� Eureka Server 7003��
+
+7. ���� micro-service-cloud-eureka-7003��ʹ����������ʡ�http://eureka7003.com:7003/�����������ͼ��
+
+![Eureka ��Ⱥ 7003](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1010306034-6.png)
+ͼ7��Eureka Server ��Ⱥ -7003
+
+����ͼ���Կ����� �����ṩ�ߣ�micro-service-cloud-provider-dept-8001�����ṩ�ķ����Ѿ�ע�ᵽ�� Eureka Server 7003�������� DS Replicas ѡ����Ҳ��ʾ�˼�Ⱥ�е��������� Eureka Server��Eureka Server 7001 �� Eureka Server 7002��
+
+�Դ����Ǿ������ Eureka Server ��Ⱥ�Ĵ��ʹ�á�
+
+## Eureka ���ұ�������
+
+�������ڱ��ص��Ի��� Eureka �ij���ʱ��Eureka ����ע�����ĺ��п��ܻ��������ͼ��ʾ�ĺ�ɫ���档
+
+![Eureka ���ұ�������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10103014a-7.png)
+ͼ8��Eureka ���ұ�����ʾ
+
+
+ʵ���ϣ���������Ǵ����� Eureka �����ұ������ƶ����ֵġ�Ĭ������£���� Eureka Server ��һ��ʱ���ڣ�Ĭ��Ϊ 90 �룩û�н��յ�ij�������ṩ�ߣ�Eureka Client�����������ͻὫ��������ṩ���ṩ�ķ���ӷ���ע������Ƴ��� �������������߾���Ҳ�޷��ӷ���ע�������л�ȡ����������ˣ����޷����ø÷���
+
+����ʵ�ʵķֲ�ʽ΢����ϵͳ�У������ķ���Eureka Client��Ҳ�п��ܻ�����������ϣ����������ӳ١����١�ӵ����ԭ�򣩶��޷��� Eureka Server ����ͨѶ������ʱ Eureka Server ��Ϊû�н����������󽫽����ķ���ӷ����б����Ƴ�������Ȼ�Dz������ġ��� Eureka �����ұ������ƾ��������������ġ�
+
+��ν ��Eureka �����ұ������ơ���������˼����ǡ��������������š������ Eureka Server ��һ��ʱ����û�н��յ� Eureka Client ����������ô Eureka Server �ͻῪ�����ұ���ģʽ�������е� Eureka Client ��ע����Ϣ����������������ֱ�Ӵӷ���ע������Ƴ���һ������ָ�����Щ Eureka Client �ṩ�ķ��񻹿��Լ������������������ѡ�
+
+���ϣ�Eureka �����ұ���������һ��Ӧ�������쳣�İ�ȫ������ʩ�����ļܹ���ѧ�ǣ�����ͬʱ��������΢���񣨽����ķ���Ͳ������ķ��񶼻ᱣ����Ҳ��äĿ�Ƴ��κν����ķ���ͨ�� Eureka �����ұ������ƣ������� Eureka Server ��Ⱥ���ӵĽ�׳���ȶ���
+
+> Eureka �����ұ�������Ҳ���ڱ׶ˡ������ Eureka ���ұ������ƴ����ڼ䣬�����ṩ���ṩ�ķ���������⣬��ô���������߾ͺ����׻�ȡ���Ѿ������ڵķ���������ֵ���ʧ�ܵ��������ʱ�����ǿ���ͨ���ͻ��˵��ݴ���������������⣬������ο� [Spring Cloud Netflix Ribbon](http://c.biancheng.net/springcloud/ribbon.html) �� [Spring Cloud Netflix Hystrix](http://c.biancheng.net/springcloud/hystrix.html)��
+
+Ĭ������£�Eureka �����ұ��������ǿ����ģ������Ҫ�رգ�����Ҫ�������ļ��������������á�
+
+
+
+
+
+```
+
+
+eureka:
+server:
+enable-self-preservation: false # false �ر� Eureka �����ұ������ƣ�Ĭ���ǿ���,һ�㲻�������޸�
+
+```
+
+
+
+
+
+## ʾ�� 3
+
+��������ͨ��һ��ʵ��������֤�� Eureka �����ұ������ơ�
+
+1\. �� micro-service-cloud-eureka-7001 �������ļ� application.yml �������������ã��ر� Eureka �����ұ������ơ�
+
+
+
+
+
+```
+
+
+eureka:
+server:
+enable-self-preservation: false # false �ر� Eureka �����ұ������ƣ�Ĭ���ǿ���,һ�㲻�������޸�
+
+```
+
+
+
+
+
+2\. ��Ⱥ�е� micro-service-cloud-eureka-7002 �� micro-service-cloud-eureka-7002 �����κ��޸ģ������ǵ����ұ��������ǿ����ġ�
+
+3\. ���� Eureka Server ��Ⱥ�Լ� micro-service-cloud-provider-dept-8001��ʹ����������ʡ�http://eureka7001.com:7001/�����������ͼ��
+
+![Eureka ���ұ������� 7001](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101030J48-8.png)
+ͼ9��Eureka �ر����ұ�������
+
+��ͼ 8 �������Կ����������ݣ�
+
+*   �� DS Replicas ѡ����������˺�ɫ������Ϣ��THE SELF PRESERVATION MODE IS TURNED OFF. THIS MAY NOT PROTECT INSTANCE EXPIRY IN CASE OF NETWORK/OTHER PROBLEMS.�������ָ���Ϣ���ʾ�� Eureka ���ұ���ģʽ�ѹرա���
+*   micro-service-cloud-provider-dept-8001 �ṩ�ķ����Ѿ�ע�ᵽ�� Eureka Server �С�
+
+4\. ʹ����������ʡ�http://eureka7002.com:7002/�����������ͼ��
+
+![Eureka ���ұ������� 7002](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1010301938-9.png)
+ͼ10��Eureka ���ұ�������
+
+��ͼ 9 ���Կ�����micro-service-cloud-provider-dept-8001 �ṩ�ķ���Ҳ�Ѿ�ע�ᵽ��ǰ Eureka Server �У��� DS Replicas ѡ���Ϸ�û���κξ�����ʾ��
+
+5\. �ر� micro-service-cloud-provider-dept-8001���ȴ������ӣ��ٴη��ʡ�http://eureka7001.com:7001/�����������ͼ��
+
+![Eureka ���ұ�������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10103014J-10.png)
+ͼ11��Eureka �ر����ұ�������-2
+
+��ͼ 10 �� �����ǿ��Կ����������ݣ�
+
+*   �� DS Replicas ѡ����������˺�ɫ������Ϣ��RENEWALS ARE LESSER THAN THE THRESHOLD. THE SELF PRESERVATION MODE IS TURNED OFF. THIS MAY NOT PROTECT INSTANCE EXPIRY IN CASE OF NETWORK/OTHER PROBLEMS.�������ָ���Ϣ���ʾ Eureka �����ұ���ģʽ�ѹرգ����Ѿ��з����Ƴ���
+*   micro-service-cloud-provider-dept-8001 �ṩ�ķ����Ѿ��ӷ����б����Ƴ���
+
+6\. �ٴη��ʡ�http://eureka7002.com:7002/�����������ͼ��
+
+![Eureka ���ұ������ƿ���](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1010301210-11.png)
+ͼ12��Eureka ���ұ���������Ч
+
+��ͼ 11 �� �������Կ����������ݣ�
+
+*   �� DS Replicas ѡ����������˺�ɫ������Ϣ��EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY'RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.�������ָ���Ϣ���� Eureka �����ұ������ƴ��ڿ���״̬�����Ѿ���������
+*   micro-service-cloud-provider-dept-8001 �ķ�����Ϣ��Ȼ���� Eureka Server ����ע����У���δ���Ƴ���
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudGateway.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudGateway.md"
new file mode 100644
index 0000000..e99968d
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudGateway.md"
@@ -0,0 +1,513 @@
+��΢����ܹ��У�һ��ϵͳ�����ɶ��΢������ɣ�����Щ������ܲ����ڲ�ͬ��������ͬ��������ͬ�����¡���������£��ͻ��ˣ�������������ֻ����������ߵȣ���Ҫֱ��������Щ���񣬾���Ҫ֪�����Ǿ���ĵ�ַ��Ϣ������ IP ��ַ���˿ںŵȡ�
+
+���ֿͻ���ֱ���������ķ�ʽ�����������⣺
+
+*   �����������ڶ�ʱ���ͻ�����Ҫά�������ķ����ַ������ڿͻ�����˵���Ƿdz��������ӵġ�
+*   ��ijЩ�����¿��ܻ���ڿ�����������⡣
+*   ������֤���Ѷȴ�ÿ��΢������Ҫ������֤��
+
+���ǿ���ͨ�� API �����������Щ���⣬�����������������ʲô�� API ���ء�
+
+## API ����
+
+API ������һ����ڿͻ��˺�΢����֮��ķ������ǿ����� API �����д���һЩ��ҵ���ܵ��߼�������Ȩ����֤����ء����桢����·�ɵȡ�
+
+API ���ؾ�������΢����ϵͳ������һ������ϵͳ�����Ψһ��ڡ����������ͻ��˻��Ƚ������͵� API ���أ�Ȼ���� API ���ظ�������ı�ʶ��Ϣ������ת����΢����ʵ����
+
+![](http://c.biancheng.net/uploads/allimg/211210/101P46212-0.png)
+ͼ1�����ַ�����ʷ�ʽ�Ա�
+
+���ڷ��������ڶࡢ���ӶȽϸߡ���ģ�Ƚϴ��ϵͳ��˵��ʹ�� API ���ؾ������ºô���
+
+*   �ͻ���ͨ�� API ������΢���񽻻�ʱ���ͻ���ֻ��Ҫ֪�� API ���ص�ַ���ɣ�������Ҫά�������ķ����ַ�����˿ͻ��˵Ŀ�����
+*   �ͻ���ֱ���� API ����ͨ�ţ��ܹ����ٿͻ������������Ľ���������
+*   �ͻ������˵ķ�����϶Ƚ��͡�
+*   ��ʡ������������ܣ������û����顣
+*   API ���ػ��ṩ�˰�ȫ�����ء����ˡ����桢�Ʒ��Լ���ص� API �������ܡ�
+
+������ API ����ʵ�ַ�����Ҫ������ 5 �֣�
+
+*   Spring Cloud Gateway
+*   Spring Cloud Netflix Zuul
+*   Kong
+*   Nginx+Lua
+*   Traefik
+
+���ڣ����ǾͶ� Spring Cloud Gateway ������ϸ���ܡ�
+
+## Spring Cloud Gateway```
+
+Spring Cloud Gateway �� Spring Cloud �Ŷӻ��� Spring 5.0��Spring Boot 2.0 �� Project Reactor �ȼ��������ĸ����� API ���������
+
+Spring Cloud Gateway ּ���ṩһ�ּ򵥶���Ч��;�������� API����Ϊ�����ṩ���й�ע�㣬���磺��ȫ�ԣ����/ָ��͵��ԡ�```
+
+> Spring Cloud Gateway �ǻ��� WebFlux ���ʵ�ֵģ��� WebFlux ��ܵײ���ʹ���˸����ܵ� Reactor ģʽͨ�ſ�� Netty��
+
+#### Spring Cloud Gateway ���ĸ���
+
+Spring Cloud GateWay ����Ҫ�Ĺ��ܾ���·��ת�������ڶ���ת������ʱ��Ҫ�漰�������������ĸ�����±���
+
+| ���ĸ��� | ���� |
+| --- | --- |
+| Route��·�ɣ� | �����������ģ�顣����һ�� ID��һ��Ŀ�� URI��һ����ԣ�Predicate����һ���������Filter����ɡ� |
+| Predicate�����ԣ� | ·��ת�����ж����������ǿ���ͨ�� Predicate ��```HTTP �������ƥ�䣬��������ʽ������·��������ͷ�������ȣ�������������ƥ��ɹ���������ת������Ӧ�ķ��� |
+| Filter���������� | �����������ǿ���ʹ����������������غ��޸ģ�������ʹ���������ĵ���Ӧ�����ٴ����� |
+
+> ע�⣺���� Route �� Predicate ����ͬʱ������
+
+#### Spring Cloud Gateway ������
+
+Spring Cloud Gateway �����������ԣ�
+
+*   ���� Spring Framework 5��Project Reactor �� Spring Boot 2.0 ������
+*   �ܹ�����������������ƥ��·�ɡ�
+*   predicates�����ԣ� �� filters�������������ض���·�ɵġ�
+*   ������ Hystrix �۶�����
+*   ������ Spring Cloud DiscoveryClient�������ֿͻ��ˣ���
+*   ���ڱ�д���Ժ͹�������
+*   �ܹ���������Ƶ�ʡ�
+*   �ܹ���д����·����
+
+## Gateway ��������
+
+Spring Cloud Gateway ������������ͼ��
+
+![Spring Cloud Gateway ��������](http://c.biancheng.net/uploads/allimg/211210/101P45T2-1.png)
+ͼ2��Spring Cloud Gateway ��������
+
+Spring Cloud Gateway ��������˵�����£�
+
+1.  �ͻ��˽������͵�```Spring Cloud Gateway �ϡ�
+2.  Spring Cloud Gateway ͨ��```Gateway Handler Mapping �ҵ���������ƥ���·�ɣ����䷢�͸� Gateway Web Handler��
+3.  Gateway Web Handler```ͨ��ָ���Ĺ���������Filter Chain����������ת����ʵ�ʵķ���ڵ��У�ִ��ҵ���߼�������Ӧ�����
+4.  ������֮�������߷ֿ�����Ϊ���������ܻ���ת������֮ǰ��pre����֮��post��ִ��ҵ���߼���
+5.  ��������Filter������������ת���������ǰ��������������غ��޸ģ��������У�顢Ȩ��У�顢������ء���־����Լ�Э��ת���ȡ�
+6.  ��������������Ӧ���ؿͻ���֮ǰ������Ӧ�������غ��ٴ����������޸���Ӧ���ݻ���Ӧͷ����־�����������صȡ�
+7.  ��Ӧԭ·���ظ��ͻ��ˡ�
+
+�ܶ���֮���ͻ��˷��͵� Spring Cloud Gateway ��������Ҫͨ��һ����ƥ�����������ܶ�λ�������ķ���ڵ㡣�ڽ�����ת����������д����Ĺ���ǰ��pre �� post�������ǻ����Զ��������Ӧ����һЩ��ϸ�����ơ�
+
+Predicate ����·�ɵ�ƥ���������� Filter ���Ƕ��������Ӧ���о�ϸ�����ƵĹ��ߡ�����������Ԫ�أ��ټ���Ŀ�� URI���Ϳ���ʵ��һ�������·���ˡ�
+
+## Predicate ����
+
+Spring Cloud Gateway ͨ��```Predicate ������ʵ�� Route ·�ɵ�ƥ����򡣼򵥵�˵��Predicate ��·��ת�����ж�����������ֻ�������� Predicate ���������Żᱻת����ָ���ķ����Ͻ��д�����
+
+ʹ�� Predicate ������Ҫע������ 3 �㣺
+
+*   Route ·���� Predicate ���ԵĶ�Ӧ��ϵΪ��һ�Զࡱ��һ��·�ɿ��԰��������ͬ���ԡ�
+*   һ��������Ҫת����ָ����·���ϣ��ͱ���ͬʱƥ��·���ϵ����ж��ԡ�
+*   ��һ������ͬʱ������·�ɵĶ�������ʱ������ֻ�ᱻ�׸��ɹ�ƥ���·��ת����
+
+![](http://c.biancheng.net/uploads/allimg/211210/101P42B6-2.png)
+ͼ3��Predicate ����ƥ��
+
+������ Predicate �������±�������ת���� URI Ϊ http://localhost:8001����
+
+| ���� | ʾ�� | ˵�� |
+| --- | --- | --- |
+| Path | - Path=/dept/list/**``` | ������·���� /dept/list/** ƥ��ʱ����������ܱ�ת����```http://localhost:8001 �ϡ� |
+| Before | - Before=2021-10-20T11:47:34.255+08:00[Asia/Shanghai] | ��```2021 �� 10 �� 20 �� 11 ʱ 47 �� 34.255 ��֮ǰ�����󣬲Żᱻת����```http://localhost:8001 �ϡ� |
+| After | - After=2021-10-20T11:47:34.255+08:00[Asia/Shanghai] | �� 2021 �� 10 �� 20 �� 11 ʱ 47 �� 34.255 ��֮������󣬲Żᱻת����```http://localhost:8001 �ϡ� |
+| Between | - Between=2021-10-20T15:18:33.226+08:00[Asia/Shanghai],2021-10-20T15:23:33.226+08:00[Asia/Shanghai] | �� 2021 �� 10 �� 20 �� 15 ʱ 18 �� 33.226 �� �� 2021 �� 10 �� 20 �� 15 ʱ 23 �� 33.226 ��֮������󣬲Żᱻת����```http://localhost:8001 �������ϡ� |
+| Cookie | - Cookie=name,c.biancheng.net | Я��```Cookie �� Cookie ������Ϊ```name=c.biancheng.net �����󣬲Żᱻת���� http://localhost:8001 �ϡ� |
+| Header | - Header=X-Request-Id,\d+ | ����ͷ��Я������ X-Request-Id ������ֵΪ���������󣬲Żᱻת���� http://localhost:8001 �ϡ� |
+| Method | - Method=GET | ֻ�� GET ����Żᱻת���� http://localhost:8001 �ϡ� |
+
+#### ʾ��
+
+�������Ǿ�ͨ��һ��ʵ��������ʾ�� Predicate �����ʹ�õġ�
+
+1\. �ڸ�����```spring-cloud-demo2 �´���һ����Ϊ```micro-service-cloud-gateway-9527 �� Spring Boot ģ�飬������ pom.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>spring-cloud-demo2</artifactId>
+        <groupId>net.biancheng.c</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <groupId>net.biancheng.c</groupId>
+    <artifactId>micro-service-cloud-gateway-9527</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>micro-service-cloud-gateway-9527</name>
+    <description>Demo project for Spring Boot</description>
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <!--�ر�ע�⣺�� gateway ���ط����в������� spring-boot-starter-web ������������ᱨ��-->
+        <!-- Spring cloud gateway ��������-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-gateway</artifactId>
+        </dependency>
+        <!--Eureka �ͻ���-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-devtools</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>
+```
+
+
+
+
+
+2\. ��```micro-service-cloud-gateway-9527 ����·����/resources Ŀ¼���£��½�һ�������ļ� application.yml�������������¡�
+
+
+
+
+
+```
+server:
+  port: 9527  #�˿ں�
+spring:
+  application:
+    name: microServiceCloudGateway
+  cloud:
+    gateway: #����·������
+      routes:
+        #�� micro-service-cloud-provider-dept-8001 �ṩ�ķ�����������������¶���ͻ��ˣ�ֻ���ͻ��˱�¶ API ���صĵ�ַ 9527
+        - id: provider_dept_list_routh   #·�� id,û�й̶����򣬵�Ψһ���������������Ӧ
+          uri: http://localhost:8001          #ƥ����ṩ�����·�ɵ�ַ
+          predicates:
+            #�����Ƕ�����������ѡȫ����������
+            - Path=/dept/list/**               #���ԣ�·��ƥ�� ע�⣺Path �� P Ϊ��д
+            - Method=GET #ֻ��ʱ GET ����ʱ�����ܷ���
+
+eureka:
+  instance:
+    instance-id: micro-service-cloud-gateway-9527
+    hostname: micro-service-cloud-gateway
+  client:
+    fetch-registry: true
+    register-with-eureka: true
+    service-url:
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
+```
+
+
+
+
+
+���������У������� spring.cloud.gateway.routes ��ʹ�� predicates ���ԣ�������������������������
+
+```
+- Path=/dept/list/**            
+- Method=GET
+```
+
+ֻ�е��ⲿ���ͻ��ˣ����͵� micro-service-cloud-gateway-9527 �� HTTP ����ͬʱ�����������еĶ���ʱ��������Żᱻת����ָ���ķ�����У��� http://localhost:8001����3\. ��```micro-service-cloud-gateway-9527 �����������ϣ�ʹ�� @EnableEurekaClient ע�⿪�� Eureka �ͻ��˹��ܣ��������¡�
+
+
+
+
+
+```
+package net.biancheng.c;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
+
+@SpringBootApplication
+@EnableEurekaClient
+public class MicroServiceCloudGateway9527Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(MicroServiceCloudGateway9527Application.class, args);
+    }
+}
+
+```
+
+
+
+
+
+4\. �������� Eureka ����ע�����ģ���Ⱥ����micro-service-cloud-provider-dept-8001 �Լ�```micro-service-cloud-gateway-9527��ʹ����������ʡ�http://localhost:9527/dept/list�����������ͼ��
+
+![Spring Cloud ��������](http://c.biancheng.net/uploads/allimg/211210/101P43419-3.png)
+ͼ4��Spring Cloud Gateway ·��ת��
+
+## Spring Cloud Gateway ��̬·��
+
+Ĭ������£�Spring Cloud Gateway ����ݷ���ע�����ģ����� Eureka Server����ά���ķ����б����Է�������spring.application.name����Ϊ·��������̬·�ɽ���ת�����Ӷ�ʵ�ֶ�̬·�ɹ��ܡ�
+
+���ǿ����������ļ��У��� Route �� uri ��ַ�޸�Ϊ������ʽ��
+
+```lb://service-name```
+
+��������˵�����£�
+
+*   lb��uri ��Э�飬��ʾ���� Spring Cloud Gateway �ĸ��ؾ��⹦�ܡ�
+*   service-name����������Spring Cloud Gateway ���������ȡ�������΢�����ַ��
+
+#### ʾ��
+
+�������Ǿ�ͨ��һ��ʵ������չʾ�� Spring Cloud Gateway �����ʵ�ֶ�̬·�ɵġ�
+
+1\. �޸�```micro-service-cloud-gateway-9527 �� application.yml �����ã�ʹ��ע�������е�΢������������̬·�ɽ���ת�����������¡�
+
+
+
+
+
+```
+server:
+  port: 9527 #�˿ں�
+ 
+spring:
+  application:
+    name: microServiceCloudGateway  #����ע������ע��ķ�����
+   
+  cloud:
+    gateway: #����·������
+      discovery:
+        locator:
+          enabled: true #Ĭ��ֵΪ true����Ĭ�Ͽ�����ע�����Ķ�̬����·�ɵĹ��ܣ�����΢����������·��
+
+      routes:
+        #�� micro-service-cloud-provider-dept-8001 �ṩ�ķ�����������������¶���ͻ��ˣ�ֻ���ͻ��˱�¶ API ���صĵ�ַ 9527
+        - id: provider_dept_list_routh   #·�� id,û�й̶����򣬵�Ψһ���������������Ӧ
+          uri: lb://MICROSERVICECLOUDPROVIDERDEPT #��̬·�ɣ�ʹ�÷�������������ľ�����˿�   http://eureka7001.com:9527/dept/list
+
+          predicates:
+            #�����Ƕ�����������ѡȫ����������
+            - Path=/dept/list/**    #���ԣ�·��ƥ�� ע�⣺Path �� P Ϊ��д
+            - Method=GET #ֻ��ʱ GET ����ʱ�����ܷ���
+
+eureka:
+  instance:
+    instance-id: micro-service-cloud-gateway-9527
+    hostname: micro-service-cloud-gateway
+  client:
+    fetch-registry: true
+    register-with-eureka: true
+    service-url:
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
+```
+
+
+
+
+
+2\. �������� Eureka ����ע�����ģ���Ⱥ���������ṩ�߼�Ⱥ��micro-service-cloud-provider-dept-8001/8002/8003���Լ�```micro-service-cloud-gateway-9527��
+
+3\. ��������з��ʡ�http://localhost:9527/dept/list�����������ͼ��
+
+![Gateway ��̬·��](http://c.biancheng.net/uploads/allimg/211210/101P46240-4.gif)
+ͼ5��Spring Cloud ʵ�ֶ�̬·��
+
+## Filter ������
+
+ͨ������£����ڰ�ȫ����Ŀ��ǣ�������ṩ�ķ�������������һ����У���߼��������û���½״̬У�顢ǩ��У��ȡ�
+
+��΢����ܹ��У�ϵͳ�ɶ��΢������ɣ�������Щ������Ҫ��ЩУ���߼�����ʱ���ǾͿ��Խ���ЩУ���߼�д�� Spring Cloud Gateway �� Filter �������С�
+
+#### Filter �ķ���
+
+Spring Cloud Gateway �ṩ�������������͵Ĺ����������Զ��������Ӧ���о�ϸ�����ơ�
+
+| ���������� | ˵�� |
+| --- | --- |
+| Pre ���� | ���ֹ�����������ת����΢����֮ǰ���Զ�����������غ��޸ģ��������У�顢Ȩ��У�顢������ء���־����Լ�Э��ת���Ȳ����� |
+| Post ���� | ���ֹ�������΢���������������Ӧ����Զ���Ӧ�������غ��ٴ����������޸���Ӧ���ݻ���Ӧͷ����־�����������صȡ� |
+
+�������÷�Χ���֣�Spring Cloud gateway �� Filter ���Է�Ϊ 2 �ࣺ
+
+*   GatewayFilter��Ӧ���ڵ���·�ɻ���һ��·���ϵĹ�������
+*   GlobalFilter��Ӧ�������е�·���ϵĹ�������
+
+#### GatewayFilter ���ع�����
+
+GatewayFilter �� Spring Cloud Gateway �������ṩ��һ��Ӧ���ڵ�����һ��·���ϵĹ������������ԶԵ���·�ɻ���һ��·���ϴ��������ʹ�����Ӧ�������أ���ʵ��һЩ��ҵ���޹صĹ��ܣ������½״̬У�顢ǩ��У�顢Ȩ��У�顢��־�����������صȡ�
+
+GatewayFilter �������ļ������� application.yml���е�д���� Predicate ���ƣ���ʽ���¡�
+
+
+
+
+
+```
+
+spring:
+  cloud:
+    gateway: 
+      routes:
+        - id: xxxx
+          uri: xxxx
+          predicates:
+            - Path=xxxx
+          filters:
+            - AddRequestParameter=X-Request-Id,1024 #��������������ƥ�������ͷ����һ������ͷ������Ϊ X-Request-Id ֵΪ 1024
+            - PrefixPath=/dept #������·��ǰ����� /dept
+            ����
+```
+
+
+
+
+
+Spring Cloud Gateway �����˶�� 31 �� GatewayFilter���±����о��˼��ֳ��õ����ع���������ʹ��ʾ����
+
+| ·�ɹ����� | ���� | ���� | ʹ��ʾ�� |
+| --- | --- | --- | --- |
+| AddRequestHeader | ```���ش�������󣬲�������������һ��ָ��������ͷ������ | name����Ҫ���ӵ�����ͷ������ key��value����Ҫ���ӵ�����ͷ������ value�� | - AddRequestHeader=my-request-header,1024 |
+| AddRequestParameter | ���ش�������󣬲�������������һ��ָ������������� | name����Ҫ���ӵ���������� key��value����Ҫ���ӵ���������� value�� | - AddRequestParameter=my-request-param,c.biancheng.net |
+| AddResponseHeader | ������Ӧ��������Ӧ������һ��ָ������Ӧͷ������ | name����Ҫ���ӵ���Ӧͷ�� key��value����Ҫ���ӵ���Ӧͷ�� value�� | - AddResponseHeader=my-response-header,c.biancheng.net |
+| PrefixPath | ���ش�������󣬲�������·������һ��ָ����ǰ׺�� | ```prefix����Ҫ���ӵ�·��ǰ׺�� | - PrefixPath=/consumer |
+| PreserveHostHeader | ת������ʱ�����ֿͻ��˵� Host ��Ϣ���䣬Ȼ�������ݵ��ṩ��������΢�����С� | �� | - PreserveHostHeader |
+| RemoveRequestHeader | �Ƴ�����ͷ��ָ���IJ����� | name����Ҫ�Ƴ�������ͷ�� key�� | - RemoveRequestHeader=my-request-header |
+| RemoveResponseHeader | �Ƴ���Ӧͷ��ָ���IJ����� | name����Ҫ�Ƴ�����Ӧͷ�� | - RemoveResponseHeader=my-response-header |
+| RemoveRequestParameter | �Ƴ�ָ������������� | name����Ҫ�Ƴ������������ | - RemoveRequestParameter=my-request-param |
+| RequestSize | ����������Ĵ�С�������������ʱ�����᷵�� 413 Payload Too Large�� | maxSize��������Ĵ�С�� | - name: RequestSize`````````args:```````````````maxSize: 5000000 |
+
+#### ʾ��
+
+��������ͨ��һ��ʵ������ʾ GatewayFilter �����ã��������¡�
+
+1\. ��```micro-service-cloud-gateway-9527 �� application.yml ��������һ����̬·�ɣ������������¡�
+
+
+
+
+
+```
+spring:
+  cloud:
+    gateway: 
+      routes:
+        - id: xxxx
+          uri: xxxx
+          predicates:
+            - Path=xxxx
+          filters:
+            - AddRequestParameter=X-Request-Id,1024 #��������������ƥ�������ͷ����һ������ͷ������Ϊ X-Request-Id ֵΪ 1024
+            - PrefixPath=/dept #������·��ǰ����� /dept
+            ����
+
+```
+
+
+
+
+
+2\. ����```micro-service-cloud-gateway-9527��ʹ����������ʡ�http://eureka7001.com:9527/get/1�����������ͼ��
+
+![Gateway ·�ɹ�����](http://c.biancheng.net/uploads/allimg/211210/101P4J58-5.png)
+ͼ6��·�ɹ�����ʾ��
+
+#### GlobalFilter ȫ�ֹ�����
+
+GlobalFilter ��һ�����������е�·���ϵ�ȫ�ֹ�������ͨ���������ǿ���ʵ��һЩͳһ����ҵ���ܣ�����Ȩ����֤��IP �������Ƶȡ���ij������·��ƥ��ʱ����ô���е� GlobalFilter ��͸�·���������õ� GatewayFilter ��ϳ�һ������������
+
+Spring Cloud Gateway Ϊ�����ṩ�˶���Ĭ�ϵ� GlobalFilter��������ת����·�ɡ����ؾ������ص�ȫ�ֹ�����������ʵ�ʵ���Ŀ�����У�ͨ�����Ƕ����Զ���һЩ�Լ��� GlobalFilter ȫ�ֹ���������������������ҵ�����󣬶�����ֱ��ʹ�� Spring Cloud``` Config �ṩ��ЩĬ�ϵ� GlobalFilter��
+
+> ����Ĭ�ϵ�ȫ�ֹ���������ϸ���ݣ���ο�```[Spring Cloud ����](https://docs.spring.io/spring-cloud-gateway/docs/current/reference/html/#global-filters)��
+
+�������Ǿ�ͨ��һ��ʵ������ʾ�£�����Զ��� GlobalFilter ȫ�ֹ�������
+
+1\. ��```net.biancheng.c.filter ���£��½�һ����Ϊ```MyGlobalFilter ȫ�ֹ����������࣬�������¡�
+
+
+
+
+
+```
+server:
+  port: 9527 #�˿ں�
+ 
+spring:
+  application:
+    name: microServiceCloudGateway  #����ע������ע��ķ�����
+   
+  cloud:
+    gateway: #����·������
+      discovery:
+        locator:
+          enabled: true #Ĭ��ֵΪ true����Ĭ�Ͽ�����ע�����Ķ�̬����·�ɵĹ��ܣ�����΢����������·��
+
+      routes:
+        #�� micro-service-cloud-provider-dept-8001 �ṩ�ķ�����������������¶���ͻ��ˣ�ֻ���ͻ��˱�¶ API ���صĵ�ַ 9527
+        - id: provider_dept_list_routh   #·�� id,û�й̶����򣬵�Ψһ���������������Ӧ
+          uri: lb://MICROSERVICECLOUDPROVIDERDEPT #��̬·�ɣ�ʹ�÷�������������ľ�����˿�   http://eureka7001.com:9527/dept/list
+
+          predicates:
+            #�����Ƕ�����������ѡȫ����������
+            - Path=/dept/list/**    #���ԣ�·��ƥ�� ע�⣺Path �� P Ϊ��д
+            - Method=GET #ֻ��ʱ GET ����ʱ�����ܷ���
+
+eureka:
+  instance:
+    instance-id: micro-service-cloud-gateway-9527
+    hostname: micro-service-cloud-gateway
+  client:
+    fetch-registry: true
+    register-with-eureka: true
+    service-url:
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
+
+```
+
+
+
+
+
+2\. ����```micro-service-cloud-gateway-9527��ʹ����������ʡ�http://eureka7001.com:9527/dept/list�������ǻᷢ�ַ��ʱ� 406 ���󣬿���̨������¡�
+
+```2021-10-21 16:25:39.450  INFO 19116 --- [ctor-http-nio-4] net.biancheng.c.filter.MyGlobalFilter    : Thu Oct 21 16:25:39 CST 2021�����Զ����ȫ�ֹ����� MyGlobalFilter
+2021-10-21 16:25:39.451  INFO 19116 --- [ctor-http-nio-4] net.biancheng.c.filter.MyGlobalFilter    : ���� uname ����Ϊ null��
+```
+
+3\. ʹ����������ʡ�http://eureka7001.com:9527/dept/list?uname=123��,�������ͼ��
+
+![�Զ���ȫ�����ع�����](http://c.biancheng.net/uploads/allimg/211210/101P43096-6.png)
+ͼ7���Զ���ȫ�����ع�����
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudHystrix.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudHystrix.md"
new file mode 100644
index 0000000..1a26d68
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudHystrix.md"
@@ -0,0 +1,1120 @@
+��΢����ܹ��У�һ��Ӧ�������ɶ��������ɣ���Щ����֮���໥������������ϵ���۸��ӡ�
+
+����һ��΢����ϵͳ�д��� A��B��C��D��E��F �ȶ���������ǵ�������ϵ����ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101623H11-0.png)
+
+ͼ1������������ϵ
+
+ͨ������£�һ���û�����������Ҫ���������ϲ�����ɡ���ͼ 1 ��ʾ�������з��񶼴��ڿ���״̬ʱ������ 1 ��Ҫ���� A��D��E��F �ĸ����������ɣ����� 2 ��Ҫ���� B��E��D �������������ɣ����� 3 ��Ҫ���÷��� C��F��E��D �ĸ����������ɡ�
+
+������ E �������ϻ������ӳ�ʱ����������������
+
+1.  ��ʹ�������з��񶼿��ã����ڷ��� E �IJ����ã���ô�û����� 1��2��3 ���ᴦ������״̬���ȴ����� E ����Ӧ���ڸ߲����ij����£��ᵼ���������������߳���Դ�ڶ�ʱ����Ѹ�����Ĵ�����
+2.  ���������ڷ��� E ����������������� B��D �Լ� F Ҳ���ᴦ���߳�����״̬���ȴ����� E ����Ӧ��������Щ����IJ����á�
+3.  ������������B��D �� F �ķ���������� A �ͷ��� C Ҳ�ᴦ���߳�����״̬���Եȴ����� D �ͷ��� F ����Ӧ�����·��� A �ͷ��� C Ҳ�����á�
+
+�����Ϲ��̿��Կ�������΢����ϵͳ��һ��������ֹ���ʱ�����ϻ����ŷ���ĵ�����·��ϵͳ�з�����ӣ����յ�������΢����ϵͳ��̱��������ǡ�ѩ��ЧӦ����Ϊ�˷�ֹ�����¼��ķ�����΢����ܹ������ˡ��۶�������һϵ�з����ݴ��ͱ������ơ�
+
+## �۶���
+
+�۶�����Circuit Breaker��һ����Դ����ѧ�еĵ�·֪ʶ�����������ǵ���·���ֹ���ʱ��Ѹ���жϵ�Դ�Ա�����·�İ�ȫ��
+
+��΢���������۶����������� Martin Fowler ���������� ��[Circuit Breake](https://martinfowler.com/bliki/CircuitBreaker.html)r��һ���������������ѧ�е��۶����������ƣ�΢����ܹ��е��۶����ܹ���ij�����������Ϻ��������÷�����һ������Ԥ�ڵġ��ɴ����Ľ�����Ӧ��FallBack���������dz�ʱ��ĵȴ������׳����÷��޷��������쳣�������ͱ�֤�˷�����÷����̲߳��ᱻ��ʱ�䡢����Ҫ��ռ�ã����������΢����ϵͳ�е����ӣ���ֹϵͳѩ��ЧӦ�ķ�����
+
+## Spring Cloud Hystrix
+
+Spring Cloud Hystrix ��һ������ķ����ݴ��뱣�������Ҳ�� Spring Cloud ������Ҫ�����֮һ��
+
+Spring Cloud Hystrix �ǻ��� Netflix ��˾�Ŀ�Դ��� Hystrix ʵ�ֵģ����ṩ���۶������ܣ��ܹ���Ч����ֹ�ֲ�ʽ΢����ϵͳ�г����������ϣ������΢����ϵͳ�ĵ��ԡ�Spring Cloud Hystrix ���з��񽵼��������۶ϡ��̸߳��롢���󻺴桢����ϲ��Լ�ʵʱ���ϼ�ص�ǿ���ܡ�
+
+> Hystrix [h?st'r?ks]�����ĺ����Ǻ����������ı��ϳ����˼��̣�ʹ��ӵ����ǿ������ұ����������� Spring Cloud Hystrix ��Ϊһ�������ݴ��뱣�������Ҳ�����÷���ӵ�����ұ��������������Ҳ���˽���Ϸ��Ϊ�������硱��
+
+��΢����ϵͳ�У�Hystrix �ܹ���������ʵ������Ŀ�꣺
+
+*   **�����߳���Դ**����ֹ��������Ĺ��Ϻľ�ϵͳ�е������߳���Դ��
+*   **����ʧ�ܻ���**����ij���������˹��ϣ����÷�����÷�һֱ�ȴ�������ֱ�ӷ�������ʧ�ܡ�
+*   **�ṩ������FallBack������**��������ʧ�ܺ��ṩһ����ƺõĽ���������ͨ����һ�����׷�����������ʧ�ܺ󼴵��ø÷�����
+*   **��ֹ������ɢ**��ʹ���۶ϻ��ƣ���ֹ������ɢ����������
+*   **��ع���**���ṩ�۶������ϼ����� Hystrix Dashboard����ʱ����۶�����״̬��
+
+## Hystrix ���񽵼�
+
+Hystrix �ṩ�˷��񽵼����ܣ��ܹ���֤��ǰ����������������ϵ�Ӱ�죬��߷���Ľ�׳�ԡ�
+
+���񽵼���ʹ�ó��������� 2 �֣�
+
+*   �ڷ�����ѹ������ʱ������ʵ��ҵ���������������һЩ����Ҫ���������ķ�������в��Եز�������򵥴������Ӷ��ͷŷ�������Դ�Ա�֤���ķ�������������
+*   ��ijЩ���񲻿���ʱ��Ϊ�˱��ⳤʱ��ȴ���ɷ��񿨶ٻ�ѩ��ЧӦ��������ִ�б��õĽ����߼����̷���һ���Ѻõ���ʾ���Ա�������ҵ����Ӱ�졣
+
+���ǿ���ͨ����д HystrixCommand �� getFallBack() ������ HystrixObservableCommand �� resumeWithFallback() ������ʹ����֧�ַ��񽵼���
+
+Hystrix ���񽵼� FallBack �ȿ��Է��ڷ���˽��У�Ҳ���Է��ڿͻ��˽��С�
+
+Hystrix �������³����½��з��񽵼�������
+
+*   ���������쳣
+*   ����ʱ
+*   �۶������ڴ�״̬
+*   �̳߳���Դ�ľ�
+
+## ʾ��1
+
+�������Ǿ�ͨ��һ���������ֱ���ʾ�� Hystrix ����˷��񽵼��Ϳͻ��˷��񽵼���
+
+#### ����˷��񽵼�
+
+1\. �������� spring-cloud-demo2 �´���һ����Ϊ micro-service-cloud-provider-dept-hystrix-8004 �ķ����ṩ�ߣ������� pom.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <!--��pom-->
+    <parent>
+        <artifactId>spring-cloud-demo2</artifactId>
+        <groupId>net.biancheng.c</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <groupId>net.biancheng.c</groupId>
+    <artifactId>micro-service-cloud-provider-dept-hystrix-8004</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>micro-service-cloud-provider-dept-hystrix-8004</name>
+    <description>Demo project for Spring Boot</description>
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-devtools</artifactId>
+            <scope>runtime</scope>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!--���� Spring Boot �ļ��ģ��-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
+        <!-- eureka �ͻ���-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
+        </dependency>
+        <!--hystrix ����-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
+
+```
+
+
+
+
+
+2\. ����·������ /resources Ŀ¼��������һ�������ļ� application.yml�������������¡�
+
+
+
+
+
+```
+
+spring:
+  application:
+    name: microServiceCloudProviderDeptHystrix  #΢�������ƣ����Ⱪ©��΢�������ƣ�ʮ����Ҫ
+
+server:
+  port: 8004
+########################################### Spring cloud �Զ���������ƺ� ip ��ַ###############################################
+eureka:
+  client: #���ͻ���ע�ᵽ eureka �����б���
+    service-url:
+      #defaultZone: http://eureka7001:7001/eureka  #�����ַ�� 7001ע�������� application.yml �б�¶������ע���ַ �������棩
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/  #������ע�ᵽ Eureka ��Ⱥ
+  instance:
+    instance-id: spring-cloud-provider-8004 #�Զ������������Ϣ
+    prefer-ip-address: true  #��ʾ����·���� ip ��ַ
+#####################spring cloud ʹ�� Spring Boot actuator ���������Ϣ###########################################
+# Spring Boot 2.50�� actuator ��������˴�����Ľڵ㣬ֻ��¶�� heath �ڵ㣬�������ã�*������Ϊ�˿������еĽڵ�
+management:
+  endpoints:
+    web:
+      exposure:
+        include: "*"   # * ��yaml �ļ����ڹؼ��֣�������Ҫ������
+info:
+  app.name: micro-service-cloud-provider-dept-hystrix
+  company.name: c.biancheng.net
+  build.aetifactId: @project.artifactId@
+  build.version: @project.version@
+
+```
+
+
+
+
+
+3\. �� net.biancheng.c.service ���´���һ����Ϊ  DeptService �Ľӿڣ��������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c.service;
+
+public interface DeptService {
+
+    // hystrix �۶���ʾ�� ok
+    public String deptInfo_Ok(Integer id);
+
+    //hystrix �۶�����ʱ����
+    public String deptInfo_Timeout(Integer id);
+}
+
+```
+
+
+
+
+
+4\. �� net.biancheng.c.service.impl ���£����� DeptService �ӿڵ�ʵ���� DeptServiceImpl���������¡�
+
+
+
+
+
+```
+package net.biancheng.c.service.impl;
+
+import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
+import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
+import net.biancheng.c.service.DeptService;
+import org.springframework.stereotype.Service;
+
+import java.util.concurrent.TimeUnit;
+
+@Service("deptService")
+public class DeptServiceImpl implements DeptService {
+
+    @Override
+    public String deptInfo_Ok(Integer id) {
+        return "�̳߳أ�" + Thread.currentThread().getName() + "  deptInfo_Ok,id:   " + id;
+    }
+
+    //һ���÷���ʧ�ܲ��׳����쳣��Ϣ�󣬻��Զ�����  @HystrixCommand ע���ע�� fallbackMethod ָ���ķ���
+    @HystrixCommand(fallbackMethod = "dept_TimeoutHandler",
+            commandProperties =
+                    //�涨 5 �������ھͲ��������������У����� 5 ��ͱ���������ָ���ķ���
+                    {@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "5000")})
+    @Override
+    public String deptInfo_Timeout(Integer id) {
+        int outTime = 6;
+        try {
+            TimeUnit.SECONDS.sleep(outTime);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        return "�̳߳أ�" + Thread.currentThread().getName() + "  deptInfo_Timeout,id:   " + id + "  ��ʱ: " + outTime;
+    }
+
+    // ��������ֹ��Ϻ󣬵��ø÷��������Ѻ���ʾ
+    public String dept_TimeoutHandler(Integer id) {
+       return  "C������������������ϵͳ��æ���Ժ����ԣ�"+"�̳߳أ�" + Thread.currentThread().getName() + "  deptInfo_Timeout,id:   " + id;
+    }
+}
+
+```
+
+
+
+
+
+���ǿ��Կ��� deptInfo_Timeout() ������ʹ�� @HystrixCommand ע�⣬��ע��˵�����£�
+
+*   ���� fallbackMethod ��������ָ������������
+*   ���� execution.isolation.thread.timeoutInMilliseconds ���������������ó�ʱʱ��ķ�ֵ����ֵ�ڿ����������У�����ִ�н�������
+
+5.  �� net.biancheng.c.controller ���´���һ����Ϊ DeptController �� Controller �࣬�������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c.controller;
+
+import lombok.extern.slf4j.Slf4j;
+import net.biancheng.c.service.DeptService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@Slf4j
+public class DeptController {
+    @Autowired
+    private DeptService deptService;
+    @Value("${server.port}")
+    private String serverPort;
+
+    @RequestMapping(value = "/dept/hystrix/ok/{id}")
+    public String deptInfo_Ok(@PathVariable("id") Integer id) {
+        String result = deptService.deptInfo_Ok(id);
+        log.info("�˿ںţ�" + serverPort + " result:" + result);
+        return result + "��   �˿ںţ�" + serverPort;
+    }
+
+    // Hystrix ����ʱ����
+    @RequestMapping(value = "/dept/hystrix/timeout/{id}")
+    public String deptInfo_Timeout(@PathVariable("id") Integer id) {
+        String result = deptService.deptInfo_Timeout(id);
+        log.info("�˿ںţ�" + serverPort + " result:" + result);
+        return result + "��   �˿ںţ�" + serverPort;
+    }
+
+}
+
+```
+
+
+
+
+
+6\. �� micro-service-cloud-provider-dept-hystrix-8004 �����������ϣ�ʹ�� @EnableCircuitBreaker ע�⿪���۶������ܣ��������¡�
+
+
+
+
+
+```
+
+
+package net.biancheng.c;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
+import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
+
+@SpringBootApplication
+@EnableEurekaClient //���� Eureka �ͻ��˹���
+@EnableCircuitBreaker //�����۶�������
+public class MicroServiceCloudProviderDeptHystrix8004Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(MicroServiceCloudProviderDeptHystrix8004Application.class, args);
+    }
+
+}
+```
+
+
+
+
+
+7\. ������������ע�����ģ�Eureka Server����Ⱥ�� micro-service-cloud-provider-dept-hystrix-8004����ʹ����������ʡ�http://eureka7001.com:8004/dept/hystrix/ok/1�����������ͼ��
+
+![Hystrix ok](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1016234615-1.png)
+ͼ2��Hystrix ����������
+
+8\. ʹ����������ʡ�http://eureka7001.com:8004/dept/hystrix/timeout/1�����������ͼ��
+
+![Hystrix ���񽵼�](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101623FR-2.png)
+ͼ3��Hystrix ����˷��񽵼�
+
+#### �ͻ��˷��񽵼�
+
+ͨ������£����Ƕ����ڿͻ��˽��з��񽵼������ͻ��˵��õķ���˵ķ��񲻿���ʱ���ͻ���ֱ�ӽ��з��񽵼��������������̱߳���ʱ�䡢����Ҫ��ռ�á�
+
+�ͻ��˷��񽵼��������¡�
+
+1\. �� micro-service-cloud-consumer-dept-feign �� pom.xml ������ Hystrix ���������������¡�
+
+
+
+
+
+```
+
+
+<!--hystrix ����-->
+<dependency>
+    <groupId>org.springframework.cloud</groupId>
+    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
+</dependency>
+```
+
+
+
+
+
+2. �� micro-service-cloud-consumer-dept-feign �� application.yml �������������ã������ͻ��˵� Hystrix ���ܡ�
+
+
+
+
+
+```
+
+feign:
+  hystrix:
+    enabled: true #�����ͻ��� hystrix
+
+```
+
+
+
+
+
+3\. �� net.biancheng.c.service ���£�����һ����Ϊ DeptHystrixService �ķ���󶨽ӿڣ��� micro-service-cloud-provider-dept-hystrix-8004 ���ṩ�ķ���ӿڽ��а󶨣��������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c.service;
+
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+@Component
+@FeignClient(value = "MICROSERVICECLOUDPROVIDERDEPTHYSTRIX")
+public interface DeptHystrixService {
+    @RequestMapping(value = "/dept/hystrix/ok/{id}")
+    public String deptInfo_Ok(@PathVariable("id") Integer id);
+
+    @RequestMapping(value = "/dept/hystrix/timeout/{id}")
+    public String deptInfo_Timeout(@PathVariable("id") Integer id);
+}
+```
+
+
+
+
+
+4\. �� net.biancheng.c.controller ���´���һ����Ϊ HystrixController_Consumer �� Controller ���������¡�
+
+
+
+
+
+```
+package net.biancheng.c.controller;
+
+import com.netflix.hystrix.contrib.javanica.annotation.DefaultProperties;
+import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;;
+import lombok.extern.slf4j.Slf4j;
+import net.biancheng.c.service.DeptHystrixService;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.annotation.Resource;
+
+@Slf4j
+@RestController
+public class HystrixController_Consumer {
+
+    @Resource
+    private DeptHystrixService deptHystrixService;
+
+    @RequestMapping(value = "/consumer/dept/hystrix/ok/{id}")
+    public String deptInfo_Ok(@PathVariable("id") Integer id) {
+        return deptHystrixService.deptInfo_Ok(id);
+    }
+
+    //�ڿͻ��˽��н���
+    @RequestMapping(value = "/consumer/dept/hystrix/timeout/{id}")
+    @HystrixCommand(fallbackMethod = "dept_TimeoutHandler") //Ϊ������ָ��ר���Ļ��˷���
+    public String deptInfo_Timeout(@PathVariable("id") Integer id) {
+        String s = deptHystrixService.deptInfo_Timeout(id);
+        log.info(s);
+        return s;
+    }
+
+    // deptInfo_Timeout������ ר�� fallback ����
+    public String dept_TimeoutHandler(@PathVariable("id") Integer id) {
+        log.info("deptInfo_Timeout �����������ѱ�������");
+        return "C�����������������������ϵͳ��æ�����Ժ����ԣ����ͻ��� deptInfo_Timeout ר���Ļ��˷���������";
+    }
+}
+
+```
+
+
+
+
+
+5\. �������ļ� appliction.yml �������������ã��ڿͻ�����������ʱ��ʱ�䡣
+
+
+
+
+
+```
+######################### Ribbon �ͻ��˳�ʱ���� ###################################
+ribbon:
+  ReadTimeout: 6000 #�����������õ�ʱ�䣬����������״������������£����������������õ�ʱ��
+  ConnectionTimeout: 6000 #�������Ӻ󣬷�������ȡ��������Դ��ʱ��
+######################��������ʱʱ��##########################
+hystrix:
+  command:
+    default:
+      execution:
+        isolation:
+          thread:
+            timeoutInMilliseconds: 7000
+####################���þ��巽����ʱʱ�� Ϊ 3 ��########################
+    DeptHystrixService#deptInfo_Timeout(Integer):
+      execution:
+        isolation:
+          thread:
+            timeoutInMilliseconds: 3000
+
+```
+
+
+
+
+
+�������ļ����������ij�ʱʱ��ʱ����Ҫע������ 2 �㣺
+
+1��Hystrix ������Ϊ�������󣨷��������ó�ʱʱ�䣨��λΪ���룩��������ʱ�򴥷�ȫ�ֵĻ��˷������д�����
+
+```hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=mmm```
+
+2��Hystrix ������Ϊij���ض��ķ������󣨷��������ó�ʱʱ�䣬��ʽ���£�
+
+```hystrix.command.xxx#yyy(zzz).execution.isolation.thread.timeoutInMilliseconds=mmm```
+
+��ʽ˵�����£�
+
+*   xxx��Ϊ�����÷��񷽷���������ƣ�ͨ��Ϊ����󶨽ӿڵ����ƣ������� DeptHystrixService �ӿڡ�
+*   yyy�����񷽷��������� deptInfo_Timeout() ������
+*   zzz�������ڵIJ������ͣ����� Integer��String �ȵ�
+*   mmm��Ҫ���õij�ʱʱ�䣬��λΪ���루1 �� =1000 ���룩
+
+6\. �� micro-service-cloud-consumer-dept-feign �����������ϣ�ʹ�� @EnableHystrix ע�⿪���ͻ��� Hystrix ���ܣ��������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.netflix.hystrix.EnableHystrix;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+
+@SpringBootApplication
+@EnableFeignClients //���� OpenFeign ����
+@EnableHystrix //���� Hystrix
+public class MicroServiceCloudConsumerDeptFeignApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(MicroServiceCloudConsumerDeptFeignApplication.class, args);
+    }
+}
+
+```
+
+
+
+
+
+7\. �޸� micro-service-cloud-provider-dept-hystrix-8004 �� DeptServiceImpl �Ĵ��룬�� deptInfo_Timeout() ����������ʱ���޸�Ϊ 4 �루С�ڳ�ʱʱ�� 5 �룩���Ա�֤������������������������������¡�
+
+
+
+
+
+```
+//һ���÷���ʧ�ܲ��׳����쳣��Ϣ�󣬻��Զ�����  @HystrixCommand ע���ע�� fallbackMethod ָ���ķ���
+@HystrixCommand(fallbackMethod = "dept_TimeoutHandler",
+        commandProperties =
+                //�涨 5 �������ھͲ��������������У����� 5 ��ͱ���������ָ���ķ���
+                {@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "5000")})
+@Override
+public String deptInfo_Timeout(Integer id) {
+    int outTime = 4;
+    try {
+        TimeUnit.SECONDS.sleep(outTime);
+    } catch (InterruptedException e) {
+        e.printStackTrace();
+    }
+    return "�̳߳أ�" + Thread.currentThread().getName() + "  deptInfo_Timeout,id:   " + id + "  ��ʱ: " + outTime;
+}
+
+```
+
+
+
+
+
+8\. ���� micro-service-cloud-provider-dept-hystrix-8004 �� micro-service-cloud-consumer-dept-feign��ʹ����������ʡ�http://eureka7001.com:8004/dept/hystrix/timeout/1����ֱ�ӵ��÷���˵� deptInfo_Timeout() �������������ͼ��
+
+![Hystrix �������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1016231059-3.png)
+ͼ4��Hystrix �������������
+
+9\. ʹ����������ʡ�http://eureka7001.com/consumer/dept/hystrix/timeout/1�����������ͼ��
+
+![Hystrix �ͻ��˷��񽵼�](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101623C94-4.png)
+ͼ5��Hystrix �ͻ��˷��񽵼�
+
+��ͼ 5 ���Կ��������ڷ�������ĺ�ʱΪ 4 �룬�����˿ͻ���Ϊ������ָ���ij�ʱʱ�� ��3 �� ������˸÷��񱻽�����������������ָ���Ļ��˷�����
+
+## ȫ�ֽ�������
+
+ͨ������ķ�ʽʵ�ַ��񽵼�ʱ����Ҫ�������ҵ�񷽷������ý����������⼫�п��ܻ���ɴ���ļ������͡�Ϊ�˽�������⣬���ǻ�����Ϊ����ҵ�񷽷�ָ��һ��ȫ�ֵĻ��˷��������岽�����¡�
+
+1\. �� HystrixController_Consumer �������ϱ�ע @DefaultProperties ע�⣬��ͨ���� defaultFallback ����ָ��һ��ȫ�ֵĽ����������������¡�
+
+
+
+
+
+```
+
+
+@Slf4j
+@RestController
+@DefaultProperties(defaultFallback = "dept_Global_FallbackMethod") //ȫ�ֵķ��񽵼�����
+public class HystrixController_Consumer {
+����
+}
+
+```
+
+
+
+
+
+2\. �� HystrixController_Consumer �У�����һ����Ϊ dept_Global_FallbackMethod ��ȫ�ֻط������������¡�
+
+
+
+
+
+```
+
+
+/**
+ * ȫ�ֵ� fallback ������
+ * ���˷�������� hystrix ��ִ�з�������ͬ����
+ * @DefaultProperties(defaultFallback = "dept_Global_FallbackMethod") ����ע�⣬���󷽷���ʹ�� @HystrixCommand ע��
+ */
+public String dept_Global_FallbackMethod() {
+    return "C���������������������г���������ϵͳ��æ�����Ժ����ԣ����ͻ���ȫ�ֻ��˷�������,��";
+}
+
+```
+
+
+
+
+
+> **ע��**��������FallBack���������������Ӧ��ҵ�񷽷���ͬһ�����У������޷���Ч��
+
+3\. �����е�ҵ�񷽷��϶���ע @HystrixCommand ע�⣬�������ǽ� deptInfo_Timeout() �����ϵ� @HystrixCommand(fallbackMethod = "dept_TimeoutHandler") �޸�Ϊ @HystrixCommand ���ɣ��������¡�
+
+
+
+
+
+```
+
+
+//�ڿͻ��˽��н���
+@RequestMapping(value = "/consumer/dept/hystrix/timeout/{id}")
+@HystrixCommand
+public String deptInfo_Timeout(@PathVariable("id") Integer id) {
+    String s = deptHystrixService.deptInfo_Timeout(id);
+    log.info(s);
+    return s;
+}
+```
+
+
+
+
+
+> **ע��**��ȫ�ֽ������������ȼ��ϵͣ�ֻ��ҵ�񷽷�û��ָ���併������ʱ�����񽵼�ʱ�Żᴥ��ȫ�ֻ��˷�������ҵ�񷽷�ָ�����Լ��Ļ��˷�������ô�ڷ��񽵼�ʱ����ֻ��ֱ�Ӵ������Լ��Ļ��˷���������ȫ�ֻ��˷�����
+
+4\. ���� micro-service-cloud-consumer-dept-feign��ʹ����������ʡ�http://eureka7001.com/consumer/dept/hystrix/timeout/1�����������ͼ��
+
+![Hystrix ȫ�ֻ��˷���](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101623J11-5.png)
+ͼ6��ȫ�ֻ��˷���
+
+## ������߼�
+
+������ҵ�񷽷�ָ���Ľ�����������ȫ�ֽ������������Ƕ������ҵ�񷽷���ͬһ�����в�����Ч��ҵ���߼��뽵���߼���϶ȼ��ߡ�
+
+�������Ƕ�ҵ���߼��뽵���߼����н�������������¡�
+
+1\. �� micro-service-cloud-consumer-dept-feign �� net.biancheng.c.service ���£��½� DeptHystrixService �ӿڵ�ʵ���� DeptHystrixFallBackService��ͳһΪ DeptHystrixService �еķ����ṩ���񽵼����� ���������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c.service;
+import org.springframework.stereotype.Component;
+/**
+* Hystrix ���񽵼�
+* ��������߼�
+*/
+@Component
+public class DeptHystrixFallBackService implements DeptHystrixService {
+    @Override
+    public String deptInfo_Ok(Integer id) {
+        return "--------------------C������������������ϵͳ��æ�����Ժ����ԣ���������˷���������-----------------------";
+    }
+    @Override
+    public String deptInfo_Timeout(Integer id) {
+        return "--------------------C������������������ϵͳ��æ�����Ժ����ԣ���������˷���������-----------------------";
+    }
+}
+
+```
+
+
+
+
+
+> **ע��**������������������ʽ���� Spring �����в�����Ч����õķ�ʽ���������ϱ�ע @Component ע�⡣
+
+2\. �ڷ���󶨽ӿ� DeptHystrixService ��ע�� @FeignClient ע�������� fallback ���ԣ�����ֵΪ DeptHystrixFallBackService.class���������¡�
+
+
+
+
+
+```
+package net.biancheng.c.service;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+@Component
+@FeignClient(value = "MICROSERVICECLOUDPROVIDERDEPTHYSTRIX", fallback = DeptHystrixFallBackService.class)
+public interface DeptHystrixService {
+    @RequestMapping(value = "/dept/hystrix/ok/{id}")
+    public String deptInfo_Ok(@PathVariable("id") Integer id);
+    @RequestMapping(value = "/dept/hystrix/timeout/{id}")
+    public String deptInfo_Timeout(@PathVariable("id") Integer id);
+}
+
+```
+
+
+
+
+
+3\. ���� micro-service-cloud-consumer-dept-feign��Ȼ��رշ���� micro-service-cloud-provider-dept-hystrix-8004��ʹ����������ʡ�http://eureka7001.com/consumer/dept/hystrix/ok/1�����������ͼ��
+
+![Hystrix ��������߼�](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1016233063-6.png)
+ͼ7��Hystrix ������˷���
+
+## Hystrix �����۶�
+
+�۶ϻ�����Ϊ��Ӧ��ѩ��ЧӦ�����ֵ�һ��΢������·�������ơ�
+
+��΢����ϵͳ�е�ij��΢���񲻿��û���Ӧʱ��̫��ʱ��Ϊ�˱���ϵͳ����������ԣ��۶�������ʱ�ж�����Ը÷���ĵ��ã������ٷ���һ���ѺõĴ�����Ӧ�������۶�״̬�������õģ��ھ�����һ����ʱ����۶������ٴμ���΢�����Ƿ�ָ�������������ָ�������ָ��������·��
+
+#### �۶�״̬
+
+���۶ϻ������漰�������۶�״̬��
+
+*   �۶Ϲر�״̬��Closed�����������������ʱ���۶������ڹر�״̬��������÷����������ضԷ�����е��á�
+*   �۶Ͽ���״̬��Open����Ĭ������£��ڹ̶�ʱ���ڽӿڵ��ó������ʴﵽһ����ֵ������ 50%�����۶���������۶Ͽ���״̬�������۶�״̬�󣬺����Ը÷���ĵ��ö��ᱻ�жϣ��۶�����ִ�б��صĽ�����FallBack��������
+*   ���۶�״̬��Half-Open���� ���۶Ͽ���һ��ʱ��֮���۶����������۶�״̬���ڰ��۶�״̬�£��۶����᳢�Իָ�������÷��Է���ĵ��ã���������������ø÷��񣬲��������óɹ��ʡ�����ɹ��ʴﵽԤ�ڣ���˵�������ѻָ��������۶�������ر�״̬������ɹ����Ծɺܵͣ������½����۶Ͽ���״̬��
+
+�����۶�״̬֮���ת����ϵ����ͼ��
+
+![�۶�״̬ת��](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10162355X-7.png)
+ͼ8�������۶�״̬ת��
+
+#### Hystrix ʵ���۶ϻ���
+
+�� Spring Cloud �У��۶ϻ�����ͨ�� Hystrix ʵ�ֵġ�Hystrix ����΢�������õ�״������ʧ�ܵ��õ�һ������ʱ������ 5 ����ʧ�� 20 �Σ����ͻ������۶ϻ��ơ�
+
+Hystrix ʵ�ַ����۶ϵIJ������£�
+
+1.  ������ĵ��ó����ʴﵽ�򳬹� Hystix �涨�ı��ʣ�Ĭ��Ϊ 50%�����۶��������۶Ͽ���״̬��
+2.  �۶��������۶Ͽ���״̬��Hystrix ������һ������ʱ�䴰�������ʱ�䴰�ڣ��÷���Ľ����߼�����ʱ�䵱ҵ�����߼�����ԭ����ҵ�����߼������á�
+3.  ���������ٴε��ø÷���ʱ����ֱ�ӵ��ý����߼����ٵط���ʧ����Ӧ���Ա���ϵͳѩ����
+4.  ������ʱ�䴰���ں�Hystrix �������۶�ת̬��������������Է���ԭ������ҵ���߼����е��ã����������óɹ��ʡ�
+5.  ������óɹ��ʴﵽԤ�ڣ���˵�������ѻָ�������Hystrix �����۶Ϲر�״̬������ԭ������ҵ���߼��ָ������� Hystrix ���½����۶Ͽ���״̬������ʱ�䴰�����¼�ʱ�������ظ��� 2 ���� 5 ����
+
+#### ʾ��
+
+�������Ǿ�ͨ��һ��ʵ������֤�� Hystrix �����ʵ���۶ϻ��Ƶġ�
+
+1\. �� micro-service-cloud-provider-dept-hystrix-8004 �е� DeptService �ӿ�������һ�� deptCircuitBreaker() �������������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c.service;
+public interface DeptService {
+    // hystrix �۶���ʾ�� ok
+    public String deptInfo_Ok(Integer id);
+   
+    //hystrix �۶�����ʱ����
+    public String deptInfo_Timeout(Integer id);
+    // Hystrix �۶ϻ��ư���
+    public String deptCircuitBreaker(Integer id);
+}
+
+```
+
+
+
+
+
+2\. �� DeptService �ӿڵ�ʵ���� DeptServiceImpl ���� deptCircuitBreaker() �ķ���ʵ�ּ�����˷������������¡�
+
+
+
+
+
+```
+//Hystrix �۶ϰ���
+@Override
+@HystrixCommand(fallbackMethod = "deptCircuitBreaker_fallback", commandProperties = {
+        //���²����� HystrixCommandProperties ������Ĭ������
+        @HystrixProperty(name = "circuitBreaker.enabled", value = "true"), //�Ƿ����۶���
+    @HystrixProperty(name = "metrics.rollingStats.timeInMilliseconds",value = "1000"), //ͳ��ʱ�䴰
+        @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"), //ͳ��ʱ�䴰���������
+        @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "10000"), //����ʱ�䴰����
+        @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "60"), //��ͳ��ʱ�䴰�������ڣ�����ʧ���ʴﵽ 60% ʱ�����۶�״̬
+})
+public String deptCircuitBreaker(Integer id) {
+    if (id < 0) {
+        //������� id Ϊ����ʱ���׳��쳣�����ý�������
+        throw new RuntimeException("c������������������id �����Ǹ�����");
+    }
+    String serialNum = IdUtil.simpleUUID();
+    return Thread.currentThread().getName() + "\t" + "���óɹ�����ˮ��Ϊ��" + serialNum;
+}
+
+//deptCircuitBreaker �Ľ�������
+public String deptCircuitBreaker_fallback(Integer id) {
+    return "c������������������id �����Ǹ���,���Ժ�����!\t id:" + id;
+}
+
+```
+
+
+
+
+
+�����ϴ����У����漰���� 4 ���� Hystrix �۶ϻ�����ص���Ҫ�������� 4 �������ĺ������±���
+
+| ����                                     | ����                                                         |
+| ---------------------------------------- | ------------------------------------------------------------ |
+| metrics.rollingStats.timeInMilliseconds  | ͳ��ʱ�䴰��                                                 |
+| circuitBreaker.sleepWindowInMilliseconds | ����ʱ�䴰���۶Ͽ���״̬����һ��ʱ����۶������Զ�������۶�״̬�����ʱ��ͱ���Ϊ���ߴ����ڡ� |
+| circuitBreaker.requestVolumeThreshold    | ����������ֵ����ͳ��ʱ�䴰�ڣ������������뵽��һ������������Hystrix �ſ��ܻὫ�۶����򿪽����۶Ͽ���ת̬��������������������� ����������ֵ��Hystrix ����������ֵĬ��Ϊ 20�������ζ����ͳ��ʱ�䴰�ڣ����������ô������� 20 �Σ���ʹ���е����󶼵��ó������۶���Ҳ����򿪡� |
+| circuitBreaker.errorThresholdPercentage  | ����ٷֱ���ֵ��������������ͳ��ʱ�䴰�ڳ���������������ֵ����������ó����ʳ���һ���ı������۶����Ż�򿪽����۶Ͽ���ת̬��������������Ǵ���ٷֱ���ֵ������ٷֱ���ֵ����Ϊ 50���ͱ�ʾ����ٷֱ�Ϊ 50%������������� 30 �ε��ã������� 15 �η����˴��󣬼������� 50% �Ĵ���ٷֱȣ���ʱ���۶����ͻ�򿪡� |
+
+3\. �� DeptController ������һ�� deptCircuitBreaker() ���������ṩ���񣬴������¡�
+
+
+
+
+
+```
+
+// Hystrix �����۶�
+@RequestMapping(value = "/dept/hystrix/circuit/{id}")
+public String deptCircuitBreaker(@PathVariable("id") Integer id){
+    String result = deptService.deptCircuitBreaker(id);
+    log.info("result:"+result);
+    return result;
+}
+
+```
+
+
+
+
+
+4\. ���� micro-service-cloud-provider-dept-hystrix-8004��ʹ����������ʡ�http://eureka7001.com:8004/dept/hystrix/circuit/1�����������ͼ��
+
+![Hystrix ʵ���۶ϻ��� ������ȷ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1016233Q8-8.png)
+ͼ9��Hystrix ʵ���۶ϻ��� ������ȷʾ��
+
+5\. �������Σ����ô�����������������ֵ�����ʡ�http://eureka7001.com:8004/dept/hystrix/circuit/-2����ʹ���ó����ʴ��ڴ���ٷֱȷ�ֵ�������ͼ��
+
+![Hystrix ʵ���۶ϻ��� �������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10162332D-9.png)
+ͼ10��Hystrix ʵ���۶ϻ��� �������
+
+6\. ���½������޸�Ϊ�������������Ϊ 3����ʹ����������ʡ�http://eureka7001.com:8004/dept/hystrix/circuit/3�����������ͼ��
+
+![Hystrix �۶Ͽ���ת̨](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1016235592-10.png)
+ͼ11��Hystrix �۶Ͽ���״̬��������
+
+ͨ��ͼ 11 ���Կ��������۶Ͽ���״̬�£���ʹ���Ǵ���IJ����Ѿ������������õ���Ȼ�����߼���
+
+7\. �����������ʡ�http://eureka7001.com:8004/dept/hystrix/circuit/3���������ͼ��
+
+![Hystrix �۶Ϲر�](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1016231R0-11.gif)
+ͼ12��Hystrix �����۶Ϲر�״̬
+
+ͨ��ͼ 12 ���Կ����������������ȷ��������һ�������ʺ�Hystrix �����۶Ϲر�״̬��
+
+## Hystrix ���ϼ��
+
+Hystrix ���ṩ��׼ʵʱ�ĵ��ü�أ�Hystrix Dashboard�����ܣ�Hystrix ������ؼ�¼����ͨ�� Hystrix ����������ִ����Ϣ������ͳ�Ʊ�������ʽչʾ���û�������ÿ��ִ��������������ɹ������������ʧ������������ȡ�
+
+�������Ǿ�ͨ��һ��ʵ����� Hystrix Dashboard����� micro-service-cloud-provider-dept-hystrix-8004 �����������
+
+1\. �ڸ��������½�һ����Ϊ micro-service-cloud-consumer-dept-hystrix-dashboard-9002 ����ģ�飬������ pom.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>spring-cloud-demo2</artifactId>
+        <groupId>net.biancheng.c</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+    <groupId>net.biancheng.c</groupId>
+    <artifactId>micro-service-cloud-consumer-dept-hystrix-dashboard-9002</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>micro-service-cloud-consumer-dept-hystrix-dashboard-9002</name>
+    <description>Demo project for Spring Boot</description>
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter</artifactId>
+        </dependency>
+        <!--Spring Boot ��������-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!--hystrix-dashboard ��ص�����-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
+        </dependency>
+        <!--���� Spring Boot �ļ��ģ��-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-devtools</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>
+
+```
+
+
+
+
+
+2\. �� micro-service-cloud-consumer-dept-hystrix-dashboard-9002 �� application.yml �������������á�
+
+
+
+
+
+```
+
+server:
+  port: 9002  #�˿ں�
+
+#http://eureka7001.com:9002/hystrix �۶������ҳ��
+# localhost:8004//actuator/hystrix.stream ��ص�ַ
+hystrix:
+  dashboard:
+    proxy-stream-allow-list:
+      - "localhost"
+
+```
+
+
+
+
+
+3\. �� micro-service-cloud-consumer-dept-hystrix-dashboard-9002 ���������������� @EnableHystrixDashboard ע�⣬���� Hystrix ��ع��ܣ��������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
+
+@SpringBootApplication
+@EnableHystrixDashboard
+public class MicroServiceCloudConsumerDeptHystrixDashboard9002Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(MicroServiceCloudConsumerDeptHystrixDashboard9002Application.class, args);
+    }
+
+}
+
+```
+
+
+
+
+
+4\. �� micro-service-cloud-provider-dept-hystrix-8004 �� net.biancheng.c.config ���£�����һ����Ϊ HystrixDashboardConfig �������࣬�������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c.config;
+
+import com.netflix.hystrix.contrib.metrics.eventstream.HystrixMetricsStreamServlet;
+import org.springframework.boot.web.servlet.ServletRegistrationBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class HystrixDashboardConfig {
+    /**
+     *  Hystrix dashboard ��ؽ����������
+     * @return
+     */
+    @Bean
+    public ServletRegistrationBean getServlet() {
+        HystrixMetricsStreamServlet streamServlet = new HystrixMetricsStreamServlet();
+        ServletRegistrationBean registrationBean = new ServletRegistrationBean(streamServlet);
+        registrationBean.setLoadOnStartup(1);
+        registrationBean.addUrlMappings("/actuator/hystrix.stream");//����·��
+        registrationBean.setName("hystrix.stream");
+        return registrationBean;
+    }
+
+}
+
+```
+
+
+
+
+
+5\. ���� micro-service-cloud-consumer-dept-hystrix-dashboard-9002��ʹ����������ʡ�http://eureka7001.com:9002/hystrix�����������ͼ��
+
+![Hystrix ���](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1016234440-12.png)
+ͼ13��Hystrix ���ҳ��
+
+6\. ���� micro-service-cloud-provider-dept-hystrix-8004������������Ϣ� Hystrix ���ҳ���У�����ͼ��
+
+![Hystrix �����Ϣ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1016232636-13.png)
+ͼ14��Hystrix �����Ϣ
+
+7\. ����·��� Monitor Stream ��ť����ת�� Hystrix �� micro-service-cloud-provider-dept-hystrix-8004 �ļ��ҳ�棬����ͼ��
+
+![Hystrix ��� 8004](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1016231229-14.png)
+ͼ15��Hystrix ���΢�����������
+
+8\. ʹ���������η��ʡ�http://eureka7001.com:8004/dept/hystrix/circuit/1���� ��http://eureka7001.com:8004/dept/hystrix/circuit/-1�����鿴 Hystrix ���ҳ�棬����ͼ��
+
+![Hystrix ��� 8004 �������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10162345J-15.png)
+ͼ16��Hystrix ��ط����������
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudLoadBalancer.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudLoadBalancer.md"
new file mode 100644
index 0000000..1a35579
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudLoadBalancer.md"
@@ -0,0 +1,346 @@
+ǰ���ã��Ұ�Mall΢����汾ȫ�������� ����ͨ��Gateway���ص������������ʱ�򣬳�����Service Unavailable�����⡣�Ų�ԭ��ʱ������Ϊ���ؾ��������Ribbon�������ˣ���ΪNetflix��Դ��һ�������Ribbon���ѽ���ά��״̬�������Ƽ�ʹ�õ���Loadbalancer���������Ǿ�������Loadbalancer��ʹ�ã�
+
+# LoadBalancer���
+
+LoadBalancer��Spring Cloud�ٷ��ṩ�ĸ��ؾ�����������������Ribbon����ʹ�÷�ʽ��Ribbon�������ݣ����Դ�Ribbon����ƽ�����ɡ�
+
+# ʹ��
+
+���������LoadBalancer�Ļ���ʹ�ã����ǽ�ʹ��Nacos��Ϊע�����ģ�ͨ��nacos-loadbalancer-service��nacos-user-service�����������໥������������ʾ��
+
+# ���ؾ���
+
+���ǽ�ʹ��RestTemplate����ʾ��LoadBalancer�ĸ��ؾ��⹦�ܡ�
+
+- ������nacos-loadbalancer-serviceģ���pom.xml�ļ�������LoadBalancer���������
+
+
+
+    <dependency>
+        <groupId>org.springframework.cloud</groupId>
+        spring-cloud-starter-loadbalancer
+    </dependency>
+
+
+
+
+
+- Ȼ�󴴽�Java�����࣬��������RestTemplate��ͬʱʹ��@LoadBalancedע�⸳���为�ؾ���������
+
+
+
+    /**
+     * RestTemplate�������
+     * Created by macro on 2019/8/29.
+     */
+    @Configuration
+    public class RestTemplateConfig {
+    
+        @Bean
+        @ConfigurationProperties(prefix = "rest.template.config")
+        public HttpComponentsClientHttpRequestFactory customHttpRequestFactory() {
+            return new HttpComponentsClientHttpRequestFactory();
+        }
+    
+        @Bean
+        @LoadBalanced
+        public RestTemplate restTemplate() {
+            return new RestTemplate(customHttpRequestFactory());
+        }
+    }
+
+
+
+
+
+- ��application.yml�п���ʹ���Զ������ö�RestTemplate�ĵ��ó�ʱ�������ã�
+
+
+
+    rest:
+      template:
+        config: # RestTemplate���ó�ʱ����
+          connectTimeout: 5000
+          readTimeout: 5000
+
+
+
+
+- Ȼ����Controller��ʹ��RestTemplate����Զ�̵��ã�
+
+
+
+    /**
+     * Created by macro on 2019/8/29.
+     */
+    @RestController
+    @RequestMapping("/user")
+    public class UserLoadBalancerController {
+        @Autowired
+        private RestTemplate restTemplate;
+        @Value("${service-url.nacos-user-service}")
+        private String userServiceUrl;
+    
+        @GetMapping("/{id}")
+        public CommonResult getUser(@PathVariable Long id) {
+            return restTemplate.getForObject(userServiceUrl + "/user/{1}", CommonResult.class, id);
+        }
+    
+        @GetMapping("/getByUsername")
+        public CommonResult getByUsername(@RequestParam String username) {
+            return restTemplate.getForObject(userServiceUrl + "/user/getByUsername?username={1}", CommonResult.class, username);
+        }
+    
+        @GetMapping("/getEntityByUsername")
+        public CommonResult getEntityByUsername(@RequestParam String username) {
+            ResponseEntity<CommonResult> entity = restTemplate.getForEntity(userServiceUrl + "/user/getByUsername?username={1}", CommonResult.class, username);
+            if (entity.getStatusCode().is2xxSuccessful()) {
+                return entity.getBody();
+            } else {
+                return new CommonResult("����ʧ��", 500);
+            }
+        }
+    
+        @PostMapping("/create")
+        public CommonResult create(@RequestBody User user) {
+            return restTemplate.postForObject(userServiceUrl + "/user/create", user, CommonResult.class);
+        }
+    
+        @PostMapping("/update")
+        public CommonResult update(@RequestBody User user) {
+            return restTemplate.postForObject(userServiceUrl + "/user/update", user, CommonResult.class);
+        }
+    
+        @PostMapping("/delete/{id}")
+        public CommonResult delete(@PathVariable Long id) {
+            return restTemplate.postForObject(userServiceUrl + "/user/delete/{1}", null, CommonResult.class, id);
+        }
+    }
+
+
+
+
+- ��nacos-user-service�������Ѿ�ʵ������Щ�ӿڣ������ṩ��nacos-loadbalancer-service�������Զ�̵��ã�
+
+
+
+- Ȼ������һ��nacos-loadbalancer-service��������nacos-user-service����ʱNacos�л���ʾ���·���
+
+
+
+- ��ʱͨ��nacos-loadbalancer-service���ýӿڽ��в��ԣ��ᷢ������nacos-user-service�����ӡ��־��Ϣ��ʹ�õ�����ѯ���ԣ����ʵ�ַ��http://localhost:8308/user/1
+
+
+
+# ����ʽ�������
+
+��ȻLoadBalancer����ʹ��RestTemplate������Զ�̵��ã�������ʹ��OpenFeign����������ʽ������ã��������Ǿ��������¡�
+
+- ����nacos-loadbalancer-serviceģ���pom.xml�ļ�������OpenFeign�����������
+
+
+
+    <dependency>
+        <groupId>org.springframework.cloud</groupId>
+        spring-cloud-starter-openfeign
+    </dependency>
+
+
+
+
+
+- Ȼ����OpenFeign�Ŀͻ��˽ӿ�����������Ҫ���õķ���ӿ��Լ����÷�ʽ��
+
+
+
+    /**
+     * Created by macro on 2019/9/5.
+     */
+    @FeignClient(value = "nacos-user-service")
+    public interface UserService {
+        @PostMapping("/user/create")
+        CommonResult create(@RequestBody User user);
+    
+        @GetMapping("/user/{id}")
+        CommonResult<User> getUser(@PathVariable Long id);
+    
+        @GetMapping("/user/getByUsername")
+        CommonResult<User> getByUsername(@RequestParam String username);
+    
+        @PostMapping("/user/update")
+        CommonResult update(@RequestBody User user);
+    
+        @PostMapping("/user/delete/{id}")
+        CommonResult delete(@PathVariable Long id);
+    }
+
+
+
+- ����Controller��ʹ��OpenFeign�Ŀͻ��˽ӿ�������Զ�̷���
+
+
+
+    /**
+     * Created by macro on 2019/8/29.
+     */
+    @RestController
+    @RequestMapping("/userFeign")
+    public class UserFeignController {
+        @Autowired
+        private UserService userService;
+    
+        @GetMapping("/{id}")
+        public CommonResult getUser(@PathVariable Long id) {
+            return userService.getUser(id);
+        }
+    
+        @GetMapping("/getByUsername")
+        public CommonResult getByUsername(@RequestParam String username) {
+            return userService.getByUsername(username);
+        }
+    
+        @PostMapping("/create")
+        public CommonResult create(@RequestBody User user) {
+            return userService.create(user);
+        }
+    
+        @PostMapping("/update")
+        public CommonResult update(@RequestBody User user) {
+            return userService.update(user);
+        }
+    
+        @PostMapping("/delete/{id}")
+        public CommonResult delete(@PathVariable Long id) {
+            return userService.delete(id);
+        }
+    }
+
+
+
+
+
+- �������������OpenFeign�ij�ʱ���õĻ���������application.yml�������������ݣ�
+
+
+
+    feign:
+      client:
+        config:
+          default: # Feign���ó�ʱ����
+            connectTimeout: 5000
+            readTimeout: 5000
+
+
+
+- ������ͨ�����Խӿڵ���Զ�̷��񣬷��ֿ����������ã����ʵ�ַ��http://localhost:8308/userFeign/1
+
+
+
+# ����ʵ������
+
+LoadBalancerΪ��������ܣ�������ÿ������ʱȥ��ȡʵ���б������ǽ�����ʵ���б������˱��ػ��档
+
+Ĭ�ϵĻ���ʱ��Ϊ35s��Ϊ�˼��ٷ��񲻿��û��ᱻѡ��Ŀ����ԣ����ǿ��Խ����������á�
+
+
+
+    spring:
+      cloud:
+        loadbalancer:
+          cache: # ���ؾ��⻺������
+            enabled: true # ��������
+            ttl: 5s # ���û���ʱ��
+            capacity: 256 # ���û����С
+
+
+
+
+# HTTP����ת��
+
+���������ÿ��Զ�̵����д����Զ��������ͷ�Ļ�����������LoadBalancerRequestTransformer��ͨ�������Զ�ԭʼ�������һ����ת����
+
+- ����������Ҫ���ú�LoadBalancerRequestTransformer��Beanʵ�����������ǽ�ServiceInstance��instanceId���뵽����ͷX-InstanceId�У�
+
+
+
+    /**
+     * LoadBalancer�������
+     * Created by macro on 2022/7/26.
+     */
+    @Configuration
+    public class LoadBalancerConfig {
+        @Bean
+        public LoadBalancerRequestTransformer transformer() {
+            return new LoadBalancerRequestTransformer() {
+                @Override
+                public HttpRequest transformRequest(HttpRequest request, ServiceInstance instance) {
+                    return new HttpRequestWrapper(request) {
+                        @Override
+                        public HttpHeaders getHeaders() {
+                            HttpHeaders headers = new HttpHeaders();
+                            headers.putAll(super.getHeaders());
+                            headers.add("X-InstanceId", instance.getInstanceId());
+                            return headers;
+                        }
+                    };
+                }
+            };
+        }
+    }
+
+
+
+
+
+- Ȼ���޸�nacos-user-service�еĴ��룬��ӡ��ȡ��������ͷX-InstanceId����Ϣ��
+
+
+
+    /**
+     * Created by macro on 2019/8/29.
+     */
+    @RestController
+    @RequestMapping("/user")
+    public class UserController {
+        @GetMapping("/{id}")
+        public CommonResult<User> getUser(@PathVariable Long id) {
+            User user = userService.getUser(id);
+            LOGGER.info("����id��ȡ�û���Ϣ���û�����Ϊ��{}", user.getUsername());
+            ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
+            HttpServletRequest request = servletRequestAttributes.getRequest();
+            String instanceId = request.getHeader("X-InstanceId");
+            if (StrUtil.isNotEmpty(instanceId)) {
+                LOGGER.info("��ȡ���Զ�������ͷ:X-InstanceId={}", instanceId);
+            }
+            return new CommonResult<>(user);
+        }
+    }
+
+- ���������ʽӿڽ��в��ԣ�nacos-user-service����̨����ӡ������־�������Զ�������ͷ�Ѿ��ɹ������ˣ����ʵ�ַ��http://localhost:8308/user/1
+
+
+
+    2022-07-26 15:05:19.920  INFO 14344 --- [nio-8206-exec-5] c.macro.cloud.controller.UserController  : ����id��ȡ�û���Ϣ���û�����Ϊ��macro
+    2022-07-26 15:05:19.921  INFO 14344 --- [nio-8206-exec-5] c.macro.cloud.controller.UserController  : ��ȡ���Զ�������ͷ:X-InstanceId=192.168.3.227#8206#DEFAULT#DEFAULT_GROUP@@nacos-user-service
+
+
+
+# �ܽ�
+
+����ͨ����LoadBalancer��һ��ʵ�����ǿ��Է��֣�ʹ��LoadBalancer��Ribbon��������ʵ��������Ҫ��һЩ���÷�ʽ����ͬ�������֮ǰʹ�ù�Ribbon�Ļ��������Ͽ����޷��л���LoadBalancer��
+
+# �����
+
+�ٷ��ĵ���https://docs.spring.io/spring-cloud-commons/docs/current/reference/html/#spring-cloud-loadbalancer
+
+# ��ĿԴ���ַ
+
+https://github.com/macrozheng/springcloud-learning/tree/master/nacos-loadbalancer-service
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudOpenFeign.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudOpenFeign.md"
new file mode 100644
index 0000000..50c14d5
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudOpenFeign.md"
@@ -0,0 +1,489 @@
+Netflix Feign �� Netflix ��˾������һ��ʵ�ָ��ؾ���ͷ�����õĿ�Դ�����Spring Cloud ������ Netflix �е�������Դ������������� Eureka��Ribbon �Լ� Hystrix �ȣ�һ�����Ͻ� Spring Cloud Netflix ģ���У����Ϻ�ȫ��Ϊ Spring Cloud Netflix Feign��
+
+Feign �� [Ribbon](http://c.biancheng.net/springcloud/ribbon.html) �����˼��ɣ����� Ribbon ά����һ�ݿ��÷����嵥����ͨ�� Ribbon ʵ���˿ͻ��˵ĸ��ؾ��⡣
+
+Feign ��һ������ʽ���������������� RestTemplate �Ļ��������˽�һ���ķ�װ��ͨ�� Feign������ֻ��Ҫ����һ���ӿڲ�ͨ��ע����м򵥵����ã������� Dao �ӿ������ Mapper ע��һ��������ʵ�ֶ� HTTP �ӿڵİ󶨡�
+
+ͨ�� Feign�����ǿ�������ñ��ط���һ��������Զ�̷��񣬶���ȫ�о����������ڽ���Զ�̵��á�
+
+Feign ֧�ֶ���ע�⣬���� Feign �Դ���ע���Լ� JAX-RS ע��ȣ����ź����� Feign ��������֧�� Spring MVC ע�⣬�����ɻ����� Spring �û��������㡣
+
+2019 �� Netflix ��˾���� Feign �����ʽ����ͣ��ά��״̬������ Spring �ٷ����Ƴ���һ����Ϊ OpenFeign �������Ϊ Feign �����������
+
+## OpenFeign
+
+OpenFeign ȫ�� Spring Cloud OpenFeign������ Spring �ٷ��Ƴ���һ������ʽ��������븺�ؾ�����������ij��־���Ϊ���������ͣ��ά��״̬�� Feign��
+
+OpenFeign �� Spring Cloud �� Feign �Ķ��η�װ�������� Feign �����й��ܣ����� Feign �Ļ����������˶� Spring MVC ע���֧�֣����� @RequestMapping��@GetMapping �� @PostMapping �ȡ�
+
+#### OpenFeign ����ע��
+
+ʹ�� OpenFegin ����Զ�̷������ʱ������ע�����±���
+
+| ע��                | ˵��                                                         |
+| ------------------- | ------------------------------------------------------------ |
+| @FeignClient        | ��ע������֪ͨ OpenFeign ����� @RequestMapping ע���µĽӿڽ��н�������ͨ����̬�����ķ�ʽ����ʵ���࣬ʵ�ָ��ؾ���ͷ�����á� |
+| @EnableFeignClients | ��ע�����ڿ��� OpenFeign ���ܣ��� Spring Cloud Ӧ������ʱ��OpenFeign ��ɨ����� @FeignClient ע��Ľӿڣ����ɴ�����ע�ᵽ Spring �����С� |
+| @RequestMapping     | Spring MVC ע�⣬�� Spring MVC ��ʹ�ø�ע��ӳ������ͨ������ָ����������Controller�����Դ�����Щ URL �����൱�� Servlet �� web.xml �����á� |
+| @GetMapping         | Spring MVC ע�⣬����ӳ�� GET ��������һ�����ע�⣬�൱�� @RequestMapping(method = RequestMethod.GET) �� |
+| @PostMapping        | Spring MVC ע�⣬����ӳ�� POST ��������һ�����ע�⣬�൱�� @RequestMapping(method = RequestMethod.POST) �� |
+
+> Spring Cloud Finchley �����ϰ汾һ��ʹ�� OpenFeign ��Ϊ����������������� OpenFeign ���� 2019 �� Feign ͣ������ά�����Ƴ��ģ���˴���� 2019 �꼰�Ժ������Ŀʹ�õĶ��� OpenFeign���� 2018 ����ǰ����Ŀһ��ʹ�� Feign��
+
+## Feign VS OpenFeign
+
+�������Ǿ����Ա��� Feign �� OpenFeign ����ͬ��
+
+#### ��ͬ��
+
+Feign �� OpenFegin ����������ͬ�㣺
+
+*   Feign �� OpenFeign ���� Spring Cloud �µ�Զ�̵��ú͸��ؾ��������
+*   Feign �� OpenFeign ����һ����������ʵ�ַ����Զ�̵��ú͸��ؾ��⡣
+*   Feign �� OpenFeign ���� Ribbon �����˼��ɣ������� Ribbon ά���˿��÷����嵥����ͨ�� Ribbon ʵ���˿ͻ��˵ĸ��ؾ��⡣
+*   Feign �� OpenFeign �����ڷ��������ߣ��ͻ��ˣ��������󶨽ӿڲ�ͨ��ע��ķ�ʽ�������ã���ʵ��Զ�̷���ĵ��á�
+
+#### ��ͬ��
+
+Feign �� OpenFeign �������²�ͬ��
+
+*   Feign �� OpenFeign �������ͬ��Feign ������Ϊ spring-cloud-starter-feign���� OpenFeign ������Ϊ spring-cloud-starter-openfeign��
+*   Feign �� OpenFeign ֧�ֵ�ע�ⲻͬ��Feign ֧�� Feign ע��� JAX-RS ע�⣬����֧�� Spring MVC ע�⣻OpenFeign ����֧�� Feign ע��� JAX-RS ע���⣬��֧�� Spring MVC ע�⡣
+
+## OpenFeign ʵ��Զ�̷������
+
+�������Ǿ�ͨ��һ��ʵ��������ʾ��ͨ�� OpenFeign �����ʵ��Զ�̷�����õġ�
+
+1\. �� spring-cloud-demo2 �´���һ����Ϊ micro-service-cloud-consumer-dept-feign �� Spring Boot ģ�飬���� pom.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>spring-cloud-demo2</artifactId>
+        <groupId>net.biancheng.c</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <groupId>net.biancheng.c</groupId>
+    <artifactId>micro-service-cloud-consumer-dept-feign</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>micro-service-cloud-consumer-dept-feign</name>
+    <description>Demo project for Spring Boot</description>
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>net.biancheng.c</groupId>
+            <artifactId>micro-service-cloud-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!--Eureka Client ����-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
+        </dependency>
+        <!-- Ribbon ����-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
+        </dependency>
+        <!--���� OpenFeign ����-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-openfeign</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
+
+```
+
+
+
+
+
+2\. �� micro-service-cloud-consumer-dept-feign �µ���·������ /resources Ŀ¼���£�����һ�� application.yml�������������¡�
+
+
+
+
+
+```
+
+server:
+  port: 80
+eureka:
+  client:
+    register-with-eureka: false #���������߿��Բ������ע������ע�����
+    service-url:
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
+    fetch-registry: true  #���������߿ͻ�����Ҫȥ��������
+```
+
+
+
+
+
+3\. �� net.biancheng.c.service ���´���һ����Ϊ DeptFeignService �Ľӿڣ����ڸýӿ���ʹ�� @FeignClient ע��ʵ�ֶԷ���ӿڵİ󶨣��������¡�
+
+
+
+
+
+```
+package net.biancheng.c.service;
+
+import net.biancheng.c.entity.Dept;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+
+import java.util.List;
+
+//����Ϊ�����ڵ�һ�����
+@Component
+// �����ṩ���ṩ�ķ������ƣ��� application.name
+@FeignClient(value = "MICROSERVICECLOUDPROVIDERDEPT")
+public interface DeptFeignService {
+    //��Ӧ�����ṩ�ߣ�8001��8002��8003��Controller �ж���ķ���
+    @RequestMapping(value = "/dept/get/{id}", method = RequestMethod.GET)
+    public Dept get(@PathVariable("id") int id);
+
+    @RequestMapping(value = "/dept/list", method = RequestMethod.GET)
+    public List<Dept> list();
+}
+
+```
+
+
+
+
+
+�ڱ�д����󶨽ӿ�ʱ����Ҫע������ 2 �㣺
+
+*   �� @FeignClient ע���У�value ���Ե�ȡֵΪ�������ṩ�ߵķ��������������ṩ�������ļ���application.yml���� spring.application.name ��ȡֵ��
+*   �ӿ��ж����ÿ��������������ṩ�ߣ��� micro-service-cloud-provider-dept-8001 �ȣ��� Controller ����ķ��񷽷���Ӧ��
+
+4\. �� net.biancheng.c.controller ���£�����һ����Ϊ DeptController_Consumer �� Controller �࣬�������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c.controller;
+
+import net.biancheng.c.entity.Dept;
+import net.biancheng.c.service.DeptFeignService;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+@RestController
+public class DeptController_Consumer {
+    
+    @Resource
+    private DeptFeignService deptFeignService;
+
+    @RequestMapping(value = "/consumer/dept/get/{id}")
+    public Dept get(@PathVariable("id") Integer id) {
+        return deptFeignService.get(id);
+    }
+
+    @RequestMapping(value = "/consumer/dept/list")
+    public List<Dept> list() {
+        return deptFeignService.list();
+    }
+}
+```
+
+
+
+
+
+5\. ���������������� @EnableFeignClients ע�⿪�� OpenFeign ���ܣ��������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+
+@SpringBootApplication
+@EnableFeignClients //���� OpenFeign ����
+public class MicroServiceCloudConsumerDeptFeignApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(MicroServiceCloudConsumerDeptFeignApplication.class, args);
+    }
+}
+```
+
+
+
+
+
+Spring Cloud Ӧ��������ʱ��OpenFeign ��ɨ����� @FeignClient ע��Ľӿ����ɴ�������ע�˵� Spring �����С�
+
+6\. ������������ע�����ļ�Ⱥ�������ṩ���Լ� micro-service-cloud-consumer-dept-feign��������ɺ�ʹ����������ʡ�http://eureka7001.com/consumer/dept/list�����������ͼ��
+
+![OpenFeign ʵ�ַ������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1014296212-0.png)
+ͼ1��OpenFeign ʵ��Զ�̷������
+
+7\. ������η��ʡ�http://eureka7001.com/consumer/dept/list�����������ͼ��
+
+![OpenFeign Ĭ�ϸ��ؾ���](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1014294062-1.gif)
+ͼ2��OpenFeign ���ؾ���
+
+��ͼ 2 ���Կ��������� OpenFeign ������ Ribbon�������Ҳʵ���˿ͻ��˵ĸ��ؾ��⣬��Ĭ�ϸ��ؾ������Ϊ��ѯ���ԡ�
+
+## OpenFeign ��ʱ����
+
+OpenFeign �ͻ��˵�Ĭ�ϳ�ʱʱ��Ϊ 1 ���ӣ��������˴��������ʱ�䳬�� 1 ��ͻᱨ����Ϊ�˱��������������������Ҫ�� OpenFeign �ͻ��˵ij�ʱʱ����п��ơ�
+
+�������Ǿ�ͨ��һ��ʵ��������ʾ OpenFeign ����ν��г�ʱ���Ƶġ�
+
+1\. �����еķ����ṩ�ߣ�����ˣ��� DeptController ������һ����Ӧʱ��Ϊ 5 ��ķ��񣬴������¡�
+
+
+
+
+
+```
+
+//��ʱ����,�÷������Ӧʱ��Ϊ 5 ��
+@RequestMapping(value = "/dept/feign/timeout")
+public String DeptFeignTimeout() {
+    //��ͣ 5 ��
+    try {
+        TimeUnit.SECONDS.sleep(5);
+    } catch (InterruptedException e) {
+        e.printStackTrace();
+    }
+    return serverPort;
+}
+
+```
+
+
+
+
+
+2\. �� micro-service-cloud-consumer-dept-feign �� DeptFeignService �ӿ����������´��룬�󶨷���˸ո����ӵij�ʱ����
+
+
+
+
+
+```
+
+@RequestMapping(value = "/dept/feign/timeout")
+public String DeptFeignTimeout();
+
+```
+
+
+
+
+
+3\. �� micro-service-cloud-consumer-dept-feign �� DeptController_Consumer �������´��롣
+
+
+
+
+
+```
+
+@RequestMapping(value = "/consumer/dept/feign/timeout")
+public String DeptFeignTimeout() {
+    // openFeign-ribbon �ͻ���һ��Ĭ�ϵȴ�һ���ӣ�������ʱ��ͻᱨ��
+    return deptFeignService.DeptFeignTimeout();
+}
+
+```
+
+
+
+
+
+4\. �������з����ṩ�ߣ�ʹ����������η��ʡ�http://eureka7001.com:8001/dept/feign/timeout������http://eureka7001.com:8002/dept/feign/timeout���͡�http://eureka7001.com:8003/dept/feign/timeout����ȷ�����з����ṩ���ṩ�ij�ʱ����������ʹ�ã�����ͼ��
+
+![�����ṩ�߳�ʱ����](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10142a102-2.png)
+ͼ3�������ṩ�ߵij�ʱ����
+
+5\. ���� micro-service-cloud-consumer-dept-feign��ʹ����������ʡ�http://eureka7001.com/consumer/dept/feign/timeout�����������ͼ��
+
+![OpenFeign ��ʱ����](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1014293G1-3.png)
+ͼ4��OpenFeign ��ʱ����
+
+6\. �� micro-service-cloud-consumer-dept-feign �� application.yml �������������ã�����ʱʱ������Ϊ 6 �롣
+
+
+
+
+
+```
+
+
+ribbon:
+  ReadTimeout: 6000 #�����������õ�ʱ�䣬����������״������������£����������������õ�ʱ��
+  ConnectionTimeout: 6000 #�������Ӻ󣬷�������ȡ��������Դ��ʱ��
+
+```
+
+
+
+
+
+> ע������ OpenFeign ������ Ribbon �����������Լ����ؾ����ڵײ㶼������ Ribbon ʵ�ֵģ���� OpenFeign ��ʱ����Ҳ��ͨ�� Ribbon ��ʵ�ֵġ�
+
+7\. �ٴ����� micro-service-cloud-consumer-dept-feign��ʹ����������ʡ�http://eureka7001.com/consumer/dept/feign/timeout�����������ͼ��
+
+![OpenFeign ��ʱ����](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10142942D-4.png)
+ͼ5��OpenFeign ��ʱ����
+
+## OpenFeign ��־��ǿ
+
+OpenFeign �ṩ����־��ӡ���ܣ����ǿ���ͨ�����õ�����־�������˽������ϸ�ڡ�
+
+Feign Ϊÿһ�� FeignClient ���ṩ��һ�� feign.Logger ʵ����ͨ�������Զ� OpenFeign ����󶨽ӿڵĵ���������м�ء�
+
+OpenFeign ��־��ӡ���ܵĿ�����ʽ�Ƚϼ򵥣��������Ǿ�ͨ��һ��ʵ��������ʾ��
+
+1\. �� micro-service-cloud-consumer-dept-feign �� application.yml �������������ݡ�
+
+
+
+
+
+```
+
+
+logging:
+  level:
+    #feign ��־��ʲô���ļ����ظýӿ�
+    net.biancheng.c.service.DeptFeignService: debug
+```
+
+
+
+
+
+��������˵�����£�
+
+*   net.biancheng.c.service.DeptFeignService �ǿ��� @FeignClient ע��Ľӿڣ�������󶨽ӿڣ�������������Ҳ����ֻ���ò���·������ʾ��ظ�·���µ����з���󶨽ӿ�
+*   debug����ʾ�����ýӿڵ���־����
+
+�������õĺ�����ǣ�OpenFeign �� debug ������ net.biancheng.c.service.DeptFeignService �ӿڡ�
+
+2. �� net.biancheng.c. config ���´���һ����Ϊ ConfigBean �������࣬�������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c.config;
+import feign.Logger;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+@Configuration
+public class ConfigBean {
+    /**
+     * OpenFeign ��־��ǿ
+     * ���� OpenFeign ��¼��Щ����
+     */
+    @Bean
+    Logger.Level feginLoggerLevel() {
+        return Logger.Level.FULL;
+    }
+}
+
+```
+
+
+
+
+
+�����õ�������ͨ�����õ� Logger.Level ������� OpenFeign ��¼��Щ��־���ݡ�
+
+Logger.Level �ľ��弶�����£�
+
+*   NONE������¼�κ���Ϣ��
+*   BASIC������¼���󷽷���URL �Լ���Ӧ״̬���ִ��ʱ�䡣
+*   HEADERS�����˼�¼ BASIC �������Ϣ�⣬�����¼�������Ӧ��ͷ��Ϣ��
+*   FULL����¼������������Ӧ����ϸ������ͷ��Ϣ�������塢Ԫ���ݵȵȡ�
+
+3\. ���� micro-service-cloud-consumer-dept-feign��ʹ����������ʡ�http://eureka7001.com/consumer/dept/list��������̨������¡�
+
+```
+2021-10-12 14:33:07.408 DEBUG 13388 --- [p-nio-80-exec-2] n.biancheng.c.service.DeptFeignService   : [DeptFeignService#list] ---> GET http://MICROSERVICECLOUDPROVIDERDEPT/dept/list HTTP/1.1
+2021-10-12 14:33:07.408 DEBUG 13388 --- [p-nio-80-exec-2] n.biancheng.c.service.DeptFeignService   : [DeptFeignService#list] ---> END HTTP (0-byte body)
+2021-10-12 14:33:07.983 DEBUG 13388 --- [p-nio-80-exec-2] n.biancheng.c.service.DeptFeignService   : [DeptFeignService#list] <--- HTTP/1.1 200 (574ms)
+2021-10-12 14:33:07.983 DEBUG 13388 --- [p-nio-80-exec-2] n.biancheng.c.service.DeptFeignService   : [DeptFeignService#list] connection: keep-alive
+2021-10-12 14:33:07.983 DEBUG 13388 --- [p-nio-80-exec-2] n.biancheng.c.service.DeptFeignService   : [DeptFeignService#list] content-type: application/json
+2021-10-12 14:33:07.983 DEBUG 13388 --- [p-nio-80-exec-2] n.biancheng.c.service.DeptFeignService   : [DeptFeignService#list] date: Tue, 12 Oct 2021 06:33:07 GMT
+2021-10-12 14:33:07.983 DEBUG 13388 --- [p-nio-80-exec-2] n.biancheng.c.service.DeptFeignService   : [DeptFeignService#list] keep-alive: timeout=60
+2021-10-12 14:33:07.983 DEBUG 13388 --- [p-nio-80-exec-2] n.biancheng.c.service.DeptFeignService   : [DeptFeignService#list] transfer-encoding: chunked
+2021-10-12 14:33:07.983 DEBUG 13388 --- [p-nio-80-exec-2] n.biancheng.c.service.DeptFeignService   : [DeptFeignService#list]
+2021-10-12 14:33:07.991 DEBUG 13388 --- [p-nio-80-exec-2] n.biancheng.c.service.DeptFeignService   : [DeptFeignService#list] [{"deptNo":1,"deptName":"������","dbSource":"bianchengbang_jdbc"},{"deptNo":2,"deptName":"���²�","dbSource":"bianchengbang_jdbc"},{"deptNo":3,"deptName":"����","dbSource":"bianchengbang_jdbc"},{"deptNo":4,"deptName":"�г���","dbSource":"bianchengbang_jdbc"},{"deptNo":5,"deptName":"��ά��","dbSource":"bianchengbang_jdbc"}]
+2021-10-12 14:33:07.991 DEBUG 13388 --- [p-nio-80-exec-2] n.biancheng.c.service.DeptFeignService   : [DeptFeignService#list] <--- END HTTP (341-byte body)```
+```
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudRibbon.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudRibbon.md"
new file mode 100644
index 0000000..74eff0a
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudRibbon.md"
@@ -0,0 +1,665 @@
+Spring Cloud Ribbon ��һ�׻��� Netflix Ribbon ʵ�ֵĿͻ��˸��ؾ���ͷ�����ù��ߡ�
+
+Netflix Ribbon �� Netflix ��˾�����Ŀ�Դ���������Ҫ�������ṩ�ͻ��˵ĸ��ؾ����㷨�ͷ�����á�Spring Cloud ������ Netflix �е�������Դ������������� Eureka��Feign �Լ� Hystrix �ȣ�һ�����Ͻ� Spring Cloud Netflix ģ���У����Ϻ�ȫ��Ϊ Spring Cloud Netflix Ribbon��
+
+Ribbon �� Spring Cloud Netflix ģ�����ģ�飬���� Spring Cloud �� Netflix Ribbon �Ķ��η�װ��ͨ���������ǿ��Խ��������� REST ģ�壨RestTemplate������ת��Ϊ�ͻ��˸��ؾ���ķ�����á�
+
+Ribbon �� Spring Cloud ��ϵ������ġ�����Ҫ�����֮һ������Ȼֻ��һ���������͵Ŀ�ܣ������� Eureka Server������ע�����ģ�������Ҫ�������𣬵�������������ÿһ��ʹ�� Spring Cloud ������΢�����С�
+
+Spring Cloud ΢����֮��ĵ��ã�API ���ص�����ת�������ݣ�ʵ���϶���ͨ�� Spring Cloud Ribbon ��ʵ�ֵģ�������������Ҫ���ܵ� [OpenFeign](http://c.biancheng.net/springcloud/open-feign.html) Ҳ�ǻ�����ʵ�ֵġ�
+
+## ���ؾ���
+
+���κ�һ��ϵͳ�У����ؾ��ⶼ��һ��ʮ����Ҫ�Ҳ��ò�ȥʵʩ�����ݣ�����ϵͳ�����߲�������������ѹ���ͷ�������ݵ���Ҫ�ֶ�֮һ��
+
+���ؾ��⣨Load Balance�� ���򵥵�˵���ǽ��û�������ƽ̯���䵽��������������У��Դﵽ��չ��������������ǿ���ݴ����������������������������Ŀ����Ժ�����Ե�Ŀ�ġ�
+
+�����ĸ��ؾ��ⷽʽ�����֣�
+
+*   ����˸��ؾ���
+*   �ͻ��˸��ؾ���
+
+#### ����˸��ؾ���
+
+����˸��ؾ���������ĸ��ؾ��ⷽʽ���乤��ԭ������ͼ��
+
+![����˸��ؾ��⹤��ԭ��](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10122164F-0.png)
+ͼ1������˸��ؾ��⹤��ԭ��
+
+����˸��ؾ������ڿͻ��˺ͷ����֮�佨��һ�������ĸ��ؾ�����������÷������ȿ�����Ӳ���豸������ F5����Ҳ���������������� Nginx����������ؾ��������ά����һ�ݿ��÷�����嵥��Ȼ��ͨ������������ɾ�����ϵķ���˽ڵ㣬�Ա�֤�嵥�е����з���ڵ㶼�ǿ����������ʵġ�
+
+���ͻ��˷�������ʱ�������󲻻�ֱ�ӷ��͵�����˽��д���������ȫ���������ؾ�����������ɸ��ؾ������������ij���㷨��������ѯ������ȣ�������ά���Ŀ��÷����嵥��ѡ��һ������ˣ�Ȼ�����ת����
+
+����˸��ؾ�����������ص㣺
+
+*   ��Ҫ����һ�������ĸ��ؾ����������
+*   ���ؾ������ڿͻ��˷����������еģ���˿ͻ��˲���֪���������ĸ�������ṩ�ķ���
+*   ���÷�����嵥�洢�ڸ��ؾ���������ϡ�
+
+#### �ͻ��˸��ؾ���
+
+����ڷ���˸��ؾ��⣬�ͻ��˷����ھ�������һ���Ƚ�С�ڵĸ��
+
+�ͻ��˸��ؾ���Ĺ���ԭ������ͼ��
+
+![�ͻ��˸��ؾ���ԭ��](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1012212Q4-1.png)
+
+ͼ2���ͻ��˸��ؾ��⹤��ԭ��
+
+
+�ͻ��˸��ؾ����ǽ����ؾ����߼��Դ������ʽ��װ���ͻ����ϣ������ؾ�����λ�ڿͻ��ˡ��ͻ���ͨ������ע�����ģ����� Eureka Server����ȡ��һ�ݷ�����ṩ�Ŀ��÷����嵥�����˷����嵥�󣬸��ؾ��������ڿͻ��˷�������ǰͨ�����ؾ����㷨ѡ��һ�������ʵ���ٽ��з��ʣ��Դﵽ���ؾ����Ŀ�ģ�
+
+�ͻ��˸��ؾ���Ҳ��Ҫ��������ȥά��������嵥����Ч�ԣ����������Ҫ��Ϸ���ע������һ����ɡ�
+
+�ͻ��˸��ؾ�����������ص㣺
+
+*   ���ؾ�����λ�ڿͻ��ˣ�����Ҫ�����һ�����ؾ����������
+*   ���ؾ������ڿͻ��˷�������ǰ���еģ���˿ͻ��������֪�����ĸ�������ṩ�ķ���
+*   �ͻ��˶�ά����һ�ݿ��÷����嵥��������嵥���Ǵӷ���ע�����Ļ�ȡ�ġ�
+
+Ribbon ����һ������ HTTP �� TCP �Ŀͻ��˸��ؾ������������ǽ� Ribbon �� Eureka һ��ʹ��ʱ��Ribbon ��� Eureka Server������ע�����ģ��л�ȡ������б���Ȼ��ͨ�����ؾ�����Խ������̯����������ṩ�ߣ��Ӷ��ﵽ���ؾ����Ŀ�ġ�
+
+#### ����˸��ؾ��� VS �ͻ��˸��ؾ���
+
+�������Ǿ����Ա��£�����˸��ؾ���Ϳͻ��˸��ؾ��⵽����ʲô�������±���
+
+| ��ͬ��                       | ����˸��ؾ���                                               | �ͻ��˸��ؾ���                                               |
+| ---------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
+| �Ƿ���Ҫ�������ؾ��������   | ��Ҫ�ڿͻ��˺ͷ����֮�佨��һ�������ĸ��ؾ����������       | �����ؾ�����߼��Դ������ʽ��װ���ͻ����ϣ���˲���Ҫ�����������ؾ���������� |
+| �Ƿ���Ҫ����ע������         | ����Ҫ����ע�����ġ�                                         | ��Ҫ����ע�����ġ��ڿͻ��˸��ؾ����У����еĿͻ��˺ͷ���˶���Ҫ�����ṩ�ķ���ע�ᵽ����ע�������ϡ� |
+| ���÷����嵥�洢��λ��       | ���÷����嵥�洢��λ�ڿͻ����������֮��ĸ��ؾ���������ϡ� | ���еĿͻ��˶�ά����һ�ݿ��÷����嵥����Щ�嵥���Ǵӷ���ע�����Ļ�ȡ�ġ� |
+| ���ؾ����ʱ��               | �Ƚ������͵����ؾ����������Ȼ���ɸ��ؾ��������ͨ�����ؾ����㷨���ڶ�������֮��ѡ��һ�����з��ʣ����ڷ��������ٽ��и��ؾ����㷨���䡣�򵥵�˵���ǣ��ȷ��������ٽ��и��ؾ��⡣ | �ڷ�������ǰ����λ�ڿͻ��˵ķ����ؾ����������� Ribbon��ͨ�����ؾ����㷨ѡ��һ����������Ȼ����з��ʡ��򵥵�˵���ǣ��Ƚ��и��ؾ��⣬�ٷ������� |
+| �ͻ����Ƿ��˽�����ṩ����Ϣ | ���ڸ��ؾ������ڿͻ��˷����������еģ���˿ͻ��˲���֪���������ĸ�������ṩ�ķ��� | ���ؾ������ڿͻ��˷�������ǰ���еģ���˿ͻ��������֪�����ĸ�������ṩ�ķ��� |
+
+## Ribbon ʵ�ַ������
+
+Ribbon ������ RestTemplate��Rest ģ�壩���ʹ�ã���ʵ��΢����֮��ĵ��á�
+
+RestTemplate �� Spring �����е�һ���������ѵ����� REST ����������ܡ�RestTemplate ʵ���˶� HTTP ����ķ�װ���ṩ��һ��ģ�廯�ķ�����÷�����ͨ������Spring Ӧ�ÿ��Ժܷ���ضԸ������͵� HTTP ������з��ʡ�
+
+RestTemplate ��Ը������͵� HTTP �����ṩ����Ӧ�ķ������д��������� HEAD��GET��POST��PUT��DELETE �����͵� HTTP ���󣬷ֱ��Ӧ RestTemplate �е� headForHeaders()��getForObject()��postForObject()��put() �Լ� delete() ������
+
+��������ͨ��һ���򵥵�ʵ��������ʾ Ribbon �����ʵ�ַ�����õġ�
+
+1\. �������� spring-cloud-demo2 �£�����һ����Ϊ micro-service-cloud-consumer-dept-80 ��΢���񣬲����� pom.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <!--������-->
+    <parent>
+        <artifactId>spring-cloud-demo2</artifactId>
+        <groupId>net.biancheng.c</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <groupId>net.biancheng.c</groupId>
+    <artifactId>micro-service-cloud-consumer-dept-80</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>micro-service-cloud-consumer-dept-80</name>
+    <description>Demo project for Spring Boot</description>
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+
+    <dependencies>
+        <!--������ģ��-->
+        <dependency>
+            <groupId>net.biancheng.c</groupId>
+            <artifactId>micro-service-cloud-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <!--Spring Boot Web-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <!--lombok-->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+        <!--Spring Boot ����-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!--Spring Cloud Eureka �ͻ�������-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
+        </dependency>
+        <!--Spring Cloud Ribbon ����-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
+
+```
+
+
+
+
+
+2. ����·������ /resource Ŀ¼���£��½�һ�������ļ� application.yml�������������¡�
+
+
+
+
+
+```
+server:
+  port: 80 #�˿ں�
+
+############################################# Spring Cloud Ribbon ���ؾ�������##########################
+eureka:
+  client:
+    register-with-eureka: false #��΢����Ϊ���������ߣ�����Ҫ���Լ�ע�ᵽ����ע������
+    fetch-registry: true  #��΢����Ϊ���������ߣ���Ҫ������ע��������������
+    service-url:
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/ #����ע�����ļ�Ⱥ
+```
+
+
+
+
+
+3\. �� net.biancheng.c.config ���£�����һ����Ϊ ConfigBean �������࣬�� RestTemplate ע�뵽�����У��������¡�
+
+
+
+
+
+```
+
+
+package net.biancheng.c.config;
+
+import com.netflix.loadbalancer.IRule;
+
+import com.netflix.loadbalancer.RetryRule;
+import org.springframework.cloud.client.loadbalancer.LoadBalanced;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestTemplate;
+// ������ע��
+@Configuration
+public class ConfigBean {
+    
+    @Bean //�� RestTemplate ע�뵽������
+    @LoadBalanced //�ڿͻ���ʹ�� RestTemplate ��������ʱ���������ؾ��⣨Ribbon��
+    public RestTemplate getRestTemplate() {
+        return new RestTemplate();
+    }
+}
+
+```
+
+
+
+
+
+4\. �� net.biancheng.c.controller ���£�����һ����Ϊ DeptController_Consumer �� Controller���� Controller �ж�����������ڵ��÷�����ṩ�ķ��񣬴������¡�
+
+
+
+
+
+```
+package net.biancheng.c.controller;
+
+import net.biancheng.c.entity.Dept;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.client.RestTemplate;
+
+import java.util.List;
+
+@RestController
+public class DeptController_Consumer {
+    //private static final String REST_URL_PROVIDER_PREFIX = "http://localhost:8001/"; ���ַ�ʽ��ֱ���÷��񷽵ķ���������û���õ� Spring Cloud
+
+    //����΢�����̣���ͨ��΢�������������ȡ���õ�ַ
+    private static final String REST_URL_PROVIDER_PREFIX = "http://MICROSERVICECLOUDPROVIDERDEPT"; // ʹ��ע�ᵽ Spring Cloud Eureka ����ע�������еķ��񣬼� application.name
+
+    @Autowired
+    private RestTemplate restTemplate; //RestTemplate ��һ�ּ򵥱�ݵķ��� restful ����ģ���࣬�� Spring �ṩ�����ڷ��� Rest ����Ŀͻ���ģ�幤�߼����ṩ�˶��ֱ�ݷ���Զ�� HTTP ����ķ���
+
+    //��ȡָ��������Ϣ
+    @RequestMapping(value = "/consumer/dept/get/{id}")
+    public Dept get(@PathVariable("id") Integer id) {
+        return restTemplate.getForObject(REST_URL_PROVIDER_PREFIX + "/dept/get/" + id, Dept.class);
+    }
+    //��ȡ�����б�
+    @RequestMapping(value = "/consumer/dept/list")
+    public List<Dept> list() {
+        return restTemplate.getForObject(REST_URL_PROVIDER_PREFIX + "/dept/list", List.class);
+    }
+}
+```
+
+
+
+
+
+5\. �� micro-service-cloud-consumer-dept-80 �����������ϣ�ʹ�� @EnableEurekaClient ע�������� Eureka �ͻ��˹��ܣ��������¡�
+
+
+
+
+
+```
+
+package net.biancheng.c;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
+
+@SpringBootApplication
+@EnableEurekaClient
+public class MicroServiceCloudConsumerDept80Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(MicroServiceCloudConsumerDept80Application.class, args);
+    }
+}
+
+```
+
+
+
+
+
+6\. ������������ע������ micro-service-cloud-eureka-7001�������ṩ�� micro-service-cloud-provider-dept-8001 �Լ����������� micro-service-cloud-consumer-dept-80��
+
+7\. ʹ����������ʡ�http://eureka7001.com:80/consumer/dept/list�����������ͼ��
+
+![Ribbon ʵ�ַ������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101221CG-2.png)
+ͼ3��Ribbon ʵ�ַ������
+
+## Ribbon ʵ�ָ��ؾ���
+
+Ribbon ��һ���ͻ��˵ĸ��ؾ��������������� Eureka ���ʹ�����ɵ�ʵ�ֿͻ��˵ĸ��ؾ��⡣Ribbon ���ȴ� Eureka Server������ע�����ģ�ȥ��ȡ������б���Ȼ��ͨ�����ؾ�����Խ������̯���������ˣ��Ӷ��ﵽ���ؾ����Ŀ�ġ�
+
+Spring Cloud Ribbon �ṩ��һ�� IRule �ӿڣ��ýӿ���Ҫ�������帺�ؾ�����ԣ����� 7 ��Ĭ��ʵ���࣬ÿһ��ʵ���඼��һ�ָ��ؾ�����ԡ�
+
+| ��� | ʵ����                    | ���ؾ������                                                 |
+| ---- | ------------------------- | ------------------------------------------------------------ |
+| 1    | RoundRobinRule            | ����������ѯ���ԣ�������һ����˳������ѡȡ����ʵ��           |
+| 2    | RandomRule                | ���ѡȡһ������ʵ��                                         |
+| 3    | RetryRule                 | ���� RoundRobinRule����ѯ���IJ�������ȡ���������ȡ�ķ���ʵ��Ϊ null ���Ѿ�ʧЧ������ָ����ʱ��֮�ڲ��ϵؽ������ԣ�����ʱ��ȡ����IJ��Ի��� RoundRobinRule �ж���IJ��ԣ����������ָ��ʱ����Ȼû��ȡ������ʵ���򷵻� null �� |
+| 4    | WeightedResponseTimeRule  | WeightedResponseTimeRule �� RoundRobinRule ��һ�����࣬���� RoundRobinRule �Ĺ��ܽ�������չ������ƽ����Ӧʱ�䣬���������з���ʵ����Ȩ�أ���Ӧʱ��Խ�̵ķ���ʵ��Ȩ��Խ�ߣ���ѡ�еĸ���Խ�󡣸�����ʱ�����ͳ����Ϣ���㣬��ʹ��������ѯ���ԣ�����Ϣ�㹻ʱ�����л��� WeightedResponseTimeRule�� |
+| 5    | BestAvailableRule         | �̳��� ClientConfigEnabledRoundRobinRule���ȹ��˵���ϻ�ʧЧ�ķ���ʵ����Ȼ����ѡ�񲢷�����С�ķ���ʵ���� |
+| 6    | AvailabilityFilteringRule | �ȹ��˵����ϻ�ʧЧ�ķ���ʵ����Ȼ����ѡ�񲢷�����С�ķ���ʵ���� |
+| 7    | ZoneAvoidanceRule         | Ĭ�ϵĸ��ؾ�����ԣ��ۺ��жϷ�����������zone�������ܺͷ���server���Ŀ����ԣ���ѡ�����ʵ������û������Ļ����£��ò�������ѯ��RandomRule���������ơ� |
+
+�������Ǿ���ͨ��һ��ʵ������֤�£�Ribbon Ĭ����ʹ��ʲô����ѡȡ����ʵ���ġ�
+
+1. �� MySQL ���ݿ���ִ������ SQL ��䣬׼���������ݡ�
+
+```
+DROP DATABASE IF EXISTS spring_cloud_db2;
+CREATE DATABASE spring_cloud_db2 CHARACTER SET UTF8;
+
+USE spring_cloud_db2;
+
+DROP TABLE IF EXISTS `dept`;
+CREATE TABLE `dept` (
+  `dept_no` int NOT NULL AUTO_INCREMENT,
+  `dept_name` varchar(255) DEFAULT NULL,
+  `db_source` varchar(255) DEFAULT NULL,
+  PRIMARY KEY (`dept_no`)
+) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+
+INSERT INTO `dept` VALUES ('1', '������', DATABASE());
+INSERT INTO `dept` VALUES ('2', '���²�', DATABASE());
+INSERT INTO `dept` VALUES ('3', '����', DATABASE());
+INSERT INTO `dept` VALUES ('4', '���', DATABASE());
+INSERT INTO `dept` VALUES ('5', '����', DATABASE());
+
+#############################################################################################
+
+DROP DATABASE IF EXISTS spring_cloud_db3;
+
+CREATE DATABASE spring_cloud_db3 CHARACTER SET UTF8;
+
+USE spring_cloud_db3;
+
+DROP TABLE IF EXISTS `dept`;
+CREATE TABLE `dept` (
+  `dept_no` int NOT NULL AUTO_INCREMENT,
+  `dept_name` varchar(255) DEFAULT NULL,
+  `db_source` varchar(255) DEFAULT NULL,
+  PRIMARY KEY (`dept_no`)
+) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+
+INSERT INTO `dept` VALUES ('1', '������', DATABASE());
+INSERT INTO `dept` VALUES ('2', '���²�', DATABASE());
+INSERT INTO `dept` VALUES ('3', '����', DATABASE());
+INSERT INTO `dept` VALUES ('4', '���', DATABASE());
+INSERT INTO `dept` VALUES ('5', '����', DATABASE());```
+
+2\. �ο� micro-service-cloud-provider-dept-8001���ٴ�������΢���� Moudle ��micro-service-cloud-provider-dept-8002 �� micro-service-cloud-provider-dept-8003��
+
+3\. �� micro-service-cloud-provider-dept-8002 �� application.yml �У��޸Ķ˿ںš����ݿ�������Ϣ�Լ��Զ������������Ϣ��eureka.instance.instance-id�����޸ĵ��������¡�
+```
+
+
+
+
+```
+
+server:
+  port: 8002  #�˿ں��޸�Ϊ 8002
+
+spring:
+  application:
+    name: microServiceCloudProviderDept  #΢�������ƣ������޸ģ��� micro-service-cloud-provider-dept-8001 �����ñ���һ��
+
+  datasource:
+    username: root        #���ݿ��½�û���
+    password: root        #���ݿ��½����
+    url: jdbc:mysql://127.0.0.1:3306/spring_cloud_db2       #���ݿ�url
+    driver-class-name: com.mysql.jdbc.Driver                  #���ݿ�����
+
+eureka:
+  client: #���ͻ���ע�ᵽ eureka �����б���
+    service-url:
+     #defaultZone: http://eureka7001:7001/eureka  #�����ַ�� 7001ע�������� application.yml �б�¶������ע���ַ �������棩
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/  #������ע�ᵽ Eureka ��Ⱥ
+  instance:
+    instance-id: spring-cloud-provider-8002 #�޸��Զ���ķ���������Ϣ
+    prefer-ip-address: true  #��ʾ����·���� ip ��ַ
+
+```
+
+
+
+
+
+4\. �� micro-service-cloud-provider-dept-8003 �� application.yml �У��޸Ķ˿ں��Լ����ݿ�������Ϣ���޸ĵ��������¡�
+
+
+
+
+
+```
+
+server:
+  port: 8003  #�˿ں��޸�Ϊ 8003
+
+spring:
+  application:
+    name: microServiceCloudProviderDept  #΢�������ƣ������޸ģ��� micro-service-cloud-provider-dept-8001 �����ñ���һ��
+
+  datasource:
+    username: root        #���ݿ��½�û���
+    password: root        #���ݿ��½����
+    url: jdbc:mysql://127.0.0.1:3306/spring_cloud_db3      #���ݿ�url
+    driver-class-name: com.mysql.jdbc.Driver                  #���ݿ�����
+
+eureka:
+  client: #���ͻ���ע�ᵽ eureka �����б���
+    service-url:
+     #defaultZone: http://eureka7001:7001/eureka  #�����ַ�� 7001ע�������� application.yml �б�¶������ע���ַ �������棩
+      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/  #������ע�ᵽ Eureka ��Ⱥ
+  instance:
+    instance-id: spring-cloud-provider-8003 #�Զ������������Ϣ
+    prefer-ip-address: true  #��ʾ����·���� ip ��ַ
+
+```
+
+
+
+
+
+5.  �������� micro-service-cloud-eureka-7001/7002/7003������ע�����ļ�Ⱥ����micro-service-cloud-provider-dept-8001/8002/8003�������ṩ�߼�Ⱥ���Լ� micro-service-cloud-consumer-dept-80�����������ߣ���
+
+6\. ʹ��������������ʡ�http://eureka7001.com/consumer/dept/get/1��,�������ͼ��
+
+![Ribbon Ĭ�ϸ��ؾ������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1012215133-3.gif)
+ͼ4��Ribbon Ĭ�ϸ��ؾ������
+
+ͨ��ͼ 4 �� dbSource �ֶ�ȡֵ�ı仯���Կ�����Spring Cloud Ribbon Ĭ��ʹ����ѯ���Խ��и��ؾ��⡣
+
+## �л����ؾ������
+
+Spring Cloud Ribbon Ĭ��ʹ����ѯ����ѡȡ����ʵ��������Ҳ���Ը��������������л����ؾ�����ԡ�
+
+�л����ؾ�����Եķ����ܼ򵥣�����ֻ��Ҫ�ڷ��������ߣ��ͻ��ˣ����������У��� IRule ������ʵ����ע�뵽�����м��ɡ�
+
+�������Ǿ�ͨ��һ��ʵ��������ʾ������л����ؾ���IJ��ԡ�
+
+1\. �� micro-service-cloud-consumer-dept-80 �������� ConfigBean ���������´��룬�����ؾ�������л�Ϊ RandomRule���������
+
+
+
+
+
+```
+
+
+@Bean
+public IRule myRule() {
+    // RandomRule �������
+    return  new RandomRule();
+}
+
+```
+
+
+
+
+
+2\. ���� micro-service-cloud-consumer-dept-80��ʹ����������ʡ�http://eureka7001.com/consumer/dept/get/1�����������ͼ��
+
+![�л����ؾ������Ϊ���](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1012214B8-4.gif)
+ͼ5���л����ؾ������Ϊ���
+
+ͨ��ͼ 5 �� dbSource �ֶ�ȡֵ�ı仯���Կ����������Ѿ������ؾ�������л�Ϊ RandomRule���������
+
+## ���Ƹ��ؾ������
+
+ͨ������£�Ribbon �ṩ����ЩĬ�ϸ��ؾ�������ǿ����������ǵ�����ģ�����������Ҫ�����ǻ����Ը������������Ƹ��ؾ�����ԡ�
+
+�������Ǿ�����ʾ����ζ��Ƹ��ؾ�����ԡ�
+
+1\. �� micro-service-cloud-consumer-dept-80 ���½�һ�� net.biancheng.myrule �������ڸð��´���һ����Ϊ MyRandomRule ���࣬�������¡�
+
+
+
+
+
+```
+
+package net.biancheng.myrule;
+
+import com.netflix.client.config.IClientConfig;
+import com.netflix.loadbalancer.AbstractLoadBalancerRule;
+import com.netflix.loadbalancer.ILoadBalancer;
+import com.netflix.loadbalancer.Server;
+
+import java.util.List;
+
+/**
+* ���� Ribbon ���ؾ������
+*/
+public class MyRandomRule extends AbstractLoadBalancerRule {
+    private int total = 0;            // �ܹ������õĴ�����ĿǰҪ��ÿ̨������5��
+    private int currentIndex = 0;    // ��ǰ�ṩ����Ļ�����
+
+    public Server choose(ILoadBalancer lb, Object key) {
+        if (lb == null) {
+            return null;
+        }
+        Server server = null;
+
+        while (server == null) {
+            if (Thread.interrupted()) {
+                return null;
+            }
+            //��ȡ������Ч�ķ���ʵ���б�
+            List<Server> upList = lb.getReachableServers();
+            //��ȡ���еķ���ʵ�����б�
+            List<Server> allList = lb.getAllServers();
+
+            //���û���κεķ���ʵ���򷵻� null
+            int serverCount = allList.size();
+            if (serverCount == 0) {
+                return null;
+            }
+            //������������ƣ���ÿ������ʵ��ֻ���ڵ��� 3 ��֮�󣬲Ż���������ķ���ʵ��
+            if (total < 3) {
+                server = upList.get(currentIndex);
+                total++;
+            } else {
+                total = 0;
+                currentIndex++;
+                if (currentIndex >= upList.size()) {
+                    currentIndex = 0;
+                }
+            }
+            if (server == null) {
+                Thread.yield();
+                continue;
+            }
+            if (server.isAlive()) {
+                return (server);
+            }
+            server = null;
+            Thread.yield();
+        }
+        return server;
+    }
+
+    @Override
+    public Server choose(Object key) {
+        return choose(getLoadBalancer(), key);
+    }
+
+    @Override
+    public void initWithNiwsConfig(IClientConfig clientConfig) {
+        // TODO Auto-generated method stub
+    }
+}
+
+```
+
+
+
+
+
+2\. �� net.biancheng.myrule ���´���һ����Ϊ MySelfRibbonRuleConfig �������࣬�����Ƕ��Ƶĸ��ؾ������ʵ����ע�뵽�����У��������¡�
+
+
+
+
+
+```
+package net.biancheng.myrule;
+
+import com.netflix.loadbalancer.IRule;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+* ���� Ribbon ���ؾ�����Ե�������
+* ���Զ��� Ribbon ���ؾ������������ ������ net.biancheng.c �������Ӱ���
+* �������е� Ribbon �ͻ��˶�����øò��ԣ��޷��ﵽ���⻯���Ƶ�Ŀ��
+*/
+@Configuration
+public class MySelfRibbonRuleConfig {
+    @Bean
+    public IRule myRule() {
+        //�Զ��� Ribbon ���ؾ������
+        return new MyRandomRule(); //�Զ��壬���ѡ��ijһ��΢����ִ�����
+    }
+}
+
+```
+
+
+
+
+
+3\. �޸�λ�� net.biancheng.c ���µ��������࣬�ڸ�����ʹ�� @RibbonClient ע�������Ƕ��Ƶĸ��ؾ��������Ч���������¡�
+
+
+
+
+
+```
+
+
+package net.biancheng.c;
+
+import net.biancheng.myrule.MySelfRibbonRuleConfig;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
+import org.springframework.cloud.netflix.ribbon.RibbonClient;
+
+@SpringBootApplication
+@EnableEurekaClient
+//�Զ��� Ribbon ���ؾ������������������ʹ�� RibbonClient ע�⣬�ڸ�΢��������ʱ�������Զ�ȥ���������Զ���� Ribbon �����࣬�Ӷ���������Ч
+// name Ϊ��Ҫ���Ƹ��ؾ�����Ե�΢�������ƣ�application name��
+// configuration Ϊ���Ƶĸ��ؾ�����Ե������࣬
+// �ҹٷ��ĵ�����ȷ������������಻���� ComponentScan ע�⣨SpringBootApplication ע���а����˸�ע�⣩�µİ������Ӱ��У����Զ��帺�ؾ��������಻���� net.biancheng.c �������Ӱ���
+@RibbonClient(name = "MICROSERVICECLOUDPROVIDERDEPT", configuration = MySelfRibbonRuleConfig.class)
+public class MicroServiceCloudConsumerDept80Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(MicroServiceCloudConsumerDept80Application.class, args);
+    }
+}
+
+```
+
+
+
+
+
+4\. ���� micro-service-cloud-consumer-dept-80��ʹ����������ʡ�http://eureka7001.com/consumer/dept/get/1�����������ͼ��
+
+![���Ƹ��ؾ������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10122152E-5.gif)
+ͼ6�����Ƹ��ؾ������
+
+ͨ��ͼ 6 �� dbSource �ֶ�ȡֵ�ı仯���Կ��������Ƕ��Ƶĸ��ؾ�������Ѿ���Ч��
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudSleuth.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudSleuth.md"
new file mode 100644
index 0000000..45bc82f
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudSleuth.md"
@@ -0,0 +1,142 @@
+> Spring Cloud Sleuth �Ƿֲ�ʽϵͳ�и��ٷ������õĹ��ߣ�������ֱ�۵�չʾ��һ������ĵ��ù��̣����Ľ������÷�������ϸ���ܡ�
+
+## [#](https://www.macrozheng.com/cloud/sleuth.html#spring-cloud-sleuth-%E7%AE%80%E4%BB%8B)Spring Cloud Sleuth ���
+
+�������ǵ�ϵͳԽ��Խ�Ӵ󣬸��������ĵ��ù�ϵҲ���Խ��Խ���ӡ����ͻ��˷���һ������ʱ��������󾭹������������շ����˽����������ÿһ�������п��ܷ����ӳٻ���󣬴Ӷ���������ʧ�ܡ���ʱ�����Ǿ���Ҫ������·���ٹ������������ǣ�����������õķ�����·��������⡣
+
+## [#](https://www.macrozheng.com/cloud/sleuth.html#%E7%BB%99%E6%9C%8D%E5%8A%A1%E6%B7%BB%E5%8A%A0%E8%AF%B7%E6%B1%82%E9%93%BE%E8%B7%AF%E8%B7%9F%E8%B8%AA)����������������·����
+
+> ���ǽ�ͨ��user-service��ribbon-service֮��ķ����������ʾ�ù��ܣ��������ǵ���ribbon-service�Ľӿ�ʱ��ribbon-service��ͨ��RestTemplate������user-service�ṩ�Ľӿڡ�
+
+*   ���ȸ�user-service��ribbon-service����������·���ٹ��ܵ�֧�֣�
+
+*   ��user-service��ribbon-service���������������
+
+
+
+```
+<dependency>
+    <groupId>org.springframework.cloud</groupId>
+    spring-cloud-starter-zipkin
+</dependency>
+
+```
+
+
+
+
+*   �޸�application.yml�ļ��������ռ���־��zipkin-server���ʵ�ַ��
+
+
+
+```
+spring:
+  zipkin:
+    base-url: http://localhost:9411
+  sleuth:
+    sampler:
+      probability: 0.1 #����Sleuth�ij����ռ�����
+
+```
+
+
+
+## [#](https://www.macrozheng.com/cloud/sleuth.html#%E6%95%B4%E5%90%88zipkin%E8%8E%B7%E5%8F%96%E5%8F%8A%E5%88%86%E6%9E%90%E6%97%A5%E5%BF%97)����Zipkin��ȡ��������־
+
+> Zipkin��Twitter��һ����Դ��Ŀ������������ȡ�ͷ���Spring Cloud Sleuth �в�����������·������־�����ṩ��Web��������������ֱ�۵ز鿴������·������Ϣ��
+
+*   SpringBoot 2.0���ϰ汾�Ѿ�����Ҫ���дzipkin-server�����ǿ��ԴӸõ�ַ����zipkin-server��https://repo1.maven.org/maven2/io/zipkin/java/zipkin-server/2.12.9/zipkin-server-2.12.9-exec.jar
+
+*   ������ɺ�ʹ��������������zipkin-server��
+
+
+
+```
+java -jar zipkin-server-2.12.9-exec.jar
+
+```
+
+1
+
+
+
+
+*   Zipkinҳ����ʵ�ַ��http://localhost:9411
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/springcloud_sleuth_01.625f37c3.png)
+
+*   ����eureka-sever��ribbon-service��user-service��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/springcloud_sleuth_02.baf7b77c.png)
+
+*   ��ε��ã�SleuthΪ�����ռ���ribbon-service�Ľӿ�[http://localhost:8301/user/1open in new window](http://localhost:8301/user/1) ���������鿴Zipkin��ҳ�����Ѿ���������·������Ϣ�ˣ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/springcloud_sleuth_03.a71d1cf1.png)
+
+*   ����鿴�������ֱ�۵ؿ������������·��ͨ��ÿ������ĺ�ʱ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/springcloud_sleuth_04.d13e3d99.png)
+
+## [#](https://www.macrozheng.com/cloud/sleuth.html#%E4%BD%BF%E7%94%A8elasticsearch%E5%AD%98%E5%82%A8%E8%B7%9F%E8%B8%AA%E4%BF%A1%E6%81%AF)ʹ��Elasticsearch�洢������Ϣ
+
+> ������ǰ�zipkin-server����һ�¾ͻᷢ�ָոյĴ洢�ĸ�����Ϣȫ����ʧ�ˣ��ɼ����Ǵ洢���ڴ��еģ���ʱ��������Ҫ��������Ϣ�洢�����������Դ洢��ElasticsearchΪ��������ʾ�¸ù��ܡ�
+
+### [#](https://www.macrozheng.com/cloud/sleuth.html#%E5%AE%89%E8%A3%85elasticsearch)��װElasticsearch
+
+*   ����Elasticsearch6.2.2��zip��������ѹ��ָ��Ŀ¼�����ص�ַ��[https://www.elastic.co/cn/downloads/past-releases/elasticsearch-6-2-2open in new window](https://www.elastic.co/cn/downloads/past-releases/elasticsearch-6-2-2)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/arch_screen_25.48daf958.png)
+
+*   ����binĿ¼�µ�elasticsearch.bat����Elasticsearch
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/arch_screen_27.ba3cb8e0.png)
+
+### [#](https://www.macrozheng.com/cloud/sleuth.html#%E4%BF%AE%E6%94%B9%E5%90%AF%E5%8A%A8%E5%8F%82%E6%95%B0%E5%B0%86%E4%BF%A1%E6%81%AF%E5%AD%98%E5%82%A8%E5%88%B0elasticsearch)�޸�������������Ϣ�洢��Elasticsearch
+
+*   ʹ�������������У��Ϳ��԰Ѹ�����Ϣ�洢��Elasticsearch����ȥ�ˣ���������Ҳ���ᶪʧ��
+
+
+
+```
+# STORAGE_TYPE����ʾ�洢���� ES_HOSTS����ʾES�ķ��ʵ�ַ
+java -jar zipkin-server-2.12.9-exec.jar --STORAGE_TYPE=elasticsearch --ES_HOSTS=localhost:9200 
+
+```
+
+
+*   ֮����Ҫ��������user-service��ribbon-service������Ч���������ε���ribbon-service�Ľӿ�[http://localhost:8301/user/1open in new window](http://localhost:8301/user/1)��
+
+*   �����װ��Elasticsearch�Ŀ��ӻ�����Kibana�Ļ������Կ��������Ѿ��洢�˸�����Ϣ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/springcloud_sleuth_05.9929ce6a.png)
+
+### [#](https://www.macrozheng.com/cloud/sleuth.html#%E6%9B%B4%E5%A4%9A%E5%90%AF%E5%8A%A8%E5%8F%82%E6%95%B0%E5%8F%82%E8%80%83)�������������ο�
+
+https://github.com/openzipkin/zipkin/tree/master/zipkin-server#elasticsearch-storage
+
+## [#](https://www.macrozheng.com/cloud/sleuth.html#%E4%BD%BF%E7%94%A8%E5%88%B0%E7%9A%84%E6%A8%A1%E5%9D%97)ʹ�õ���ģ��
+
+
+
+```
+springcloud-learning
+������ eureka-server -- eurekaע������
+������ user-service -- �ṩUser����CRUD�ӿڵķ���
+������ ribbon-service -- ribbon������ò��Է���
+
+```
+
+
+
+
+## [#](https://www.macrozheng.com/cloud/sleuth.html#%E9%A1%B9%E7%9B%AE%E6%BA%90%E7%A0%81%E5%9C%B0%E5%9D%80)��ĿԴ���ַ
+
+[https://github.com/macrozheng/springcloud-learning](https://github.com/macrozheng/springcloud-learning)
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudZuul.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudZuul.md"
new file mode 100644
index 0000000..9040110
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloudZuul.md"
@@ -0,0 +1,392 @@
+Spring Cloud Zuul ��Spring Cloud Netflix ����Ŀ�ĺ������֮һ��������Ϊ΢����ܹ��е�API����ʹ�ã�֧�ֶ�̬·������˹��ܣ����Ľ������÷�������ϸ���ܡ�
+
+# Zuul���
+
+API����Ϊ΢����ܹ��еķ����ṩ��ͳһ�ķ�����ڣ��ͻ���ͨ��API���ط�����ط���API���صĶ������������ģʽ�е�����ģʽ�����൱������΢����ܹ��е����棬���пͻ��˵ķ��ʶ�ͨ����������·�ɼ����ˡ���ʵ��������·�ɡ����ؾ��⡢У����ˡ������ݴ�������ۺϵȹ��ܡ�
+
+#����һ��zuul-proxyģ��
+
+�������Ǵ���һ��zuul-proxyģ������ʾzuul�ij��ù��ܡ�
+
+#��pom.xml�������������
+
+
+
+    <dependency>
+        <groupId>org.springframework.cloud</groupId>
+        spring-cloud-starter-netflix-eureka-client
+    </dependency>
+    <dependency>
+        <groupId>org.springframework.cloud</groupId>
+        spring-cloud-starter-netflix-zuul
+    </dependency>
+
+
+
+
+# ��application.yml�������
+
+
+
+    server:
+      port: 8801
+    spring:
+      application:
+        name: zuul-proxy
+    eureka:
+      client:
+        register-with-eureka: true
+        fetch-registry: true
+        service-url:
+          defaultZone: http://localhost:8001/eureka/
+
+
+#��������������@EnableZuulProxyע��������Zuul��API���ع���
+
+
+
+    @EnableZuulProxy
+    @EnableDiscoveryClient
+    @SpringBootApplication
+    public class ZuulProxyApplication {
+    
+        public static void main(String[] args) {
+            SpringApplication.run(ZuulProxyApplication.class, args);
+        }
+    
+    }
+
+
+
+# ���ù���
+
+# ������ط���
+
+��������ͨ������eureka-server������user-service��feign-service��zuul-proxy����ʾZuul�ij��ù��ܣ�������ע��������ʾ���¡�
+
+
+
+# ����·�ɹ���
+
+- ���ǿ���ͨ���޸�application.yml�е�����������·�ɹ����������ǽ�ƥ��/userService/**������·�ɵ�user-service������ȥ��ƥ��/feignService/**������·�ɵ�feign-service��ȥ��
+
+
+
+    zuul:
+      routes: #����������·��
+        user-service:
+          path: /userService/**
+        feign-service:
+          path: /feignService/**
+
+
+
+- ����http://localhost:8801/userService/user/1open in new window���Է�������·�ɵ���user-service���ˣ�
+- ����http://localhost:8801/feignService/user/1open in new window���Է�������·�ɵ���feign-service���ˡ�
+
+# Ĭ��·�ɹ���
+
+- Zuul��Eureka���ʹ�ã�����ʵ��·�ɵ��Զ����ã��Զ����õ�·���Է�������Ϊƥ��·�����൱���������ã�
+
+
+
+    zuul:
+      routes: #����������·��
+        user-service:
+          path: /user-service/**
+        feign-service:
+          path: /feign-service/**
+
+
+
+- ����http://localhost:8801/user-service/user/1open in new windowͬ������·�ɵ���user-service���ˣ�
+- ����http://localhost:8801/feign-service/user/1open in new windowͬ������·�ɵ���feign-service���ˡ�
+- �������ʹ��Ĭ�ϵ�·�ɹ��򣬿���������������������Ĭ��·�����ã�
+
+
+
+    zuul:
+      ignored-services: user-service,feign-service #�ر�Ĭ��·������
+
+
+
+
+
+# ���ؾ��⹦��
+
+��ε���http://localhost:8801/user-service/user/1open in new window���в��ԣ����Է���������8201��8202��user-service�������ӡ������Ϣ��
+
+
+
+    2019-10-05 10:31:58.738  INFO 11520 --- [nio-8202-exec-5] c.macro.cloud.controller.UserController  : ����id��ȡ�û���Ϣ���û�����Ϊ��macro
+    2019-10-05 10:32:00.356  INFO 11520 --- [nio-8202-exec-6] c.macro.cloud.controller.UserController  : ����id��ȡ�û���Ϣ���û�����Ϊ��macro
+
+
+
+# ���÷���ǰ׺
+
+���ǿ���ͨ������������������·������ǰ׺���˴�������/proxyǰ׺������������Ҫ����http://localhost:8801/proxy/user-service/user/1open in new window���ܷ��ʵ�user-service�еĽӿڡ�
+
+
+
+    zuul:
+      prefix: /proxy #������·������ǰ׺
+
+
+
+
+# Header���˼��ض�������Host
+
+- Zuul������·��ʱ��Ĭ�ϻ���˵�һЩ���е�ͷ��Ϣ���������ÿ��Է�ֹ·��ʱ��Cookie��Authorization�Ķ�ʧ��
+
+
+
+    zuul:
+      sensitive-headers: Cookie,Set-Cookie,Authorization #���ù������е�����ͷ��Ϣ������Ϊ�վͲ������
+
+
+
+
+- Zuul������·��ʱ���������������hostͷ��Ϣ���������ÿ��Խ����
+
+
+
+    zuul:
+      add-host-header: true #����Ϊtrue�ض����ǻ�����host����ͷ
+
+
+
+# �鿴·����Ϣ
+
+���ǿ���ͨ��SpringBoot Actuator���鿴Zuul�е�·����Ϣ��
+
+- ��pom.xml���������������
+
+
+
+    <dependency>
+        <groupId>org.springframework.boot</groupId>
+        spring-boot-starter-actuator
+    </dependency>
+
+
+
+
+
+
+- �޸�application.yaml�����ļ��������鿴·�ɵĶ˵㣺
+
+
+
+    management:
+      endpoints:
+        web:
+          exposure:
+            include: 'routes'
+
+
+
+
+
+- ͨ������http://localhost:8801/actuator/routesopen in new window�鿴��·����Ϣ��
+
+
+
+- ͨ������http://localhost:8801/actuator/routes/detailsopen in new window�鿴��ϸ·����Ϣ��
+
+
+
+# ������
+
+·���������Zuul��������Ĺ��ܣ�·�ɹ��ܸ����ⲿ����ת��������ķ���ʵ����ȥ����ʵ��ͳһ������ڵĻ��������˹��ܸ����������̽��ж���Ĵ�����������У����˼�����ۺϵĻ�����
+
+# ����������
+
+Zuul�������¼��ֵ��͵Ĺ��������͡�
+
+- pre��������·�ɵ�Ŀ�����ǰִ�У�����Ȩ��У�顢��ӡ��־�ȹ��ܣ�
+- routing��������·�ɵ�Ŀ�����ʱִ�У�����ʹ��Apache HttpClient��Netflix Ribbon�����ͷ���ԭʼHTTP����ĵط���
+- post��������·�ɵ�Ŀ������ִ�У������Ŀ��������Ӧ����ͷ��Ϣ���ռ�ͳ�����ݵȹ��ܣ�
+- error�������������׶η�������ʱִ�С�
+
+# ����������������
+
+��ͼ������һ��HTTP���󵽴�API���غ�����ڸ��ֲ�ͬ���͵Ĺ���������ת�Ĺ��̡�
+
+
+
+# �Զ��������
+
+�����������Զ���һ������������ʾ�¹����������á�
+
+# ����PreLogFilter��̳�ZuulFilter
+
+����һ��ǰ�ù�����������������·�ɵ�Ŀ�����ǰ��ӡ������־��
+
+
+
+    /**
+     * Created by macro on 2019/9/9.
+     */
+    @Component
+    public class PreLogFilter extends ZuulFilter {
+        private Logger LOGGER = LoggerFactory.getLogger(this.getClass());
+    
+        /**
+         * ���������ͣ���pre��routing��post��error���֡�
+         */
+        @Override
+        public String filterType() {
+            return "pre";
+        }
+    
+        /**
+         * ������ִ��˳����ֵԽС���ȼ�Խ�ߡ�
+         */
+        @Override
+        public int filterOrder() {
+            return 1;
+        }
+    
+        /**
+         * �Ƿ���й��ˣ�����true��ִ�й��ˡ�
+         */
+        @Override
+        public boolean shouldFilter() {
+            return true;
+        }
+    
+        /**
+         * �Զ���Ĺ������߼�����shouldFilter()����trueʱ��ִ�С�
+         */
+        @Override
+        public Object run() throws ZuulException {
+            RequestContext requestContext = RequestContext.getCurrentContext();
+            HttpServletRequest request = requestContext.getRequest();
+            String host = request.getRemoteHost();
+            String method = request.getMethod();
+            String uri = request.getRequestURI();
+            LOGGER.info("Remote host:{},method:{},uri:{}", host, method, uri);
+            return null;
+        }
+    }
+
+
+
+# ������������ʾ
+
+���ӹ����������Ƿ���http://localhost:8801/user-service/user/1open in new window�����£����ӡ������־��
+
+
+
+    2019-10-05 15:13:10.232  INFO 11040 --- [nio-8801-exec-7] com.macro.cloud.filter.PreLogFilter      : Remote host:0:0:0:0:0:0:0:1,method:GET,uri:/user-service/user/1
+
+
+
+
+
+
+# ��������
+
+    ����������                  	�������� 	���ȼ� 	������������                                  
+    ServletDetectionFilter 	pre  	-3  	��⵱ǰ������ͨ��DispatcherServlet�������еĻ���ZuulServlet���д����ġ�
+    Servlet30WrapperFilter 	pre  	-2  	��ԭʼ��HttpServletRequest���а�װ��             
+    FormBodyWrapperFilter  	pre  	-1  	��Content-TypeΪapplication/x-www-form-urlencoded��multipart/form-data�������װ��FormBodyRequestWrapper����
+    DebugFilter            	route	1   	����zuul.debug.request�������������Ƿ��ӡdebug��־��  
+    PreDecorationFilter    	route	5   	�Ե�ǰ�������Ԥ�����Ա�ִ�к���������                     
+    RibbonRoutingFilter    	route	10  	ͨ��Ribbon��Hystrix�������ʵ���������󣬲������������з��ء�  
+    SimpleHostRoutingFilter	route	100 	ֻ����������������routeHost�����Ľ��д�����ֱ��ʹ��HttpClient��routeHost��Ӧ��������ַ����ת����
+    SendForwardFilter      	route	500 	ֻ����������������forward.to�����Ľ��д��������б�����ת��      
+    SendErrorFilter        	post 	0   	�������������ڲ������쳣ʱ�Ļ����������д���������������Ӧ��          
+    SendResponseFilter     	post 	1000	�������������ĵ���Ӧ��Ϣ����֯����ɹ�����Ӧ���ݡ�
+
+# ���ù�����
+
+- ���ǿ��ԶԹ��������н��õ����ã����ø�ʽ���£�
+
+
+
+    zuul:
+      filterClassName:
+        filter:
+          disable: true 
+
+
+
+- �����ǽ���PreLogFilter��ʾ�����ã�
+
+
+
+    zuul:
+      PreLogFilter:
+        pre:
+          disable: true 
+
+
+
+#Ribbon��Hystrix��֧��
+
+����Zuul�Զ�������Ribbon��Hystrix������Zuul�������и��ؾ���ͷ����ݴ����������ǿ���ͨ��Ribbon��Hystrix������������Zuul�е���Ӧ���ܡ�
+
+- ����ʹ��Hystrix������������·��ת��ʱHystrixCommand��ִ�г�ʱʱ�䣺
+
+
+
+    hystrix:
+      command: #���ڿ���HystrixCommand����Ϊ
+        default:
+          execution:
+            isolation:
+              thread:
+                timeoutInMilliseconds: 1000 #����HystrixCommandִ�еij�ʱʱ�䣬ִ�г�����ʱ�����з��񽵼�����
+
+
+- ����ʹ��Ribbon������������·��ת��ʱ�������Ӽ������ij�ʱʱ�䣺
+
+
+
+    ribbon: #ȫ������
+      ConnectTimeout: 1000 #�����������ӳ�ʱʱ�䣨���룩
+      ReadTimeout: 3000 #������������ʱʱ�䣨���룩
+
+
+#��������
+
+
+
+    zuul:
+      routes: #����������·��
+        user-service:
+          path: /userService/**
+        feign-service:
+          path: /feignService/**
+      ignored-services: user-service,feign-service #�ر�Ĭ��·������
+      prefix: /proxy #������·������ǰ׺
+      sensitive-headers: Cookie,Set-Cookie,Authorization #���ù������е�����ͷ��Ϣ������Ϊ�վͲ������
+      add-host-header: true #����Ϊtrue�ض����ǻ�����host����ͷ
+      retryable: true # �ر����Ի���
+      PreLogFilter:
+        pre:
+          disable: false #�����Ƿ����ù�����
+
+
+#ʹ�õ���ģ��
+
+
+
+    springcloud-learning
+    ������ eureka-server -- eurekaע������
+    ������ user-service -- �ṩUser����CRUD�ӿڵķ���
+    ������ feign-service -- feign������ò��Է���
+    ������ zuul-proxy -- zuul��Ϊ���صIJ��Է���
+
+
+#��ĿԴ���ַ
+
+https://github.com/macrozheng/springcloud-learning
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloud\346\246\202\350\277\260.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloud\346\246\202\350\277\260.md"
new file mode 100644
index 0000000..a525595
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud/SpringCloud\346\246\202\350\277\260.md"
@@ -0,0 +1,143 @@
+Spring Cloud ��һ����� Spring Boot ʵ�ֵ�΢�����ܡ�Spring Cloud Դ�� Spring ��������Ҫ�� Pivotal �� Netflix ����˾�ṩ����������ά����
+
+����΢����Ļ����У����������������˾����̷�����������΢����ܹ��У���Բ�ͬ�������ֵĸ�������Ľ�������Ϳ�Դ��ܡ�
+
+*   **��������**������ͰͿ�Դ�� Dubbo �͵����������������չ������ DubboX��Netflix �� Eureka �Լ� Apache �� Consul �ȡ�
+*   **�ֲ�ʽ���ù���**���ٶȵ� Disconf��Netflix �� Archaius��360 �� QConf��Я�̵� Apollo �Լ� Spring Cloud �� Config �ȡ�
+*   **��������**���������� Elastic-Job��LinkedIn �� Azkaban �Լ� Spring Cloud �� Task �ȡ�
+*   **�������**�������� Hydra��Spring Cloud �� Sleuth �Լ� Twitter �� Zipkin �ȡ�
+*   **����**
+
+������Щ΢�����ܻ����������������� 2 ���ص㣺
+
+*   ����ͬһ��΢�������⣬����������˾�����Ľ������������ͬ��
+*   һ��΢�����ܻ���������ֻ�ܽ��΢�����е�ijһ����ij�������⣬������������������Ϊ����
+
+��������£��һ��΢�ֲ�ʽ΢����ϵͳ������Ҫ�����Щ��������Ľ������������ѡ����ʹ�����Dz��ò��������ľ���������ǰ�ڵĵ��С������Լ�ʵ���ϡ�
+
+Spring Cloud ����Ϊ�����ֲ�ʽ΢����ϵͳ�ġ�ȫ��Ͱ������������ijһ�ż���������һϵ��΢�������������ܵ����򼯺ϡ����������ϳ���ġ�������֤��΢������������������ͨ�� Spring Boot ��˼������ٷ�װ�����ε����и��ӵ����ú�ʵ��ԭ��������Ϊ������Ա�ṩ��һ�׼��׶����ײ������ά���ķֲ�ʽϵͳ�������߰���
+
+Spring Cloud �а����� spring-cloud-config��spring-cloud-bus �Ƚ� 20 ������Ŀ���ṩ�˷����������������ء�����·�ɡ����ؾ��⡢��·������ظ��١��ֲ�ʽ��Ϣ���С����ù���������Ľ��������
+
+Spring Cloud ������һ�����������õĿ�ܣ�����һ��΢����淶���������� 2 ��ʵ�֣�
+
+*   ��һ��ʵ�֣�Spring Cloud Netflix
+*   �ڶ���ʵ�֣�Spring Cloud Alibaba
+
+�������ǽ��ܵ� Spring Cloud ��ָ Spring Cloud �ĵ�һ��ʵ�֡�
+
+## Spring Cloud �������
+
+Spring Cloud ���� Spring Cloud Gateway��Spring Cloud Config��Spring Cloud Bus �Ƚ� 20 �������������Щ����ṩ�˷����������������ء�����·�ɡ����ؾ��⡢�۶�������ظ��١��ֲ�ʽ��Ϣ���С����ù���������Ľ��������
+
+Spring Cloud �ij���������±���ʾ��
+
+| Spring Cloud ���            | ����                                                         |
+| ---------------------------- | ------------------------------------------------------------ |
+| Spring Cloud Netflix Eureka  | Spring Cloud Netflix �еķ��������������������ע�����ġ�����ע���뷢�ֻ��Ƶ�ʵ�֡� |
+| Spring Cloud Netflix Ribbon  | Spring Cloud  Netflix �еķ�����úͿͻ��˸��ؾ��������     |
+| Spring Cloud Netflix Hystrix | �˳ơ������硱��Spring Cloud Netflix ���ݴ����������Ϊ�����г��ֵ��ӳٺ͹����ṩǿ����ݴ������� |
+| Spring Cloud Netflix Feign   | ���� Ribbon �� Hystrix ������ʽ������������                |
+| Spring Cloud Netflix Zuul    | Spring Cloud Netflix �е�����������ṩ������·�ɡ����ʹ��˵ȹ��ܡ� |
+| Spring Cloud Gateway         | һ������ Spring 5.0��Spring Boot 2.0 �� Project Reactor �ȼ������������ؿ�ܣ���ʹ�� Filter ���ķ�ʽ�ṩ�����صĻ������ܣ����簲ȫ�����/ָ��������ȡ� |
+| Spring Cloud Config          | Spring Cloud �����ù������ߣ�֧��ʹ�� Git �洢�������ݣ�ʵ��Ӧ�����õ��ⲿ���洢����֧���ڿͻ��˶����ý���ˢ�¡����ܡ����ܵȲ����� |
+| Spring Cloud Bus             | Spring Cloud ���¼�����Ϣ���ߣ���Ҫ�����ڼ�Ⱥ�д����¼���״̬�仯���Դ��������Ĵ��������綯̬ˢ�����á� |
+| Spring Cloud Stream          | Spring Cloud ����Ϣ�м��������������� Apache Kafka �� RabbitMQ ����Ϣ�м������ͨ�����������Ϊ�м�㣬������ʵ����Ӧ�ó�������Ϣ�м��֮��ĸ��롣ͨ����Ӧ�ó���¶ͳһ�� Channel ͨ����ʹ��Ӧ�ó�����Ҫ�ٿ��Ǹ��ֲ�ͬ����Ϣ�м��ʵ�֣��������ɵط��ͺͽ�����Ϣ�� |
+| Spring Cloud Sleuth          | Spring Cloud �ֲ�ʽ��·����������ܹ����������� Twitter �� Zipkin�� |
+
+> ע��Netflix ��������һ��������Ƶ��վ�����ǹ��ϵĴ��ģ������΢����Ľܳ�ʵ���ߣ�΢�������̳���Netflix �Ŀ�Դ����Ѿ�������ģ�ֲ�ʽ΢���񻷾��о����˶��������ʵս��֤�������ҿɿ���
+
+## Spring Boot �� Spring Cloud ����������ϵ
+
+Spring Boot �� Spring Cloud ���� Spring ������һԱ��������΢���񿪷��ж�������ʮ����Ҫ�Ľ�ɫ������֮��ȴ�������Ҳ������ϵ��
+
+#### 1\. Spring Boot �� Spring Cloud �ֹ���ͬ
+
+Spring Boot ��һ������ Spring �Ŀ��ٿ�����ܣ����ܹ�����������Ѹ�ٴ� Web ���̡���΢���񿪷��У�Spring Boot רע�ڿ��١�����ؿ�������΢����
+
+Spring Cloud ��΢����ܹ��µ�һվʽ���������Spring Cloud רע��ȫ��΢�����Э�����������������仰˵��Spring Cloud �൱��΢����Ĵ�ܼң����� Spring Boot ������һ����΢���������������Ϊ�����ṩ���ù����������֡���·����·�ɡ�΢�������¼����ߡ����߾�ѡ�Լ��ֲ�ʽ�Ự�ȷ���
+
+#### 2\. Spring Cloud �ǻ��� Spring Boot ʵ�ֵ�
+
+Spring Cloud �ǻ��� Spring Boot ʵ�ֵġ��� Spring Boot ���ƣ�Spring Cloud ҲΪ�ṩ��һϵ�� Starter����Щ Starter �� Spring Cloud ʹ�� Spring Boot ˼��Ը���΢�����ܽ����ٷ�װ�IJ��������������Щ΢�������и��ӵ����ú�ʵ��ԭ����ʹ������Ա�ܹ����١������ʹ�� Spring Cloud �һ�׷ֲ�ʽ΢����ϵͳ��
+
+#### 3\. Spring Boot �� Spring Cloud ������������ͬ
+
+Spring Boot ����һ���������Ŀ�ܣ����� Spring Boot ����������������١�
+
+Spring Cloud ��һϵ��΢�����ܼ����ļ����壬����ÿ���������Ҫһ�������������Starter POM���������Ҫ����һ�������� Spring  Cloud ����������Ҫ�����������
+
+#### 4\. Spring Cloud �������� Spring Boot ��������
+
+Spring Boot ����Ҫ Spring Cloud������ֱ�Ӵ����ɶ������еĹ��̻�ģ�顣
+
+Spring Cloud �ǻ��� Spring Boot ʵ�ֵģ������ܶ����������̻�ģ�飬���������� Spring Boot �������С�
+
+> ע�⣺��Ȼ Spring Boot �ܹ����ڿ�������΢���񣬵��������߱�������Э��΢����������������ֻ������һ��΢������ٿ�����ܣ�����΢�����ܡ�
+
+## Spring Cloud �汾
+
+Spring Cloud ��������������Ŀ�����������Щ����Ŀ���Ƕ����������ݸ��º͵����ģ����Զ�ά�����Լ��ķ����汾�š�
+
+Ϊ�˱��� Spring Cloud �İ汾����������Ŀ�İ汾�Ż�����Spring Cloud û�в��ó��������ְ汾�ţ�����ͨ�����·�ʽ����汾��Ϣ��
+
+<pre>{version.name} .{version.number}</pre>
+
+Spring Cloud �汾��Ϣ˵�����£�
+
+*   **version.name**���汾��������Ӣ���׶ص���վ��վ������������������ĸ����˳�򣨼��� A �� Z������Ӧ Spring Cloud �İ汾����˳�������һ���汾Ϊ Angel���ڶ����汾Ϊ Brixton��Ӣ����������Ȼ�������� Camden��Dalston��Edgware��Finchley��Greenwich��Hoxton �ȡ�
+*   **version.number**���汾�ţ�ÿһ���汾�� Spring Cloud �ڸ������ݻ��۵�һ�������������ش� BUG �޸�ʱ���ͻᷢ��һ����service releases���汾����� SRX �汾������ X Ϊһ�����������֣����� Hoxton.SR8 �ͱ�ʾ Hoxton �ĵ� 8 �� Release �汾��
+
+## Spring Cloud �汾ѡ��
+
+��ʹ�� Spring Boot + Spring Cloud ����΢���񿪷�ʱ��������Ҫ������Ŀ�� Spring Boot �İ汾������ Spring Cloud �汾�����������������벻���Ĵ���
+
+Spring Boot �� Spring Cloud �İ汾��Ӧ��ϵ���±����ο���[ ](https://spring.io/projects/spring-cloud)[Spring Cloud ����](http://spring.io/projects/spring-cloud)����
+
+| Spring Cloud        | Spring Boot                                    |
+| ------------------- | ---------------------------------------------- |
+| 2020.0.x ��Ilford�� | 2.4.x, 2.5.x ���� Spring Cloud 2020.0.3 ��ʼ�� |
+| Hoxton              | 2.2.x, 2.3.x ���� Spring Cloud SR5 ��ʼ��      |
+| Greenwich           | 2.1.x                                          |
+| Finchley            | 2.0.x                                          |
+| Edgware             | 1.5.x                                          |
+| Dalston             | 1.5.x                                          |
+
+> ע�⣺Spring Cloud �ٷ��Ѿ�ֹͣ�� Dalston��Edgware��Finchley �� Greenwich �İ汾���¡�
+
+�����ϱ���չʾ�İ汾��Ӧ��ϵ֮�⣬���ǻ�����ʹ����������� [https://start.spring.io/actuator/info](https://start.spring.io/actuator/info)����ȡ Spring Cloud �� Spring Boot �İ汾��Ӧ��ϵ��JSON �棩��
+
+
+
+
+
+
+
+
+
+
+````
+
+{
+   ����
+    "bom-ranges":{
+        ����
+        "spring-cloud":{
+            "Hoxton.SR12":"Spring Boot >=2.2.0.RELEASE and <2.4.0.M1",
+            "2020.0.4":"Spring Boot >=2.4.0.M1 and <2.5.6-SNAPSHOT",
+            "2020.0.5-SNAPSHOT":"Spring Boot >=2.5.6-SNAPSHOT and <2.6.0-M1",
+            "2021.0.0-M1":"Spring Boot >=2.6.0.M1 and <2.6.0-SNAPSHOT",
+            "2021.0.0-SNAPSHOT":"Spring Boot >=2.6.0-SNAPSHOT"
+        },
+        ����
+    },
+ ����
+}
+
+````
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaNacos.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaNacos.md"
new file mode 100644
index 0000000..4fc0f7b
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaNacos.md"
@@ -0,0 +1,1212 @@
+Nacos Ӣ��ȫ��Ϊ Dynamic Naming and Configuration Service����һ���ɰ���Ͱ��Ŷ�ʹ�� Java ���Կ����Ŀ�Դ��Ŀ��
+
+Nacos ��һ�������ڰ���������ԭ��Ӧ�õĶ�̬�����֡����úͷ������ƽ̨���ο��� [Nacos ����](https://nacos.io/zh-cn/index.html)����
+
+Nacos ���������� 3 ������ɣ�
+
+| ��ɲ��� | ȫ��              | ����                                                         |
+| -------- | ----------------- | ------------------------------------------------------------ |
+| Na       | naming/nameServer | ������ע�����ģ��� Spring Cloud Eureka �Ĺ������ơ�          |
+| co       | configuration     | ���������ģ��� Spring Cloud Config+Spring Cloud Bus �Ĺ������ơ� |
+| s        | service           | �����񣬱�ʾ Nacos ʵ�ֵķ���ע�����ĺ��������Ķ����Է���Ϊ���ĵġ� |
+
+���ǿ��Խ� Nacos ����ɷ���ע�����ĺ��������ĵ�����壬�������滻 [Eureka](http://c.biancheng.net/springcloud/eureka.html) ��Ϊ����ע�����ģ�ʵ�ַ����ע���뷢�֣��������滻 [Spring Cloud Config](http://c.biancheng.net/springcloud/config.html) ��Ϊ�������ģ�ʵ�����õĶ�̬ˢ�¡�
+
+Nacos ��Ϊ����ע�����ľ�����ʮ�ꡰ˫ʮһ���ĺ�忼�飬���м����á��ȶ��ɿ�������׿Խ���ŵ㣬���԰����û������ݡ����׵ع����͹���΢����Ӧ�á�
+
+Nacos ֧�ּ��������������͡����񡱵ķ��֡����ú͹�����
+
+*   [Kubernetes Service](https://kubernetes.io/docs/concepts/services-networking/service/)
+*   [gRPC ](https://grpc.io/docs/what-is-grpc/core-concepts#service-definition)& [Dubbo RPC Service](https://dubbo.apache.org/zh/)
+*   Spring Cloud RESTful Service
+
+## Nacos ������
+
+Nacos �ṩ��һϵ�м����õ����ԣ��ܹ��������ǿ��ٵ�ʵ�ֶ�̬�����֡��������õȹ��ܡ�
+
+#### ������
+
+Nacos ֧�ֻ��� DNS �� RPC �ķ����֡��������ṩ��ʹ��ԭ�� SDK��OpenAPI ��һ�������� Agent TODO �� Nacos ע�����󣬷��������߿����� Nacos ��ͨ�� DNS TODO �� HTTP&API ���ҡ����ַ���
+
+#### ���񽡿����
+
+Nacos �ṩ�Է����ʵʱ������飬�ܹ���ֹ�����͵����������������ʵ���ϡ�Nacos ���ṩ��һ����������DZ��̣��ܹ��������Ǹ��ݽ���״̬��������Ŀ����Լ�������
+
+#### ��̬���÷���
+
+��̬���÷�����������������Ļ����ⲿ���Ͷ�̬���ķ�ʽ���������л�����Ӧ�����úͷ������á�
+
+��̬�������������ñ��ʱ���²���Ӧ�úͷ������Ҫ�������ù�����ø��Ӹ�Ч�����ݡ�
+
+�������Ļ�������ʵ����״̬�����ø��򵥣��÷����赯����չ��ø����ס�
+
+Nacos �ṩ��һ��������õ� UI �������ǹ������з����Ӧ�õ����á�Nacos ���ṩ�������ð汾���١���˿ȸ������һ���ع������Լ��ͻ������ø���״̬�������ڵ�һϵ�п��伴�õ����ù������ԣ��������Ǹ���ȫ�������������й������ñ���ͽ������ñ�������ķ��ա�
+
+#### ��̬ DNS ����
+
+Nacos �ṩ�˶�̬ DNS �����ܹ������Ǹ����׵�ʵ�ָ��ؾ��⡢���������Լ��������������ļ� DNS ��������
+
+Nacos �ṩ��һЩ�򵥵� DNS APIs TODO�����԰������ǹ�������Ĺ��������Ϳ��õ� IP:PORT �б���
+
+#### ������Ԫ���ݹ���
+
+Nacos �������Ǵ�΢����ƽ̨������ӽǹ����������ĵ����з���Ԫ���ݣ���������������������������ڡ�����ľ�̬��������������Ľ���״̬�����������������·�ɼ���ȫ���ԡ������ SLA �Լ� metrics ͳ�����ݡ�
+
+## Nacos �������
+
+�� Eureka ���ƣ�Nacos Ҳ���� CS��Client/Server���ͻ���/���������ܹ���������������������±���
+��
+
+| ���                                                         | ����                                                         | ����                                                         |
+| ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
+| Nacos Server                                                 | Nacos ����ˣ��� Eureka Server ��ͬ��Nacos Server �ɰ���Ͱ��Ŷ�ʹ�� Java ���Ա�д���� Nacos Server �����ص�ַ���û����û�ֻ��Ҫֱ�����ز����м��ɡ� | Nacos Server ������Ϊ����ע�����ģ����� Nacos Client ʵ�ַ����ע���뷢�֡� |
+| Nacos Server ������Ϊ�������ģ����� Nacos Client �ڲ�����������£�ʵ�����õĶ�̬ˢ�¡� |                                                              |                                                              |
+| Nacos Client                                                 | Nacos �ͻ��ˣ�ͨ��ָ����΢����ܹ��еĸ����������û��Լ��������ʹ�ö������Ա�д�� | Nacos Client ͨ���������� spring-cloud-starter-alibaba-nacos-discovery���ڷ���ע�����ģ�Nacos Server����ʵ�ַ����ע���뷢�֡� |
+| Nacos Client ͨ���������� spring-cloud-starter-alibaba-nacos-config�����������ģ�Nacos Server����ʵ�����õĶ�̬ˢ�¡� |                                                              |                                                              |
+
+## Nacos ����ע������
+
+Nacos ��Ϊ����ע�����Ŀ���ʵ�ַ����ע���뷢�֣���������ͼ��
+
+![Nacos ����ע���뷢��](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1022563360-0.png)
+ͼ1��Nacos ����ע���뷢��
+
+��ͼ 1 �й��漰������ 3 ����ɫ��
+
+*   ����ע�����ģ�Register Service��������һ�� Nacos Server������Ϊ�����ṩ�ߺͷ����������ṩ����ע��ͷ��ֹ��ܡ�
+*   �����ṩ�ߣ�Provider Service��������һ�� Nacos Client�����ڶ�����������Լ��ṩ�ķ���ע�ᵽ����ע�����ģ��Թ����������߷��ֺ͵��á�
+*   ���������ߣ�Consumer Service��������һ�� Nacos Client���������ѷ��������Դӷ���ע�����Ļ�ȡ�����б�����������ķ���
+
+Nacos ʵ�ַ���ע���뷢�ֵ��������£�
+
+1.  �� Nacos �ٷ��ṩ������ҳ���У����� Nacos Server �����С�
+2.  �����ṩ�� Nacos Client ����ʱ����ѷ����Է�������spring.application.name���ķ�ʽע�ᵽ����ע�����ģ�Nacos Server����
+3.  ���������� Nacos Client ����ʱ��Ҳ�Ὣ�Լ��ķ���ע�ᵽ����ע�����ģ�
+4.  ������������ע������ͬʱ��������ӷ���ע�����Ļ�ȡһ�ݷ���ע���б���Ϣ�����б��а���������ע�ᵽ����ע�������ϵķ������Ϣ�����������ṩ�ߺ���������Ϣ����
+5.  �ڻ�ȡ�˷����ṩ�ߵ���Ϣ�󣬷���������ͨ�� HTTP ����Ϣ�м��Զ�̵��÷����ṩ���ṩ�ķ���
+
+#### ��װ������ Nacos Server
+
+���������� Nacos 2.0.3 Ϊ������ʾ����ΰ�װ������ Nacos Server���������¡�
+
+1\. ʹ����������� [Nacos Server ����ҳ��](https://github.com/alibaba/nacos/releases/tag/2.0.3)������ҳ�����·�������� nacos-server-2.0.3.zip������ͼ��
+
+![Nacos ����](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1022562c6-1.png)
+ͼ2��Nacos Server ����
+
+2\. ������ɺ󣬽�ѹ nacos-server-2.0.3.zip��Ŀ¼�ṹ���¡�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1022563922-2.png)
+ͼ3��Nacos Server Ŀ¼�ṹ
+
+Nacos Server �¸�Ŀ¼˵�����£�
+
+*   bin�����ڴ�� Nacos �Ŀ�ִ�����
+*   conf�����ڴ�� Nacos �����ļ���
+*   target�����ڴ�� Nacos Ӧ�õ� jar ����
+
+3\. �������д��ڣ���ת�� Nacos Server ��װĿ¼�� bin �£�ִ����������Ե���ģʽ���� Nacos Server��
+
+startup.cmd -m standalone
+
+4\. Nacos Server ������־���¡�
+
+"nacos is starting with standalone"
+
+
+         ,--.
+       ,--.'|
+
+   ,--,:  : |                                           Nacos 2.0.3
+,`--.'`|  ' :                       ,---.               Running in stand alone mode, All function modules
+|   :  :  | |                      '   ,'\   .--.--.    Port: 8848
+:   |   \ | :  ,--.--.     ,---.  /   /   | /  /    '   Pid: 27512
+|   : '  '; | /       \   /     \.   ; ,. :|  :  /`./   Console: http://192.168.3.138:8848/nacos/index.html
+'   ' ;.    ;.--.  .-. | /    / ''   | |: :|  :  ;_
+|   | | \   | \__\/: . ..    ' / '   | .; : \  \    `.      https://nacos.io
+'   : |  ; .' ," .--.; |'   ; :__|   :    |  `----.   \
+|   | '`--'  /  /  ,.  |'   | '.'|\   \  /  /  /`--'  /
+'   : |     ;  :   .'   \   :    : `----'  '--'.     /
+;   |.'     |  ,     .-./\   \  /            `--'---'
+'---'        `--`---'     `----'
+````
+2021-11-08 16:16:38,877 INFO Bean 'org.springframework.security.access.expression.method.DefaultMethodSecurityExpressionHandler@5ab9b447' of type [org.springframework.security.access.expression.method
+.DefaultMethodSecurityExpressionHandler] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
+2021-11-08 16:16:38,884 INFO Bean 'methodSecurityMetadataSource' of type [org.springframework.security.access.method.DelegatingMethodSecurityMetadataSource] is not eligible for getting processed by al
+l BeanPostProcessors (for example: not eligible for auto-proxying)
+2021-11-08 16:16:40,001 INFO Tomcat initialized with port(s): 8848 (http)
+2021-11-08 16:16:40,713 INFO Root WebApplicationContext: initialization completed in 14868 ms
+2021-11-08 16:16:52,351 INFO Initializing ExecutorService 'applicationTaskExecutor'
+2021-11-08 16:16:52,560 INFO Adding welcome page: class path resource [static/index.html]
+2021-11-08 16:16:54,239 INFO Creating filter chain: Ant [pattern='/**'], []
+2021-11-08 16:16:54,344 INFO Creating filter chain: any request, [org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter@7dd611c8, org.springframework.security.web.con
+text.SecurityContextPersistenceFilter@5c7668ba, org.springframework.security.web.header.HeaderWriterFilter@fb713e7, org.springframework.security.web.csrf.CsrfFilter@6ec7bce0, org.springframework.secur
+ity.web.authentication.logout.LogoutFilter@7d9ba6c, org.springframework.security.web.savedrequest.RequestCacheAwareFilter@158f4cfe, org.springframework.security.web.servletapi.SecurityContextHolderAwa
+reRequestFilter@6c6333cd, org.springframework.security.web.authentication.AnonymousAuthenticationFilter@5d425813, org.springframework.security.web.session.SessionManagementFilter@13741d5a, org.springf
+ramework.security.web.access.ExceptionTranslationFilter@3727f0ee]
+2021-11-08 16:16:54,948 INFO Initializing ExecutorService 'taskScheduler'
+2021-11-08 16:16:54,977 INFO Exposing 16 endpoint(s) beneath base path '/actuator'
+2021-11-08 16:16:55,309 INFO Tomcat started on port(s): 8848 (http) with context path '/nacos'
+2021-11-08 16:16:55,319 INFO Nacos started successfully in stand alone mode. use embedded storage
+````
+5\. ʹ����������ʡ�http://localhost:8848/nacos������ת�� Nacos Server ��½ҳ�棬����ͼ��
+
+![Nacos ��½ҳ��](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1022562045-3.png)
+ͼ4��Nacos Server ��½ҳ��
+
+6\. �ڵ�½ҳ�����¼�������루Ĭ�϶��� nacos��������ύ��ť����ת�� Nacos Server ����̨��ҳ������ͼ��
+
+![Nacos Server ��ҳ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10225633C-4.png)
+ͼ5��Nacos Server ����̨
+
+�Դˣ����Ǿ������ Nacos Server �����ء���װ�����й�����
+
+#### ������ṩ��
+
+���������������һ�������ṩ�ߣ��������¡�
+
+1. ����һ����Ϊ spring-cloud-alibaba-demo �� Maven ���� ���ù��̵� pom.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>
+    <packaging>pom</packaging>
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        spring-boot-starter-parent
+        <version>2.5.6</version>
+        <relativePath/> <!-- lookup parent from repository -->
+    </parent>
+    <groupId>net.biancheng.c</groupId>
+    spring-cloud-alibaba-demo
+    <version>1.0-SNAPSHOT</version>
+
+
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <junit.version>4.12</junit.version>
+        <log4j.version>1.2.17</log4j.version>
+        <lombok.version>1.16.18</lombok.version>
+        <spring-cloud.version>2020.0.4</spring-cloud.version>
+    </properties>
+    <dependencyManagement>
+        <dependencies>
+            <!--Spring Cloud Alibaba �İ汾��Ϣ-->
+            <dependency>
+                <groupId>com.alibaba.cloud</groupId>
+                spring-cloud-alibaba-dependencies
+                <version>2021.1</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+            <!--Spring Cloud �İ汾��Ϣ-->
+            <dependency>
+                <groupId>org.springframework.cloud</groupId>
+                spring-cloud-dependencies
+                <version>${spring-cloud.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+</project>
+````
+
+
+
+
+> �ڸù��̵� pom.xml �У�����ͨ�� dependencyManagement �� Spring Cloud Alibaba �İ汾��Ϣ���й������ù����µĸ�����ģ�������� Spring Cloud Alibaba �ĸ������ʱ�Ͳ�Ҫ����ָ���汾���ˡ�
+
+2\. �� spring-cloud-alibaba-demo �£�����һ����Ϊ spring-cloud-alibaba-provider-8001 �� Spring Boot ģ�飬������ pom.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <!--������-->
+    <parent>
+        <groupId>net.biancheng.c</groupId>
+        <version>1.0-SNAPSHOT</version>
+        spring-cloud-alibaba-demo
+    </parent>
+
+
+    <groupId>net.biancheng.c</groupId>
+    spring-cloud-alibaba-provider-8001
+    <version>0.0.1-SNAPSHOT</version>
+    <name>spring-cloud-alibaba-provider-8001</name>
+    <description>Demo project for Spring Boot</description>
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter-web
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-devtools
+            <scope>runtime</scope>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            lombok
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter-test
+            <scope>test</scope>
+        </dependency>
+        <!--Spring Cloud Alibaba Nacos discovery -->
+        <dependency>
+            <groupId>com.alibaba.cloud</groupId>
+            spring-cloud-starter-alibaba-nacos-discovery
+        </dependency>
+    </dependencies>
+    
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                spring-boot-maven-plugin
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            lombok
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
+
+````
+
+
+
+3\. �� spring-cloud-alibaba-provider-8001 �������ļ� application.properties �������������ã��������¡�
+````
+#�˿ں�
+server.port=8001
+#������
+spring.application.name=spring-cloud-alibaba-provider
+#Nacos Server �ĵ�ַ
+spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
+management.endpoints.web.exposure.include=*
+````
+
+4\. �� net.biacheng.c.controller ���£�����һ����Ϊ DeptController �� Controller �࣬�������¡�
+
+
+
+
+````
+package net.biancheng.c.controller;
+
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@Slf4j
+public class DeptController {
+    @Value("${server.port}")
+    private String serverPort;
+
+    @GetMapping(value = "/dept/nacos/{id}")
+    public String getPayment(@PathVariable("id") Integer id) {
+        return "<h2>c������������������������ʳɹ���</h2>��������spring-cloud-alibaba-provider<br /> �˿ںţ� " + serverPort + "<br /> ����IJ�����" + id;
+    }
+
+}
+
+````
+
+
+
+5\. �� spring-cloud-alibaba-provider-8001 �����������ϣ�ʹ�� @EnableDiscoveryClient ע�⿪�� Nacos �����ֹ��ܣ��������¡�
+
+
+
+
+
+package net.biancheng.c;
+
+````
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
+
+@SpringBootApplication
+@EnableDiscoveryClient //���������ֹ���
+public class SpringCloudAlibabaProvider8001Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(SpringCloudAlibabaProvider8001Application.class, args);
+    }
+
+}
+````
+
+
+
+
+6\. ���� spring-cloud-alibaba-provider-8001��ʹ����������ʡ�http://localhost:8001/dept/nacos/1�����������ͼ��
+
+![���ʷ����ṩ�ߵķ���](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10225C033-5.png)
+ͼ6�������ṩ��
+
+7\. ʹ����������ʡ�http://localhost:8848/nacos�����鿴������������µġ������б���������ͼ��
+
+[![Nacos �����б�](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10225Ab5-6.png)](http://new-local.weixueyuan.net/uploads/allimg/211108/6-21110QJ12b02.png)
+ͼ7������ע���б�
+
+��ͼ 7 ���Կ��������Ǵ�ķ����ṩ�� spring-cloud-alibaba-provider-8001 ���ṩ�ķ����Ѿ���ע�ᵽ�� Nacos Server ���ˡ�
+
+#### �����������
+
+���棬���Ǿ����һ������������������ spring-cloud-alibaba-provider-8001 �ṩ�ķ��񣬲������¡�
+
+1\. �������� spring-cloud-alibaba-demo �£�����һ����Ϊ spring-cloud-alibaba-consumer-nacos-8801 �� Spring Boot ģ�飬������ pom.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>net.biancheng.c</groupId>
+        <version>1.0-SNAPSHOT</version>
+        spring-cloud-alibaba-demo
+    </parent>
+    <groupId>net.biancheng.c</groupId>
+    spring-cloud-alibaba-consumer-nacos-8081
+    <version>0.0.1-SNAPSHOT</version>
+    <name>spring-cloud-alibaba-consumer-nacos-8081</name>
+    <description>Demo project for Spring Boot</description>
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+    <dependencies>
+        <!--SpringCloud ailibaba nacos discovery-->
+        <dependency>
+            <groupId>com.alibaba.cloud</groupId>
+            spring-cloud-starter-alibaba-nacos-discovery
+        </dependency>
+        <!--���� Netflix Ribbon ����ͣ��ά���׶Σ�����°汾�� Nacos discovery ���Ѿ��Ƴ��� Ribbon ����ʱ������Ҫ���� loadbalancer ���� -->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            spring-cloud-loadbalancer
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter-web
+        </dependency>
+
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-devtools
+            <scope>runtime</scope>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            lombok
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter-test
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                spring-boot-maven-plugin
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            lombok
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
+
+````
+
+
+
+
+> ע�⣺���� Netflix Ribbon �Ѿ�����ͣ��ά��״̬��Nacos Discovery �Ѿ�ͣ�˶� Ribbon ��֧�֣����������Ҫ�ڷ��������ߵ� pom.xml ������ spring-cloud-loadbalancer ���ܵ��÷����ṩ���ṩ�ķ���
+
+2\. �� spring-cloud-alibaba-consumer-nacos-8801 �������ļ� application.yml �У������������á�
+
+
+````
+
+
+server:
+  port: 8801  #�˿ں�
+spring:
+  application:
+    name: spring-cloud-alibaba-consumer #������
+  cloud:
+    nacos:
+      discovery:
+        server-addr: localhost:8848  #Nacos server �ĵ�ַ
+````
+
+#����������Ϣ������Ĭ�����ã����������Զ�������ã�Ŀ���Dz��� Controller ��Ӳ��������ṩ�ߵķ�����
+````
+service-url:
+  nacos-user-service: http://spring-cloud-alibaba-provider #�����ṩ�ߵķ�����
+````
+
+
+
+
+3\. �� spring-cloud-alibaba-consumer-nacos-8801 �����������ϣ�ʹ�� @EnableDiscoveryClient ע�⿪�������ֹ��ܣ��������¡�
+
+
+
+
+````
+package net.biancheng.c;
+
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
+
+@SpringBootApplication
+@EnableDiscoveryClient // ��������ע���뷢�ֹ���
+public class SpringCloudAlibabaConsumerNacos8801Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(SpringCloudAlibabaConsumerNacos8081Application.class, args);
+    }
+
+}
+````
+
+
+
+
+4\. �� net.biancheng.c.config ���´���һ����Ϊ ApplicationContextBean �������࣬��ʹ�� @LoadBalanced ע���� Ribbon ���м��ɿ������ؾ��⹦�ܣ��������¡�
+
+
+
+
+````
+package net.biancheng.c.config;
+
+
+import org.springframework.cloud.client.loadbalancer.LoadBalanced;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestTemplate;
+
+@Configuration
+public class ApplicationContextBean {
+
+    @Bean
+    @LoadBalanced //�� Ribbon ���ɣ����������ؾ��⹦��
+    public RestTemplate getRestTemplate() {
+        return new RestTemplate();
+    }
+
+}
+
+````
+
+
+
+5\. �� net.biancheng.c.controller ���£�����һ����Ϊ DeptController_Consumer �� Controller �࣬�������¡�
+
+
+
+
+````
+package net.biancheng.c.controller;
+
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.client.RestTemplate;
+
+import javax.annotation.Resource;
+
+@RestController
+@Slf4j
+public class DeptController_Consumer {
+
+    @Resource
+    private RestTemplate restTemplate;
+    
+    @Value("${service-url.nacos-user-service}")
+    private String serverURL; //�����ṩ�ߵķ�����
+    
+    @GetMapping("/consumer/dept/nacos/{id}")
+    public String paymentInfo(@PathVariable("id") Long id) {
+        return restTemplate.getForObject(serverURL + "/dept/nacos/" + id, String.class);
+    }
+
+}
+````
+
+
+
+
+6\. ���� spring-cloud-alibaba-consumer-nacos-8801���鿴 Nacos Server �ķ����б�������ͼ��
+
+[![������������ Nacos Server ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10225621N-7.png)](http://new-local.weixueyuan.net/uploads/allimg/211109/6-21110Z91435H1.png)
+ͼ8������������
+
+7\. ʹ����������ʡ�http://localhost:8801/consumer/dept/nacos/1�����������ͼ��
+
+![Nacos �������������ѷ���](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10225B156-8.png)
+ͼ9�����������ߵ��÷���
+
+## Nacos ��������
+
+Nacos Server ��������Ϊ�������ģ��� Spring Cloud Ӧ�õ��ⲿ���ý���ͳһ�ؼ��л�������������ֻ��Ҫ��Ӧ�õ� POM �ļ������� spring-cloud-starter-alibaba-nacos-config ����ʵ�����õĻ�ȡ�붯̬ˢ�¡�
+
+�����ù����ĽǶȿ���Nacos ����˵�� Spring Cloud Config ���������������Ⱥ��� Nacos ��ʹ�ø��򵥣���������Ҳ���١�
+
+������������ͨ��һ��ʵ������ʾ�� Nacos �����ʵ�����õ�ͳһ�����Ͷ�̬ˢ�µġ�
+
+1\. �������� spring-cloud-alibaba-demo �£�����һ����Ϊ spring-cloud-alibaba-config-client-3377 �� Spring Boot ģ�飬������ pom.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>net.biancheng.c</groupId>
+        <version>1.0-SNAPSHOT</version>
+        spring-cloud-alibaba-demo
+    </parent>
+    <groupId>net.biancheng.c</groupId>
+    spring-cloud-alibaba-config-client-3377
+    <version>0.0.1-SNAPSHOT</version>
+    <name>spring-cloud-alibaba-nacos-config-client-3377</name>
+    <description>Demo project for Spring Boot</description>
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter-web
+        </dependency>
+        <!--SpringCloud2020���Ժ�İ汾Ĭ�ϲ����� bootstrap ���ã�������Ҫ��pom������ʽ�����룺-->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            spring-cloud-starter-bootstrap
+        </dependency>
+
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-devtools
+            <scope>runtime</scope>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            lombok
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter-test
+            <scope>test</scope>
+        </dependency>
+        <!--Spring Cloud Alibaba Config ����-->
+        <dependency>
+            <groupId>com.alibaba.cloud</groupId>
+            spring-cloud-starter-alibaba-nacos-config
+        </dependency>
+        <!--SpringCloud ailibaba nacos ����ע���뷢��ģ�� -->
+        <dependency>
+            <groupId>com.alibaba.cloud</groupId>
+            spring-cloud-starter-alibaba-nacos-discovery
+        </dependency>
+        <!--Spring Boot ���ģ��-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter-actuator
+        </dependency>
+    </dependencies>
+    
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                spring-boot-maven-plugin
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            lombok
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
+
+````
+
+
+
+> ע�⣺����ʹ�õ� Spring Cloud 2020 �汾Ĭ�ϲ����� bootstrap������Ҫ��Ӧ������ʱ���� bootstrap ���ã����� bootstrap.yml �� bootstrap.properties��������Ҫ������ pom.xml ����ʽ������ spring-cloud-starter-bootstrap ������
+
+2\. �� spring-cloud-alibaba-config-client-3377 ����·�������� /resources Ŀ¼���£�����һ�� bootstrap.yml�������������¡�
+
+
+
+
+````
+server:
+  port: 3377 #�˿ں�
+spring:
+  application:
+    name: config-client #������
+  cloud:
+    nacos:
+      discovery:
+        server-addr: 127.0.0.1:8848 #Nacos����ע�����ĵ�ַ
+
+
+      config:
+        server-addr: 127.0.0.1:8848 #Nacos��Ϊ�������ĵ�ַ
+        file-extension: yaml #ָ��yaml��ʽ������
+
+````
+
+
+
+3\. �� spring-cloud-alibaba-config-client-3377 ����·�������� /resources Ŀ¼���£�����һ�� application.yml�������������¡�
+
+
+
+
+````
+spring:
+  profiles:
+    active: dev #���� dev ������
+
+````
+
+
+
+
+4\. �� net.biancheng.c.controller ���£�����һ����Ϊ ConfigClientController �� Controller �࣬���ڸ�����ʹ�� @RefreshScope ע��ʵ�����õ��Զ����£��������¡�
+
+
+
+
+````
+package net.biancheng.c.controller;
+
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.cloud.context.config.annotation.RefreshScope;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RefreshScope
+public class ConfigClientController {
+
+    @Value("${config.info}")
+    private String ConfigInfo;
+    
+    @GetMapping("/config/info")
+    public String getConfigInfo(){
+        return ConfigInfo;
+    }
+
+}
+````
+
+
+
+
+5\. �� spring-cloud-alibaba-config-client-3377 �����������ϣ�ʹ�� @EnableDiscoveryClient ע�⿪�������ֹ��ܣ��������¡�
+
+
+
+
+````
+package net.biancheng.c;
+
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
+
+@SpringBootApplication
+@EnableDiscoveryClient
+public class SpringCloudAlibabaNacosConfigClient3377Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run(SpringCloudAlibabaNacosConfigClient3377Application.class, args);
+    }
+
+}
+````
+
+
+
+
+6\. ���� Nacos Server������ Nacos Server ����̨�ġ����ù������µġ������б����У������+����ť���½��������á�
+````
+Data ID:        config-client-dev.yaml
+
+
+Group  :        DEFAULT_GROUP
+
+���ø�ʽ:        YAML
+
+��������:      config:
+                  info: c.biancheng.net
+````
+�� Nacos Server �У����õ� dataId���� Data ID����������ʽ���£�
+````
+${prefix}-${spring.profiles.active}.${file-extension}
+````
+dataId ��ʽ�и�����˵�����£�
+
+*   ${prefix}��Ĭ��ȡֵΪ΢����ķ��������������ļ��� spring.application.name ��ֵ�����ǿ����������ļ���ͨ������ spring.cloud.nacos.config.prefix ��ָ����
+*   ${spring.profiles.active}����ʾ��ǰ������Ӧ�� Profile������ dev��test��prod �ȡ���û��ָ�������� Profile ʱ�����Ӧ�����ӷ�Ҳ�������ڣ� dataId �ĸ�ʽ��� ${prefix}.${file-extension}��
+*   ${file-extension}����ʾ�������ݵ����ݸ�ʽ�����ǿ����������ļ���ͨ�������� spring.cloud.nacos.config.file-extension �����ã����� properties �� yaml��
+
+7\. ���� spring-cloud-alibaba-config-client-3377����ʹ����������ʡ�http://localhost:3377/config/info�����������ͼ��
+
+![Nacos Config](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10225B3C-9.png)
+ͼ10��Nacos Config
+
+8\. �� Nacos Server �У��� config-client-dev.yaml �е������޸ij��������ݡ�
+````
+config:
+    info: this is c.biancheng.net
+````
+
+9\. �ڲ����� spring-cloud-alibaba-config-client-3377 ������£�ʹ��������ٴη��ʡ�http://localhost:3377/config/info�����������ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1022563A7-10.png)
+ͼ11��Nacos Cofig
+
+## Nacos Server ��Ⱥ������
+
+��ʵ�ʵ���Ŀ�����У�һ��΢����ϵͳ������ʮ������ʮ���������ٸ�΢������ɡ� ��Щ������ȫ��ע�ᵽͬһ̨ Nacos Server���ͼ��п��ܵ��� Nacos Server ��Ϊ�����ظ������������յ�������΢����ϵͳ̱����������������ֱ�ӵİ취����ʹ�� Nacos Server ��Ⱥ��
+
+Nacos Server �ļ�Ⱥ��������һ��ʮ�����Ե��ŵ㣬�Ǿ��ǿ��Ա���ϵͳ�ĸ߿����ԡ��ڼ�Ⱥ�������У�ֻҪ�������е� Nacos Server ��ֹͣ������Nacos Client �ͻ����ԴӼ�Ⱥ�������� Nacos Server �ϻ�ȡ������Ϣ�����ã������ᵼ��ϵͳ������̱��������� Nacos Server ��Ⱥ������ĸ߿����ԡ�
+
+��ͼչʾ�� Nacos Server ��Ⱥ������Ļ����ܹ���
+
+![Nacos Server ��Ⱥ�ܹ�](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1022563543-11.png)
+ͼ12��Nacos Server ��Ⱥ�ܹ�
+
+���������� Windows ϵͳΪ������ʾ��β��� Nacos Server ��Ⱥ��
+
+1\. �� MySQL �У��½�һ����Ϊ nacos_config �����ݿ�ʵ�������ڸ����ݿ���ִ������ SQL ��䡣
+````
+/******************************************/
+/*   ���ݿ�ȫ�� = nacos_config   */
+/*   ������ = config_info   */
+/******************************************/
+CREATE TABLE `config_info` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
+  `data_id` varchar(255) NOT NULL COMMENT 'data_id',
+  `group_id` varchar(255) DEFAULT NULL,
+  `content` longtext NOT NULL COMMENT 'content',
+  `md5` varchar(32) DEFAULT NULL COMMENT 'md5',
+  `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '����ʱ��',
+  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '�޸�ʱ��',
+  `src_user` text COMMENT 'source user',
+  `src_ip` varchar(50) DEFAULT NULL COMMENT 'source ip',
+  `app_name` varchar(128) DEFAULT NULL,
+  `tenant_id` varchar(128) DEFAULT '' COMMENT '�⻧�ֶ�',
+  `c_desc` varchar(256) DEFAULT NULL,
+  `c_use` varchar(64) DEFAULT NULL,
+  `effect` varchar(64) DEFAULT NULL,
+  `type` varchar(64) DEFAULT NULL,
+  `c_schema` text,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_configinfo_datagrouptenant` (`data_id`,`group_id`,`tenant_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info';
+
+
+/******************************************/
+/*   ���ݿ�ȫ�� = nacos_config   */
+/*   ������ = config_info_aggr   */
+/******************************************/
+CREATE TABLE `config_info_aggr` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
+  `data_id` varchar(255) NOT NULL COMMENT 'data_id',
+  `group_id` varchar(255) NOT NULL COMMENT 'group_id',
+  `datum_id` varchar(255) NOT NULL COMMENT 'datum_id',
+  `content` longtext NOT NULL COMMENT '����',
+  `gmt_modified` datetime NOT NULL COMMENT '�޸�ʱ��',
+  `app_name` varchar(128) DEFAULT NULL,
+  `tenant_id` varchar(128) DEFAULT '' COMMENT '�⻧�ֶ�',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_configinfoaggr_datagrouptenantdatum` (`data_id`,`group_id`,`tenant_id`,`datum_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='�����⻧�ֶ�';
+
+/******************************************/
+/*   ���ݿ�ȫ�� = nacos_config   */
+/*   ������ = config_info_beta   */
+/******************************************/
+CREATE TABLE `config_info_beta` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
+  `data_id` varchar(255) NOT NULL COMMENT 'data_id',
+  `group_id` varchar(128) NOT NULL COMMENT 'group_id',
+  `app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',
+  `content` longtext NOT NULL COMMENT 'content',
+  `beta_ips` varchar(1024) DEFAULT NULL COMMENT 'betaIps',
+  `md5` varchar(32) DEFAULT NULL COMMENT 'md5',
+  `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '����ʱ��',
+  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '�޸�ʱ��',
+  `src_user` text COMMENT 'source user',
+  `src_ip` varchar(50) DEFAULT NULL COMMENT 'source ip',
+  `tenant_id` varchar(128) DEFAULT '' COMMENT '�⻧�ֶ�',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_configinfobeta_datagrouptenant` (`data_id`,`group_id`,`tenant_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info_beta';
+
+/******************************************/
+/*   ���ݿ�ȫ�� = nacos_config   */
+/*   ������ = config_info_tag   */
+/******************************************/
+CREATE TABLE `config_info_tag` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
+  `data_id` varchar(255) NOT NULL COMMENT 'data_id',
+  `group_id` varchar(128) NOT NULL COMMENT 'group_id',
+  `tenant_id` varchar(128) DEFAULT '' COMMENT 'tenant_id',
+  `tag_id` varchar(128) NOT NULL COMMENT 'tag_id',
+  `app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',
+  `content` longtext NOT NULL COMMENT 'content',
+  `md5` varchar(32) DEFAULT NULL COMMENT 'md5',
+  `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '����ʱ��',
+  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '�޸�ʱ��',
+  `src_user` text COMMENT 'source user',
+  `src_ip` varchar(50) DEFAULT NULL COMMENT 'source ip',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_configinfotag_datagrouptenanttag` (`data_id`,`group_id`,`tenant_id`,`tag_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info_tag';
+
+/******************************************/
+/*   ���ݿ�ȫ�� = nacos_config   */
+/*   ������ = config_tags_relation   */
+/******************************************/
+CREATE TABLE `config_tags_relation` (
+  `id` bigint(20) NOT NULL COMMENT 'id',
+  `tag_name` varchar(128) NOT NULL COMMENT 'tag_name',
+  `tag_type` varchar(64) DEFAULT NULL COMMENT 'tag_type',
+  `data_id` varchar(255) NOT NULL COMMENT 'data_id',
+  `group_id` varchar(128) NOT NULL COMMENT 'group_id',
+  `tenant_id` varchar(128) DEFAULT '' COMMENT 'tenant_id',
+  `nid` bigint(20) NOT NULL AUTO_INCREMENT,
+  PRIMARY KEY (`nid`),
+  UNIQUE KEY `uk_configtagrelation_configidtag` (`id`,`tag_name`,`tag_type`),
+  KEY `idx_tenant_id` (`tenant_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_tag_relation';
+
+/******************************************/
+/*   ���ݿ�ȫ�� = nacos_config   */
+/*   ������ = group_capacity   */
+/******************************************/
+CREATE TABLE `group_capacity` (
+  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '����ID',
+  `group_id` varchar(128) NOT NULL DEFAULT '' COMMENT 'Group ID�����ַ���ʾ������Ⱥ',
+  `quota` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '��0��ʾʹ��Ĭ��ֵ',
+  `usage` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'ʹ����',
+  `max_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '�������ô�С���ޣ���λΪ�ֽڣ�0��ʾʹ��Ĭ��ֵ',
+  `max_aggr_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '�ۺ�����������������0��ʾʹ��Ĭ��ֵ',
+  `max_aggr_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '�����ۺ����ݵ������ô�С���ޣ���λΪ�ֽڣ�0��ʾʹ��Ĭ��ֵ',
+  `max_history_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '�������ʷ����',
+  `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '����ʱ��',
+  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '�޸�ʱ��',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_group_id` (`group_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='��Ⱥ����Group������Ϣ��';
+
+/******************************************/
+/*   ���ݿ�ȫ�� = nacos_config   */
+/*   ������ = his_config_info   */
+/******************************************/
+CREATE TABLE `his_config_info` (
+  `id` bigint(64) unsigned NOT NULL,
+  `nid` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
+  `data_id` varchar(255) NOT NULL,
+  `group_id` varchar(128) NOT NULL,
+  `app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',
+  `content` longtext NOT NULL,
+  `md5` varchar(32) DEFAULT NULL,
+  `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `src_user` text,
+  `src_ip` varchar(50) DEFAULT NULL,
+  `op_type` char(10) DEFAULT NULL,
+  `tenant_id` varchar(128) DEFAULT '' COMMENT '�⻧�ֶ�',
+  PRIMARY KEY (`nid`),
+  KEY `idx_gmt_create` (`gmt_create`),
+  KEY `idx_gmt_modified` (`gmt_modified`),
+  KEY `idx_did` (`data_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='���⻧����';
+
+/******************************************/
+/*   ���ݿ�ȫ�� = nacos_config   */
+/*   ������ = tenant_capacity   */
+/******************************************/
+CREATE TABLE `tenant_capacity` (
+  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '����ID',
+  `tenant_id` varchar(128) NOT NULL DEFAULT '' COMMENT 'Tenant ID',
+  `quota` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '��0��ʾʹ��Ĭ��ֵ',
+  `usage` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'ʹ����',
+  `max_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '�������ô�С���ޣ���λΪ�ֽڣ�0��ʾʹ��Ĭ��ֵ',
+  `max_aggr_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '�ۺ�������������',
+  `max_aggr_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '�����ۺ����ݵ������ô�С���ޣ���λΪ�ֽڣ�0��ʾʹ��Ĭ��ֵ',
+  `max_history_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '�������ʷ����',
+  `gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '����ʱ��',
+  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '�޸�ʱ��',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_tenant_id` (`tenant_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='�⻧������Ϣ��';
+
+CREATE TABLE `tenant_info` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
+  `kp` varchar(128) NOT NULL COMMENT 'kp',
+  `tenant_id` varchar(128) default '' COMMENT 'tenant_id',
+  `tenant_name` varchar(128) default '' COMMENT 'tenant_name',
+  `tenant_desc` varchar(256) DEFAULT NULL COMMENT 'tenant_desc',
+  `create_source` varchar(32) DEFAULT NULL COMMENT 'create_source',
+  `gmt_create` bigint(20) NOT NULL COMMENT '����ʱ��',
+  `gmt_modified` bigint(20) NOT NULL COMMENT '�޸�ʱ��',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_tenant_info_kptenantid` (`kp`,`tenant_id`),
+  KEY `idx_tenant_id` (`tenant_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='tenant_info';
+
+CREATE TABLE `users` (
+`username` varchar(50) NOT NULL PRIMARY KEY,
+`password` varchar(500) NOT NULL,
+`enabled` boolean NOT NULL
+);
+
+CREATE TABLE `roles` (
+`username` varchar(50) NOT NULL,
+`role` varchar(50) NOT NULL,
+UNIQUE INDEX `idx_user_role` (`username` ASC, `role` ASC) USING BTREE
+);
+
+CREATE TABLE `permissions` (
+    `role` varchar(50) NOT NULL,
+    `resource` varchar(255) NOT NULL,
+    `action` varchar(8) NOT NULL,
+    UNIQUE INDEX `uk_role_permission` (`role`,`resource`,`action`) USING BTREE
+);
+
+INSERT INTO users (username, password, enabled) VALUES ('nacos', '$2a$10$EuWPZHzz32dJN7jexM34MOeYirDdFAZm2kuWj7VEOJhhZkDrxfvUu', TRUE);
+
+INSERT INTO roles (username, role) VALUES ('nacos', 'ROLE_ADMIN');
+````
+2\. �� Nacos Server ��װĿ¼�µ� conf �ļ����У��� cluster.conf.example ������Ϊ cluster.conf��Ȼ���ڸ��ļ��������������ݡ�
+
+    192.168.3.138:3333
+    192.168.3.138:4444
+    192.168.3.138:5555
+
+
+����˵�����£�
+
+*   192.168.138 Ϊ���ص��������� IP ��ַ��������ò�Ҫд�� localhost �� 127.0.0.1������ Nacos Server ��Ⱥ���ܻ�ʧ�ܣ�
+*   ���δ�� Nacos Server ��Ⱥ�Ķ˿ڷֱ�Ϊ��3333��4444��5555��
+
+3\. �� config Ŀ¼�µ� application.properties �У��� server.port���˿ںţ��޸�Ϊ 3333�����ڸ��ļ������� MySQL ���ݿ����ã������޸��������¡�
+````
+server.port=3333
+################ MySQL ���ݿ�����##################
+spring.datasource.platform=mysql
+
+
+db.num=1
+db.url.0=jdbc:mysql://127.0.0.1:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai
+db.user=root
+db.password=root
+````
+4\. ���� Nacos Server Ŀ¼���Ƶ�������̨�����ϣ��������ǵĶ˿ںŷֱ��޸�Ϊ�� 4444 �� 5555��
+
+5\. ���� Nginx�����޸� Nginx �� conf Ŀ¼�µ� nginx.conf �����ã��������¡�
+````
+#user  nobody;
+worker_processes  1;
+
+
+#error_log  logs/error.log;
+
+#error_log  logs/error.log  notice;
+
+#error_log  logs/error.log  info;
+
+#pid        logs/nginx.pid;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    include       mime.types;
+    default_type  application/octet-stream;
+    sendfile        on;
+    keepalive_timeout  65;
+    upstream cluster{
+        server 127.0.0.1:3333;
+        server 127.0.0.1:4444;
+        server 127.0.0.1:5555;
+    }
+
+    server {
+        listen       1111;
+        server_name  localhost;
+        #charset koi8-r;
+        #access_log  logs/host.access.log  main;
+        location / {
+            #root   html;
+            #index  index.html index.htm;
+            proxy_pass http://cluster;
+        }
+    }
+
+}
+````
+6\. ������Ⱥ�����е� Nacos Server����������������ʱ����ʾ Nacos Server �����ɹ���
+````
+"nacos is starting with cluster"
+
+
+         ,--.
+       ,--.'|
+
+   ,--,:  : |                                           Nacos 2.0.3
+,`--.'`|  ' :                       ,---.               Running in cluster mode, All function modules
+|   :  :  | |                      '   ,'\   .--.--.    Port: ****
+:   |   \ | :  ,--.--.     ,---.  /   /   | /  /    '   Pid: 21592
+|   : '  '; | /       \   /     \.   ; ,. :|  :  /`./   Console: http://192.168.3.138:3333/nacos/index.html
+'   ' ;.    ;.--.  .-. | /    / ''   | |: :|  :  ;_
+|   | | \   | \__\/: . ..    ' / '   | .; : \  \    `.      https://nacos.io
+'   : |  ; .' ," .--.; |'   ; :__|   :    |  `----.   \
+|   | '`--'  /  /  ,.  |'   | '.'|\   \  /  /  /`--'  /
+'   : |     ;  :   .'   \   :    : `----'  '--'.     /
+;   |.'     |  ,     .-./\   \  /            `--'---'
+'---'        `--`---'     `----'
+
+2021-11-09 16:25:00,993 INFO The server IP list of Nacos is [192.168.3.138:3333, 192.168.3.138:4444, 192.168.3.138:5555]
+
+2021-11-09 16:27:07,318 INFO Nacos is starting...
+
+2021-11-09 16:27:08,325 INFO Nacos is starting...
+
+2021-11-09 16:27:09,340 INFO Nacos is starting...
+
+2021-11-09 16:27:10,343 INFO Nacos is starting...
+
+2021-11-09 16:27:10,742 INFO Nacos started successfully in cluster mode. use external storage
+````
+7\. ����Ⱥ�е����� Nacos Server �������ɹ���˫�� Nignx ��װĿ¼�µ� nginx.exe������ Nginx��
+
+![Nginx ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10225BO0-12.png)
+ͼ13��Nginx �����ű�
+
+8\. ʹ����������ʡ�http://localhost:1111/nacos/�������ɹ����� Nacos Server �Ŀ���̨����˵�� Nacos ��Ⱥ����ɹ�������ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10225C554-13.png)
+ͼ14��Nacos ��Ⱥ
+
+9\. �������� spring-cloud-alibaba-demo ��������ģ�������ļ��е� Nacos Server ��ַͳһ�޸�Ϊ��localhost:1111�������� spring-cloud-alibaba-consumer-nacos-8801 Ϊ���������ļ� application.yml �������������¡�
+
+
+
+
+````
+server:
+  port: 8801  #�˿ں�
+spring:
+  application:
+    name: spring-cloud-alibaba-consumer #������
+  cloud:
+    nacos:
+      discovery:
+        #server-addr: localhost:8848  #������ Nacos Server �ĵ�ַ
+        server-addr: localhost:1111  #��Ⱥ�� Nacos Server �ĵ�ַ
+````
+
+#����������Ϣ������Ĭ�����ã����������Զ�������ã�Ŀ���Dz��� Controller ��Ӳ��������ṩ�ߵķ�����
+````
+service-url:
+  nacos-user-service: http://spring-cloud-alibaba-provider #�����ṩ�ߵķ�����
+````
+
+
+
+
+10\. ���� spring-cloud-alibaba-consumer-nacos-8801����ʹ����������ʡ�http://localhost:1111/nacos�����鿴������������µġ������б������������ͼ��
+
+[![Nacos ��Ⱥ 2](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10225A913-14.png)](http://new-local.weixueyuan.net/uploads/allimg/211109/6-2111091H412N8.png)
+ͼ15������ע�ᵽ Nacos Server ��Ⱥ��
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaRocketMQ.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaRocketMQ.md"
new file mode 100644
index 0000000..6cb2d45
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaRocketMQ.md"
@@ -0,0 +1,243 @@
+1. RocketMQ ���
+
+RocketMQ �ǰ���ͰͿ�Դ�ķֲ�ʽ��Ϣ�м����֧��������Ϣ��˳����Ϣ��������Ϣ����ʱ��Ϣ����Ϣ���ݵȡ��������м��������ڱ�׼��Ϣ�м���ĸ����Group��Topic��Queue�ȡ�ϵͳ�������Producer��Consumer��Broker��NameServer�ȡ�
+
+RocketMQ �ص�
+
+- ֧�ַ���/���ģ�Pub/Sub���͵�Ե㣨P2P����Ϣģ�ͣ�
+- ��һ�������пɿ����Ƚ��ȳ���FIFO�����ϸ��˳�򴫵ݣ�RocketMQ ���Ա�֤�ϸ����Ϣ˳�򣬶�ActiveMQ �޷���֤��
+- ֧������Pull�����ƣ�Push��������Ϣģʽ��Push �����⣬�����������߶����� Listener �ص����� Pull������Ȩ����Ӧ�ã���Ӧ����Ҫ�����ĵ�������Ϣ������ Broker ��ȡ��Ϣ�����������һ������λ�ü�¼�����⣨�������¼���ᵼ����Ϣ�ظ����ѣ���
+- ��һ���а�����Ϣ�Ķѻ�������RocketMQ �ṩ�ڼ���Ϣ�Ķѻ��������ⲻ���ص㣬�ص��Ƕѻ����ڼ�����Ϣ����Ȼ����д����ӳ٣�
+- ֧�ֶ�����ϢЭ�飬�� JMS��MQTT �ȣ�
+- �ֲ�ʽ�߿��õIJ���ܹ�����������һ����Ϣ�������壻RocketMQ ԭ������֧�ֲַ�ʽ�ģ���ActiveMQ ԭ�����ڵ����ԣ�
+- �ṩ docker �������ڸ�����Ժ��Ƽ�Ⱥ����
+- �ṩ���á�ָ��ͼ�صȹ��ܷḻ�� Dashboard��
+
+Broker
+
+Broker ��ʵ���� RocketMQ ������������洢��Ϣ��ת����Ϣ��Broker �� RocketMQ ϵͳ�и�����մ������߷���������Ϣ���洢��ͬʱΪ�����ߵ���ȡ������׼����Broker Ҳ�洢��Ϣ��ص�Ԫ���ݣ������������顢���ѽ���ƫ�ƺ�����Ͷ�����Ϣ�ȡ�
+
+Broker Server �� RocketMQ ������ҵ����ģ������˶����Ҫ����ģ�飺
+
+- ·��ģ�飺���� Broker ��ʵ�壬���������� clients �˵�����
+- �ͻ��˹�������������ͻ���(Producer/Consumer)��ά�� Consumer �� Topic ������Ϣ
+- �洢�����ṩ����򵥵� API �ӿڴ�����Ϣ�洢������Ӳ�̺Ͳ�ѯ���ܡ�
+- �߿��÷��񣺸߿��÷����ṩ Master Broker �� Slave Broker ֮�������ͬ�����ܡ�
+- ��Ϣ�������񣺸����ض��� Message key ��Ͷ�ݵ� Broker ����Ϣ���������������ṩ��Ϣ�Ŀ��ٲ�ѯ��
+
+NameServer
+
+NameServer ��һ���dz��򵥵� Topic ·��ע�����ģ����ɫ���� Dubbo �е� zookeeper��֧�� Broker �Ķ�̬ע���뷢�֡�
+
+��Ҫ�����������ܣ�
+
+- Broker ������NameServer ���� Broker ��Ⱥ��ע����Ϣ���ұ���������Ϊ·����Ϣ�Ļ������ݡ�Ȼ���ṩ���������ƣ���� Broker �Ƿ񻹴�
+- ·����Ϣ�������� Producer �� Consumer �ṩ�����ȡ Broker �б���ÿ�� NameServer ��������� Broker ��Ⱥ������·����Ϣ�����ڿͻ��˲�ѯ�Ķ�����Ϣ��Ȼ�� Producer �� Conumser ͨ�� NameServer �Ϳ���֪������ Broker ��Ⱥ��·����Ϣ���Ӷ�������Ϣ��Ͷ�ݺ����ѡ�
+
+2. ʹ�� Docker ���ٴ RocketMQ 4.4
+
+rocketmq ��Ҫ���� broker �� nameserver �����ǵ��ֿ�����Ƚ��鷳�����ｫ��ʹ�� docker-compose�����⣬����Ҫ�һ�� web ���ӻ�����̨�����Լ�� mq ����״̬���Լ���Ϣ�������������ʹ�� rocketmq-console��ͬ���ó���Ҳ��ʹ�� docker ��װ��
+
+1. �� linux ��������ѡ�񲢽���Ŀ¼��
+
+   mkdir rocketmq-docker
+   ���ƴ���
+
+1. ���� rocketmq-docker Ŀ¼������һ����Ϊ broker.conf �������ļ����������£�
+
+   # ������Ⱥ���ƣ�����ڵ�϶�������ö��
+   brokerClusterName = DefaultCluster
+   # broker���ƣ�master��slaveʹ����ͬ�����ƣ��������ǵ����ӹ�ϵ
+   brokerName = broker-a
+   # 0��ʾMaster������0��ʾ��ͬ��slave
+   brokerId = 0
+   # ��ʾ��������Ϣɾ��������Ĭ�����賿4��
+   deleteWhen = 04
+   # �ڴ����ϱ�����Ϣ��ʱ������λ��Сʱ
+   fileReservedTime = 48
+   # ������ֵ��SYNC_MASTER��ASYNC_MASTER��SLAVE��ͬ�����첽��ʾMaster��Slave֮��ͬ�����ݵĻ��ƣ�
+   brokerRole = ASYNC_MASTER
+   # ˢ�̲��ԣ�ȡֵΪ��ASYNC_FLUSH��SYNC_FLUSH��ʾͬ��ˢ�̺��첽ˢ�̣�SYNC_FLUSH��Ϣд����̺�ŷ��سɹ�״̬��ASYNC_FLUSH����Ҫ��
+   flushDiskType = ASYNC_FLUSH
+   # ����broker�ڵ����ڷ�������ip��ַ
+   # brokerIP1 = 192.168.138.131
+   ���ƴ���
+
+ע�⣺����� brokerIP1 ��������ã�����Ĭ�ϻ��Ϊ docker �����ڲ�IP�����������Ӳ��ϡ�
+
+1. ������ rocketmq-docker Ŀ¼������һ����Ϊ rocketmq.yaml �Ľű��ļ���
+
+
+
+rocketmq.yaml ��������:
+
+    version: '2'
+    services:
+      namesrv:
+        image: rocketmqinc/rocketmq
+        container_name: rmqnamesrv
+        ports:
+          - 9876:9876
+        volumes:
+          - /docker/rocketmq/data/namesrv/logs:/home/rocketmq/logs
+          - /docker/rocketmq/data/namesrv/store:/home/rocketmq/store
+        command: sh mqnamesrv
+      broker:
+        image: rocketmqinc/rocketmq
+        container_name: rmqbroker
+        ports:
+          - 10909:10909
+          - 10911:10911
+          - 10912:10912
+        volumes:
+          - /docker/rocketmq/data/broker/logs:/home/rocketmq/logs
+          - /docker/rocketmq/data/broker/store:/home/rocketmq/store
+          - /docker/rocketmq/conf/broker.conf:/opt/rocketmq-4.4.0/conf/broker.conf
+        command: sh mqbroker -n namesrv:9876 -c /opt/rocketmq-4.4.0/conf/broker.conf
+        depends_on:
+          - namesrv
+        environment:
+          - JAVA_HOME=/usr/lib/jvm/jre
+      console:
+        image: styletang/rocketmq-console-ng
+        container_name: rocketmq-console-ng
+        ports:
+          - 8087:8080
+        depends_on:
+          - namesrv
+        environment:
+          - JAVA_OPTS= -Dlogging.level.root=info   -Drocketmq.namesrv.addr=rmqnamesrv:9876 
+          - Dcom.rocketmq.sendMessageWithVIPChannel=false
+    ���ƴ���
+
+1. ���� broker �õ��ķ���ǽ�˿ڣ��������ʹ�ã�
+
+   firewall-cmd --zone=public --add-port=10909-10912/tcp --permanent
+   ���ƴ���
+
+1. ִ�� sentinel-dashboard.yaml �ű�����������
+
+   docker-compose -f rocketmq.yaml up
+   ���ƴ���
+
+1. ���� rocketmq ����̨�����ǻᷢ�����Ƶ�ͼ������Ȼ��ʼ�϶��ǿյģ���
+
+   http://(��װRocketMQ������IP):8087
+   ���ƴ���
+
+
+
+1. ����ѡ�� ����Ⱥ�� ��һ����������ܿ����������õ� broker ������IP�ˣ�
+
+
+
+�����������������Ѿ���� RocketMQ ����˵IJ������ھͿ���ȥ Spring ��Ŀ��ʹ�ÿͻ����ˡ�
+
+3. �� Spring ��Ŀ������ RocketMQ �ͻ���
+
+1. ���� pom �ļ�������
+
+            <dependency>
+                <groupId>org.apache.rocketmq</groupId>
+                rocketmq-spring-boot-starter
+                <version>2.0.4</version>
+            </dependency>
+   ���ƴ���
+
+1. �� application.yml �������ã�
+
+   server:
+   port: 10801
+
+   spring:
+   application:
+   name: (��Ŀ����)-service
+
+   rocketmq:
+   name-server: (��װRocketMQ������IP):9876
+   producer:
+   group: (��Ŀ����)-group
+   ���ƴ���
+
+1. �½�һ����Ϣ������ MessageProducer ��Ϊ��Ϣ�� �����ߣ�
+
+   @Service
+   public class MessageProducer implements CommandLineRunner {
+
+        @Resource
+        private RocketMQTemplate rocketMQTemplate;
+    
+        @Override
+        public void run(String... args) throws Exception {
+            rocketMQTemplate.send("test-topic-1", MessageBuilder.withPayload("Hello, World! I'm from spring message").build());
+        }
+
+   }
+   ���ƴ���
+
+1. �½�һ����Ϣ������ MessageListener ��Ϊ��Ϣ�� �����ߣ�
+
+   @Slf4j
+   @Service
+   @RocketMQMessageListener(topic = "test-topic-1", consumerGroup = "my-consumer_test-topic-1")
+   public class MessageListener implements RocketMQListener<String> {
+
+        @Override
+        public void onMessage(String message) {
+            log.info("received message: {}", message);
+        }
+
+   }
+   ���ƴ���
+
+1. �½�һ�� MessageProducer �ĵ��ÿ������ࣺ
+
+   @RestController
+   @RequestMapping
+   public class HelloController {
+
+        @Resource
+        private MessageProducer messageProducer;
+    
+        @RequestMapping("/message")
+        public void message() throws Exception {
+            messageProducer.run("");
+        }
+   ���ƴ���
+
+1. ���� Spring ��Ŀ������������һ����򵥵���Ϣ����:
+
+   GET http://localhost:10801/message
+   Accept: */*
+   Cache-Control: no-cache
+   ���ƴ���
+
+
+
+����Ҳ���� RocketMQ �Ĺ�������̨�����¿�����Ϣ�����������
+
+
+
+ʵս�������ﲢû�н���һЩ������ܴ�һ��е㷸�Ժ���
+
+Topic�����⣩�൱��һ�����͵���Ϣ������������� Topic1 ר���Ƿ�����ҵ�� Topic2 ר�����Ż�ȯ��ҵ�񣻶� Group�����飩�൱�ڶ������ߺ������ߵķ��飬�����ǵ�΢���������������Ҳ���������ߣ������������ Group1 ����Ʒ��΢����Group2 �Ƕ�����΢���񣬵�Ȼ��Ҫ�������������߷��黹�������߷��顣
+
+- Group����ΪProducerGroup �� ConsumerGroup, ����ijһ��������ߺ������ߣ�һ����˵ͬһ�����������Ϊ Group��ͬһ�� Group һ����˵���ͺ����ѵ���Ϣ����һ���ġ�
+- Topic����Ϣ���⣬һ����Ϣ���ͣ����������䷢����Ϣ�������߶�ȡ����Ϣ��
+- Queue: ��Ϊ����д���ֶ��У�һ����˵��д��������һ�£������һ�¾ͻ���ֺܶ����⡣
+
+Topic ���з�Ϊ�˶�� Queue������ʵ�����Ƿ���/��ȡ��Ϣͨ������С��λ�����Ƿ�����Ϣ����Ҫָ��ij��д��ij�� Queue����ȡ��Ϣ��ʱ��Ҳ��Ҫָ����ȡij�� Queue���������ǵ�˳����Ϣ���Ի������ǵ� Queue ά�ȱ��ֶ����������������ȫ��������ô��Ҫ�� Queue ��С����Ϊ1���������е����ݶ����� Queue ������
+
+
+
+���ߣ��ײ�˵����
+���ӣ�https://juejin.cn/post/6930869079217717256
+��Դ��ϡ�����
+����Ȩ���������С���ҵת������ϵ���߻����Ȩ������ҵת����ע��������
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaSeata.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaSeata.md"
new file mode 100644
index 0000000..1264b0e
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaSeata.md"
@@ -0,0 +1,1075 @@
+## ���
+
+���Ƕ�֪�� Seata ��һ���ֲ�ʽ����Ľ���������������Ǿ���������˽�һ��ʲô�Ƿֲ�ʽ�����������������˽�һ�»�����֪ʶ�����������������˽�һ������ĸ�����ʲô��
+
+### ��������
+
+�����IJ��ֹ��ɡ� ACID��
+
+*   A(Atomic)��ԭ���ԣ�������������в�����Ҫôȫ��ִ�гɹ���Ҫôȫ��ִ��ʧ�ܣ�������ֲ��ֳɹ����߲���ʧ�ܵ������
+*   C(Consistency)��һ���ԣ�������ִ��ǰ�����ݿ��һ����Լ��û�б��ƻ������磬С��ȥ����ȡ100��Ǯ��ȡ֮ǰ��600��ȡ֮��Ӧ����400��ȡ֮ǰ��ȡ֮�������Ϊ��ȷ��ֵΪһ���ԣ����ȡ��100�������������Ǯû�м��٣�ҪôС��ҪЦ���ˣ������û�дﵽһ���Ե�Ҫ��
+*   I(Isolation):�����ԣ����ݿ��е�����һ�㶼�Dz����ģ���������ֻ�ڲ�������������ִ�й��̻������ţ�һ��������ִ�й����в��ܿ��������������й��̵��м�״̬��ͨ������������뼶����Ա���������ظ��������⡣
+*   D(Durability)���־��ԣ����������֮����������ݵĸ��Ļᱻ�־û������ݿ⣬�Ҳ���ع���
+
+�����Ϊ�����֣���������ͷֲ�ʽ����
+
+#### ��������
+
+�ڼ����ϵͳ�У��Ƚ϶����ͨ����ϵ�����ݿ����������������������ݿⱾ�����������Խ���ʵ�ֵģ���ΪӦ����Ҫ����ϵ�����ݿ���ά�����񣬼������ݿ��Ӧ�ö���ͬһ�������������Ի��ڹ�ϵ�����ݵ������ֱ���Ϊ��������
+
+#### �ֲ�ʽ����
+
+�ֲ�ʽ������ָ����IJ����ߡ�֧������ķ���������Դ�������Լ���������߷ֱ�λ�ڲ�ͬ�ķֲ�ʽϵͳ�IJ�ͬ�ڵ�֮�ϣ������ڲ�ͬ��Ӧ�ã��ֲ�ʽ������Ҫ��֤��Щ����Ҫôȫ���ɹ���Ҫôȫ��ʧ�ܣ��ֲ�ʽ�������Ϊ�˱�֤�ڲ�ͬ�����������ݿ����ݵ�һ���ԡ�
+
+Seata �����˼·�ǽ�����������ı����������һ��ȫ�������������ɸ��������񣬶�������ACID������γ�һ�����ķֲ�ʽ���񣬲����ֲ�ʽ��������Dz�����������һ����
+
+�ֲ�ʽϵͳ���һ��Ӧ�ò��Ϊ����ɶ�������ķ��񣬷����ڷ���֮��ͨ����ҪԶ��Э�������������IJ��������ֲַ�ʽϵͳ���������ڲ�ͬ�ķ���֮��ͨ������Զ��Э����ɵ����񱻳�Ϊ�ֲ�ʽ�������繩Ӧ��ϵͳ�У��������������ɶ������ۼ���桢��Լ֪ͨ�������ȡ�
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/6471b8f38c5920f6ace85580abd1567bc0f021.png "ͼƬ")
+
+����ͼ�����ǿ��Կ�����ֻҪ�漰�������������Դ���ͻ������������⣬������ʵ�ʿ�����Ӧ��Ҫ���������������ij��֣�������Ȼϵͳ����չ��Ӧ�ú�Ӧ��֮���Ȼ�����Ӧ��֮������ķ��룬��΢����ܹ��У���Ҫ��MQ��Seata�����˽�����֮ǰ�����������˽�һ�·ֲ�ʽ������������ɣ��Լ����ʵ�ֵġ�
+
+## �ֲ�ʽ����
+
+#### �ֲ�ʽ������ʲô��
+
+�ֲ�ʽ����ָ��������IJ����ߣ�֧������ķ���������Դ�������ֱ�λ�ڷֲ�ʽϵͳ�IJ�ͬ�ڵ�֮�ϣ�ͨ��һ���ֲ�ʽ�����л��漰���Զ������Դ��ҵ��ϵͳ�IJ�����
+
+���Ż������ķ�չ����֮ǰ�ĵ�һ��Ŀ����ֲ�ʽ������ת���������΢�����ڸ�����˾�Ѿ��ձ���ڣ�����ʱ�ı��������Ѿ��޷�����ֲ�ʽӦ�õ�Ҫ����˷ֲ�ʽ����֮�������Э���Ͳ��������⣬��������������֮������IJ������ܹ��񱾵�����һ����ѭACIDԭ�򣬳�Ϊһ�����⣬�����ڴ�ţ�Dz��ϵ�̽���£������ҵ��˷ֲ�ʽ������������������ݣ�CAP���ɺ�BASE���ۡ�
+
+### CAP����
+
+CAP������һ����(C)��������(A)�������ݴ���(P)��ɣ��ڷֲ�ʽϵͳ�У�������ͬʱ����Consistency(һ����)/Availability(������)/Partition tolerance(�����ݴ���) �������ԣ����ֻ��ͬʱ�����������
+
+*   һ����(C)���ڷֲ�ʽϵͳ�����е����ݱ��ݣ���ͬһʱ�̱���һ�µ����ԣ����е�Ӧ�ýڵ���ʵĶ���ͬһ�����µ����ݸ�����
+*   ������(A): ����Ⱥ��һ���ֽڵ�����Ժ󣬼�Ⱥ�����ܹ���Ӧ�ͻ��˵Ķ�д���󣬶����ݸ��¾߱��߿����ԡ�
+*   �����ݴ���(P): ���ϵͳ�ڹ涨ʱ�������ڲ��ܴ�����ݵ�һ���ԣ��ͱ�ʾҪ�����������������ǰ������Ҫ��C��A֮������ѡ����ϵͳ�ܹ�������������ϵ������ʱ����Ȼ�ܹ���֤�����ṩ����һ���Ի��߿����Եķ���
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/a5ec7fb950052bd1116452eb0ca9f52fd4e5a5.png "ͼƬ")
+
+����ͼ�����ǿ��Կ������������û�ȥ���ﳵ�������µ������ʱ�����Ȼᾭ�����ǿ������жϿ���Ƿ��㹻����������㣬�ۼ�����Ժ�������Ҫ������ͬ���������������ϣ���һ����Ϊ�˱�֤���ݵĽ����һ���ԣ����ʱ�����������������ˣ����ǵ�ϵͳ��Ҫ��֤�����ݴ��ԣ�Ҳ�������DZ�������������������һЩ���⣬��ʱ�뱣֤һ���ԣ�����Ҫ���������ԡ�
+
+�������Ϊ�˱�֤�߿����ԣ���ô�ڸ߲���������£����޷���֤���޶�ʱ���ڸ�����Ӧ����������IJ��ɿ������ǵĶ�����������޷��õ����µ����ݣ���������Ҫ���û�������Ӧ����ôҲ�޷���֤һ���ԣ�����AP���޷���֤ǿһ���Եġ�
+
+�������Ҫ��֤�߿�������Ҫ��֤һ���ԣ��������������õ�����²���ʵ�֣���ô�������ֻ��һ�����Ǿ�����Ҫ����桢��������Լ�ŵ�һ�𣬵����������ȥ������΢��������ã�Ҳ�Ͳ����Ƿֲ�ʽϵͳ�ˡ�
+
+�ڷֲ�ʽϵͳ�У������ݴ����DZ�����ڵģ�����ֻ����һ���ԺͿ�������ȡ�ᣬ�����������¾͵�����BASE���ۡ�
+
+### BASE����
+
+BASE�� �������� (Basically Available)����״̬ (Soft state)�� ����һ���� (Eventually consistent) �����������ɣ��Ƕ�CAP��һ���ԺͿ�����Ȩ��Ľ������Դ�ڶԻ�����ϵͳ�ֲ�ʽʵ�����ܽᣬ�ǻ���CAP�������ݻ������ģ�������ϵ�Ǹ��Ǽ�ʱ�޷�����ǿһ���ԣ�����ÿ��Ӧ�ö����Ը���������ҵ���ص㣬�����ʵ��ķ�ʽ��ʹϵͳ�ﵽ����һ���ԡ�
+
+1.  �������ã�����������ָ���ֲ�ʽϵͳ���ֲ���Ԥ֪���ϵ�ʱ��������ʧ���ֿ����ԣ��������ﲢ����˵��ʾϵͳ�������ã���Ҫ����Ϊ���¼���:
+
+*   ��Ӧʱ���ϵ���ʧ������������£�һ����������������Ҫ��0.5��֮�ڷ��ظ��û���Ӧ�IJ�ѯ������������ڳ��ֹ��ϣ���ѯ�������Ӧʱ��������1-2�롣
+*   ϵͳ�����ϵ���ʧ������������£�һ������������վ�Ͻ��й�������߼����ܹ�˳�������ÿһ��������������һЩ���մ��������߷��ڵ�ʱ��������վ�Ϲ�������������Ϊ�˱�֤ϵͳ���ȶ��ԣ����������߿��ܻ�������һ����ʱ����������ҳ�������ʾ��
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/a7dac0d93bc82c6c6c7076b77061ed1ebed415.png "ͼƬ")
+
+�������õ���˼�ǣ��������ǵĺ��ķ����ǿ���ʹ�õģ������ķ�������ʵ��Ľ�����Ӧʱ�䣬�����ǽ��з��񽵼��������ڵ�ǰ�У����Ͷ����϶��Ǻ��ķ����������ǵķ���ϵͳ�ڵ�ʱֻҪ��֤�������þ��У�����ͬ��������һ������ӳٸ��ߣ��ȴ������߷��ȥ�Ժ��ڽ��лָ���
+
+1.  ��״̬����״̬��ָ����ϵͳ�е����ݴ����м�״̬������Ϊ���м�״̬�Ĵ��ڲ���Ӱ��ϵͳ����������ԣ�������ϵͳ���ýڵ�����ݸ���֮���������ͬ���Ĺ��̴�����ʱ��
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/610c63492ee5e0f1d30493958b54430c85a9f3.png "ͼƬ")
+
+��״̬����˼��˵�������Ǵ����µ���ʱ�򣬿ۼ����ʱ���������������ʱ������������ʵ������߶����У����ܻὫϵͳŪ�壬������������ǿ����������ݵ�ͬ�������ӳ٣���Ӱ������ϵͳ��ʹ�á�
+
+1.  ����һ���ԣ�����һ����ǿ�������������ݸ������ھ���һ��ʱ���ͬ��֮�����ն��ܹ��ﵽһ��һ�µ�״̬����ˣ�����һ���Եı�������Ҫϵͳ��֤���������ܹ��ﵽһ�£���������Ҫʵʱ��֤ϵͳ��ǿһ���ԡ�
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/a23602e9776d2c7bd3d507582538c32a471c8c.png "ͼƬ")
+
+���������߷����Ժ󣬾���һ��ʱ���ͬ�������м�״̬�������������һ���ԣ���֤�����������ݵ�һ���ԡ�
+
+### ���׶��ύ(2PC)
+
+2PC�����׶��ύЭ�飬�ǽ������������̷�Ϊ�����׶Σ�P��ָ׼���׶Σ�C��ָ�ύ�׶Ρ�
+
+�ͺñ�����ȥKCC�����ܳԣ��Ǹպ��л���ڶ�����ۣ���������һ���ˣ����ʱ��պ��и�С�����������ڿ����������ܳԣ����ʱ������������AA��Ҳ�ͻ�˵ֻ�е��������ͬ���������ʱ�򣬲��ܹ��򵽣��������������һ����ͬ����ô�Ͳ������������ܳԡ�
+
+**�׶�һ��**׼���׶� �ϰ�Ҫ�����Ƚ��и����ͬ�⸶����ɺ���Ҫ��Ů�����Ů��ͬ�⸶����ɡ�
+
+**�׶ζ���**�ύ�׶� ��������ɣ��ϰ���ͣ������˶��Ե�����ܡ�
+
+������Ӿ������һ�����������Ů˫����һ���˾ܾ������ô�ϰ�Ͳ�����ͣ����һ������ȡ��Ǯԭ·�˻ء�
+
+�������������������������Ͳ�������ɵģ����ϰ�������������������Ǹ�Ů�����Dz����ߣ�������������������ֲ�ʽ�����ڼ�����й�ϵ����֧�����׶��ύЭ�飺
+
+*   ׼���׶�(Prepare phase)�������������ÿ�������߷���Prepare ��Ϣ��ÿ�����ݿ�������ڱ���ִ�����񣬲�д���ص�Undo/Redo ��־����ʱ����û���ύ��
+
+> undo��־�Ǽ�¼�޸�ǰ�����ݣ��������ݿ�ع���
+>
+> Redo ��־�Ǽ�¼�޸ĺ�����ݣ������ύ����д�������ļ���
+
+*   �ύ�׶�(commit phase)���������������յ��˲����ߵ�ִ��ʧ�ܻ��߳�ʱ��Ϣʱ��ֱ�Ӹ�ÿ�������߷���(Rollback) ��Ϣ������յ������߶��ɹ�������(Commit) �����߸��������������ָ��ִ���ύ���߻ع����������ͷ�������������ʹ�õ���Դ��
+
+#### �ɹ��ύ��
+
+��������������в����߷����������ݣ�ѯ���Ƿ�׼�����ˣ��ȴ������ߵ���Ӧ����������������ڵ�ִ��������������� Undo��Redo ��Ϣ����������־�С���������߳ɹ�ִ������������������������YES��������ʾ�������ִ�У�����Э���ߴ����еIJ����߻�÷�������Yes��Ӧ����ô�ͻ�ִ�������ύ��
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/48e1a2907174a1ed035541e548755d39490441.png "ͼƬ")
+
+#### ʧ�ܣ�
+
+�����κ�һ�������������������������Noָ����ߵȴ���ʱ֮������������޷����յ����в����ߵķ�����Ӧ����ô�ж����񣬷��ͻع�������������������в����߽ڵ㷢�� RollBack ���󣬲����߽��յ� RollBack ����󣬻������ڽ׶�һ��¼��Undo��Ϣִ������Ļع�����������ɻع�֮���ͷ�����ִ���ڼ�ռ�õ���Դ�����������������ع�֮����Э���߷���ACK��Ϣ������������ڽ��ܵ����в����߷�����ACK��Ϣ֮����������жϡ�
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/0928e8933a69a75eff4968f6989ca78ceaeb47.png "ͼƬ")
+
+### ���׶��ύ(3PC)
+
+3PC ��Ҫ��Ϊ�˽�����׶��ύЭ��ĵ�������������С������������Χ���Ƕ��׶��ύ��2PC���ĸĽ��汾���������ڵ�ij�ʱ����֮�⣬3PC��2PC��׼���׶ηֳ�����ѯ�ʣ��ý׶β���������������Ԥ�ύ,�������׶ηֱ�Ϊ CanCommit��PreCommit��DoCommit��
+
+#### CanCommit ѯ��״̬
+
+CanCommit�׶� Э����(Coordinator)���������(Participant) ����CanCommit��Ϣ��ѯ���Ƿ����ִ�в������������յ���Ϣ�󣬱�ʾ�ܹ�ִ�У��᷵�ظ�Э�����ܹ�ִ�е�(yes)���
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/c9cc9e8959b9a5393cb59672bc05a9121825ff.png "ͼƬ")
+
+��������߲���ִ�У��᷵��No����,�ͷ���Դ����������
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/61bf61d800a42fb1583689ccbc1b1e862fec29.png "ͼƬ")
+
+#### PreCommit Ԥ�ύ
+
+PreCommit �׶����Э�����յ������߷��ص�״ֵ̬ΪYES����ô��֤�����Ƕ�������ȥִ�������������ôЭ���߾ͻ������в����� ���� PreCommit ��Ϣ��Э�����յ� PreCommit��Ϣ�󣬻�ȥִ�б����������ִ�гɹ��Ὣ�������񱣴浽 undo��redo ���ٷ��ظ�Э����YESָ����ִ�б�������ʧ�ܣ�����Э����No,ֻҪЭ�����յ�һ��ִ��ʧ�ܣ������в����߷����ж�������Ϣ���������յ���Ϣ�󣬶�������лع�������
+
+������׶β����ߺ�Э���߶������˳�ʱ���ƣ����������û���յ���Э���ߵ���Ϣ������Э����û���յ������߷��ص�Ԥִ�н��״̬���ڵȴ���ʱ֮��������жϣ������������������
+
+Э����������߷���PreCommit�����������ִ�гɹ�������yes![ͼƬ](https://s2.51cto.com/oss/202206/18/91b004f982c531b8a641821cf1a49be547f9b3.gif "ͼƬ")��
+
+���������ִ��ʧ�ܣ�ֻ����һ������No��Э���ߣ�Э���߻�������߷����ж��������Ϣ�������߻ع�����
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/996ca048361577f6ba066998a6b3ed9ac0450b.png "ͼƬ")
+
+#### DoCommit �ύ
+
+Э�����յ����в����߷��ص�״̬����YES����ʱЭ���߻������еIJ����߶����� DoCommit ���������յ� DoCommit �󣬻��������ύ���񣬵������ύ�ɹ��󣬷���Э����YES״̬����ʾ���Ѿ����������ύ�ˣ�Э�����յ����в����߶�����YES״̬����ô������˱�������
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/f4ab1eb14668202d8be313dc1b754833689c37.png "ͼƬ")
+
+���ij�������߷���No��Ϣ��Э���߷����ж�������Ϣ(abort)�����������ǣ������߻ع�����
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/42ab62f59f9e71c66f7213a6833c2c7e436193.png "ͼƬ")
+
+3PC��2PC�������棬�����˳�ʱ���ƣ�����˵����������������������⣬����3PC��Ȼ���ܽ������һ���Ե����⣬��Ϊ��DoCommit�׶Σ��������������߳�ʱ��ԭ���²������ղ���Э���߷��͹����� �ж�������Ϣ(abort) ���������ʱ��󣬲����߻��ύ���񣬱�����Ӧ�ý��лع����ύ����󣬻ᵼ�����ݲ�һ�µ�������֣�2PC��Ȼ�������������´���ǿһ���Ա��ƻ������⣬���ǹ��ϻָ��Ժ��ܱ�֤����һ���ԣ�3PC��Ȼ�г�ʱʱ�䣬���������������˿����ԣ�����������һ���ԣ����������粨�����⵼������������һ���ϣ�2PC������3PC�ġ�
+
+## Seata
+
+������https://seata.io/zh-cn/docs/overview/what-is-seata.html��
+
+Seata ��һ�Դ�ķֲ�ʽ�������������������ṩ�����ܺͼ����õķֲ�ʽ�������Seata ��Ϊ�û��ṩ�� AT��TCC��SAGA �� XA ����ģʽ��Ϊ�û�����һվʽ�ķֲ�ʽ���������
+
+![ͼƬ](https://s6.51cto.com/oss/202206/18/22906d30493df9861728958921200a254ef5d5.gif "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/e335a42151fa17eb25e848defd449317e036d3.png "ͼƬ")
+
+��΢����ϵͳ�У�һ��ҵ��ᱻ��ֳɶ�����ģ�飬�ڹٷ��ṩ�Ľṹͼ�У����ǿ��Կ�����ǰ��Ҫ��Ϊ����ģ�顣
+
+*   �����񣺶�����Ʒ�����Ϣ�������ӻ��߼��ٲ�����
+*   �������񣺸����û�ָ����Ʒ���ɶ�����
+*   �˻����񣺴��û��˻��п۳������ӻ��֣�ά����ַ��Ϣ�ȵȡ�
+
+�ڵ�ǰ�ܹ��У��û���ѡ���ǵ���Ʒ�µ�����Ҫ������������ɲ�����ÿһ��������ڲ���ӵ��һ�������ı�����������֤��ǰ�������ݵ�ǿһ���ԣ���������������ɵ�ȫ������һ���Ծ�û�취���б�֤����ôSeata����������������ġ�
+
+### Seata����
+
+������ַ��https://seata.io/zh-cn/docs/overview/terminology.html��
+
+���˽�Seata֮ǰ�����������˽�һ�� Seata �����ؼ��ĸ��
+
+1.  TC(Transaction Coordinator)����Э���ߣ�ά��ȫ�ֺͷ�֧�����״̬������ȫ�������ύ���߻ع���
+2.  TM(Transaction Manager) ��������ߣ� �����ߣ�ͬʱһ��RM��һ�֣�����ȫ������ķ�Χ����ʼȫ�������ύ��ع�ȫ������
+3.  RM(Resource Manager) ��Դ��������  ���������΢���񣬹�����֧����������Դ����TC��̸��ע���֧����ͱ����֧�����״̬����������֧�����ύ��ع���
+
+### Seata 2PC
+
+**һ�׶Σ�** ҵ�����ݺͻع���־��¼��ͬһ�������������ύ���ͷű�������������Դ��
+
+**���׶Σ�** �ύ�첽�����dz����ٵ���ɡ��ع�ͨ��һ�׶εĻع���־���з��򲹳���
+
+һ�׶α��������ύǰ����Ҫȷ�����õ� ȫ���� ���ò���ȫ���� �������ύ����������ȫ�����ij��Ա�������һ����Χ�ڣ�������Χ�����������ع����������ͷű�������
+
+�����ݿⱾ��������뼶������ύ�����ϵĻ����ϣ�Seata��AT ģʽ����Ĭ��ȫ�ָ��뼶���� ��δ�ύ��
+
+���Ӧ�����ض������£�����Ҫ��ȫ�ֵ� �����ύ ��Ŀǰ Seata �ķ�ʽ��ͨ�� SELECT FOR UPDATE ���Ĵ�����
+
+Seataִ�����̷�����
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/c7e10e315ebb9d8effa798730cebde46ec741a.png "ͼƬ")
+
+ÿ��RM ʹ�� DataSourceProxy ��������·��Ŀ����ʹ�� ConnectionProxy ��ʹ������Դ�����ݴ�����Ŀ�����ڵ�һ�׶ν� undo��ҵ�����ݷ���һ�������������ύ�������ͱ�����ֻҪ��ҵ�������һ������dudo��־��
+
+�ڵ�һ�׶��У�undo����������޸�ǰ���޸ĵ�ֵ����Ϊ������ع�����׼�����ڵ�һ�׶���ɾ��Ѿ�����֧�����ύ�ˣ�Ҳ���ͷ�������Դ��
+
+TM����ȫ������ʼ����XIDȫ������ID���������������У�ͨ��feign���ý�XID�������η������У�ÿ����֧�����Լ��� Branch ID��֧����ID��XID���й�����
+
+�ڵڶ��׶�ȫ�������ύ��TC��֪ͨ������֧�������ύ��֧�����ڵ�һ�׶��Ѿ��ύ�˷�֧�����������������ֻ��Ҫɾ��undo���ɣ����ҿ����첽ִ�С�
+
+���ijһ����֧�����쳣�ˣ��ڶ��׶�ȫ������ع�������TC��֪ͨ������֧�����߻ع���֧����ͨ��XID��Branch-ID�ҵ���Ӧ�Ļع���־��ͨ���ع���־���ɵķ���SQLִ�У���ɷ�֧����ع���֮ǰ��״̬��
+
+### Seata ���ذ�װ
+
+���ص�ַ��https://github.com/seata/seata/releases��
+
+![ͼƬ](https://s7.51cto.com/oss/202206/18/97b6c0b520c17b43b883003d10ef8e22d933a2.gif "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/019d53972f031fdf1767425abf92f907f0f1c8.png "ͼƬ")
+
+��ѹ���ҵ�confĿ¼��
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/88a3fa94605fb2567a64954540711876f4a6df.png "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/6998821822b0d8ed7a44318b8b3390bc421303.png "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/d157544494550bb1c865815e31ae990fbac40b.png "ͼƬ")
+
+����������seata֮ǰ������Ҫ����nacos����ʵҲ�ܼ򵥣�ֻ��Ҫ����nacos���������У���֪��nacos��ô�����Ŀ�����Ľ���nacos�������ܣ�������֮��������������seata��binĿ¼��seata-server.bat![ͼƬ](https://s5.51cto.com/oss/202206/18/b8605b968056145dc6c740b5c95f346a98eaae.gif "ͼƬ")��
+
+������ǿ���8091�˿��ڼ�����������nacos��������ע����ȥ�ˣ��ͱ�ʾ����seata�����ɹ��ˡ�
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/96829da176e4fcca80a0230d5c14b601ac549b.png "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/c253ebd69820f7d2daa259c97f27cdc70fd160.png "ͼƬ")
+
+## �ܽ�
+
+���������ǹ��ڷֲ�ʽ����ĺ�seata�Ľ��ܾͽ����ˣ���ʵ���ڷֲ�ʽ����MQʵ�ֿɿ���Ϣ����һ���ԣ�MQ��Ҫ������������ܣ�������������Ϣ���͵�ԭ�������⡣������뷽������Ϣ�Ŀɿ��ԡ�
+
+## ǰ��
+
+����һ�������ǽ����ˣ����ڷֲ�ʽ�����seata�Ļ������ܺ�ʹ�ã�����Ȥ��С�����Իع�һ��[������˵�㲻֪���ֲ�ʽ������!��](https://developer.51cto.com/article/711909.html) ���СũҲ˵�ˣ����ڻ������ҹ���Seata�й���seata��AT��TCC��SAGA �� XA ģʽ�Ľ��ܺ�ʹ�ã���������������Seata�зֲ�ʽ����ģ�͵Ľ��ܡ�
+
+Seata��Ϊ����ģ�飬�ֱ��� TM��RM �� TC��
+
+**TC (Transaction Coordinator) - ����Э���ߣ�**ά��ȫ�ֺͷ�֧�����״̬������ȫ�������ύ��ع���
+
+**TM (Transaction Manager) - �����������**����ȫ������ķ�Χ����ʼȫ�������ύ��ع�ȫ������
+
+**RM (Resource Manager) - ��Դ��������**������֧����������Դ����TC��̸��ע���֧����ͱ����֧�����״̬����������֧�����ύ��ع���
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/c1ba09f1965be00dd7b817c1942fccfa2d7d25.png "ͼƬ")
+
+�� Seata �У��ֲ�ʽ�����ִ�����̣�
+
+*   TM �����ֲ�ʽ����TM �� TC ע��ȫ�������¼����
+*   ��ҵ�񳡾����������ݿ⡢�������������Դ��RM �� TC �㱨��Դ׼��״̬ ����
+*   TM �����ֲ�ʽ��������һ�׶ν�����TM ֪ͨ TC �ύ/�ع��ֲ�ʽ���񣩡�
+*   TC ����������Ϣ�������ֲ�ʽ�������ύ���ǻع���
+*   TC ֪ͨ���� RM �ύ/�ع� ��Դ��������׶ν�����
+
+TM �� RM ����Ϊ Seata �Ŀͻ�����ҵ��ϵͳ������һ��TC ��Ϊ Seata �ķ���˶�������
+
+����˴洢ģʽ֧�����֣�
+
+**file��** ����ģʽ��ȫ������Ự��Ϣ�ڴ��ж�д���־û������ļ�root.data�����ܽϸߣ�Ĭ�ϣ���
+
+**DB:**  �߿���ģʽ��ȫ������Ự��Ϣͨ��DB������������ܲ�һЩ��
+
+**redis��** Seata-Server1.3�����ϰ汾֧�֣����ܽϸߣ�����������Ϣ��ʧ���գ���Ҫ���ʵ�ʳ���ʹ�á�
+
+### TC��������
+
+��������ʹ��DB�߿���ģʽ���ҵ�conf/file.conf�ļ���
+
+![ͼƬ](https://s9.51cto.com/oss/202207/03/84e02c1536f8c1431cc833b98958c1168f8658.gif "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/d9e1e2d06e2f4e53344238a2806fbc9bdbaf7b.png "ͼƬ")
+
+�޸������е���Ϣ���ҵ���Ӧ��db���ã��޸����е�jdbc���ӣ�Ҫע�������漰����������global_table��branch_table��lock_table����ͬʱ mysql5��mysql8�������Dz�һ���ġ�
+
+> mysql5��com.mysql.jdbc.Driver��
+>
+> mysql8��com.mysql.cj.jdbc.Driver��
+
+��������ַ��https://github.com/seata/seata/blob/develop/script/server/db/mysql.sql��
+
+**global_table��** ȫ���������ÿ����һ��ȫ��������󣬾ͻ��ڸñ��м�¼ȫ�������ID��
+
+**branch_table��** ��֧���������¼ÿһ����֧����� ID����֧����������ĸ����ݿ����Ϣ��
+
+**lock_table��** ȫ������
+
+���������ú��Ժ�����Seata������Ч��
+
+### Seata ���� Nacos
+
+Seata֧��ע�����Nacos���Լ�֧��Seata�������÷ŵ�Nacos�������ģ���Nacos��ͳһά������ �߿���ģʽ�¾���Ҫ���Nacos�����
+
+�����ҵ� conf/registry.conf���޸�registry��Ϣ��
+
+
+
+
+
+
+
+
+
+```
+registry {
+  # file ��nacos ��eureka��redis��zk��consul��etcd3��sofa
+  type = "nacos"
+  nacos {
+    application = "seata-server" # ���������Ҫ�Ϳͻ��˱���һ��
+    serverAddr = "127.0.0.1:8848"
+    group = "SEATA_GROUP"  # ���������Ҫ�Ϳͻ��˱���һ��
+    namespace = ""
+    cluster = "default"
+    username = "nacos"
+    password = "nacos"
+  }
+  config {
+  # file��nacos ��apollo��zk��consul��etcd3
+  type = "nacos"
+  nacos {
+    serverAddr = "127.0.0.1:8848"
+    namespace = ""
+    group = "SEATA_GROUP"
+    username = "nacos"
+    password = "nacos"
+    dataId = "seataServer.properties"
+  }
+  ......
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+�޸ĺú󣬽�seata�е�һЩ�����ϴ���Nacos�У���Ϊ������Ƚ϶࣬���Թٷ��ṩ��һ��config.txt��ֻ���ز����޸�����ijЩ�������ϴ���Nacos�м��ɡ�
+
+**���ص�ַ��**https://github.com/seata/seata/tree/develop/script/config-center��
+
+�޸������£�
+
+
+
+
+
+
+
+
+
+
+
+```
+service.vgroupMapping.mygroup=default # �������
+store.mode=db
+store.db.driverClassName=com.mysql.cj.jdbc.Driver
+store.db.url=jdbc:mysql://127.0.0.1:3306/seata?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
+store.db.user=root
+store.db.password=123456
+```
+
+
+
+
+
+
+
+
+
+
+
+�޸ĺ�����ļ��Ժ󣬰�����ļ��ŵ�seataĿ¼�£�
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/b42aeca797a2bcb8fb5791e836d0f6011e9848.png "ͼƬ")
+
+����Щ���ö����뵽Nacos�����У�Ҫ����һ���ű�������ִ�У��ٷ��Ѿ��ṩ�á�
+
+**��ַΪ��**https://github.com/seata/seata/blob/develop/script/config-center/nacos/nacos-config.sh��
+
+�½�һ��nacos-config.sh�ļ������ű����ݸ��ƽ�ȥ���޸�congfig.txt��·����
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/b876340233c7ac1623731359ea33164becafc1.png "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/f563db6014ec0cb7f5a13952c63552c916da05.png "ͼƬ")
+
+�����ļ��޸ĺú󣬴�git���ߣ���nacos-config.sh������ק�������м��ɻ���ʹ�����
+
+> sh nacos-config.sh -h 127.0.0.1 -p 8848 -g SEATA_GROUP -t 88b8f583-43f9-4272-bd46-78a9f89c56e8 -u nacos -w nacos��
+>
+> -h��nacos��ַ��
+>
+> -p���˿ڣ�Ĭ��8848��
+>
+> -g��seata�ķ����б��������ơ�
+>
+> -t��nacos�����ռ�id��
+>
+> -u��-w��nacos���û��������롣
+
+![ͼƬ](https://s3.51cto.com/oss/202207/03/b685868586971f9c3b1490e3fcf50041fc2f6b.gif "ͼƬ")![ͼƬ](https://s4.51cto.com/oss/202207/03/965180d92863b00defe5550f051ade40ac60e8.gif "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/764bfaf385a67b25f732035cde02cc76bbcd20.png "ͼƬ")
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/110a73f54f3f0e565cd21630cf0e0cf4b80ee2.png "ͼƬ")
+
+�������ĸ�ִ��ʧ�ܣ�����Ϊredis�����Ĺ�ϵ��������Ժ��ԣ���Ӱ������ʹ�á������Կ�����Nacos���кܶ�������˵������ɹ�������������seata���ɹ�������8091�˿ڣ���ʾǰ�ù������Ѿ�׼����ɡ�
+
+![ͼƬ](https://s7.51cto.com/oss/202207/03/573560212aa718ea82c317737eefc492908086.gif "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/f71535950882c017bbd05116c54c16ccb20f0e.png "ͼƬ")
+
+### Seata������ģʽ
+
+Seata ������ȫ������Ŀ�ܣ���Ҫ��Ϊ���¼�����
+
+1.  TM �� TC���� ����(Begin)���ύ(Commit)���ع�(Rollback)��ȫ������
+2.  TM�Ѵ���ȫ�������XID�󶨵���֧�����ϡ�
+3.  RM��TCע�ᣬ�ѷ�֧���������XID������ȫ�������С�
+4.  RM�ѷ�֧�����ִ�н���ϱ���TC��
+5.  TC���ͷ�֧�ύ��Branch Commit�����֧�ع���Branch Rollback�������RM��
+
+![ͼƬ](https://s9.51cto.com/oss/202207/03/410c3b93872ba8a55a9532876f3afbe1853d88.gif "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/a30dd41045c8db4e0c5757095c6d1ab52fd57e.png "ͼƬ")
+
+Seata �� ȫ������ �������̣���Ϊ�����׶Σ�
+
+*   ִ�н׶� ��ִ�з�֧���񣬲���ִ֤�н��������_�ɻع��ģ�Rollbackable��_��_�־û��ģ�Durable��_��
+*   ��ɽ׶Σ����� ִ�н׶� ����γɵľ��飬Ӧ��ͨ�� TM ������ȫ���ύ��ع�������� TC��TC ���� RM ���� ��֧���� ���� Commit �� Rollback��
+
+Seata ����ν����ģʽ��ָ�������� Seata ȫ���������µ� ��֧���� ����Ϊģʽ��׼ȷ�ؽ���Ӧ�ý��� ��֧����ģʽ��
+
+��ͬ�� ����ģʽ �������� ��֧���� ʹ�ò�ͬ�ķ�ʽ�ﵽȫ�����������׶ε�Ŀ�ꡣ�����ش������������⣺
+
+*   ִ�н׶� �����ִ�в� ��֤ ִ�н��������_�ɻع��ģ�Rollbackable��_��_�־û��ģ�Durable��_��
+*   ��ɽ׶Σ��յ� TC ����������������֧���ύ��ع���
+
+������ATģʽΪ����
+
+*   ִ�н׶Σ�
+
+*   �ɻع������� SQL �����������¼�ع���־
+*   �־û����ع���־��ҵ�� SQL ��ͬһ�������������ύ�����ݿ�
+
+*   ��ɽ׶Σ�
+*   ��֧�ύ���첽ɾ���ع���־��¼
+*   ��֧�ع������ݻع���־���з��򲹳�����
+
+�������ͽ�����ͷϷ��Seata�Ĵ�ģʽ�Ľ��ܡ�
+
+## Seata-XAģʽ
+
+Seata 1.2.0 �汾�������µ�����ģ�ͣ�XAģʽ��ʵ���˶�XAЭ���֧�֡�����XAģʽ������Ҫ��������ȥ��������
+
+*   XAģʽ��ʲô��
+*   Ϊʲô֧��XA��
+*   XAģʽ���ʵ�ֺ�ʹ�á�
+
+### XAģʽ���
+
+������Ҫ֪��XAģ����ʲô��XA �淶���������� 90 ������ͱ���������ڽ���ֲ�ʽ������������⣬��Ҳ������ķֲ�ʽ��������������Ϊ��Ҫ���ݿ��ڲ�Ҳ��֧��XAģʽ�ģ�����MYSQL��XAģʽ����ǿһ���Ե��ص㣬����������ݿ�ռ��ʱ��Ƚϳ����������ܱȽϵ͡�
+
+XAģʽ�������׶��ύ��
+
+1.  ��һ�׶ν�������ע�ᣬ������ע�ᵽTC�У�ִ��SQL��䡣
+2.  �ڶ��׶�TC�ж������������֪ͨ���������ύ������ع���
+3.  �ڵ�һ���ڶ��׶ι����У�����һֱռ�����ݿ�����������ܱȽϵͣ�������������Ҫôһ���ύ��Ҫôһ��ع���������ʵ��ǿһ���ԡ�
+
+������ATģʽ��TCC����SAGA����Щģʽ�����������Դ��XA�淶��ijЩҵ�񳡾��޷����㡣
+
+### ʲô��XAЭ��
+
+XA�淶��X/OPEN��֯����ķֲ�ʽ��������DTP��Distributed Transaction Processing����׼��XA�淶������ȫ������������;ֲ���Դ������֮��Ľӿڣ�XA�淶��Ŀ�������������Դ(�����ݿ⣬Ӧ�÷���������Ϣ���еȣ���ͬһ�����з��ʣ���������ʹ ACID ���Կ�ԽӦ�ó����������Ч��
+
+XA �淶 ʹ�����׶��ύ��2PC��Two-Phase Commit������֤������Դͬʱ�ύ��ع��κ��ض���������ΪXA�淶���类��������Լ������е��������ݿⶼ���ж�XA�淶��֧�֡�
+
+�ֲ�ʽ����DTPģ�Ͷ���Ľ�ɫ���£�
+
+*   AP����Ӧ�ó��򣬿�������Ϊʹ��DTP�ֲ�ʽ����ij������綩�����񡢿�����
+*   RM����Դ����������������Ϊ����IJ����ߣ�һ���������ָһ�����ݿ��ʵ����MySql����ͨ����Դ�������Ը����ݿ���п��ƣ���Դ�����������ŷ�֧����
+*   TM�����������������Э���͹����������������������ȫ�����񣬹���ʵ���������ڣ���Э������RM��ȫ��������ָ�ֲ�ʽ�����������У���Ҫ����������ݿ⹲ͬ���һ�������������������һ��ȫ������
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/85cb437444a4debfdbb835519a1b2fdd16ee7b.png "ͼƬ")
+
+DTPģʽ����TM��RM֮��ͨѶ�Ľӿڹ淶��XA��������Ϊ���ݿ��ṩ��2PC�ӿ�Э�飬�������ݿ��XAЭ����ʵ�ֵ�2PC�ֳ�ΪXA������
+
+������Ӧ�ó���(AP)���ж�����Ϳ��⣬Ӧ�ó���(AP)ͨ��TM֪ͨ������(RM)�Ϳ���(RM)�����пۼ��������ɶ��������ʱ��RM��û���ύ���񣬶���������Դ��
+
+��TM�յ�ִ����Ϣ�������һ��RMִ��ʧ�ܣ��ֱ�������RMҲ���ͻع����񣬻ع���ϣ��ͷ�����Դ��
+
+��TM�յ�ִ����Ϣ��RMȫ���ɹ���������RM�����ύ�����ύ��ϣ��ͷ�����Դ��
+
+![ͼƬ](https://s7.51cto.com/oss/202207/03/d264d0e03f64cdd85f1600518e2db31ee0b8a5.gif "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/8298749403719fbb05d917a501c3dd3b1cc449.png "ͼƬ")
+
+�ֲ�ʽͨ��Э��XA�淶������ִ������������ʾ��
+
+![ͼƬ](https://s7.51cto.com/oss/202207/03/3609cd043edf05941832252b7e7ce838b95837.gif "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/9235cb212a65d21b72549719fdc8b7e4cdd340.png "ͼƬ")
+
+��һ����AP������RM1,RM2��JDBC���ӡ�
+
+�ڶ�����AP֪ͨ����ȫ������ID������RM1��RM2ע�ᵽȫ������ID��
+
+��������ִ�ж��׶�Э���еĵ�һ�׶�prepare��
+
+���IJ�������prepare���󣬾��������ύ��ع���
+
+���Ƕ���XA���ԣ����һ������ȫ���������Դ��ʧ�����ˣ���ô����ζ��TM�ղ�����֧��������������ô�����������ݣ�����һֱ���������Ӷ��������������Ҳ��Seata��Ҫ�ص��������⡣
+
+��Seata����ķֲ�ʽ����ܹ��У�����������Դ(���ݾ֡���Ϣ)�ȶ�XAЭ�����֧�֣���XAЭ��Ļ�����������֧����
+
+![ͼƬ](https://s2.51cto.com/oss/202207/03/a93391c180ce2293be8525a483594c701ebcbd.gif "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/52b22c57810685deea7412204aa069e494f863.png "ͼƬ")
+
+*   ִ�н׶Σ�
+
+*   �ɻع���ҵ��SQL������XA��֧�н��У�����Դ��������XAЭ���֧������֤�ɻع���
+*   �־û���ZA��֧����Ժ�ִ�� XA prepare��ͬ��������Դ��XAЭ���֧������֤�־û���
+
+*   ��ɽ׶Σ�
+
+### XA���ڵ�����
+
+*   ��֧�ύ��ִ��XA��֧��commit��
+*   ��֧�ع���ִ��XA��֧��rollback��
+
+Seata �Ѿ�֧������������ģʽ��AT\TCC\SAGA�����������Dz��������񣬲���������������ƹ����� ������Դ ֮��(Ҫô�м�����棬ҪôӦ�ò�)��������Դ�������ڷֲ�ʽ���������޸�֪�ģ����ֶ��ڷֲ�ʽ������޸�֪������һ�������Ե����⣬�޷�����������ȫ��һ���ԡ�
+
+����һ������¼���ڲ����������������У���80�ۼ�Ϊ60�����ʱ��ֿ����Ա��ѯ���ݽ������������60��֮����Ϊ�쳣�ع������ع���ԭ����80����ô���ʱ�������Ա������60����ʵ���������ݣ�������м�״̬���Dz�����������ڵ������ݡ�
+
+�Ͳ���������ͬ��XAЭ��Ҫ��������Դ �����ṩ�Թ淶��Э���֧�֣���Ϊ������Դ��֪������ֲ�ʽ�����������У�����������Դ���Ա�֤�������ӽǶ����ݵķ�����Ч�����ԣ�����ȫ�����ݵ�һ���ԡ�
+
+### XAģʽ��ʹ��
+
+**�ٷ�������**https://github.com/seata/seata-samples��
+
+**��Ŀ����**seata-samples��
+
+**ҵ��ʼ��**business-xa������stock-xa��������order-xa�˺ŷ���account-xa��
+
+�������Ŀ�������������Ժ��ҵ���Ŀ��Ϊseata-xa��Ŀ¼�������в������ݿ�����ӣ���������ò������ݿ⣬ֻ��Ҫ�޸Ĺٷ��ĵ������ݿ�������Ϣ���ɡ�
+
+���ȹ�ע���� business-xa��Ŀ������Ĺ�עBusinessService.purchase()������
+
+
+
+
+
+
+
+
+
+
+```
+@GlobalTransactional
+    public void purchase(String userId, String commodityCode, int orderCount, boolean rollback) {
+        String xid = RootContext.getXID();
+        LOGGER.info("New Transaction Begins: " + xid);       
+        //���ÿ������
+        String result = stockFeignClient.deduct(commodityCode, orderCount);
+        if (!SUCCESS.equals(result)) {
+            throw new RuntimeException("���������ʧ��,����ع�!");
+        }
+        //���ɶ���
+        result = orderFeignClient.create(userId, commodityCode, orderCount);
+        if (!SUCCESS.equals(result)) {
+            throw new RuntimeException("�����������ʧ��,����ع�!");
+        }
+        if (rollback) {
+            throw new RuntimeException("Force rollback ... ");
+        }
+    }
+```
+
+
+
+
+
+
+
+
+
+
+
+��ʵ�ַ�����֮ǰ��࣬����ֻ��Ҫ��order-xa����(OrderService.create)��������Ϊ����(int i = 1/0;)��
+
+
+
+
+
+
+
+
+
+
+
+```
+public void create(String userId, String commodityCode, Integer count) {
+        String xid = RootContext.getXID();
+        LOGGER.info("create order in transaction: " + xid);
+        int i = 1/0;
+        // �����ܼ� = ��������(count) * ��Ʒ����(100)
+        int orderMoney = count * 100;
+        // ���ɶ���
+        jdbcTemplate.update("insert order_tbl(user_id,commodity_code,count,money) values(?,?,?,?)",
+            new Object[] {userId, commodityCode, count, orderMoney});
+        // �����˻����ۼ�
+        String result = accountFeignClient.reduce(userId, orderMoney);
+        if (!SUCCESS.equals(result)) {
+            throw new RuntimeException("Failed to call Account Service. ");
+        }
+
+    }
+```
+
+
+
+
+
+
+
+
+
+
+
+������һ���������Խ���XAģʽ��ATģʽ��ת��OrderXADataSourceConfiguration.dataSource��
+
+
+
+
+
+
+
+
+
+
+```
+@Bean("dataSourceProxy")
+    public DataSource dataSource(DruidDataSource druidDataSource) {
+        // DataSourceProxy for AT mode
+        // return new DataSourceProxy(druidDataSource);
+        // DataSourceProxyXA for XA mode
+        return new DataSourceProxyXA(druidDataSource);
+    }
+```
+
+
+
+
+
+
+
+
+
+
+
+�����������ĸ����񣬷��ʵ�ַ http://localhost:8084/purchase��
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/d82378852259a962ae041377e8433a31eb8602.png "ͼƬ")
+
+���ǿ������б�����Ȼ����ȥ����Ӧ���ݿ�����ݣ�û�з������ģ�˵�����ǵ�XAģʽ��Ч�ˣ�����dubugȥ������Ŀ������ʱ�򣬵��������ݸ��ĵ�ʱ�����ݿ�������ʵҲ��û�м�¼�ģ���ΪXA��ǿһ���ԣ�ֻ�е������������Ժ󣬲Ż�������е����ݡ�
+
+XAģʽ�ļ��룬������Seata��ȫ��һ���Գ����µ�ȱ�ڣ��γ���AT��TCC��Saga��XA �Ĵ�����ģʽ�İ�ͼ���������������г����ֲ�ʽ������������
+
+����XA��AT����ҵ������ģ���TCC��Saga����һ��ҵ������ġ�
+
+## Seata-ATģʽ
+
+��������һ��ATģʽ��ATģʽ��һ��û������ķֲ�ʽ����Ľ����������ATģʽ�£��û�ֻ���ע�Լ���ҵ��SQL���û���ҵ��SQL��Ϊһ�׶Σ�Seata��ܻ��Զ�����������ж��׶��ύ�ͻع�������
+
+**���׶��ύЭ����ݱ䣺**
+
+*   һ�׶Σ�ҵ�����ݺͻع���־��¼��ͬһ�������������ύ���ͷű�������������Դ��
+*   ���׶Σ�
+    �ύ�첽�����dz����ٵ���ɡ�
+    �ع�ͨ��һ�׶εĻع���־���з��򲹳���
+
+#### ATģʽ��Ҫ�ص�
+
+1.  ����һ���ԡ�
+2.  ���ܽ�XA�ߡ�
+3.  ֻ�ڵ�һ�׶λ�ȡ�����ڵ�һ�׶ν����ύ���ͷ�����
+
+��һ�׶��У�Seata������ ҵ��SQL �����Ƚ���SQL���壬�ҵ�Ҫ������ҵ�����ݣ������ݱ�����ǰ������������¼ undo log��Ȼ��ִ�� ҵ��SQL �������ݣ�����֮���ٴα������� redo log�����������������Щ�������ڱ������ݿ���������ɣ�������֤��һ�׶ε�ԭ���ԡ�
+
+���һ�׶Σ����׶αȽϼ򵥣���������Ļع����ύ�����֮ǰ��һ�׶����б�������û��ͨ������ô��ִ��ȫ�ֻع�������ִ��ȫ���ύ���ع��õ��ľ���һ�׶μ�¼�� undo Log ��ͨ���ع���¼���ɷ������SQL��ִ�У�����ɷ�֧�Ļع�����Ȼ������ɺ���ͷ�������Դ��ɾ��������־��
+
+AT���̷�Ϊ���׶Σ���Ҫ�߼�ȫ���ڵ�һ�׶Σ��ڶ��׶���Ҫ���ع�����־�����Ĺ������������£�
+
+![ͼƬ](https://s9.51cto.com/oss/202207/03/c7d9f9e7001e9fca3d8309b146f3014ecfbf06.gif "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/02880c46589d54a3f12449afa76a44e9b8e73a.png "ͼƬ")
+
+����ͼ�����ǿ��Կ���������������TM��TC���뿪��һ��ȫ������һ��ͨ��@GlobalTransactional��ע������TC�᷵��һ��ȫ������ID(XID)������������ִ�б�������֮ǰ��RM������TCע��һ����֧���� ����������������undo log ִ�б�����������redo log �ύ����������TC�㱨������ִ��OK��
+
+����������Զ�̵��ã�������ID���ݸ������񣬿�������ִ�б�������֮ǰ������TCע���֧���񣬿�����ͬ������undo Log��redo Log����TC�㱨������״̬�ɹ���
+
+�������ȫ���ύ��TC֪ͨRMһ������������undo��redo��־���������һ������ִ��ʧ�ܣ���ô����ع�����ͨ��undo log���лع���
+
+�����ﻹ�����һ�����⣬��Ϊÿ������ӱ����ύ��֪ͨ�ع����ʱ�����棬�������������Ѿ���������������޸ģ����ֱ����undo log���лع������ܻᵼ�����ݲ�һ�µ������
+
+���ʱ�� RM���� redo log������֤���Ա������Ƿ�һ�����Ӷ���֪�����Ƿ��б����������޸Ĺ���undo log�����ڱ��޸�ǰ�����ݣ����������ع���redolog�����ڱ��޸ĺ�����ݣ����ڻع�У�顣
+
+�������û�б����������޸Ĺ�������ֱ�ӽ��лع�������������ݣ�redologУ�����д�����
+
+### ʵս
+
+�˽���ATģ�͵Ļ�������������������ʵս����һ�£�����ATģ�;��������ʵ�ֵġ���������������� cloud-alibaba-seata-order �� cloud-alibaba-seata-stock��
+
+���ṹt_order��t_stock��undo_log���ű�����ĿԴ��ͱ��ṹ������undo_log�����˱��������ݵĻع�����ĩ�����ӡ�
+
+cloud-alibaba-seata-order���Ĵ������£�
+
+controller��
+
+
+
+
+
+
+
+
+
+
+```
+@RestController
+public class OrderController {
+    @Autowired
+    private OrderService orderService;
+    @GetMapping("order/create")
+    @GlobalTransactional //�����ֲ�ʽ����
+    public String create(){
+        orderService.create();
+        return "���������ɹ���";
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+OrderService��
+
+
+
+
+
+
+
+
+
+
+```
+public interface OrderService {
+    void create();
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+StockClient��
+
+
+
+
+
+
+
+
+
+
+```
+@FeignClient(value = "seata-stock")
+public interface StockClient {
+    @GetMapping("/stock/reduce")
+    String reduce();
+
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+OrderServiceImpl��
+
+
+
+
+
+
+
+
+
+
+```
+@Service
+public class OrderServiceImpl implements OrderService{
+    @Autowired
+    private OrderMapper orderMapper;
+    @Autowired
+    private StockClient stockClient;
+    @Override
+    public void create() {
+        //�ۼ����
+        stockClient.reduce();
+        System.out.println("�ۼ����ɹ���");
+        //�ֹ��쳣 ���ڻع������Ϣ
+        int i = 1/0;
+        System.err.println("�쳣��");
+        //��������
+        orderMapper.createOrder();
+        System.out.println("���������ɹ���");
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+OrderMapper��
+
+
+
+
+
+
+
+
+
+
+```
+@Mapper
+public interface OrderMapper {
+    @Insert("insert into t_order (order_no,order_num) value (order_no+1,1)")
+    void createOrder();
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+cloud-alibaba-seata-stock���Ĵ������£�
+
+
+
+
+
+
+
+
+
+
+```
+@RestController
+public class StockController {
+    @Autowired
+    private StockService stockService;
+    @GetMapping("stock/reduce")
+    public String reduce(){
+        stockService.reduce();
+        return "��������ѿۼ���"+ new Date();
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+public interface StockService {
+    void reduce();
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+@Service
+public class StockServiceImpl implements StockService{
+    @Autowired
+    StockMapper stockMapper;
+    @Override
+    public void reduce() {
+        stockMapper.reduce();
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+@Mapper
+@Repository
+public interface StockMapper {
+    @Update("update t_stock set order_num = order_num - 1 where order_no = 1 ")
+    void reduce();
+
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+���붼�Ƚϼ򵥣����ǾͲ������������������ע��Ҳ���У�������������Ҫ��order��stock��������������֮ǰ���ǵ�Nacos��Seata��Ҫ�������������ʱ�����Ƿ���order��Rest�ӿڣ�http://localhost:8087/order/create,Ϊ����֤undo_log�ı������ڴ洢�ع����ݣ�������OrderServiceImpl.create()�����Ӷϵ㣬��debug�ķ�ʽ������
+
+![ͼƬ](https://s5.51cto.com/oss/202207/03/e9df0649789b2ad3b0a9120c1992f9a7e55cb9.gif "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/64e370d42b8375a8f7a1285cc1bc47b1437bff.png "ͼƬ")
+
+Ȼ�����http://localhost:8087/order/create��������������ڵ��ʱ�䣬����ȥ��undo_log�Ϳ������ᷢ�֣����ȷʵ�����ˣ�����undo_logҲ�����˶�Ӧ�Ŀ��ռ�¼�޸ĵ�ǰ��������Ϣ��������ݾ��������ع������ݡ�
+
+![ͼƬ](https://s8.51cto.com/oss/202207/03/9361fc3173dcb931a615608893af1f48fbeed0.gif "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/567b564906d2c473d3d770087b745a5218587f.png "ͼƬ")
+
+���ǵ�����F9ͨ���Ժ󣬿�������ָ�������undo_log����������Ҳû���ˣ����ʱ��֤�����ǵ�Seata������Ч���ع��ɹ���
+
+![ͼƬ](https://s8.51cto.com/oss/202207/03/66c11ca96212ce62540349442f14ccff8b87a4.gif "ͼƬ")![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/75cd0d103bd57d300e5194f66aa826f8494b94.png "ͼƬ")
+
+���������Ǿ���֤��AT�����ִ�й��̣������XA��TCC������ģ�ͣ�Seata��ATģ�Ϳ���Ӧ�Դ������ҵ�񳡾������ҿ���������ҵ�����룬�������޸�֪���������������Э�����ύ���߻ع�������������ͨ��AOP��ɣ�������ֻ��Ҫ��עҵ�񼴿ɡ�
+
+����Seata��Ҫ�ڲ�ͬ�ķ���֮�䴫��ȫ��Ψһ������ID����Dubbo�ȿ�ܼ��ɻ�Ƚ��Ѻã�����Dubbo�����ù���ʿ��������������ID�Ĵ��ݣ���������ID�Ĵ������̶Կ�����Ҳ���������޸�֪��
+
+## Seata-TCCģʽ
+
+����ʹ�ð�����https://seata.io/zh-cn/blog/integrate-seata-tcc-mode-with-spring-cloud.html��
+
+### ʲô��TCC
+
+TCC �Ƿֲ�ʽ�����еĶ��׶��ύЭ�飬����ȫ��Ϊ Try-Confirm-Cancel������ԴԤ����Try����ȷ�ϲ�����Confirm����ȡ��������Cancel�������ǵľ��庬�����£�
+
+1.  Try����ҵ����Դ�ļ�鲢Ԥ����
+2.  Confirm����ҵ���������ύ���� commit ������ֻҪ Try �ɹ�����ô�ò���һ���ɹ���
+3.  Cancel����ҵ��������ȡ�������ع��������ò���ض� Try Ԥ������Դ�����ͷš�
+
+TCC ��һ������ʽ�ķֲ�ʽ����������������������������Ҫҵ��ϵͳ����ʵ�֣���ҵ��ϵͳ���ŷdz���������ԣ������Ը��ӣ����ŵ��� TCC ��ȫ���������ݿ⣬�ܹ�ʵ�ֿ����ݿ⡢��Ӧ����Դ����������Щ��ͬ���ݷ���ͨ������ʽ�ı��뷽ʽʵ��һ��ԭ�Ӳ��������õؽ�����ڸ��ָ���ҵ�񳡾��µķֲ�ʽ�������⡣
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1431eaa67529de68d4f9506ae25dc17c3882b8.png "ͼƬ")
+
+### TCC��AT����
+
+AT ģʽ���� ֧�ֱ��� ACID ���� �� ��ϵ�����ݿ⣺
+
+*   һ�׶� prepare ��Ϊ���ڱ��������У�һ���ύҵ�����ݸ��º���Ӧ�ع���־��¼��
+*   ���׶� commit ��Ϊ�����ϳɹ�������**�Զ�**�첽���������ع���־��
+*   ���׶� rollback ��Ϊ��ͨ���ع���־��**�Զ�**���ɲ���������������ݻع���
+
+��Ӧ�ģ�TCC ģʽ���������ڵײ�������Դ������֧�֣�
+
+*   һ�׶� prepare ��Ϊ������**�Զ���**�� prepare �߼���
+*   ���׶� commit ��Ϊ������**�Զ���**�� commit �߼���
+*   ���׶� rollback ��Ϊ������**�Զ���**�� rollback �߼���
+
+��ν TCC ģʽ����ָ֧�ְ� **�Զ���** �ķ�֧�������뵽ȫ������Ĺ����С�
+
+#### �ص㣺
+
+1.  �����ԱȽ�ǿ��������Ҫ�Լ�ʵ�������������߼�
+2.  ���������̻���û���������ܽ�ǿ
+
+## Seata-Sagaģʽ
+
+Sagaģʽ��SEATA�ṩ�ij���������������Sagaģʽ�У�ҵ��������ÿ�������߶��ύ�������񣬵�����ijһ��������ʧ���򲹳�ǰ���Ѿ��ɹ��IJ����ߣ�һ�׶��������Ͷ��׶β�������ִ�д���ʱ������ˣ���һ���޸��Ļ��ᣩ����ҵ�񿪷�ʵ�֡�
+
+Saga ģʽ�·ֲ�ʽ����ͨ�������¼������ģ�����������֮�����첽ִ�еģ�Saga ģʽ��һ�ֳ�������������
+
+֮ǰ����ѧϰ��Seata�ֲ�ʽ���ֲ���ģ������ʹ�õĵ�΢����ȫ�����Ը��ݿ����ߵ���������޸ģ�������һЩ���⻷���£�������ϵͳ����յ�ϵͳ���޷��޸ģ�ͬʱû���κηֲ�ʽ�������룩����ôAT��XA��TCCģ�ͽ�ȫ������ʹ�ã�Ϊ�˽�����������⣬��������Sagaģ�͡�
+
+���磺��������߿�����������˾�ķ������������ϵͳ���޷����죬����ʹ��Sagaģʽ��
+
+![ͼƬ](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/e923ef663d8c0a9de06072d96c6debbac49795.png "ͼƬ")
+
+Sagaģʽ��Seata�ṩ�ij��������������ṩ���칹ϵͳ������ͳһ����ģ�͡���Sagaģʽ�У����е���ҵ�񶼲���ֱ�Ӳ�����������Ĵ�����ֻ���𱾵�����Ĵ�����������ȫ�����������յ��ö�������ʵ�֣����ڽ�����ҵ���߼�����ʱ����ijһ����ҵ���������ʱ�����Զ�����ȫ���Ѿ��ɹ������������ߣ�����һ�׶ε����������úͶ��׶εķ��񲹳�����ȫ������ҵ�񿪷�ʵ�֡�
+
+### Saga״̬��
+
+ĿǰSeata�ṩ��Sagaģʽֻ��ͨ��״̬��������ʵ�֣���Ҫ�������ֹ��Ľ���Sagaҵ�����̻��ƣ����ҽ���ת��ΪJson�����ļ��������ڳ�������ʱ���������������ļ�ʵ��ҵ�����Լ����񲹳���������Ҫ�����Saga״̬ͼ�Ļ��ƣ�һ����Ҫͨ��Saga״̬����ʵ�֡�
+
+#### ����ԭ����
+
+*   ͨ��״̬ͼ�����������õ����̲�����json�����ļ���
+*   ״̬ͼ��һ���ڵ���Ե���һ�����񣬽ڵ�����������IJ����ڵ㡣
+*   ״̬ͼ json ��״̬����������ִ�У��������쳣ʱ״̬���淴��ִ���ѳɹ��ڵ��Ӧ�IJ����ڵ㽫����ع���
+*   ����ʵ�ַ����������֧�ֵ���ѡ�񡢲����������̡�����ת��������ӳ�䡢����ִ��״̬�жϡ��쳣����ȹ��ܡ�
+
+#### Saga״̬����Ӧ��
+
+**�ٷ��ĵ���ַ��**https://seata.io/zh-cn/docs/user/saga.html��
+
+Seata Safa״̬�����ӻ�ͼ�������ʹ�õ�ַ��https://github.com/seata/seata/blob/develop/saga/seata-saga-statemachine-designer/README.zh-CN.md��
+
+## �ܽ�
+
+�ܵ���˵��Seata����ATģʽ������������ٷ�֮80�ķֲ�ʽ�����ҵ������ATģʽʵ�ֵ�������һ���ԣ����Կ��ܴ����м�״̬����XAģʽʵ�ֵ�ǿһ���ԣ�����Ч�ʽϵ�һ�㣬��Saga��������������ͬ��������֮��ķֲ�ʽ�������Թ��ڷֲ�ʽ������Ĵ�ģ�ͣ����������������е�ҵ�񳡾�������XA��ATû��ҵ�������ԣ���Saga��TCC����һ����ҵ�����롣
+
+# �����
+https://www.51cto.com/article/713007.html
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaSentinel.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaSentinel.md"
new file mode 100644
index 0000000..e476038
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaSentinel.md"
@@ -0,0 +1,594 @@
+## ժҪ
+
+Spring Cloud Alibaba �������ṩ΢���񿪷���һվʽ���������Sentinel ��Ϊ��������֮һ�������۶���������һϵ�з��񱣻����ܣ����Ľ������÷�������ϸ���ܡ�
+
+## Sentinel���
+
+����΢��������У�����ͷ���֮����ȶ��Ա��Խ��Խ��Ҫ�� Sentinel ������Ϊ����㣬���������ơ��۶Ͻ�����ϵͳ���ر����ȶ��ά�ȱ���������ȶ��ԡ�
+
+Sentinel������������:
+
+*   �ḻ��Ӧ�ó������н��˰���Ͱͽ� 10 ���˫ʮһ��������ĺ��ij�����������ɱ������ʵʱ�۶����β�����Ӧ�ã�
+*   �걸��ʵʱ��أ�ͬʱ�ṩʵʱ�ļ�ع��ܡ������ڿ���̨�п�������Ӧ�õĵ�̨�����뼶���ݣ����� 500 ̨���¹�ģ�ļ�Ⱥ�Ļ������������
+*   �㷺�Ŀ�Դ��̬���ṩ���伴�õ���������Դ���/�������ģ�飬������ Spring Cloud��Dubbo��gRPC �����ϣ�
+*   ���Ƶ� SPI ��չ�㣺�ṩ�����á����Ƶ� SPI ��չ�㡣������ͨ��ʵ����չ�㣬���ٵĶ����߼���
+
+## ��װSentinel����̨
+
+> Sentinel����̨��һ���������Ŀ���̨Ӧ�ã���������ʵʱ�鿴������Դ��ؼ���Ⱥ��Դ���ܣ����ṩ��һϵ�еĹ���������ܣ������ع��򡢽��������ȵ����ȡ�
+
+*   �����ȴӹ�������Sentinel���������ص���`sentinel-dashboard-1.6.3.jar`�ļ������ص�ַ��[github.com/alibaba/Sen��](https://link.juejin.cn?target=https%3A%2F%2Fgithub.com%2Falibaba%2FSentinel%2Freleases "https://github.com/alibaba/Sentinel/releases")
+
+*   ������ɺ�������������������������Sentinel����̨��
+
+```
+java -jar sentinel-dashboard-1.6.3.jar
+���ƴ���
+```
+
+*   Sentinel����̨Ĭ��������8080�˿��ϣ���¼�˺������Ϊ`sentinel`��ͨ�����µ�ַ���Խ��з��ʣ�[http://localhost:8080](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080 "http://localhost:8080")
+
+![image-20230423173003900](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423173003900.png)
+
+
+
+
+
+
+*   Sentinel����̨���Բ鿴��̨������ʵʱ������ݡ�
+
+![image-20230423173019956](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423173019956.png)
+
+
+
+
+
+
+## ����sentinel-serviceģ��
+
+> �������Ǵ���һ��sentinel-serviceģ�飬������ʾSentinel���۶����������ܡ�
+
+*   ��pom.xml�����������������������ʹ��Nacos��Ϊע�����ģ�������Ҫͬʱ����Nacos��������
+
+```
+<dependency>
+    <groupId>com.alibaba.cloud</groupId>
+    spring-cloud-starter-alibaba-nacos-discovery
+</dependency>
+<dependency>
+    <groupId>com.alibaba.cloud</groupId>
+    spring-cloud-starter-alibaba-sentinel
+</dependency>
+���ƴ���
+```
+
+*   ��application.yml������������ã���Ҫ��������Nacos��Sentinel����̨�ĵ�ַ��
+
+```
+server:
+  port: 8401
+spring:
+  application:
+    name: sentinel-service
+  cloud:
+    nacos:
+      discovery:
+        server-addr: localhost:8848 #����Nacos��ַ
+    sentinel:
+      transport:
+        dashboard: localhost:8080 #����sentinel dashboard��ַ
+        port: 8719
+service-url:
+  user-service: http://nacos-user-service
+management:
+  endpoints:
+    web:
+      exposure:
+        include: '*'
+���ƴ���
+```
+
+## ��������
+
+> Sentinel Starter Ĭ��Ϊ���е� HTTP �����ṩ��������㣬����Ҳ����ͨ��ʹ��@SentinelResource���Զ���һЩ������Ϊ��
+
+### ����RateLimitController��
+
+> ���ڲ����۶Ϻ��������ܡ�
+
+```
+/**
+ * ��������
+ * Created by macro on 2019/11/7.
+ */
+@RestController
+@RequestMapping("/rateLimit")
+public class RateLimitController {
+
+    /**
+     * ����Դ������������Ҫָ�����������߼�
+     */
+    @GetMapping("/byResource")
+    @SentinelResource(value = "byResource",blockHandler = "handleException")
+    public CommonResult byResource() {
+        return new CommonResult("����Դ��������", 200);
+    }
+
+    /**
+     * ��URL��������Ĭ�ϵ����������߼�
+     */
+    @GetMapping("/byUrl")
+    @SentinelResource(value = "byUrl",blockHandler = "handleException")
+    public CommonResult byUrl() {
+        return new CommonResult("��url����", 200);
+    }
+
+    public CommonResult handleException(BlockException exception){
+        return new CommonResult(exception.getClass().getCanonicalName(),200);
+    }
+
+}
+���ƴ���
+```
+
+### ������Դ��������
+
+> ���ǿ��Ը���@SentinelResourceע���ж����value����Դ���ƣ�����������������������Ҫָ�����������߼���
+
+*   ���ع��������Sentinel����̨�������ã���������ʹ����Nacosע�����ģ�����������Nacos��sentinel-service��
+
+*   ����Sentinel���õ������ع�����Ҫ�����ȷ����½ӿڣ�Sentinel����̨�вŻ��ж�Ӧ������Ϣ�������ȷ����¸ýӿڣ�[http://localhost:8401/rateLimit/byResource](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8401%2FrateLimit%2FbyResource "http://localhost:8401/rateLimit/byResource")
+
+*   ��Sentinel����̨�������ع��򣬸���@SentinelResourceע���valueֵ��
+
+![image-20230423173034164](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423173034164.png)
+
+
+
+
+
+
+*   ���ٷ�������Ľӿڣ����Է��ַ������Լ����������������Ϣ��
+
+![image-20230423173044930](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423173044930.png)
+
+
+
+
+
+
+### ����URL����
+
+> ���ǻ�����ͨ�����ʵ�URL���������᷵��Ĭ�ϵ�����������Ϣ��
+
+*   ��Sentinel����̨�������ع���ʹ�÷��ʵ�URL��
+
+![image-20230423173055243](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423173055243.png)
+
+
+
+
+
+
+*   ��η��ʸýӿڣ��᷵��Ĭ�ϵ��������������[http://localhost:8401/rateLimit/byUrl](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8401%2FrateLimit%2FbyUrl "http://localhost:8401/rateLimit/byUrl")
+
+![image-20230423173105426](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423173105426.png)
+
+
+
+
+
+
+### �Զ������������߼�
+
+> ���ǿ����Զ���ͨ�õ����������߼���Ȼ����@SentinelResource��ָ����
+
+*   ����CustomBlockHandler�������Զ������������߼���
+
+```
+/**
+ * Created by macro on 2019/11/7.
+ */
+public class CustomBlockHandler {
+
+    public CommonResult handleException(BlockException exception){
+        return new CommonResult("�Զ���������Ϣ",200);
+    }
+}
+���ƴ���
+```
+
+*   ��RateLimitController��ʹ���Զ������������߼���
+
+```
+/**
+ * ��������
+ * Created by macro on 2019/11/7.
+ */
+@RestController
+@RequestMapping("/rateLimit")
+public class RateLimitController {
+
+    /**
+     * �Զ���ͨ�õ����������߼�
+     */
+    @GetMapping("/customBlockHandler")
+    @SentinelResource(value = "customBlockHandler", blockHandler = "handleException",blockHandlerClass = CustomBlockHandler.class)
+    public CommonResult blockHandler() {
+        return new CommonResult("�����ɹ�", 200);
+    }
+
+}
+���ƴ���
+```
+
+## �۶Ϲ���
+
+> Sentinel ֧�ֶԷ������ý��б������Թ���Ӧ�ý����۶ϲ�������������ʹ��RestTemplate������nacos-user-service�������ṩ�Ľӿ�����ʾ�¸ù��ܡ�
+
+*   ����������Ҫʹ��@SentinelRestTemplate����װ��RestTemplateʵ����
+
+```
+/**
+ * Created by macro on 2019/8/29.
+ */
+@Configuration
+public class RibbonConfig {
+
+    @Bean
+    @SentinelRestTemplate
+    public RestTemplate restTemplate(){
+        return new RestTemplate();
+    }
+}
+���ƴ���
+```
+
+*   ����CircleBreakerController�࣬�����nacos-user-service�ṩ�ӿڵĵ��ã�
+
+```
+/**
+ * �۶Ϲ���
+ * Created by macro on 2019/11/7.
+ */
+@RestController
+@RequestMapping("/breaker")
+public class CircleBreakerController {
+
+    private Logger LOGGER = LoggerFactory.getLogger(CircleBreakerController.class);
+    @Autowired
+    private RestTemplate restTemplate;
+    @Value("${service-url.user-service}")
+    private String userServiceUrl;
+
+    @RequestMapping("/fallback/{id}")
+    @SentinelResource(value = "fallback",fallback = "handleFallback")
+    public CommonResult fallback(@PathVariable Long id) {
+        return restTemplate.getForObject(userServiceUrl + "/user/{1}", CommonResult.class, id);
+    }
+
+    @RequestMapping("/fallbackException/{id}")
+    @SentinelResource(value = "fallbackException",fallback = "handleFallback2", exceptionsToIgnore = {NullPointerException.class})
+    public CommonResult fallbackException(@PathVariable Long id) {
+        if (id == 1) {
+            throw new IndexOutOfBoundsException();
+        } else if (id == 2) {
+            throw new NullPointerException();
+        }
+        return restTemplate.getForObject(userServiceUrl + "/user/{1}", CommonResult.class, id);
+    }
+
+    public CommonResult handleFallback(Long id) {
+        User defaultUser = new User(-1L, "defaultUser", "123456");
+        return new CommonResult<>(defaultUser,"���񽵼�����",200);
+    }
+
+    public CommonResult handleFallback2(@PathVariable Long id, Throwable e) {
+        LOGGER.error("handleFallback2 id:{},throwable class:{}", id, e.getClass());
+        User defaultUser = new User(-2L, "defaultUser2", "123456");
+        return new CommonResult<>(defaultUser,"���񽵼�����",200);
+    }
+}
+���ƴ���
+```
+
+*   ����nacos-user-service��sentinel-service����
+
+*   �������Dz�û����nacos-user-service�ж���idΪ4���û������з������½ӿڻ᷵�ط��񽵼������[http://localhost:8401/breaker/fallback/4](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8401%2Fbreaker%2Ffallback%2F4 "http://localhost:8401/breaker/fallback/4")
+
+```
+{
+	"data": {
+		"id": -1,
+		"username": "defaultUser",
+		"password": "123456"
+	},
+	"message": "���񽵼�����",
+	"code": 200
+}
+���ƴ���
+```
+
+*   ��������ʹ����exceptionsToIgnore����������NullPointerException���������Ƿ��ʽӿڱ���ָ��ʱ���ᷢ�����񽵼���[http://localhost:8401/breaker/fallbackException/2](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8401%2Fbreaker%2FfallbackException%2F2 "http://localhost:8401/breaker/fallbackException/2")
+
+![](https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2019/11/18/16e7eb0fb3df7c01~tplv-t2oaga2asx-zoom-in-crop-mark:4536:0:0:0.awebp)
+
+
+
+
+
+
+## ��Feign���ʹ��
+
+> SentinelҲ������Feign���������ʹ��Feign�����з�������ʱ��Ҳ����ʹ�����������۶ϡ�
+
+*   ����������Ҫ��pom.xml������Feign���������
+
+```
+<dependency>
+    <groupId>org.springframework.cloud</groupId>
+    spring-cloud-starter-openfeign
+</dependency>
+���ƴ���
+```
+
+*   ��application.yml�д�Sentinel��Feign��֧�֣�
+
+```
+feign:
+  sentinel:
+    enabled: true #��sentinel��feign��֧��
+���ƴ���
+```
+
+*   ��Ӧ��������������@EnableFeignClients����Feign�Ĺ��ܣ�
+
+*   ����һ��UserService�ӿڣ����ڶ����nacos-user-service����ĵ��ã�
+
+```
+/**
+ * Created by macro on 2019/9/5.
+ */
+@FeignClient(value = "nacos-user-service",fallback = UserFallbackService.class)
+public interface UserService {
+    @PostMapping("/user/create")
+    CommonResult create(@RequestBody User user);
+
+    @GetMapping("/user/{id}")
+    CommonResult<User> getUser(@PathVariable Long id);
+
+    @GetMapping("/user/getByUsername")
+    CommonResult<User> getByUsername(@RequestParam String username);
+
+    @PostMapping("/user/update")
+    CommonResult update(@RequestBody User user);
+
+    @PostMapping("/user/delete/{id}")
+    CommonResult delete(@PathVariable Long id);
+}
+���ƴ���
+```
+
+*   ����UserFallbackService��ʵ��UserService�ӿڣ����ڴ������񽵼��߼���
+
+```
+/**
+ * Created by macro on 2019/9/5.
+ */
+@Component
+public class UserFallbackService implements UserService {
+    @Override
+    public CommonResult create(User user) {
+        User defaultUser = new User(-1L, "defaultUser", "123456");
+        return new CommonResult<>(defaultUser,"���񽵼�����",200);
+    }
+
+    @Override
+    public CommonResult<User> getUser(Long id) {
+        User defaultUser = new User(-1L, "defaultUser", "123456");
+        return new CommonResult<>(defaultUser,"���񽵼�����",200);
+    }
+
+    @Override
+    public CommonResult<User> getByUsername(String username) {
+        User defaultUser = new User(-1L, "defaultUser", "123456");
+        return new CommonResult<>(defaultUser,"���񽵼�����",200);
+    }
+
+    @Override
+    public CommonResult update(User user) {
+        return new CommonResult("����ʧ�ܣ����񱻽���",500);
+    }
+
+    @Override
+    public CommonResult delete(Long id) {
+        return new CommonResult("����ʧ�ܣ����񱻽���",500);
+    }
+}
+���ƴ���
+```
+
+*   ��UserFeignController��ʹ��UserServiceͨ��Feign����nacos-user-service�����еĽӿڣ�
+
+```
+/**
+ * Created by macro on 2019/8/29.
+ */
+@RestController
+@RequestMapping("/user")
+public class UserFeignController {
+    @Autowired
+    private UserService userService;
+
+    @GetMapping("/{id}")
+    public CommonResult getUser(@PathVariable Long id) {
+        return userService.getUser(id);
+    }
+
+    @GetMapping("/getByUsername")
+    public CommonResult getByUsername(@RequestParam String username) {
+        return userService.getByUsername(username);
+    }
+
+    @PostMapping("/create")
+    public CommonResult create(@RequestBody User user) {
+        return userService.create(user);
+    }
+
+    @PostMapping("/update")
+    public CommonResult update(@RequestBody User user) {
+        return userService.update(user);
+    }
+
+    @PostMapping("/delete/{id}")
+    public CommonResult delete(@PathVariable Long id) {
+        return userService.delete(id);
+    }
+}
+���ƴ���
+```
+
+*   �������½ӿڻᷢ�����񽵼������ط��񽵼�������Ϣ��[http://localhost:8401/user/4](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8401%2Fuser%2F4 "http://localhost:8401/user/4")
+
+```
+{
+	"data": {
+		"id": -1,
+		"username": "defaultUser",
+		"password": "123456"
+	},
+	"message": "���񽵼�����",
+	"code": 200
+}
+���ƴ���
+```
+
+## ʹ��Nacos�洢����
+
+> Ĭ������£���������Sentinel����̨�����ù���ʱ������̨���͹���ʽ��ͨ��API�������������ͻ��˲�ֱ�Ӹ��µ��ڴ��С�һ����������Ӧ�ã�������ʧ���������ǽ�������ν����ù�����г־û����Դ洢��NacosΪ����
+
+### ԭ��ʾ��ͼ
+
+![image-20230423173120010](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423173120010.png)
+
+
+
+
+
+
+*   ��������ֱ�����������Ĵ��������������Ľ��������͵��ͻ��ˣ�
+
+*   Sentinel����̨Ҳ����������ȥ��ȡ������Ϣ��
+
+### ������ʾ
+
+*   ����pom.xml���������������
+
+```
+<dependency>
+    <groupId>com.alibaba.csp</groupId>
+    sentinel-datasource-nacos
+</dependency>
+���ƴ���
+```
+
+*   �޸�application.yml�����ļ�������Nacos����Դ���ã�
+
+```
+spring:
+  cloud:
+    sentinel:
+      datasource:
+        ds1:
+          nacos:
+            server-addr: localhost:8848
+            dataId: ${spring.application.name}-sentinel
+            groupId: DEFAULT_GROUP
+            data-type: json
+            rule-type: flow
+���ƴ���
+```
+
+*   ��Nacos���������ã�
+
+![image-20230423173137516](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423173137516.png)
+
+
+
+
+
+
+*   ����������Ϣ���£�
+
+```
+[
+    {
+        "resource": "/rateLimit/byUrl",
+        "limitApp": "default",
+        "grade": 1,
+        "count": 1,
+        "strategy": 0,
+        "controlBehavior": 0,
+        "clusterMode": false
+    }
+]
+���ƴ���
+```
+
+*   ��ز������ͣ�
+
+    *   resource����Դ���ƣ�
+    *   limitApp����ԴӦ�ã�
+    *   grade����ֵ���ͣ�0��ʾ�߳�����1��ʾQPS��
+    *   count��������ֵ��
+    *   strategy������ģʽ��0��ʾֱ�ӣ�1��ʾ������2��ʾ��·��
+    *   controlBehavior������Ч����0��ʾ����ʧ�ܣ�1��ʾWarm Up��2��ʾ�Ŷӵȴ���
+    *   clusterMode���Ƿ�Ⱥ��
+*   ����Sentinel����̨�Ѿ�����������������
+
+![image-20230423173152487](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423173152487.png)
+
+
+
+
+
+
+*   ���ٷ��ʲ��Խӿڣ����Է��ַ���������������Ϣ��
+
+![image-20230423173203461](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423173203461.png)
+
+
+
+
+
+
+## �����
+
+Spring Cloud Alibaba �ٷ��ĵ���[github.com/alibaba/spr��](https://link.juejin.cn?target=https%3A%2F%2Fgithub.com%2Falibaba%2Fspring-cloud-alibaba%2Fwiki "https://github.com/alibaba/spring-cloud-alibaba/wiki")
+
+## ʹ�õ���ģ��
+
+```
+springcloud-learning
+������ nacos-user-service -- ע�ᵽnacos���ṩUser����CRUD�ӿڵķ���
+������ sentinel-service -- sentinel���ܲ��Է���
+���ƴ���
+```
+
+## ��ĿԴ���ַ
+
+[github.com/macrozheng/��](https://link.juejin.cn?target=https%3A%2F%2Fgithub.com%2Fmacrozheng%2Fspringcloud-learning "https://github.com/macrozheng/springcloud-learning")
+
+
+
+���ߣ�MacroZheng
+���ӣ�https://juejin.cn/post/6844903999876022279
+��Դ��ϡ�����
+����Ȩ���������С���ҵת������ϵ���߻����Ȩ������ҵת����ע��������
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaSkywalking.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaSkywalking.md"
new file mode 100644
index 0000000..3bce54d
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibabaSkywalking.md"
@@ -0,0 +1,413 @@
+# 1\. SkyWalking ���
+
+> Skywalking ���ɹ��ڿ�Դ���������ɣ�ԭ OneAPM ����ʦ��Ŀǰ�ڻ�Ϊ����Դ���ύ�� Apache �������IJ�Ʒ����ͬʱ������ Zipkin/Pinpoint/CAT �����˼·��֧�ַ�����ʽ��㡣��һ����ڷֲ�ʽ���ٵ�Ӧ�ó������ܼ��ϵͳ��������������չ����һ���� OpenTracing ����֯��ּ���ƽ���������ص�һЩ�淶�ͱ�׼������
+
+*   SkyWalking ��һ����Դ���ƽ̨�����ڴӷ������ԭ��������ʩ�ռ����������ۺϺͿ��ӻ����ݡ�
+*   SkyWalking �ṩ��һ�ּ򵥵ķ�����ά���ֲ�ʽϵͳ��������ͼ���������Կ��Ʋ鿴������һ���ִ�APM��ר��Ϊ��ԭ�������������ķֲ�ʽϵͳ��ơ�
+*   SkyWalking ������ά�ȶ�Ӧ�ý��м��ӣ�service������, service instance��ʵ����, endpoint���˵㣩�������ʵ���Ͳ���˵�ˣ��˵��Ƿ����е�ij��·������˵URI��
+*   SkyWalking �����û��˽����Ͷ˵�֮������˹�ϵ���鿴ÿ������/����ʵ��/�˵�Ķ����������þ�������
+
+## SkyWalking�����
+
+SkyWalking��Ҫ�ļ������ģ��:
+
+1.  Agent ��Ҫ�����ϵͳ�вɼ�����ָ�꣬��·���ݣ����͸� oap ����
+2.  oap ������� Agent ���͹��������ݣ��洢��ִ�з������ṩ��ѯ�ͱ������ܡ�
+3.  Storage �� UI ����洢�����Լ��鿴���ݡ�
+
+# 2\. ʹ�� Docker ���ٴ SkyWalking 8.0
+
+1.  **�� linux ��������ѡ�񲢽���Ŀ¼**��
+
+```
+mkdir skywalking-docker
+���ƴ���
+```
+
+1.  **���� skywalking-docker Ŀ¼������һ����Ϊ skywalking.yaml �Ľű��ļ�����������**��
+
+```
+version: '3'
+services:
+  elasticsearch7:
+    image: docker.elastic.co/elasticsearch/elasticsearch:7.5.0
+    container_name: elasticsearch7
+    restart: always
+    ports:
+      - 9023:9200
+    environment:
+      - discovery.type=single-node
+      - bootstrap.memory_lock=true
+      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
+      - TZ=Asia/Shanghai
+    ulimits:
+      memlock:
+        soft: -1
+        hard: -1
+    networks:
+      - skywalking
+    volumes:
+      - elasticsearch7:/usr/share/elasticsearch/data
+  oap:
+    image: apache/skywalking-oap-server:8.0.1-es7
+    container_name: oap
+    depends_on:
+      - elasticsearch7
+    links:
+      - elasticsearch7
+    restart: always
+    ports:
+      - 9022:11800
+      - 9021:12800
+    networks:
+      - skywalking
+    volumes:
+      - ./ext-config:/skywalking/ext-config
+  ui:
+    image: apache/skywalking-ui:8.0.1
+    container_name: ui
+    depends_on:
+      - oap
+    links:
+      - oap
+    restart: always
+    ports:
+      - 9020:8080
+    environment:
+      SW_OAP_ADDRESS: oap:12800
+    networks:
+      - skywalking
+
+networks:
+  skywalking:
+    driver: bridge
+
+volumes:
+  elasticsearch7:
+    driver: local
+���ƴ���
+```
+
+**ע��**����������븲�� oap �����е� /skywalking/config Ŀ¼�µ������ļ������ǿ����� docker �й���һ�� /skywalking/ext-config Ŀ¼���������ļ�������Ŀ¼�м��ɡ�
+
+![image-20230423174422281](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423174422281.png)
+
+1.  **ִ�� skywalking.yaml �ű���������**��
+
+```
+docker-compose -f skywalking.yaml up
+���ƴ���
+```
+
+1.  **���� skywalking �Ŀ���̨�����ָ����DZ��̣���ʼ��Ȼ�ǿյ�**��
+
+```
+http://(��װSkyWalking������IP):9020
+���ƴ���
+```
+
+![image-20230423174444272](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423174444272.png)
+
+# 3\. �� Spring ��Ŀ������ SkyWalking �ͻ���
+
+ȫ����־׷�� traceId ��ʹ�ã�
+
+1.  **���� pom �ļ�����**��
+
+```
+        <dependency>
+            <groupId>org.apache.skywalking</groupId>
+            apm-toolkit-logback-1.x
+            <version>8.0.1</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.skywalking</groupId>
+            apm-toolkit-trace
+            <version>8.0.1</version>
+        </dependency>
+���ƴ���
+```
+
+1.  **�� resources Ŀ¼�� ���� logback-spring.xml �ļ�����������**:
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <property name="logger.path" value="/mnt/logs"/>
+
+    <!-- ��ɫ��־ -->
+    <!-- ��ɫ��־��������Ⱦ�� -->
+    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
+    <conversionRule conversionWord="wex"
+                    converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
+    <conversionRule conversionWord="wEx"
+                    converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>
+    <!-- ��ɫ��־��ʽ -->
+    <property name="CONSOLE_LOG_PATTERN"
+              value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
+
+    <!-- ���������̨ -->
+    
+        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+            <level>info</level>
+        </filter>
+        <encoder>
+            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+    
+
+    <!-- ConsoleAppender������־���������̨ -->
+    
+        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
+            <layout class="org.apache.skywalking.apm.toolkit.log.logback.v1.x.mdc.TraceIdMDCPatternLogbackLayout">
+                <Pattern>
+                    <![CDATA[%clr(%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}}){faint} [%X{tid}] %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}]]></Pattern>
+            </layout>
+        </encoder>
+    
+
+    <!-- ������ļ� -->
+    <!-- ʱ�������� levelΪ DEBUG ��־ -->
+    <!-- 
+        <file>${logger.path}/log_debug.log</file>
+        &lt;!&ndash;��־�ļ������ʽ&ndash;&gt;
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+            <charset>UTF-8</charset> &lt;!&ndash; �����ַ��� &ndash;&gt;
+        </encoder>
+        &lt;!&ndash; ��־��¼���Ĺ������ԣ������ڣ�����С��¼ &ndash;&gt;
+        <rollingPolicy >
+            &lt;!&ndash; ��־�鵵 &ndash;&gt;
+            <fileNamePattern>${logger.path}/debug/log-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <timeBasedFileNamingAndTriggeringPolicy >
+                <maxFileSize>100MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+            &lt;!&ndash;��־�ļ���������&ndash;&gt;
+            <maxHistory>15</maxHistory>
+        </rollingPolicy>
+        &lt;!&ndash; ����־�ļ�ֻ��¼debug����� &ndash;&gt;
+        <filter >
+            <level>debug</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+     -->
+
+    <!-- ʱ�������� levelΪ INFO ��־ -->
+    
+        <!-- ���ڼ�¼����־�ļ���·�����ļ��� -->
+        <file>${logger.path}/log_info.log</file>
+        <!--��־�ļ������ʽ-->
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+        <!-- ��־��¼���Ĺ������ԣ������ڣ�����С��¼ -->
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <!-- ÿ����־�鵵·���Լ���ʽ -->
+            <fileNamePattern>${logger.path}/info/log-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+                <maxFileSize>100MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+            <!--��־�ļ���������-->
+            <maxHistory>15</maxHistory>
+        </rollingPolicy>
+        <!-- ����־�ļ�ֻ��¼info����� -->
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>info</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+    
+
+    <!-- ʱ�������� levelΪ WARN ��־ -->
+    <!-- 
+        &lt;!&ndash; ���ڼ�¼����־�ļ���·�����ļ��� &ndash;&gt;
+        <file>${logger.path}/log_warn.log</file>
+        &lt;!&ndash;��־�ļ������ʽ&ndash;&gt;
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+            <charset>UTF-8</charset> &lt;!&ndash; �˴������ַ��� &ndash;&gt;
+        </encoder>
+        &lt;!&ndash; ��־��¼���Ĺ������ԣ������ڣ�����С��¼ &ndash;&gt;
+        <rollingPolicy >
+            <fileNamePattern>${logger.path}/warn/log-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <timeBasedFileNamingAndTriggeringPolicy >
+                <maxFileSize>100MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+            &lt;!&ndash;��־�ļ���������&ndash;&gt;
+            <maxHistory>15</maxHistory>
+        </rollingPolicy>
+        &lt;!&ndash; ����־�ļ�ֻ��¼warn����� &ndash;&gt;
+        <filter >
+            <level>warn</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+     -->
+
+    <!-- ʱ�������� levelΪ ERROR ��־ -->
+    
+        <!-- ���ڼ�¼����־�ļ���·�����ļ��� -->
+        <file>${logger.path}/log_error.log</file>
+        <!--��־�ļ������ʽ-->
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+            <charset>UTF-8</charset> <!-- �˴������ַ��� -->
+        </encoder>
+        <!-- ��־��¼���Ĺ������ԣ������ڣ�����С��¼ -->
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <fileNamePattern>${logger.path}/error/log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+                <maxFileSize>100MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+            <!--��־�ļ���������-->
+            <maxHistory>15</maxHistory>
+        </rollingPolicy>
+        <!-- ����־�ļ�ֻ��¼ERROR����� -->
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>ERROR</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+    
+
+    <!--
+        root�ڵ��DZ�ѡ�ڵ㣬����ָ�����������־�������ֻ��һ��level����
+        level:�������ô�ӡ���𣬴�Сд�޹أ�TRACE, DEBUG, INFO, WARN, ERROR, ALL �� OFF��
+        ��������ΪINHERITED����ͬ���NULL��Ĭ����DEBUG
+        ���԰����������Ԫ�أ���ʶ���appender�������ӵ����logger��
+    -->
+    <root level="info">
+        
+        
+        <!---->
+        
+        <!---->
+        
+    </root>
+
+</configuration>
+���ƴ���
+```
+
+**ע��**������������־�������ã���Ҫ���ⲿ�� `` �����á�
+
+1.  **���� skywalking �������� SkyWalking APM����Ҫ��Ҫ�õ� agent**��
+
+skywalking �������ص�ַ��[skywalking.apache.org/downloads/](https://link.juejin.cn?target=http%3A%2F%2Fskywalking.apache.org%2Fdownloads%2F "http://skywalking.apache.org/downloads/")
+
+![image-20230423174506711](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423174506711.png)
+
+1.  **��ѹ���ص� apache-skywalking-apm-es7-8.0.1.tar.gz ����Ŀ¼�ṹ��ͼ**��
+
+![image-20230423174522153](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423174522153.png)
+
+����ֻҪ���е� agent Ŀ¼���У�agent ��Ķ����������Щ��
+
+![image-20230423174533023](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423174533023.png)
+
+�� agent Ŀ¼���Ƶ�һ�����Ƶ�Ŀ¼�£�һ�����Ҫ���� JVM ��������Ŀ¼����Ȼ����ֱ�ӷŵ�����Ŀ�
+
+![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8deaee160419423e9a71e710d3b2c3dd~tplv-k3u1fbpfcp-zoom-in-crop-mark:1512:0:0:0.awebp)
+
+1.  **�� idea �������������������� JVM ��������**��
+
+```
+-javaagent:(agent�ļ������ڵ�Ŀ¼)\agent\skywalking-agent.jar -Dskywalking.agent.service_name=(������)-service -Dskywalking.agent.instance_name=(������)-instance -Dskywalking.collector.backend_service=(��װSkyWalking������IP):9022
+���ƴ���
+```
+
+![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/96e9d5a3aa5c44c3b0b948929609ae1f~tplv-k3u1fbpfcp-zoom-in-crop-mark:1512:0:0:0.awebp)
+
+��Ϊ skywalking �Ƿ�����ʽ���ʵ�ֲַ�ʽ��·���ٺ����ܼ�أ�����һ����� javaagent �ķ�ʽ��
+
+> **Javaagent ��ʲô**��JVM ����ǰ��̬ Instrument����
+>
+> Javaagent �� java �����һ������������ javaagent ��������ָ��һ�� jar �������ҶԸ� java ��������Ҫ��
+>
+> 1.  ��� jar ���� MANIFEST.MF �ļ�����ָ�� Premain-Class �
+> 2.  Premain-Class ָ�����Ǹ������ʵ�� premain() ������
+>
+> premain() �����������������⣬���������� main() ����֮ǰ�ĵ��ࡣ�� Java ���������ʱ����ִ�� main() ����֮ǰ��jvm �������� -javaagent ��ָ�� jar ���� Premain-Class ������ premain() ���� ��
+
+1.  **����ǰ��ƪ�����д����������Ŀ������Щ��Ŀ��ȫ�������ϱߵ�����һ�飬��������Ч��**��
+
+*   ���ط���herring-gateway��zuul ͳһ����΢����
+*   ��֤����herring-oauth2��oauth2 ��֤����΢����
+*   ��Ա����herring-member-service��΢����֮һ�����յ������ᵽ��֤������֤��
+*   ��������herring-orders-service��΢����֮�������յ������ᵽ��֤������֤��
+*   ��Ʒ����herring-product-service��΢����֮�������յ������ᵽ��֤������֤��
+
+![image-20230423174600279](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423174600279.png)
+
+1.  **����������һ�£��������� token��Ȼ�������� /api/member/update**��
+
+```
+#### 
+
+POST http://localhost:8080/oauth2-service/oauth/token?grant_type=password&username=admin&password=123456&client_id=app-client&client_secret=client-secret-8888&scope=all
+Accept: */*
+Cache-Control: no-cache
+���ƴ���
+```
+
+�õ����ؽ�� token��
+
+```
+{
+  "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOlsiZ2F0ZXdheS1zZXJ2aWNlIl0sInVzZXJfbmFtZSI6ImFkbWluIiwiand0LWV4dCI6IkpXVCDmianlsZXkv6Hmga8iLCJzY29wZSI6WyJhbGwiXSwiZXhwIjoxNjEzOTcwMDk2LCJhdXRob3JpdGllcyI6WyJST0xFX0FETUlOIl0sImp0aSI6IjU4MDY5ODlhLWUyNDQtNGQyMy04YTU5LTBjODRiYzE0Yjk5OSIsImNsaWVudF9pZCI6ImFwcC1jbGllbnQifQ.EP4acam0tkJQ9kSGRGk_mQsfi1y4M_hhiBL0H931v60",
+  "token_type": "bearer",
+  "refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOlsiZ2F0ZXdheS1zZXJ2aWNlIl0sInVzZXJfbmFtZSI6ImFkbWluIiwiand0LWV4dCI6IkpXVCDmianlsZXkv6Hmga8iLCJzY29wZSI6WyJhbGwiXSwiYXRpIjoiNTgwNjk4OWEtZTI0NC00ZDIzLThhNTktMGM4NGJjMTRiOTk5IiwiZXhwIjoxNjE0MDM0ODk2LCJhdXRob3JpdGllcyI6WyJST0xFX0FETUlOIl0sImp0aSI6IjQxZGM1ZDc1LTZmZDgtNDU3My04YmRjLWI4ZTMwNWEzMThmMyIsImNsaWVudF9pZCI6ImFwcC1jbGllbnQifQ.CGmGx_msqJBHxa95bBROY2SAO14RyeRklVPYrRxZ7pQ",
+  "expires_in": 7199,
+  "scope": "all",
+  "jwt-ext": "JWT ��չ��Ϣ",
+  "jti": "5806989a-e244-4d23-8a59-0c84bc14b999"
+}
+���ƴ���
+```
+
+����ִ�� /api/member/update
+
+```
+####
+
+GET http://localhost:8080/member-service/api/member/update
+Accept: */*
+Cache-Control: no-cache
+Authorization: bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOlsiZ2F0ZXdheS1zZXJ2aWNlIl0sInVzZXJfbmFtZSI6ImFkbWluIiwiand0LWV4dCI6IkpXVCDmianlsZXkv6Hmga8iLCJzY29wZSI6WyJhbGwiXSwiZXhwIjoxNjEzOTcwMDk2LCJhdXRob3JpdGllcyI6WyJST0xFX0FETUlOIl0sImp0aSI6IjU4MDY5ODlhLWUyNDQtNGQyMy04YTU5LTBjODRiYzE0Yjk5OSIsImNsaWVudF9pZCI6ImFwcC1jbGllbnQifQ.EP4acam0tkJQ9kSGRGk_mQsfi1y4M_hhiBL0H931v60
+���ƴ���
+```
+
+**�DZ��̽��չʾ**:
+
+![image-20230423174639471](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423174639471.png)
+
+![image-20230423174721822](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423174721822.png)
+
+![image-20230423174742703](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423174742703.png)
+
+**����ͼ���չʾ**��
+
+![image-20230423174809108](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423174809108.png)
+
+![image-20230423174831290](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423174831290.png)
+
+**��·׷�ٽ��չʾ**��
+
+![image-20230423174845526](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423174845526.png)
+
+
+
+���ߣ��ײ�˵����
+���ӣ�https://juejin.cn/post/6931922457741770760
+��Դ��ϡ�����
+����Ȩ���������С���ҵת������ϵ���߻����Ȩ������ҵת����ע��������
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibaba\346\246\202\350\247\210.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibaba\346\246\202\350\247\210.md"
new file mode 100644
index 0000000..6fa981f
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba/SpringCloudAlibaba\346\246\202\350\247\210.md"
@@ -0,0 +1,202 @@
+Spring Cloud Alibaba�������ṩ΢���񿪷���һվʽ�������������Spring Cloud�����ֲ��AlibabaԪ��֮��IJ������Spring Cloud Alibaba�����Կ��ٴ΢����ܹ�����ɼ�����������С��ҵ�����Ҫ�������ҵ����̨�ͼ�����̨���������ֻ�ҵ��ת�ͣ���Spring Cloud Alibaba������һ������������
+
+# ʲô��Spring Cloud Alibaba
+
+�ð������ȿ���Spring Cloud Alibaba�Ĺ���������ͼ��ʾ��
+
+![image-20230423165959115](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423165959115.png)
+
+��ͼ�оͿ��Կ�����Spring Cloud Alibaba��Spring Cloud������Ŀ���ðɣ�������Ŀһ��ʼ�Ķ�λ���Ǹ��ӹ�ϵ��
+
+�����ٷ�����û����߸�Spring Cloud�ļܹ�˼�룬ֻ������һ����������ǿ����չ��
+
+
+# ΪʲôҪ��Spring Cloud Alibaba
+
+
+�����ȿ���Spring Cloud Alibaba����Щ������
+
+
+
+Spring Cloud Alibaba ��������ܼ�����Ѱ汾��Ҳ���շѰ汾��
+
+Sentinel���ԡ�����Ϊ����㣬���������ơ������ԡ��ݴ������͸��ر����ȷ����ṩ����������Ա���������ȶ��ԡ�
+
+
+
+Nacos��һ���߱���̬�����ֺͷֲ�ʽ���õȹ��ܵĹ���ƽ̨����Ҫ���ڹ�����ԭ��Ӧ�ó���
+
+
+
+RocketMQ��һ�������ܡ��߿��á����������Ľ��ڼ���Ϣ�м����Spring Cloud Alibaba ��RocketMQ ���ƻ���װ��������Ա�ɡ����伴�á���
+
+
+
+Dubbo��һ������Java�ĸ����ܿ�ԴRPC��ܡ�
+
+
+
+Seata��һ��������������ʹ�õķֲ�ʽ������������������΢����ܹ���
+
+������OSS�������ƶ���洢���񣩣�һ�ּ��ܵİ�ȫ�ƴ洢���񣬿��Դ洢�������ͷ������������κεط��Ĵ������ݡ�
+
+
+
+������SchedulerX��һ��ֲ�ʽ������Ȳ�Ʒ��֧�ֶ����������ָ��ʱ��㴥������
+
+
+
+������SMS��һ�ָ���ȫ�����Ϣ�����ṩ��ݡ���Ч�����ܵ�ͨ�Ź��ܣ��ɰ�����ҵ������ϵ��ͻ���
+
+
+
+������������Spring Cloud Alibaba�ĸ����汾�ĶԱȣ�����ͼ��ʾ��
+
+![image-20230423170034102](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423170034102.png)
+
+��������������û��Spring Cloud Alibaba֮ǰ���������ʹ��Spring Cloud����΢���񿪷���
+
+
+
+Spring Cloud֧�ֶ���ע�����ģ�����Eureka��ZooKeeper��Consul�ȡ�
+
+
+
+�������������Ա��Ҫ����Eureka��Ϊע�����ģ�����Ҫ�һ��Eureka Server��Ⱥ�����ڹ���ע�����ķ����Ԫ���ݣ�Ȼ��Ӧ�÷�����Ҫ����Eureka������Ҫʹ�ö�Ӧ��ע�⽫�����ṩ���Լ���������ע�ᵽEurekaע�����ġ�ͬ��ZooKeeper��ConsulҲ�Dz���ͬ���ķ�ʽ��ʹ�ö�Ӧע�����ĵ�ע����ɷ����ע��Ͷ��ġ�
+
+
+
+Spring CloudΪ�˷�������������Ա���ٵĽ��벻ͬ��ע�����ģ�ͳһʹ��ע��@EnableDiscoveryClient+��Ӧע�����ĵ�Starter�������ȻEureka���������ϵ�ʹ�÷�ʽ@EnableEurekaClient+��Ӧע�����ĵ�Starter�������Ҫ������Spring Cloud�Ѿ�ֹͣ�˶�Eureka��ά����
+
+
+
+�ð��������ˣ�Spring Cloud�Ѿ���ZooKeeper��Consul��ʹ�÷�ʽͳһ����������������Ա�dz����Ľ�Ӧ�ý���Spring Cloud������Ŀǰ�������ֳ���һ���µ�ע�����ģ�����Nacos���������ܷdz��ߣ�����֧��CP��APģʽ������Spring Cloud��֧�֡�
+
+
+
+��������������û��Spring Cloud Alibaba֮ǰ���������ʹ��Nacos��
+
+
+
+�ðɣ�Nacos��һ���֧�ֲַ�ʽע�����ĺͷֲ�ʽ�������ĵ�������Nacos�ٷ��ṩ�˺ܶ����ģʽ������Spring Framework��Spring Boot�ȣ�������ײ㱾����������Nacos�ṩ��SDK,����Nacos Client��
+
+
+
+�������Spring Framework+Nacos Client������nacos-spring-context��������Ҫ������Ա�Լ�ά��NacosNamingServce��NacosConfigServiceʵ������Ҳ����˵������Ա��Ҫ�Լ�����Nacos Client�����ο������ɱ��dz���
+
+
+
+�������Spring Boot+Nacos Starter���������nacos-discovery-spring-boot-starter�����򿪷���Ա���Ը�Ч�Ľ���Nacos�������ģ����ҿ���ʹ��Spring Boot�ṩ�ĸ���Starter�����
+
+
+
+����������Spring Cloud��Ϊ������ܣ�����ʹ��Nacos��Ϊע�����ģ��þ��ᰡ��
+
+
+
+��ô��û��һ����ܼȿ���ʹ��Spring Cloud���ֿ���ʹ��Spring Boot�����ܼ��ݸ���ע�������أ��ܸ��˵ĸ��ߴ�ң�Spring Cloud Alibaba������������������Ľ���˿�����Ա΢����ܹ����ѡ�͵����⣬���������ˡ�
+
+# Spring Cloud Alibaba�ĺ��ļܹ�˼��
+
+
+Spring Cloud Alibaba����ܹ�������ͼ��
+
+![image-20230423170108696](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230423170108696.png)
+
+Spring Cloud Alibaba�ܹ���ľĿ���ǽ���Դ��Ʒ���Ƴ����ںϣ�����ҵ�����Ϻ����µ��޷���ݣ�ҵ�񿪷���Աֻ��Ҫ����ҵ����Ŀ�������ײ㼼��ϸ�ھͽ���Spring Cloud Alibaba��
+
+
+
+��ο������ֲ�ʹ��
+
+
+
+
+�ðɣ�˵����ô����������������Ա��ô��������Spring Cloud Alibaba�أ�
+
+��ʵ��򵥵ķ�ʽ��������������Ȼ���Լ����Զ���ʹ��Spring Cloud Alibaba�Ĺ��ܣ���ȥ����Դ���������ܸ�����̵���Ϥԭ����
+
+
+
+Ҳ������һЩ�˻���Ϊ���ҿ���Դ���������������Ϥ�ˣ�����һ����֮��������ˣ���ʲô���ء������������룬�����Dz���Դ�룬�������������飬һ����֮��Ҳ�����ǵġ�ֻ��ͨ�����ۺ�ʵս��ϣ���Ż᳤�ڵı���ϰ��ȥ��ϰ�������¹ʶ�֪�¡�
+
+
+
+������������������Ա��������Java������Ա��Ӧ�ö���IDEA������Ŀ�������Ҿ��þͿ��������������ٵ�����һ��Spring Cloud Alibaba��Ŀ����������Spring Framework�ٷ��Ľ��ּ���ĿSpring Initializr�ȡ�
+
+
+
+���о���Ҫ���ܽ�һЩ���ʵ��������Ҫ��Spring Cloud Alibaba�������ļ���ʼ����ߣһЩ���õ�ҵ�񳡾����������ܸ�����̵��˽�Spring Cloud Alibaba�����˼�롣
+
+
+Copyright ? ���� Link: [https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html](https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html)
+
+�����ٷ��ĵ�һ�����򵥵Ľ���Spring Cloud Alibaba��������Щ��Ҫ���֣����и������ӡ�󣬺��浱Ȼ����ϸ�Ľ��ܣ���ȥ�������⡣
+
+- **���������ͽ���**��֧��`WebServlet`��`WebFlux`��`OpenFeign`��`RestTemplate`��`Dubbo`���������ͽ���������ͨ��`console`ʵʱ�޸������������ԣ�֧�ּ����������ָ��
+- **����ע��ͷ���**������ע�����clients����ͨ��Spring������bean����ʵ�������ں���Ribbon
+- **�ֲ�ʽ����**��֧�ֲַ�ʽϵͳ��������չ�����øı�ʱ�Զ�ˢ��
+- **Rpc ����**����չSpring Cloud��RestTemplate��OpenFeign֧�ֵ���Dubbo RPC����
+- **�¼�����**��֧�ֹ���ͨ��������Ϣϵͳ���ӵĸ߶ȿ��������¼�������΢����
+- **�ֲ�ʽ����**��֧�ָ����ܡ�����ʹ�õķֲ�ʽ����������
+- �����ƶ���洢��������������ȡ������ƶ��ŷ���
+
+����������ǰѹٷ��ĵ���������ģ����Է���Spring Cloud Alibaba�dz�ǿ�󣬻����Ķ������¿�~
+
+
+
+# ������
+
+## ![springCloud-Alibaba-1](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/springCloud-Alibaba-1.png)[#](#�汾��ϵ) �汾��ϵ
+
+[�ٷ��汾˵��(opens new window)](https://github.com/alibaba/spring-cloud-alibaba/wiki/%E7%89%88%E6%9C%AC%E8%AF%B4%E6%98%8E)
+
+### 2021.x ��֧
+
+| Spring Cloud Alibaba Version | Spring Cloud Version  | Spring Boot Version |
+| ---------------------------- | --------------------- | ------------------- |
+| 2021.0.1.0*                  | Spring Cloud 2021.0.1 | 2.6.3               |
+| 2021.1                       | Spring Cloud 2020.0.1 | 2.4.2               |
+
+### 2.2.x ��֧
+
+| Spring Cloud Alibaba Version      | Spring Cloud Version        | Spring Boot Version |
+| --------------------------------- | --------------------------- | ------------------- |
+| 2.2.8.RELEASE*                    | Spring Cloud Hoxton.SR12    | 2.3.12.RELEASE      |
+| 2.2.7.RELEASE                     | Spring Cloud Hoxton.SR12    | 2.3.12.RELEASE      |
+| 2.2.6.RELEASE                     | Spring Cloud Hoxton.SR9     | 2.3.2.RELEASE       |
+| 2.1.4.RELEASE                     | Spring Cloud Greenwich.SR6  | 2.1.13.RELEASE      |
+| 2.2.1.RELEASE                     | Spring Cloud Hoxton.SR3     | 2.2.5.RELEASE       |
+| 2.2.0.RELEASE                     | Spring Cloud Hoxton.RELEASE | 2.2.X.RELEASE       |
+| 2.1.2.RELEASE                     | Spring Cloud Greenwich      | 2.1.X.RELEASE       |
+| 2.0.4.RELEASE(ֹͣά������������) | Spring Cloud Finchley       | 2.0.X.RELEASE       |
+| 1.5.1.RELEASE(ֹͣά������������) | Spring Cloud Edgware        | 1.5.X.RELEASE       |
+
+### ����汾��ϵ
+
+| Spring Cloud Alibaba Version                              | Sentinel Version | Nacos Version | RocketMQ Version | Dubbo Version | Seata Version |
+| --------------------------------------------------------- | ---------------- | ------------- | ---------------- | ------------- | ------------- |
+| 2.2.8.RELEASE                                             | 1.8.4            | 2.1.0         | 4.9.3            | ~             | 1.5.1         |
+| 2021.0.1.0                                                | 1.8.3            | 1.4.2         | 4.9.2            | ~             | 1.4.2         |
+| 2.2.7.RELEASE                                             | 1.8.1            | 2.0.3         | 4.6.1            | 2.7.13        | 1.3.0         |
+| 2.2.6.RELEASE                                             | 1.8.1            | 1.4.2         | 4.4.0            | 2.7.8         | 1.3.0         |
+| 2021.1 or 2.2.5.RELEASE or 2.1.4.RELEASE or 2.0.4.RELEASE | 1.8.0            | 1.4.1         | 4.4.0            | 2.7.8         | 1.3.0         |
+| 2.2.3.RELEASE or 2.1.3.RELEASE or 2.0.3.RELEASE           | 1.8.0            | 1.3.3         | 4.4.0            | 2.7.8         | 1.3.0         |
+| 2.2.1.RELEASE or 2.1.2.RELEASE or 2.0.2.RELEASE           | 1.7.1            | 1.2.1         | 4.4.0            | 2.7.6         | 1.2.0         |
+| 2.2.0.RELEASE                                             | 1.7.1            | 1.1.4         | 4.4.0            | 2.7.4.1       | 1.0.0         |
+| 2.1.1.RELEASE or 2.0.1.RELEASE or 1.5.1.RELEASE           | 1.7.0            | 1.1.4         | 4.4.0            | 2.7.3         | 0.9.0         |
+| 2.1.0.RELEASE or 2.0.0.RELEASE or 1.5.0.RELEASE           | 1.6.3            | 1.1.1         | 4.4.0            | 2.7.3         | 0.7.1         |
+
+# �ܽ�
+
+
+
+���ľ��Ǵ�ȫ������һЩSpring Cloud Alibaba��һЩ�ܹ�˼�룬����û�д�ϸ���ģ�����ϸ�ڿ��Բο���Spring Cloud Alibabaϵ�С���
+
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudAlibabaNacos\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\346\234\215\345\212\241\345\217\221\347\216\260.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudAlibabaNacos\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\346\234\215\345\212\241\345\217\221\347\216\260.md"
new file mode 100644
index 0000000..af691d6
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudAlibabaNacos\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\346\234\215\345\212\241\345\217\221\347\216\260.md"
@@ -0,0 +1,469 @@
+# һ��Nacos����������ͼ
+
+![���������ͼƬ����](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/b5b4ef0330dc4882b0fc2f73994face7.png "���������ͼƬ����")
+
+�������Լ�����һ�����̣�Ҳ���Բο���[Nacos����ע��Դ���������ͼ](https://blog.csdn.net/Saintmm/article/details/121981184)
+
+# ������Դ�����
+
+spring-cloud-commons���ж�����һ�׷����ֵĹ淶�������߼���`DiscoveryClient`�ӿ��У�
+![���������ͼƬ����](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/75ebfd400023456faaafd95e7d9cdbf7.png "���������ͼƬ����")
+����Spring Cloudʵ�ַ����ֵ��������ʵ��`DiscoveryClient`�ӿڣ�nacos-discovery���µ�`NacosDiscoveryClient`��ʵ��`DiscoveryClient`�ӿڡ�
+![���������ͼƬ����](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/0c330a7ce5c744c4a2b25dc024b2430f.png "���������ͼƬ����")
+
+# �����ͻ��˷�����
+
+> 1����nacos�ͻ�����?����֮����ֻ��ȥ������ע�ᡢ���û�ȡ�Ȳ���������������ȥ���������Ϣ��
+> 2������һ������ʱ�򣬲Ż�ȥ��ȡ���񣬼�`�����ػ���`��
+
+#### 1���ȴӱ��ػ���serviceInfoMap�л�ȡ����ʵ����Ϣ����ȡ������ͨ��`NamingProxy`����Nacos ����˻�ȡ����ʵ����Ϣ���������ʱ����ÿ���������� ��ȡʵ����Ϣ�б��������±��ػ���serviceInfoMap��
+
+```
+// NacosDiscoveryClient#getInstances()
+public List<ServiceInstance> getInstances(String serviceId) {
+    try {
+        // ͨ��NacosNamingService��ȡ�����Ӧ��ʵ����Ϣ�����ȥ
+        List<Instance> instances = discoveryProperties.namingServiceInstance()
+                .selectInstances(serviceId, true);
+        return hostToServiceInstanceList(instances, serviceId);
+    } catch (Exception e) {
+        throw new RuntimeException(
+                "Can not get hosts from nacos server. serviceId: " + serviceId, e);
+    }
+}
+
+// NacosNamingService#selectInstances()
+public List<Instance> selectInstances(String serviceName, boolean healthy) throws NacosException {
+    return selectInstances(serviceName, new ArrayList<String>(), healthy);
+}
+public List<Instance> selectInstances(String serviceName, List<String> clusters, boolean healthy)
+    throws NacosException {
+    // Ĭ���߶���ģʽ
+    return selectInstances(serviceName, clusters, healthy, true);
+}
+public List<Instance> selectInstances(String serviceName, List<String> clusters, boolean healthy,
+                                      boolean subscribe) throws NacosException {
+    // Ĭ�ϲ�ѯDEFAULT_GROUP�µķ���ʵ����Ϣ
+    return selectInstances(serviceName, Constants.DEFAULT_GROUP, clusters, healthy, subscribe);
+}
+public List<Instance> selectInstances(String serviceName, String groupName, List<String> clusters, boolean healthy, boolean subscribe) throws NacosException {
+
+    ServiceInfo serviceInfo;
+    // Ĭ���߶���ģʽ����subscribeΪTRUE
+    if (subscribe) {
+        serviceInfo = hostReactor.getServiceInfo(NamingUtils.getGroupedName(serviceName, groupName), StringUtils.join(clusters, ","));
+    } else {
+        serviceInfo = hostReactor.getServiceInfoDirectlyFromServer(NamingUtils.getGroupedName(serviceName, groupName), StringUtils.join(clusters, ","));
+    }
+    return selectInstances(serviceInfo, healthy);
+}
+```
+
+`HostReactor#getServiceInfo()`������������ȡ����ʵ����Ϣ�ĵط���
+
+```
+public ServiceInfo getServiceInfo(final String serviceName, final String clusters) {
+
+    NAMING_LOGGER.debug("failover-mode: " + failoverReactor.isFailoverSwitch());
+    String key = ServiceInfo.getKey(serviceName, clusters);
+    if (failoverReactor.isFailoverSwitch()) {
+        return failoverReactor.getService(key);
+    }
+
+    // 1���ӱ��ػ���serviceInfoMap�л�ȡʵ����Ϣ
+    ServiceInfo serviceObj = getServiceInfo0(serviceName, clusters);
+
+    // 2��������ػ�����û�У�����HTTP���ô�Nacos����˻�ȡ
+    if (null == serviceObj) {
+        serviceObj = new ServiceInfo(serviceName, clusters);
+
+        serviceInfoMap.put(serviceObj.getKey(), serviceObj);
+
+        updatingMap.put(serviceName, new Object());
+        updateServiceNow(serviceName, clusters);
+        updatingMap.remove(serviceName);
+
+    } else if (updatingMap.containsKey(serviceName)) {
+
+        if (UPDATE_HOLD_INTERVAL > 0) {
+            // hold a moment waiting for update finish
+            synchronized (serviceObj) {
+                try {
+                    serviceObj.wait(UPDATE_HOLD_INTERVAL);
+                } catch (InterruptedException e) {
+                    NAMING_LOGGER.error("[getServiceInfo] serviceName:" + serviceName + ", clusters:" + clusters, e);
+                }
+            }
+        }
+    }
+
+    // 3������һ����ʱ����ÿ��һ���Nacos����˻�ȡ���µķ���ʵ����Ϣ�����µ����ػ���seriveInfoMap��
+    scheduleUpdateIfAbsent(serviceName, clusters);
+
+    // 4�� �ӱ��ػ���serviceInfoMap�л�ȡ����ʵ����Ϣ
+    return serviceInfoMap.get(serviceObj.getKey());
+}
+```
+
+1���ӱ��ػ����л�ȡ����ʵ����Ϣ��
+
+```
+private ServiceInfo getServiceInfo0(String serviceName, String clusters) {
+
+    String key = ServiceInfo.getKey(serviceName, clusters);
+
+    return serviceInfoMap.get(key);
+}
+```
+
+2������HTTP���ô�Nacos����˻�ȡ����ʵ����Ϣ��
+
+```
+public void updateServiceNow(String serviceName, String clusters) {
+    ServiceInfo oldService = getServiceInfo0(serviceName, clusters);
+    try {
+
+        // ͨ��NamingProxy��HTTP�ӿڵ��ã���ȡ����ʵ����Ϣ
+        String result = serverProxy.queryList(serviceName, clusters, pushReceiver.getUDPPort(), false);
+        if (StringUtils.isNotEmpty(result)) {
+            // ���±��ػ���serviceInfoMap
+            processServiceJSON(result);
+        }
+    } catch (Exception e) {
+        NAMING_LOGGER.error("[NA] failed to update serviceName: " + serviceName, e);
+    } finally {
+        if (oldService != null) {
+            synchronized (oldService) {
+                oldService.notifyAll();
+            }
+        }
+    }
+}
+```
+
+3������һ����ʱ����ÿ��һ���Nacos����˻�ȡ���µķ���ʵ����Ϣ�����µ����ػ���seriveInfoMap�У�
+
+```
+public void scheduleUpdateIfAbsent(String serviceName, String clusters) {
+    if (futureMap.get(ServiceInfo.getKey(serviceName, clusters)) != null) {
+        return;
+    }
+
+    synchronized (futureMap) {
+        if (futureMap.get(ServiceInfo.getKey(serviceName, clusters)) != null) {
+            return;
+        }
+
+        // ������ʱ����
+        ScheduledFuture<?> future = addTask(new UpdateTask(serviceName, clusters));
+        futureMap.put(ServiceInfo.getKey(serviceName, clusters), future);
+    }
+}
+
+// ��ʱ����ִ���߼���UpdateTask#run()
+public void run() {
+    try {
+        ServiceInfo serviceObj = serviceInfoMap.get(ServiceInfo.getKey(serviceName, clusters));
+
+        if (serviceObj == null) {
+            updateServiceNow(serviceName, clusters);
+            executor.schedule(this, DEFAULT_DELAY, TimeUnit.MILLISECONDS);
+            return;
+        }
+
+        if (serviceObj.getLastRefTime() <= lastRefTime) {
+            updateServiceNow(serviceName, clusters);
+            serviceObj = serviceInfoMap.get(ServiceInfo.getKey(serviceName, clusters));
+        } else {
+            // if serviceName already updated by push, we should not override it
+            // since the push data may be different from pull through force push
+            refreshOnly(serviceName, clusters);
+        }
+
+        // ����һ����ʱ����1s֮��ִ��
+        executor.schedule(this, serviceObj.getCacheMillis(), TimeUnit.MILLISECONDS);
+
+        lastRefTime = serviceObj.getLastRefTime();
+    } catch (Throwable e) {
+        NAMING_LOGGER.warn("[NA] failed to update serviceName: " + serviceName, e);
+    }
+
+}
+```
+
+��ѯ����ʵ���б���
+
+```
+public String queryList(String serviceName, String clusters, int udpPort, boolean healthyOnly)
+    throws NacosException {
+
+    final Map<String, String> params = new HashMap<String, String>(8);
+    params.put(CommonParams.NAMESPACE_ID, namespaceId);
+    params.put(CommonParams.SERVICE_NAME, serviceName);
+    params.put("clusters", clusters);
+    params.put("udpPort", String.valueOf(udpPort));
+    params.put("clientIP", NetUtils.localIP());
+    params.put("healthyOnly", String.valueOf(healthyOnly));
+
+    return reqAPI(UtilAndComs.NACOS_URL_BASE + "/instance/list", params, HttpMethod.GET);
+}
+```
+
+#### 2����HostReactorʵ������ʱ���ʵ����PushReceiver����������һ���߳���ѭ��ͨ��`DatagramSocket#receive()`����Nacos������з���ʵ����Ϣ����������UDP֪ͨ��
+
+```
+public class PushReceiver implements Runnable {
+    private DatagramSocket udpSocket;
+
+    public PushReceiver(HostReactor hostReactor) {
+        try {
+            this.hostReactor = hostReactor;
+            udpSocket = new DatagramSocket();
+            // ����һ���߳�
+            executorService = new ScheduledThreadPoolExecutor(1, new ThreadFactory() {
+                @Override
+                public Thread newThread(Runnable r) {
+                    Thread thread = new Thread(r);
+                    thread.setDaemon(true);
+                    thread.setName("com.alibaba.nacos.naming.push.receiver");
+                    return thread;
+                }
+            });
+
+            executorService.execute(this);
+        } catch (Exception e) {
+            NAMING_LOGGER.error("[NA] init udp socket failed", e);
+        }
+    }
+
+    public void run() {
+        while (true) {
+            try {
+                // byte[] is initialized with 0 full filled by default
+                byte[] buffer = new byte[UDP_MSS];
+                DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
+
+                // ����Nacos����˷���ʵ����Ϣ������֪ͨ
+                udpSocket.receive(packet);
+
+                String json = new String(IoUtils.tryDecompress(packet.getData()), "UTF-8").trim();
+                NAMING_LOGGER.info("received push data: " + json + " from " + packet.getAddress().toString());
+
+                PushPacket pushPacket = JSON.parseObject(json, PushPacket.class);
+                String ack;
+                if ("dom".equals(pushPacket.type) || "service".equals(pushPacket.type)) {
+                    hostReactor.processServiceJSON(pushPacket.data);
+
+                    // send ack to server
+                    ack = "{\"type\": \"push-ack\""
+                        + ", \"lastRefTime\":\"" + pushPacket.lastRefTime
+                        + "\", \"data\":" + "\"\"}";
+                } else if ("dump".equals(pushPacket.type)) {
+                    // dump data to server
+                    ack = "{\"type\": \"dump-ack\""
+                        + ", \"lastRefTime\": \"" + pushPacket.lastRefTime
+                        + "\", \"data\":" + "\""
+                        + StringUtils.escapeJavaScript(JSON.toJSONString(hostReactor.getServiceInfoMap()))
+                        + "\"}";
+                } else {
+                    // do nothing send ack only
+                    ack = "{\"type\": \"unknown-ack\""
+                        + ", \"lastRefTime\":\"" + pushPacket.lastRefTime
+                        + "\", \"data\":" + "\"\"}";
+                }
+
+                udpSocket.send(new DatagramPacket(ack.getBytes(Charset.forName("UTF-8")),
+                    ack.getBytes(Charset.forName("UTF-8")).length, packet.getSocketAddress()));
+            } catch (Exception e) {
+                NAMING_LOGGER.error("[NA] error while receiving push data", e);
+            }
+        }
+    }
+
+}
+```
+
+# �ġ�����˷�����
+
+Nacos����˵ķ�������Ҫ�������£�
+
+> 1����ѯ����ʵ���б����ȴӻ���serviceMap���ҵ�service��Ӧ��Cluster���ٴ�Cluster������Set��`persistentInstances`��`ephemeralInstances`��ȡȫ����ʵ����Ϣ��
+> 2�����ͻ��˴�����ip��udp�˿ںż����ӵ�`clientMap`���������������ͣ�clientMap����`NamingSubscriberService`��ʵ����`NamingSubscriberServiceV1Impl`����key��service name��value�Ƕ����˸÷���Ŀͻ����б�(ip+�˿ں�)��
+
+��naming��Ŀ�µ� InstanceController���list()������
+
+#### 1����ȡ����ʵ���б�
+
+```
+@GetMapping("/list")
+@Secured(parser = NamingResourceParser.class, action = ActionTypes.READ)
+public Object list(HttpServletRequest request) throws Exception {
+
+    String namespaceId = WebUtils.optional(request, CommonParams.NAMESPACE_ID, Constants.DEFAULT_NAMESPACE_ID);
+    String serviceName = WebUtils.required(request, CommonParams.SERVICE_NAME);
+    NamingUtils.checkServiceNameFormat(serviceName);
+
+    String agent = WebUtils.getUserAgent(request);
+    String clusters = WebUtils.optional(request, "clusters", StringUtils.EMPTY);
+    String clientIP = WebUtils.optional(request, "clientIP", StringUtils.EMPTY);
+    int udpPort = Integer.parseInt(WebUtils.optional(request, "udpPort", "0"));
+    boolean healthyOnly = Boolean.parseBoolean(WebUtils.optional(request, "healthyOnly", "false"));
+
+    boolean isCheck = Boolean.parseBoolean(WebUtils.optional(request, "isCheck", "false"));
+
+    String app = WebUtils.optional(request, "app", StringUtils.EMPTY);
+    String env = WebUtils.optional(request, "env", StringUtils.EMPTY);
+    String tenant = WebUtils.optional(request, "tid", StringUtils.EMPTY);
+
+    Subscriber subscriber = new Subscriber(clientIP + ":" + udpPort, agent, app, clientIP, namespaceId, serviceName,
+            udpPort, clusters);
+    // ��ȥInstanceOperatorServiceImpl#listInstance()������ȡ����ʵ���б�
+    return getInstanceOperator().listInstance(namespaceId, serviceName, subscriber, clusters, healthyOnly);
+}
+
+//InstanceOperatorServiceImpl#listInstance()
+public ServiceInfo listInstance(String namespaceId, String serviceName, Subscriber subscriber, String cluster,
+            boolean healthOnly) throws Exception {
+        ClientInfo clientInfo = new ClientInfo(subscriber.getAgent());
+        String clientIP = subscriber.getIp();
+        ServiceInfo result = new ServiceInfo(serviceName, cluster);
+        Service service = serviceManager.getService(namespaceId, serviceName);
+        long cacheMillis = switchDomain.getDefaultCacheMillis();
+
+        // now try to enable the push
+        try {
+            // �����������ͷ���UdpPushService��������ʵ����Ϣ�������ʱͨ��UDP�ķ�ʽ֪ͨNacos Client
+            if (subscriber.getPort() > 0 && pushService.canEnablePush(subscriber.getAgent())) {
+                subscriberServiceV1.addClient(namespaceId, serviceName, cluster, subscriber.getAgent(),
+                        new InetSocketAddress(clientIP, subscriber.getPort()), pushDataSource, StringUtils.EMPTY,
+                        StringUtils.EMPTY);
+                cacheMillis = switchDomain.getPushCacheMillis(serviceName);
+            }
+        } catch (Exception e) {
+            Loggers.SRV_LOG.error("[NACOS-API] failed to added push client {}, {}:{}", clientInfo, clientIP,
+                    subscriber.getPort(), e);
+            cacheMillis = switchDomain.getDefaultCacheMillis();
+        }
+
+        if (service == null) {
+            if (Loggers.SRV_LOG.isDebugEnabled()) {
+                Loggers.SRV_LOG.debug("no instance to serve for service: {}", serviceName);
+            }
+            result.setCacheMillis(cacheMillis);
+            return result;
+        }
+
+        // �������Ƿ����
+        checkIfDisabled(service);
+
+        // �����ǻ�ȡ����ע����Ϣ�Ĺؼ����룬��ȡ�������ú���ʱ����ʵ��
+        List<com.alibaba.nacos.naming.core.Instance> srvedIps = service
+                .srvIPs(Arrays.asList(StringUtils.split(cluster, StringUtils.COMMA)));
+
+        // filter ips using selector��ѡ�������˷���
+        if (service.getSelector() != null && StringUtils.isNotBlank(clientIP)) {
+            srvedIps = selectorManager.select(service.getSelector(), clientIP, srvedIps);
+        }
+
+        // ����Ҳ��������򷵻ص�ǰ����
+        if (CollectionUtils.isEmpty(srvedIps)) {
+        .......
+        return result;
+    }
+
+// Service#srvIPs()
+public List<Instance> srvIPs(List<String> clusters) {
+    if (CollectionUtils.isEmpty(clusters)) {
+        clusters = new ArrayList<>();
+        clusters.addAll(clusterMap.keySet());
+    }
+    return allIPs(clusters);
+}
+
+// Service#allIPs()
+public List<Instance> allIPs(List<String> clusters) {
+    List<Instance> result = new ArrayList<>();
+    for (String cluster : clusters) {
+        // ����ע���ʱ�򣬻Ὣʵ����Ϣд��clusterMap�У����ڴ�����ȡ
+        Cluster clusterObj = clusterMap.get(cluster);
+        if (clusterObj == null) {
+            continue;
+        }
+
+        result.addAll(clusterObj.allIPs());
+    }
+    return result;
+}
+
+// Cluster#allIPs()
+public List<Instance> allIPs() {
+    List<Instance> allInstances = new ArrayList<>();
+    // ��ȡ���������еij־û�ʵ��
+    allInstances.addAll(persistentInstances);
+    // ��ȡ���������е���ʱʵ��
+    allInstances.addAll(ephemeralInstances);
+    return allInstances;
+}
+```
+
+#### 2������UDP��ʽ������ʵ������
+
+NamingSubscriberServiceV1Impl#addClient()��
+
+```
+public void addClient(String namespaceId, String serviceName, String clusters, String agent,
+        InetSocketAddress socketAddr, DataSource dataSource, String tenant, String app) {
+
+    // ��ʼ�����Ϳͻ���ʵ��PushClient
+    PushClient client = new PushClient(namespaceId, serviceName, clusters, agent, socketAddr, dataSource, tenant,
+            app);
+    // ��������Ŀ��ͻ���
+    addClient(client);
+}
+
+// ���ط���addClient()
+public void addClient(PushClient client) {
+    // client is stored by key 'serviceName' because notify event is driven by serviceName change
+    // �ͻ����ɼ��� serviceName���洢����Ϊ֪ͨ�¼���serviceName��������
+    String serviceKey = UtilsAndCommons.assembleFullServiceName(client.getNamespaceId(), client.getServiceName());
+    ConcurrentMap<String, PushClient> clients = clientMap.get(serviceKey);
+    // �����ȡ�����ͻ�������õ�ServiceName��Ӧ�����Ϳͻ��ˣ����½����Ϳͻ��ˣ�������
+    if (clients == null) {
+        clientMap.putIfAbsent(serviceKey, new ConcurrentHashMap<>(1024));
+        clients = clientMap.get(serviceKey);
+    }
+
+    PushClient oldClient = clients.get(client.toString());
+    // �����ϵ�PushClient����ˢ��
+    if (oldClient != null) {
+        oldClient.refresh();
+    } else {
+        // ���򻺴�PushClient
+        PushClient res = clients.putIfAbsent(client.toString(), client);
+        if (res != null) {
+            Loggers.PUSH.warn("client: {} already associated with key {}", res.getAddrStr(), res);
+        }
+        Loggers.PUSH.debug("client: {} added for serviceName: {}", client.getAddrStr(), client.getServiceName());
+    }
+}
+```
+
+# �塢�ܽ�
+
+�ͻ��ˣ�
+
+> 1�����ȴӱ��ػ����л�ȡ����ʵ����Ϣ��
+> 2��ά����ʱ����ʱ��Nacos����˻�ȡ����ʵ����Ϣ��
+
+����ˣ�
+
+> 1������ָ�������ռ����ڴ�ע��������е�����ʵ������ʱʵ�����ͻ��ˣ�
+> 2������һ��UDP����ʵ����Ϣ������ͷ���
+
+
+# �����
+https://developer.aliyun.com/article/1058262
+https://ost.51cto.com/posts/14835
+https://developer.aliyun.com/article/1048465
+https://zhuanlan.zhihu.com/p/70478036
+https://juejin.cn/post/6999814668390760484#heading-8
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudAlibabaNacos\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\346\234\215\345\212\241\346\263\250\345\206\214.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudAlibabaNacos\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\346\234\215\345\212\241\346\263\250\345\206\214.md"
new file mode 100644
index 0000000..1a59865
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudAlibabaNacos\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\346\234\215\345\212\241\346\263\250\345\206\214.md"
@@ -0,0 +1,357 @@
+# һ�� Nacos����ע��Դ�����
+
+
+
+* * *
+
+
+
+## 1.1  Դ�뷽ʽ���
+
+
+
+* * *
+
+
+
+�ͻ���Դ�������Ӵ����ʽ����Դ��������
+
+
+
+
+
+
+
+```<plugin>  <groupId>org.apache.maven.plugins</groupId>  maven-source-plugin  <version>3.2.1</version>  <configuration>  true  </configuration>  <executions>  <execution>  <phase>compile</phase>  <goals>  <goal>jar</goal>  </goals>  </execution>  </executions> </plugin> ```
+
+
+
+
+
+
+
+Ȼ������
+
+
+
+
+
+
+
+```mvn install -DskipTests ```
+
+
+
+
+
+
+
+## 1.2 ���
+
+
+
+* * *
+
+
+
+[github.com/alibaba/nac��](https://link.juejin.cn?target=https%3A%2F%2Fgithub.com%2Falibaba%2Fnacos%2Ftree%2F1.4.1)
+
+�������ǻ��Դ���������������ǻ�ͨ��Դ��ķ�ʽ���������� �����ͨ��debug�ķ�ʽ�����������ж��������й��̡�
+
+���Ǵ�Դ��ĽǶ�������һ�£����������������ϱ���ע�����ģ�
+
+NacosNamingService ���Ƿ���ע��ͷ�����ص��࣬�����������ｫ��ǰ�����ķ������ע��ʵ���ķ��������ǿ�һ�����������ʲô�ˣ�
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/fc004433c7304147905c088dd3227005.png "image.png")
+
+![image-20211221124947544](E:\BaiduNetdiskWorkspace\springcloud alibaba\img\image-20211221124947544.png)
+
+������ƴ����һЩ��������http���󣬵������ע�����Ľ��з��֣�����ľ������·����
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/51f5b45b70ef4a7dbe1258e05314fa61.png "image.png")
+
+������Ƕ�Ӧ��·�������ǻص��ٷ��ĵ���ָ�ϵ���
+
+[nacos.io/zh-cn/docs/��](https://link.juejin.cn?target=https%3A%2F%2Fnacos.io%2Fzh-cn%2Fdocs%2Fopen-api.html)
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/d3b30ba715ab4363b3ee8b4e21a2f3a2.png "image.png")
+
+�ã��������ǽ�������Ͳ����������濴�ˣ����ǿ��Ե��ȥ��һ�£�
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/9f4bbf69cc1746e79545831252796e55.png "image.png")
+
+�������ĵ��ø����������
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/b06c94937d374ddb9fc2c224e5932205.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/d0d55d3616ad4109837d9aee36e5a946.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/450565c4c14f4f3bb2097ab1ea69aae7.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/527d2af9bb0c4206b090d3410238a576.png "image.png")
+
+����������
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/3f3f39de5aaa4ad2b3ac7dccc33aa574.png "image.png")
+
+������ͬѧ������ô֪���ϵ�ʹﵽ��������ǿ�һ�������鿴Դ���������·�������ǿ�һ�����Ƕ���΢�����·��������Ҫ����nacos�ķ����ֹ��ܣ�����Ҫ�������ǵ�discovery�İ�������һ��starter��ǰ������ѧ��springboot����֪���κ�starter����һ���и�spring.factories����Ϊһ�����
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/be47c62f16f94507a1af84d0169ebf53.png "image.png")
+
+�����涯̬���ص���ܶ࣬NacosServiceRegistryAutoConfiguration �������������ܷ�������һ��nacos����ע����Զ������࣬
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/84017587439846a4b21a696f12775b6c.png "image.png")
+
+������ʵ���������࣬���ǿ�һ�������NacosAUtoServiceRegistration
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/fe7ee87e88944b689835432c833972c2.png "image.png")
+
+�Զ�ע���࣬���ǿ��Կ�һ�����ļ��ɹ�ϵ����һ��ApplicationListener  spring������ɺ󶼻ᷢ��һ����Ϣ��applicaitonListener����ͨ�����������ϢȻ�����ִ�еġ���������֪����һ������Ӧ����ô����
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2a12ba62dae24aa092f97b0cff5dfaaa.png "image.png")
+
+���Բ鿴���ij����ࡣ
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1f9253dbbbd349ffb6d0e60d0761b3ec.png "image.png")
+
+�鿴onApplicationEvent�����������ڷ�������ͻᷢ������һ����Ϣ���յ������Ϣ�ͻ�������bind����
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/41a7323a2e2c49d19aaf5768e66af7d8.png "image.png")
+
+�����и�if return ���Ǿ�ֱ����������һ���Ƿ�֧���룬�������ķ�֧�������ǾͲ�Ҫ������һ ��Ҫ�����ߣ���������ֱ�ӿ������start�����������������û�ж�Ӧ�Ĵ����߼����ǿ��Խ��������֧������ �ã�������start, begin��init��register�������Ǻ���Ҫ�ķ���������һ��Ҫ��ȥ��
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/3923ffd589e9488eb1143811a50d28c0.png "image.png")
+
+��һ��if�Ͳ��ÿ����ڶ���if��Ҫ������Ϊ�����û���߼����㿴���register()��Ӧ�þ��������������Ϊ����Dz鿴ע������̡�
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/d5b527e0900a4f1b9abcd76db4bfc138.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/d3501fdf6479417180e881c38638bdac.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7c0ea798fcd7404d8f350047e947add1.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/0ca3ab1a98f248a0aa3854730eba85fb.png "image.png")
+
+������Ҫ��֪��SpringBoot�Զ�װ��Ļ���֪ʶ�����Ҫ֪��Spring�������ֵ� ����֪ʶ��
+
+## 1.3 ����ע��
+
+
+
+* * *
+
+
+
+Nacos�߲���֧���첽�������ڴ��������
+
+�ղ����ڷ����ṩ�����潲�����ݣ��������Ƿ���ע����������һ��
+
+�������instanceʵ���������һ��springmvc��controller���������ǿ���ȫ������ Controller��������instanceʵ���ɣ�������������InstanceController
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/4e02f16787a84704add5aa41f9d7662a.png "image.png")
+
+��֮ǰ�����õ���post�����������Dz鿴post������������delete,update...,��������ʲô��� restFul
+
+���Ƿ�������û�ж�Ӧ��DefaultGroup���ڷ���ע��ͷ��ֵ���������group�Dz������õġ����õĻ�ֻ���Լ��Ĺ淶�ͷ�������ġ��ڷ���ע��ͷ�����Դ���ж�û���á��������ռ䣬��������Ȼ�����Dz���ת��Ϊʵ����������Ƿ���ģ���е�����ģ�͡�
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/09f059ba31a7444a88a24b03399d502d.png "image.png")
+
+�����ǿ�һ������ע��ʵ����������ʲô�� ����������ע��������ע��instance�����Ǿ�Χ�����������з������Dz��Ǿ�����addInstance��
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/4b69913abe6f40288a08dee89ecb0772.png "image.png")
+
+createEmptyService
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/b8a3063b3c924ee195af64d5d8efa647.png "image.png")
+
+1����ȡservice ���λ�ȡһ��Ϊ�գ����ǿ��Խ�ȥ����һ��
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/fdf453ebadee486c9def86560bc3b8de.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7025fb4edcc247b3aca0f1f851d26203.png "image.png")
+
+�������ע���������ǰ��˵��nacos��������ģ�͡����Բο�ͼ�������map���Ƕ�Ӧ��ע���
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/4f1db03d3fcc4f93aaa17cc485fb59c2.png "image.png")
+
+���������÷���ͳ�ʼ��
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1af3a9015b2c4e1ab06da283e4dc5332.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/cb795dd33b114f84bc51cdbdca5af202.png "image.png")
+
+�����ʼ��������
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/0d0583abf0184ed49bf5fd93c9effafe.png "image.png")
+
+�������Ǹ�scheduleNamingHealth��һ����ʱ��������ֻ��Ҫ��һ��task����Ϳ���
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/51ba8120a9954389b9e2f44d49532a14.png "image.png")
+
+task����������Ҫ��һ��run������
+
+���������ǿ��ǻ�ȡ���е�ʵ�������Ե��ȥ��һ�¡�
+
+��ǰʱ�� -  �ϴ�����ʱ�� �������15�� ��ʵ������Ϊ�ǽ����� ������30��û���յ�������ֱ���޳�
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/f9131eea860e410685d8c4cd5beea69e.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/586fd2fcb489414590295ce2dfafd91d.png "image.png")
+
+�ã����ǻ�����������������ر�ã�createEmtyService���Ǵ���һ���շ��񣬺������ǵ�ʵ�����Dz��ǻ���ע�ᵽ���棬
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/9518406856b642298d3ee2f16e36bed0.png "image.png")
+
+> ���ǿ��Կ�һ�·���ģ�ͣ���������ǰ˵����һ��
+>
+> �����ռ� ��cluster ��Ⱥ����
+>
+> ![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/0323827c8249417b8ab3fd6c4bd3e61e.png "image.png")
+>
+> ![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/044d8f58dc5b4c7e83dab05c62397566.png "image.png")
+>
+> ��Ⱥ�ж�Ӧ��ʵ����
+>
+> ![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/da6adcbf25f44992b08f919988f81b62.png "image.png")
+
+���ǿ�һ��addinstance
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/cb9d4cb8fd4d4f0aa75e5d95c4923aae.png "image.png")
+
+������Ӧ��key:
+
+
+
+
+
+
+
+```String key = KeyBuilder.buildInstanceListKey(namespaceId, serviceName, ephemeral); ```
+
+
+
+
+
+
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/6ab491f925e3403fa1377c2649d4721d.png "image.png")
+
+
+
+
+
+
+
+```//��ȡע��ʵ����IP�˿��б� List<Instance> instanceList = addIpAddresses(service, ephemeral, ips); ```
+
+
+
+
+
+
+
+���ǽ���򵥵Ŀ�һ�£����Ƿ������add,remove����������������Ƴ�ʵ��
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/bebd689b54d04e0dab0e64ac552e965e.png "image.png")
+
+������Ҫ������дע�������ips�������Ǿ͵��ips����������ʾ������Ȼ���������ѭ��instance���������ǿ��Կ�����������Ƴ��ʹ�map�����Ƴ���ȥ���������������instanceMap������һ�£�����ڷ��ء�
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/4d797c90012b4c22ac6e999bdfad8d63.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/158d309e86084a76be392ac8b67ccb94.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/04b51596154e4d4b933a39f0eb249587.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/86453757688743df89df30752bbbe0e5.png "image.png")
+
+���࣬���ǿ��Բ²�һ�£�����debug��ȥ����Ȼ����࣬���ǵ��һ�£��������ĵط�
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/f7a189074e00495da10119f2a5de7bc5.png "image.png")
+
+��ָ�������ƣ�
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/c54ca72e12e04d80b189d587a535d834.png "image.png")
+
+�ã�����ȫ��������һ�£�
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2b24cf84302c42669bed76d19a11e301.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/fcf6ffab779548a694a68c443a90a214.png "image.png")
+
+����֪��ǰ��˵��ephemeral��true����ѡ���һ���� �����ʣ�
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/4adb989d26cf46f98c943a114e047679.png "image.png")
+
+����Ӧ�õ���EphemeralConsistencyService��Ӧ��put����������EphemeralConsistencyServiceֻ��һ���ӿڣ�����Ӧ�õ��ö�Ӧ��ʵ��ʵ����
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/87869280d709441fbb8ceec818d67a97.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/3764ecf8f5904315af85482f3c3ee71d.png "image.png")
+
+���ǿ�һ������onput������
+
+���ڷŵ������У�
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/02a34386b7444f0e8a6e35e57ceedf84.png "image.png")
+
+��������ǰѺ��ĵ�����ŵ�blockquene���棬Ҳ����һ������������
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/81b1c141753c492493eb095ead9e34da.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/252863f614a24c2da64713af52669ce5.png "image.png")
+
+����ע��Ĺ��̾���ô�򵥣�һ��������������ս�����ע������󣬷ŵ����ǵ��������е��У��ŵ���ɫ����֮�������������оͷ����ˡ��Ƿŵ���������֮�������з�������������С�
+
+���ע�����Notifier��һ���̣߳���ʦ�����һ�����ɣ��������һ���߳̾���Ҫ������run������Ϊrun���������� ����ִ�д���ĵط���
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/659d96fac1d445859a6ea6086ab8277c.png "image.png")
+
+�����������ѭ���������ݴ��������ϵĴ����ͻ���ע�����Ϣ����������ʵ�ֺ�����첽ע����Ϣ��
+
+����̻߳�һֱ��ת��һֱ���У������������˵����������͹ҵ��ˣ��ã��㿴��������쳣Ҳ�Ե��ˣ�����һֱ�����У����û�����������������������ó�cpu
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/487a2e6d15f642549fe0d145447cc5cf.png "image.png")
+
+ע����ṹ�ķ�����
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/3eab037db7e2480ba4a9b439b18567da.png "image.png")
+
+���ȵ����Ǹ�change��ʱ�����Ǿͽ���onChange�����Ǹ������������ǽ�������service����ȥ����
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/4adf69d76188430d860f2003b6c508d6.png "image.png")
+
+������Ͳ��ÿ��ˣ��ȿ�Ȩ�أ�Ȩ�ش��ڶ��ٵ�ʱ���������ֵ��Ȩ��С�ڶ��ٵ�ʱ������һ����Сֵ��Ȼ����Ǻ��ĵķ���updateIP
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/887332bfdcb64c2f9ad871ee55961b59.png "image.png")
+
+�����updateIPs����ʲô�أ� ���ľ����ұ���������Ҫע���ʵ����Ȼ��ͷŵ����ǵ�clusterMap����
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/87df4508357847f1ab49a785ab464e5b.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/b31cf0150533469ebd4fbc462c6a0952.png "image.png")
+
+�ǵ������ҿ��ܾ��������ˣ���ʲôʱ����������̣߳���ʵʱ����������Ϣ�����������أ� �̴�������һ������������������ڿ��Ÿ����Notifier����Ϊ����������һ���̣߳����ᶪ��һ���̳߳��н������У����ǿ�һ����������������ʵ�����ģ�
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/16223a5f9aab4fdaa004d0698e6cb0a6.png "image.png")
+
+���ǿ���������������ע����ǵ����spring��һ������г�ʼ��֮����е��õģ������ǿ�һ�����init��������������ʲô
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/b9d2a25274834d73ab8f939006e9b075.png "image.png")
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/64f25704efac43a7ae6ee5afda46cdf7.png "image.png")
+
+��һ��Scheduled�̳߳أ�
+
+![image-20211222222903941](E:\BaiduNetdiskWorkspace\springcloud alibaba\img\image-20211222222903941.png)
+
+Ҳ�����ڶ����ʼ����ʱ��ͽ�������һ���̳߳أ�ȥ����notifier��Ӧ�ķ��������run������������run�ġ�������ͻ�ʵʱ�����첽���С�����д�ĺô������ǽ�д�ʹ�����ȫ�����ˡ�ͨ�����������ܵ��ڴ���У�������������飬�������ĺô���1���������
+
+![image.png](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/e27c8e72b30845c3ab9346b89932fb42.png "image.png")
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudAlibabaNacos\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\346\246\202\350\247\210.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudAlibabaNacos\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\346\246\202\350\247\210.md"
new file mode 100644
index 0000000..dc517a0
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudAlibabaNacos\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\346\246\202\350\247\210.md"
@@ -0,0 +1,501 @@
+�ڿ���ƪ����֮ǰ����ö�NACOS��ع��������˽⣬�Ƽ�����[Spring Cloud Alibaba Nacos������ƪ��](https://zhuanlan.zhihu.com/p/68700978)��
+
+��Թ��ܣ���Ŀ�ĵ�ȥ�����Ӧ��Դ���룬��һ���˽⹦������α�ʵ�ֳ����ġ�
+
+���������һ��Դ�����Ķ��������Ⱥ����������̫���ϸ�ڣ�����Ҫ���ߴ�Դ����٣�������ᡣ
+
+## һ������
+
+����GitHub��Ӧ��[ҳ��](https://link.zhihu.com/?target=https%3A//github.com/alibaba/nacos)����NACOS����clone������Ŀ¼���ļ����������߳������Ƕ��ڿ�Դ���������а����IJ��ֲ����ࡣ
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-e9966f158af7cfac39baf5bba456fd17_720w.webp)
+
+<figcaption>nacos����Ŀ¼�ṹ</figcaption>
+
+</figure>
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-9195cfddde4e94b16f239bc101825a5a_720w.webp)
+
+<figcaption>ģ������ͼ</figcaption>
+
+</figure>
+
+<figure data-size="normal">
+
+
+![](https://pic4.zhimg.com/80/v2-6b30d0fc994745002ee7dcc7b04154d3_720w.webp)
+
+<figcaption>nacos����ģ��</figcaption>
+
+</figure>
+
+����������ͼ������˳���ҵ�ͻ�ƿ��ˣ��������ݾͼ�����nacos-console��nacos-naming��nacos-config��˳�����ϣ����ܿ������������ˡ�
+
+������Ǹо��޴����ֵĻ����Ǿ��Ʋ�nacos-example����������Ҫҵ��ĵ�����ڣ�һ����֪��
+
+## �������÷���
+
+���ȴ�һ��������˵��com.alibaba.nacos.api.NacosFactory��
+
+����ľ�̬�������ڴ���ConfigService��NamingService���������ƣ��Դ���ConfigServiceΪ����
+
+
+
+```
+public static ConfigService createConfigService(Properties properties) throws NacosException {
+        try {
+            Class<?> driverImplClass = Class.forName("com.alibaba.nacos.client.config.NacosConfigService");
+            Constructor constructor = driverImplClass.getConstructor(Properties.class);
+            ConfigService vendorImpl = (ConfigService) constructor.newInstance(properties);
+            return vendorImpl;
+        } catch (Throwable e) {
+            throw new NacosException(-400, e.getMessage());
+        }
+}
+```
+
+
+
+û��ʲô���ӵ��߼���ʹ�õ��ǻ����ķ���ԭ�����������������properties����Щ���Կ���ͨ��bootstrap.yml��ָ������Ӧ����NacosConfigProperties��
+
+��Ҫϸ�����ǹ��캯���ж���namespace��ʼ�����Dz������ݡ�
+
+
+
+```
+private void initNamespace(Properties properties) {
+        String namespaceTmp = null;
+
+        String isUseCloudNamespaceParsing =
+            properties.getProperty(PropertyKeyConst.IS_USE_CLOUD_NAMESPACE_PARSING,
+                System.getProperty(SystemPropertyKeyConst.IS_USE_CLOUD_NAMESPACE_PARSING,
+                    String.valueOf(Constants.DEFAULT_USE_CLOUD_NAMESPACE_PARSING)));
+
+        if (Boolean.valueOf(isUseCloudNamespaceParsing)) {
+            namespaceTmp = TemplateUtils.stringBlankAndThenExecute(namespaceTmp, new Callable<String>() {
+                @Override
+                public String call() {
+                    return TenantUtil.getUserTenantForAcm();
+                }
+            });
+
+            namespaceTmp = TemplateUtils.stringBlankAndThenExecute(namespaceTmp, new Callable<String>() {
+                @Override
+                public String call() {
+                    String namespace = System.getenv(PropertyKeyConst.SystemEnv.ALIBABA_ALIWARE_NAMESPACE);
+                    return StringUtils.isNotBlank(namespace) ? namespace : EMPTY;
+                }
+            });
+        }
+
+        if (StringUtils.isBlank(namespaceTmp)) {
+            namespaceTmp = properties.getProperty(PropertyKeyConst.NAMESPACE);
+        }
+        namespace = StringUtils.isNotBlank(namespaceTmp) ? namespaceTmp.trim() : EMPTY;
+        properties.put(PropertyKeyConst.NAMESPACE, namespace);
+}
+```
+
+
+
+�����properties��ָ���Ƿ�����ƻ����е�namespace����������ǵģ�����ȥ��ȡ�����ƻ�����ϵͳ������������ǣ���ô�Ͷ�ȡproperties��ָ����namespace��û��ָ���Ļ������ս����������ǿ��ַ������Ӵ����Ͽ���������ȡ�ƻ�����namespace�������첽������ʽ������Ŀǰ�汾����ʹ�õ�ͬ�����á�
+
+��������ConfigService�����涨����һϵ�нӿڷ���������������Ҫ���ġ�
+
+ÿ��ҵ��ʵ�����ն����ΪHttp���󣬾������õ�serverAddr�������ַ��������תʹ�ã���Ȼ����һ����ʱʱ�����������󣬶����󲻳ɹ��ˣ��Ǿͻ��׳��쳣��
+
+������nacos-client�����շ����ն����䵽nacos-config�����ϣ����ʹ��JdbcTemplate�������ݳ־û���
+
+��һ���ֵĴ���һ�������ף��������ã���ȡ���ú�ɾ�����ö��������֣��Ͳ�չ�������ˡ�
+
+�ص����һ�����ü������ֵ�Դ���롣
+
+�Ƚ�ע��������com.alibaba.nacos.client.config.impl.CacheData������ݽṹ�ϣ��Ǹ����͵ij�Ѫģ�ͣ���Ҫ�dz䵱listener�����ߵĽ�ɫ����������������ȡ�ò�������ô�Ѻ��ˡ�
+
+ʵ���ϣ����Կ���CacheData��������Ϣ��namespace, content����listener�ۺ���һ���ˣ�������Ϊһ�����ÿ��Ը��Ӷ���listenerʵʩ��������Ϊlistener�ӿڿ����ж���ʵ�֣���ÿ��listenerֻ����һ��ʵ�������������ϡ�
+
+
+
+```
+public void addListener(Listener listener) {
+        if (null == listener) {
+            throw new IllegalArgumentException("listener is null");
+        }
+        ManagerListenerWrap wrap = new ManagerListenerWrap(listener);
+        if (listeners.addIfAbsent(wrap)) {
+            LOGGER.info("[{}] [add-listener] ok, tenant={}, dataId={}, group={}, cnt={}", name, tenant, dataId, group,
+                listeners.size());
+        }
+}
+```
+
+
+
+ʹ����CopyOnWriteArrayList.addIfAbsent�����������������Ҫ����equals������ManagerListenerWrap�Ƕ�listener������һ����ʽ�İ�������ʵ����equals������
+
+
+
+```
+@Override
+public boolean equals(Object obj) {
+        if (null == obj || obj.getClass() != getClass()) {
+            return false;
+        }
+        if (obj == this) {
+            return true;
+        }
+        ManagerListenerWrap other = (ManagerListenerWrap) obj;
+        return listener.equals(other.listener);
+}
+```
+
+
+
+�����ϲ㷭�������ҵ�����listener���߲�Ĺ���API��com.alibaba.nacos.client.config.impl.ClientWorker��
+
+ͬ���Ƕ�listener�Ĺ����������������ظ�У�飬����cacheMap�ǹؼ������¶��壺
+
+
+
+```
+private final AtomicReference<Map<String, CacheData>> cacheMap = new AtomicReference<Map<String, CacheData>>()
+```
+
+
+
+ʹ���˾���ԭ���Բ������Ե�AtomicReference�����Ա��Ⲣ�����������ݲ�һ�µ����⣬�����������һ��HashMap��value��CacheData���󣬶�key����һ�����ɹ���ģ���GroupKey������п����ҵ���
+
+
+
+```
+static public String getKeyTenant(String dataId, String group, String tenant) {
+        StringBuilder sb = new StringBuilder();
+        urlEncode(dataId, sb);
+        sb.append('+');
+        urlEncode(group, sb);
+        if (StringUtils.isNotEmpty(tenant)) {
+            sb.append('+');
+            urlEncode(tenant, sb);
+        }
+        return sb.toString();
+}
+```
+
+
+
+ʵ�����ǽ�������Ϣ�á�+���Ž���ƴ�ӣ����������Ϣ�б��������ˡ�+���͡�%������ʹ��urlEncode�������б���ת�塣��Ȼ��Ҳ�����׵Ľ�������������Ͳ���չ�������ˡ�
+
+���������޷Ǿ��Ǿ�cacheMap��һϵ��get��set����������ά��listener���ر�ע����ǣ�ÿ�θ��²�������������һ��copy���󣬲����˶���֮��������set�����ǣ���cacheMap�С�
+
+���˵һ��listener��������������ġ�
+
+��Ȼ����ClientWorker���п����ҵ�����ע����ת�Ƶ����캯���С����У�����ע�⵽����ʼ���������̳߳أ�
+
+
+
+```
+    executor = Executors.newScheduledThreadPool(1, new ThreadFactory() {
+            @Override
+            public Thread newThread(Runnable r) {
+                Thread t = new Thread(r);
+                t.setName("com.alibaba.nacos.client.Worker." + agent.getName());
+                t.setDaemon(true);
+                return t;
+            }
+        });
+
+        executorService = Executors.newScheduledThreadPool(Runtime.getRuntime().availableProcessors(), new ThreadFactory() {
+            @Override
+            public Thread newThread(Runnable r) {
+                Thread t = new Thread(r);
+                t.setName("com.alibaba.nacos.client.Worker.longPolling." + agent.getName());
+                t.setDaemon(true);
+                return t;
+            }
+        });
+
+        executor.scheduleWithFixedDelay(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    checkConfigInfo();
+                } catch (Throwable e) {
+                    LOGGER.error("[" + agent.getName() + "] [sub-check] rotate check error", e);
+                }
+            }
+       }, 1L, 10L, TimeUnit.MILLISECONDS);
+```
+
+
+
+��������ִ�ж�ʱ�����scheduledThreadPool�����������̳߳صķֹ�Ҳ��Ƕ�׵ģ�executor���ڷ������ü������񣬶�executorService��������Ľ����ߣ�������ִ������Ľ�ɫ��
+
+���Է���������̳߳�ֻ������1�������߳�������ִ��������̳߳صĺ����߳���CPU������
+
+��Ϊ���ü����һ������ѯ�Ĺ��̣�һ������ִ�����ܼ�������������Ҫ�õ����ƣ�����NACOSĿǰʹ����һ���Ƚϼ򵥵ķ��������
+
+
+
+```
+public void checkConfigInfo() {
+        // ������
+        int listenerSize = cacheMap.get().size();
+        // ����ȡ��Ϊ����
+        int longingTaskCount = (int) Math.ceil(listenerSize / ParamUtil.getPerTaskConfigSize());
+        if (longingTaskCount > currentLongingTaskCount) {
+            for (int i = (int) currentLongingTaskCount; i < longingTaskCount; i++) {
+                // Ҫ�ж������Ƿ���ִ�� �����Ҫ�ú����롣 �����б�����������ġ��仯���̿���������
+                executorService.execute(new LongPollingRunnable(i));
+            }
+            currentLongingTaskCount = longingTaskCount;
+        }
+}
+```
+
+
+
+��ParamUtil.getPerTaskConfigSize()�з��ص���ÿ�������ܼ��������������ޣ�Ĭ����3000��������ͨ��ϵͳ����PER_TASK_CONFIG_SIZE����������ޡ�
+
+�Ӵ����Ͽ��Կ����������ǰlistener������û�г���3000�������ü����̳߳ػ���ת�����������ϸ��������ֵĴ��룬���ǻᷢ��һЩ����ģ���Ҫ��Χ���������������������һϵ�����⡣
+
+����ѯ������Ҫ���������߼���
+
+*   ��鱾�����ã���CacheData�洢����Ϣ����һ�£�
+*   ���server�����ã�����CacheData�洢����Ϣ��
+
+## ��������ע���뷢��
+
+���������Ļ������ⲿ�ִ��뿴������Ƚ������ˣ��ṹ�ϻ������ơ�
+
+ֱ�ӽ���com.alibaba.nacos.api.naming.NamingService�������ж��registerInstance�ع����������ڷ���ע�ᡣ
+
+�ȿ���Instanceʵ������������ݣ�id��ip��port��serviceName��clusterName�����ڼ�Ⱥ����weight��Ȩ�أ���healthy���Ƿ���������enabled���Ƿ����ã���ephemeral���Ƿ�����ʱ�ģ�����9������ȫ����������Console���������֡�
+
+Ȼ��ֱ�ӿ�ע�����ķ�����
+
+
+
+```
+   @Override
+    public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
+
+        if (instance.isEphemeral()) {
+            BeatInfo beatInfo = new BeatInfo();
+            beatInfo.setServiceName(NamingUtils.getGroupedName(serviceName, groupName));
+            beatInfo.setIp(instance.getIp());
+            beatInfo.setPort(instance.getPort());
+            beatInfo.setCluster(instance.getClusterName());
+            beatInfo.setWeight(instance.getWeight());
+            beatInfo.setMetadata(instance.getMetadata());
+            beatInfo.setScheduled(false);
+            beatReactor.addBeatInfo(NamingUtils.getGroupedName(serviceName, groupName), beatInfo);
+        }
+        serverProxy.registerService(NamingUtils.getGroupedName(serviceName, groupName), groupName, instance);
+    }
+```
+
+
+
+ǰ��һ��δ����Ƕ���ʱ����ʵ���Ĵ����������ڹ���һ�����������͸�NACOS����
+
+registerService�������Ƿ�װ��HTTP����������InstanceController�д�������
+
+�����Ŀ������spring-cloud-starter-alibaba-nacos-discovery������������Ĭ�����Զ�ע��ġ�����뿴�Զ�ע��Ĺ��̣����Դ�AbstractAutoServiceRegistration��ʼ���֣�������һ�δ��룺
+
+
+
+```
+	@EventListener(WebServerInitializedEvent.class)
+	public void bind(WebServerInitializedEvent event) {
+		ApplicationContext context = event.getApplicationContext();
+		if (context instanceof ConfigurableWebServerApplicationContext) {
+			if ("management".equals(
+					((ConfigurableWebServerApplicationContext) context).getServerNamespace())) {
+				return;
+			}
+		}
+		this.port.compareAndSet(0, event.getWebServer().getPort());
+		this.start();
+	}
+```
+
+
+
+������Web�����ʼ����ɵ��¼������ջ�ִ��start������
+
+
+
+```
+	public void start() {
+		if (!isEnabled()) {
+			if (logger.isDebugEnabled()) {
+				logger.debug("Discovery Lifecycle disabled. Not starting");
+			}
+			return;
+		}
+		// only initialize if nonSecurePort is greater than 0 and it isn't already running
+		// because of containerPortInitializer below
+		if (!this.running.get()) {
+			register();
+			if (shouldRegisterManagement()) {
+				registerManagement();
+			}
+			this.context.publishEvent(new InstanceRegisteredEvent<>(this, getConfiguration()));
+			this.running.compareAndSet(false, true);
+		}
+
+	}
+```
+
+
+
+���У�register������������ĵIJ����ˣ���Դ��NacosServiceRegistry��ʵ�֣�
+
+
+
+```
+	@Override
+	public void register(NacosRegistration registration) {
+
+		if (!registration.isRegisterEnabled()) {
+			logger.info("Nacos Registration is disabled...");
+			return;
+		}
+		if (StringUtils.isEmpty(registration.getServiceId())) {
+			logger.info("No service to register for nacos client...");
+			return;
+		}
+		NamingService namingService = registration.getNacosNamingService();
+		String serviceId = registration.getServiceId();
+
+		Instance instance = new Instance();
+		instance.setIp(registration.getHost());
+		instance.setPort(registration.getPort());
+		instance.setWeight(registration.getRegisterWeight());
+		instance.setClusterName(registration.getCluster());
+		instance.setMetadata(registration.getMetadata());
+		try {
+			namingService.registerInstance(serviceId, instance);
+			logger.info("nacos registry, {} {}:{} register finished", serviceId, instance.getIp(), instance.getPort());
+		}catch (Exception e) {
+			logger.error("nacos registry, {} register failed...{},", serviceId, registration.toString(), e);
+		}
+	}
+```
+
+
+
+��δ���ͷdz���Ϥ�ˣ����վͻص���������namingService.registerInstance������
+
+
+
+```
+    /**
+     * Map<namespace, Map<group::serviceName, Service>>
+     */
+    private Map<String, Map<String, Service>> serviceMap = new ConcurrentHashMap<>();
+```
+
+
+
+���ϳ���������һ��ʵ���ࣺcom.alibaba.nacos.naming.core.Service��Service�ǰ�����Instance��һ��Service���ж��Instance���������һ��Cluster��
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-21ca2c51d56d6401dee0db0444df8ddf_720w.webp)
+
+<figcaption>��ʵ����Ⱥ</figcaption>
+
+</figure>
+
+�ڵ���registerInstanceע��ʵ����ʱ��������ֶ�Ӧ��Serviceû�б�ע�ᣬ��ô��registerService�����һ��ʼ����Ӧ��Cluster�������������Ķ�ʱ����
+
+��registerInstance�෴����deregisterInstance����Ϊȡ��ע�ᣬҲ������Ϊ�Ƿ���ʵ�����ߡ�
+
+���������NACOS���ʵ�ַ����ֹ��ܡ�
+
+�������ߣ����÷����ĽǶ����������ɵ�starter��Ŀ���и��ࣺNacosServerList������Ҫ���Ǽ̳���AbstractServerList��ʵ���������ؼ��Ľӿڷ������൱����NACOS��Ribbon�ĶԽӵ㡣
+
+
+
+```
+public interface ServerList<T extends Server> {
+
+    public List<T> getInitialListOfServers();
+
+    /**
+     * Return updated list of servers. This is called say every 30 secs
+     * (configurable) by the Loadbalancer's Ping cycle
+     * 
+     */
+    public List<T> getUpdatedListOfServers();   
+
+}
+```
+
+
+
+NACOS������������ӿڵ�ʵ�֣���ʹ����getServers�����������뵽getServers���������棬��ʵ����������������˵��NacosNamingService.selectInstances������ͨ��serviceId��ȡ��ServiceInfo����Ȼ���ȡ��Service�����������Ч��Instance��
+
+���ṩ�ߣ������÷����ĽǶȿ���NACOS��ͨ����ʱ����ʵʱ����ServiceInfo����Ҫҵ���߼�����HostReactor��ʵ�ֵġ���ǰ����serviceMap��һ����HostReactor��ά������serviceInfoMap��
+
+
+
+```
+private Map<String, ServiceInfo> serviceInfoMap;
+```
+
+
+
+HostReactor������FailoverReactor��ServiceInfo���˴��̻��棬��Ȼ�������˶�ʱ������ָ����Ŀ¼�����л�ServiceInfo���Դ�ʵ����Failover���ơ�������failover-modeҲ���п��صģ���ʵ����һ���ض��ļ���һ�������ݣ���Щ���õļ��Ҳ��ͨ����ʱ������ʵ�ֵġ�
+
+
+
+```
+File switchFile = new File(failoverDir + UtilAndComs.FAILOVER_SWITCH);
+```
+
+
+
+������������ͼ��ʾ��
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-d16112ec6ff6dda0b029b019c313177c_720w.webp)
+
+<figcaption>�����ָ���ͼ</figcaption>
+
+</figure>
+
+## �ġ���������̨(Console)
+
+��һ�����ǹ�������̨��ʵ�֣���ʵ��һ���dz����͵�WEB��Ŀ��
+
+ʹ����Spring Security + JWT���а�ȫ���ƣ�ǰ�˼�����ReactJs������JdbcTemplate�������ݿ�־û���
+
+��Ҫע����ǣ�����̨�ṩ�Ĺ��ܲ������Ǵ�nacos-console��������л�ȡ�����ݣ����Ƿ�ɢ���˸��������С�
+
+nacos-console�ṩ�˿���̨��¼��namespace����������̨����״̬�������������������ù����ͷ�������ֱ��������nacos-config��nacos-naming���ṩ��API������ЩAPI���ǹ������ᵽ��Open-API��
+
+## �塢�ܽ�
+
+NACOS���Դ��ͨ���׶���û��ʲô��������Ҳû�н��в���װ�Ͱ�������һ����̾���ij���Ա���ڰ�Сʱ֮�ڰ���������Ŀ�����硣
+
+��Ȼ��Ҳ�����һЩ���ɺ��ӵ�ȱ�㣬���磬ע�͹��٣����뻹�кܴ���ع��ռ䣬tenant��namespace�����������ʹ�á�
+
+����Spring Cloud Alibaba Nacos�Ľ��ܵ��˾ͽ����ˣ�ϣ����������������
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudAlibabaNacos\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\351\205\215\347\275\256\344\270\255\345\277\203.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudAlibabaNacos\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\351\205\215\347\275\256\344\270\255\345\277\203.md"
new file mode 100644
index 0000000..7515d8b
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudAlibabaNacos\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\351\205\215\347\275\256\344\270\255\345\277\203.md"
@@ -0,0 +1,266 @@
+# Nacos��������
+
+## Nacos�������ĵ�ʹ��
+
+�ο��ٷ���[github.com/alibaba/spr��](https://link.juejin.cn?target=https%3A%2F%2Fgithub.com%2Falibaba%2Fspring-cloud-alibaba%2Fwiki%2FNacos-config "https://github.com/alibaba/spring-cloud-alibaba/wiki/Nacos-config")
+
+## Config�������
+
+           Nacos ����ģ�� Key ����Ԫ��Ψһȷ��, NamespaceĬ���ǿմ������������ռ䣨public��������Ĭ���� DEFAULT_GROUP
+
+![image-20230429084711954](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230429084711954.png)
+
+* **֧�����õĶ�̬����**
+
+        ����̬����ˢ��ʱ������µ� Enviroment�У��������ÿ��һ���д�Enviroment�л�ȡ����
+
+```
+@SpringBootApplication
+public class NacosConfigApplication {
+
+    public static void main(String[] args) throws InterruptedException {
+        ConfigurableApplicationContext applicationContext = SpringApplication.run(NacosConfigApplication.class, args);
+
+         while(true) {
+        //����̬����ˢ��ʱ������µ� Enviroment�У��������ÿ��һ���д�Enviroment�л�ȡ����
+         String userName = applicationContext.getEnvironment().getProperty("common.name");
+        String userAge = applicationContext.getEnvironment().getProperty("common.age");
+        System.err.println("common name :" + userName + "; age: " + userAge);
+            TimeUnit.SECONDS.sleep(1);
+        }
+    }
+}
+���ƴ���
+```
+
+* **֧��profile���ȵ�����**
+
+  spring-cloud-starter-alibaba-nacos-config �ڼ������õ�ʱ�򣬲������������� dataid Ϊ spring.application.name.{spring.application.name}.spring.application.name.{file-extension:properties} Ϊǰ׺�Ļ������ã���������dataidΪ spring.application.name?{spring.application.name}-spring.application.name?{profile}.file?extension:properties�Ļ������á�
+
+  ���ճ�����������������׻����µIJ�ͬ���ã�����ͨ��Spring�ṩ��{file-extension:properties} �Ļ������á����ճ�����������������׻����µIJ�ͬ���ã�����ͨ��Spring �ṩ�� file?extension:properties�Ļ������á����ճ�����������������׻����µIJ�ͬ���ã�����ͨ��Spring�ṩ��{spring.profiles.active} ��������������á�
+
+```
+spring.profiles.active=dev
+���ƴ���
+```
+
+* **֧���Զ��� namespace ������**
+
+  ���ڽ����⻧���ȵ����ø��롣��ͬ�������ռ��£����Դ�����ͬ�� Group �� Data ID �����á�Namespace �ij��ó���֮һ�Dz�ͬ���������õ����ָ��룬���翪�����Ի����������������ʣ������á����񣩸���ȡ�
+
+  ��û����ȷָ�� ${spring.cloud.nacos.config.namespace} ���õ�����£� Ĭ��ʹ�õ��� Nacos �� Public ���namespace�������Ҫʹ���Զ���������ռ䣬����ͨ������������ʵ�֣�
+
+```
+spring.cloud.nacos.config.namespace=71bb9785-231f-4eca-b4dc-6be446e12ff8
+���ƴ���
+```
+
+* **֧���Զ��� Group ������**
+
+  Group����֯���õ�ά��֮һ��ͨ��һ����������ַ������� Buy �� Trade �������ü����з��飬�Ӷ����� Data ID ��ͬ�����ü��������� Nacos �ϴ���һ������ʱ�����δ��д���÷�������ƣ������÷��������Ĭ�ϲ��� DEFAULT_GROUP �����÷���ij�����������ͬ��Ӧ�û����ʹ������ͬ���������ͣ��� database_url ���ú� MQ_topic ���á�
+
+��û����ȷָ�� ${spring.cloud.nacos.config.group} ���õ�����£�Ĭ����DEFAULT_GROUP �������Ҫ�Զ����Լ��� Group������ͨ������������ʵ�֣�
+
+```
+spring.cloud.nacos.config.group=DEVELOP_GROUP
+���ƴ���
+```
+
+* **֧���Զ�����չ�� Data Id ����**
+
+        Data ID ����֯�������õ�ά��֮һ��Data ID ͨ��������֯����ϵͳ�����ü���һ��ϵͳ����Ӧ�ÿ��԰���������ü���ÿ�����ü������Ա�һ������������Ʊ�ʶ��Data ID ͨ�������� Java ������ com.taobao.tc.refund.log.level������������֤ȫ��Ψһ�ԡ������������ǿ�ơ�
+
+ͨ���Զ�����չ�� Data Id ���ã��ȿ��Խ�����Ӧ�ü����ù��������⣬�ֿ���֧��һ��Ӧ���ж�������ļ���
+
+```
+# �Զ��� Data Id ������
+#��ͬ���̵�ͨ������ ֧�ֹ����� DataId
+spring.cloud.nacos.config.sharedConfigs[0].data-id= common.yaml
+spring.cloud.nacos.config.sharedConfigs[0].group=REFRESH_GROUP
+spring.cloud.nacos.config.sharedConfigs[0].refresh=true
+
+# config external configuration
+# ֧��һ��Ӧ�ö�� DataId ������
+spring.cloud.nacos.config.extensionConfigs[0].data-id=ext-config-common01.properties
+spring.cloud.nacos.config.extensionConfigs[0].group=REFRESH_GROUP
+spring.cloud.nacos.config.extensionConfigs[0].refresh=true
+
+spring.cloud.nacos.config.extensionConfigs[1].data-id=ext-config-common02.properties
+spring.cloud.nacos.config.extensionConfigs[1].group=REFRESH_GROUP
+���ƴ���
+```
+
+## ���õ����ȼ�
+
+Spring Cloud Alibaba Nacos Config Ŀǰ�ṩ���������������� Nacos ��ȡ��ص����á�
+
+*   A: ͨ�� spring.cloud.nacos.config.shared-configs ֧�ֶ������ Data Id ������
+
+*   B: ͨ�� spring.cloud.nacos.config.ext-config[n].data-id �ķ�ʽ֧�ֶ����չ Data Id ������
+
+*   C: ͨ���ڲ���ع���(Ӧ������Ӧ����+ Profile )�Զ�������ص� Data Id ����
+
+�����ַ�ʽ��ͬʹ��ʱ�����ǵ�һ�����ȼ���ϵ��:A < B < C
+
+���ȼ��Ӹߵ��ͣ�
+
+1.  nacos-config-product.yaml ��׼����
+
+2.  nacos-config.yaml ͬ���̲�ͬ������ͨ������
+
+3.  ext-config: ��ͬ���� ��չ����
+
+4.  shared-dataids ��ͬ����ͨ������
+
+## @RefreshScope
+
+@Valueע����Ի�ȡ���������ĵ�ֵ�������޷���̬��֪�޸ĺ��ֵ����Ҫ����@RefreshScopeע��
+
+```
+@RestController
+@RefreshScope
+public class TestController {
+
+    @Value("${common.age}")
+    private String age;
+
+    @GetMapping("/common")
+    public String hello() {
+        return age;
+    }
+}
+���ƴ���
+```
+
+## Nacos��������Դ�����
+
+**��ϸԴ������ͼ��**
+
+[www.processon.com/view/link/6��](https://link.juejin.cn?target=https%3A%2F%2Fwww.processon.com%2Fview%2Flink%2F60f78ddbf346fb761bbac19d "https://www.processon.com/view/link/60f78ddbf346fb761bbac19d")
+
+### �������ļܹ�
+
+![image-20230429084840636](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230429084840636.png)
+
+��������ʹ��demo
+
+```
+public class ConfigServerDemo {
+
+    public static void main(String[] args) throws NacosException, InterruptedException {
+        String serverAddr = "localhost";
+        String dataId = "nacos-config-demo.yaml";
+        String group = "DEFAULT_GROUP";
+        Properties properties = new Properties();
+        properties.put(PropertyKeyConst.SERVER_ADDR, serverAddr);
+        //��ȡ���÷���
+        ConfigService configService = NacosFactory.createConfigService(properties);
+        //��ȡ����
+        String content = configService.getConfig(dataId, group, 5000);
+        System.out.println(content);
+        //ע�������
+        configService.addListener(dataId, group, new Listener() {
+            @Override
+            public void receiveConfigInfo(String configInfo) {
+                System.out.println("===recieve:" + configInfo);
+            }
+
+            @Override
+            public Executor getExecutor() {
+                return null;
+            }
+        });
+
+        //��������
+        //boolean isPublishOk = configService.publishConfig(dataId, group, "content");
+        //System.out.println(isPublishOk);
+        //����properties��ʽ
+        configService.publishConfig(dataId,group,"common.age=30", ConfigType.PROPERTIES.getType());
+
+        Thread.sleep(3000);
+        content = configService.getConfig(dataId, group, 5000);
+        System.out.println(content);
+
+//        boolean isRemoveOk = configService.removeConfig(dataId, group);
+//        System.out.println(isRemoveOk);
+//        Thread.sleep(3000);
+
+//        content = configService.getConfig(dataId, group, 5000);
+//        System.out.println(content);
+//        Thread.sleep(300000);
+    }
+}
+���ƴ���
+```
+
+## nacos config clientԴ��
+
+�������ĺ��Ľӿ�ConfigService
+
+![image-20230429084850542](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230429084850542.png)
+
+### ��ȡ����
+
+        ��ȡ���õ���Ҫ������ NacosConfigService ��� getConfig ������ͨ������¸÷���ֱ�Ӵӱ����ļ���ȡ�����õ�ֵ����������ļ������ڻ�������Ϊ�գ�����ͨ�� HTTP GET ������Զ����ȡ���ã������浽���ؿ����С���ͨ�� HTTP ��ȡԶ������ʱ��Nacos �ṩ�������۶ϲ��ԣ�һ�dz�ʱʱ�䣬����������Դ�����Ĭ���������Ρ�
+
+![image-20230429084858759](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230429084858759.png)
+
+### ע�������
+
+�������Ŀͻ��˻�ͨ����������ע��������ﵽ������������ʱ��ִ�лص��Ĺ���
+
+* NacosConfigService#getConfigAndSignListener
+
+* ConfigService#addListener
+
+        Nacos ����ͨ�����Ϸ�ʽע��������������ڲ���ʵ�־��ǵ��� ClientWorker ��� addCacheDataIfAbsent������ CacheData ��һ��ά�������������ע������м�������ʵ�������е� CacheData �������� ClientWorker ���е�ԭ�� cacheMap �У����ڲ��ĺ��ij�Ա�У�
+
+![image-20230429084908207](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230429084908207.png)
+
+![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f14749bd9b614b21a55a261187cd5521~tplv-k3u1fbpfcp-zoom-in-crop-mark:4536:0:0:0.awebp)
+
+### ���ó���ѯ
+
+         ClientWorker ͨ�����µ������̳߳�������ó���ѯ�Ĺ�����һ���ǵ��̵߳� executor��ÿ�� 10ms ����ÿ 3000 ��������Ϊһ������ȡ����ѯ�� cacheData ʵ���������װ��Ϊһ�� LongPollingTask �ύ����ڶ����̳߳� executorService ������
+
+![image-20230429084917535](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230429084917535.png)
+
+## nacos config serverԴ�����
+
+### ����dump
+
+![image-20230429084926987](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230429084926987.png)
+
+       ���������ʱ�ͻ����� DumpService �� init �����������ݿ��� load ���ô洢�ڱ��ش����ϣ�����һЩ��Ҫ��Ԫ��Ϣ���� MD5 ֵ�������ڴ��С�����˻���������ļ��б�������һ������ʱ�䣬���жϵ����Ǵ����ݿ� dump ȫ���������ݻ��Dz��������������ݣ���������ϴ���������� 6h ���ڵĻ�����
+
+ȫ�� dump ��Ȼ����մ��̻��棬Ȼ��������� ID ÿ����ȡһǧ������ˢ�����̺��ڴ档���� dump ������ȡ�����Сʱ���������ã��������µĺ�ɾ���ģ����Ȱ�����������ˢ��һ���ڴ���ļ����ٸ����ڴ������е�����ȫ��ȥ�ȶ�һ�����ݿ⣬����иı����ͬ��һ�Σ������ȫ�� dump �Ļ������һ�������ݿ� IO �ʹ��� IO ������
+
+### ���÷���
+
+        �������õĴ���λ�� ConfigController#publishConfig�С���Ⱥ��������һ��ʼҲֻ���һ̨��������̨���������ò���Mysql�н��г־û�������˲��������ÿ�����ò�ѯ��ȥ���� MySQL �����ǻ����� dump �����ڱ����ļ��н����û�����������˵���̨���������������֮����Ҫ֪ͨ��������ˢ���ڴ�ͱ��ش����е��ļ����ݣ�������ᷢ��һ����Ϊ ConfigDataChangeEvent ���¼�������¼���ͨ�� HTTP ����֪ͨ���м�Ⱥ�ڵ㣨���������������������ļ����ڴ��ˢ�¡�
+
+### ��������ѯ
+
+        �ͻ��˻���һ������ѯ������ȡ����˵����ñ��������˴����߼���LongPollingService���У�������һ�� Runnable ������ΪClientLongPolling������˻Ὣ�ܵ�����ѯ�����װ��һ�� ClientLongPolling ���񣬸��������һ�� AsyncContext ��Ӧ����ͨ����ʱ�̳߳��Ӻ� 29.5s ִ�С��ȿͻ��� 30s �ij�ʱʱ����ǰ 500ms ������Ϊ�����̶��ϱ�֤�ͻ��˲�����Ϊ������ʱ��ɳ�ʱ.
+
+![image-20230429084934117](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230429084934117.png)
+
+
+
+
+
+
+
+
+
+���ߣ������Ƶ��������Ŷ�
+���ӣ�https://juejin.cn/post/6999814668390760484
+��Դ��ϡ�����
+����Ȩ���������С���ҵת������ϵ���߻����Ȩ������ҵת����ע��������
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudRocketMQ\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudRocketMQ\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..9be0e22
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudRocketMQ\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,534 @@
+### һ��NameServer����
+
+Դ����ڣ�NamesrvStartup#main
+
+##### 1.NamesrvController controller = createNamesrvController(args);
+
+*   ����������
+*   �����������ö���NamesrvConfig��NettyServerConfig
+*   ���� -c ��-p����
+*   ���RocketMQ_HOME��������
+*   final NamesrvController controller = new NamesrvController(namesrvConfig, nettyServerConfig);����controller
+*   controller.getConfiguration().registerConfig(properties); ע������������Ϣ
+
+##### 2.start(controller);
+
+*   controller.initialize()�� ִ�г�ʼ��
+    �� this.kvConfigManager.load(); ����KV����
+    �� this.remotingServer = new NettyRemotingServer(this.nettyServerConfig, this.brokerHousekeepingService);����NettyServer���紦������
+    �� this.remotingExecutor =Executors.newFixedThreadPool(nettyServerConfig.getServerWorkerThreads(), new ThreadFactoryImpl("RemotingExecutorThread_")); ����Netty�����������̳߳�
+    �� this.registerProcessor(); ע��NameServer��Processor ע�ᵽRemotingServer��
+    �� NamesrvController.this.routeInfoManager.scanNotActiveBroker() ������ʱ�����Ƴ�����Ծ��Broker
+    �� NamesrvController.this.kvConfigManager.printAllPeriodically() ��ʱ��ӡKV������Ϣ
+*   Runtime.getRuntime().addShutdownHook ע��رչ��ӣ��ڹرշ���ʱ�ͷ���Դ
+*   controller.start()�� ����controller
+
+NameServer��������Ҫ��������
+1.ά��broker�ķ����ַ��Ϣ�������и���
+2.��Producer��consumer�ṩBroker�ķ����б�
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/3245844-46ca880d83fb583b.png)
+
+
+
+image.png
+
+
+
+### ����Broker����
+
+Դ����ڣ�Brokerstartup#main
+
+##### 1.createBrokerController(args)
+
+*   �����ĸ��������ö���BrokerConfig��NettyServerConfig��NettyClientConfig��MessageStoreConfig
+*   BrokerConfigֻ���� -c����
+*   RocketMq_HOME�����������
+*   RemotingUtil.string2SocketAddress(addr) ��namesrvAddr��ַ���в��
+*   messageStoreConfig.getBrokerRole() ͨ��BrokerId�ж����ӣ�masterId=0��Deldger��Ⱥ������Broker�ڵ�ID����-1
+*   ���� -p��-m���������������IJ������ӵ��ĸ��������ö�����
+*   BrokerController controller = new BrokerController ����brokerController�����ĸ����������ഫ��
+*   controller.getConfiguration().registerConfig(properties); ����ע�ᣨ���£�����
+*   controller.initialize(); ��ʼ��controller
+    �� ���ش����ϵ������ļ���topicConfigManager��consumerOffsetManager��subscriptionGroupManager��consumerFilterManager
+    �� this.messageStore =new DefaultMessageStore() ������Ϣ�洢���
+    �� this.messageStore.load() ���ش����ļ�
+    �� this.remotingServer = new NettyRemotingServer ����Netty�������
+    �� this.fastRemotingServer = new NettyRemotingServer ���fastRemotingServer��RemotingServer���ܻ�����࣬����VIP�˿�����
+    �� ������dz�ʼ��һЩ�̳߳�
+    �� this.registerProcessor(); brokerע��һЩProcessor��������
+*   Runtime.getRuntime().addShutdownHook ע��رչ���
+
+##### 2.start(BrokerController controller)
+
+*   this.messageStore.start(); ��������������Ҫ��Ϊ�˽�CommitLog��д���¼��ַ���ComsumeQueue��IndexFile
+*   ��������Netty����remotingServer��fastRemotingServer
+*   this.fileWatchService.start(); �ļ���������
+*   this.brokerOuterAPI.start(); brokerOuterAPI��������Ϊһ��Netty�ͻ��ˣ����ⷢ�������������緢������
+*   this.pullRequestHoldService.start(); ����ѯ������ͣ����
+*   this.filterServerManager.start(); ʹ��filter���й���
+*   BrokerController.this.registerBrokerAll() Broker���ĵ�����ע������,��Ҫ���þ��ǽ�brokerע�ᵽNamesrv��
+
+broker�ĺ������ã�
+**1.��Ϊclientʱ����nameServer����������Ϣ�����������״̬���**
+**2.��Ϊ�����ʱ�����ڴ洢��Ϣ����Ӧconsumer�˵�����**
+
+### ����Netty����ע����
+
+### �ġ�Broker����ע�����
+
+Դ����ڣ�BrokerController.this.registerBrokerAll(true, false, brokerConfig.isForceRegister())
+
+
+
+```
+public synchronized void registerBrokerAll(final boolean checkOrderConfig, boolean oneway, boolean forceRegister) {
+    TopicConfigSerializeWrapper topicConfigWrapper = this.getTopicConfigManager().buildTopicConfigSerializeWrapper();
+
+    if (!PermName.isWriteable(this.getBrokerConfig().getBrokerPermission())
+        || !PermName.isReadable(this.getBrokerConfig().getBrokerPermission())) {
+        ConcurrentHashMap<String, TopicConfig> topicConfigTable = new ConcurrentHashMap<String, TopicConfig>();
+        for (TopicConfig topicConfig : topicConfigWrapper.getTopicConfigTable().values()) {
+            TopicConfig tmp =
+                new TopicConfig(topicConfig.getTopicName(), topicConfig.getReadQueueNums(), topicConfig.getWriteQueueNums(),
+                                this.brokerConfig.getBrokerPermission());
+            topicConfigTable.put(topicConfig.getTopicName(), tmp);
+        }
+        topicConfigWrapper.setTopicConfigTable(topicConfigTable);
+    }
+    //������DZȽϹؼ��ĵط������ж��Ƿ���Ҫע�ᣬȻ�����doRegisterBrokerAll��������ȥע�ᡣ
+    if (forceRegister || needRegister(this.brokerConfig.getBrokerClusterName(),
+                                      this.getBrokerAddr(),
+                                      this.brokerConfig.getBrokerName(),
+                                      this.brokerConfig.getBrokerId(),
+                                      this.brokerConfig.getRegisterBrokerTimeoutMills())) {
+        doRegisterBrokerAll(checkOrderConfig, oneway, topicConfigWrapper);
+    }
+}
+
+```
+
+
+
+
+
+```
+// Brokerע������ĵIJ���
+private void doRegisterBrokerAll(boolean checkOrderConfig, boolean oneway,
+                                 TopicConfigSerializeWrapper topicConfigWrapper) {
+    // ע��broker����
+    List<RegisterBrokerResult> registerBrokerResultList = this.brokerOuterAPI.registerBrokerAll(
+        this.brokerConfig.getBrokerClusterName(),
+        this.getBrokerAddr(),
+        this.brokerConfig.getBrokerName(),
+        this.brokerConfig.getBrokerId(),
+        this.getHAServerAddr(),
+        topicConfigWrapper,
+        this.filterServerManager.buildNewFilterServerList(),
+        oneway,
+        this.brokerConfig.getRegisterBrokerTimeoutMills(),
+        this.brokerConfig.isCompressedRegister());
+
+    if (registerBrokerResultList.size() > 0) {
+        RegisterBrokerResult registerBrokerResult = registerBrokerResultList.get(0);
+        if (registerBrokerResult != null) {
+            //ע���걣�����ӽڵ�ĵ�ַ
+            if (this.updateMasterHAServerAddrPeriodically && registerBrokerResult.getHaServerAddr() != null) {
+                this.messageStore.updateHaMasterAddress(registerBrokerResult.getHaServerAddr());
+            }
+
+            this.slaveSynchronize.setMasterAddr(registerBrokerResult.getMasterAddr());
+
+            if (checkOrderConfig) {
+                this.getTopicConfigManager().updateOrderTopicConfig(registerBrokerResult.getKvTable());
+            }
+        }
+    }
+}
+
+```
+
+
+
+
+
+```
+public List<RegisterBrokerResult> registerBrokerAll(
+    final String clusterName,
+    final String brokerAddr,
+    final String brokerName,
+    final long brokerId,
+    final String haServerAddr,
+    final TopicConfigSerializeWrapper topicConfigWrapper,
+    final List<String> filterServerList,
+    final boolean oneway,
+    final int timeoutMills,
+    final boolean compressed) {
+    //ʹ��CopyOnWriteArrayList����������ȫ��
+    final List<RegisterBrokerResult> registerBrokerResultList = new CopyOnWriteArrayList<>();
+    // ��ȡ����nameServer�ĵ�ַ��Ϣ
+    List<String> nameServerAddressList = this.remotingClient.getNameServerAddressList();
+    if (nameServerAddressList != null && nameServerAddressList.size() > 0) {
+
+        final RegisterBrokerRequestHeader requestHeader = new RegisterBrokerRequestHeader();
+        requestHeader.setBrokerAddr(brokerAddr);
+        requestHeader.setBrokerId(brokerId);
+        requestHeader.setBrokerName(brokerName);
+        requestHeader.setClusterName(clusterName);
+        requestHeader.setHaServerAddr(haServerAddr);
+        requestHeader.setCompressed(compressed);
+
+        RegisterBrokerBody requestBody = new RegisterBrokerBody();
+        requestBody.setTopicConfigSerializeWrapper(topicConfigWrapper);
+        requestBody.setFilterServerList(filterServerList);
+        final byte[] body = requestBody.encode(compressed);
+        final int bodyCrc32 = UtilAll.crc32(body);
+        requestHeader.setBodyCrc32(bodyCrc32);
+        //ͨ��CountDownLatch����֤������NameServer�����ע�����һ�������
+        final CountDownLatch countDownLatch = new CountDownLatch(nameServerAddressList.size());
+        for (final String namesrvAddr : nameServerAddressList) {
+            brokerOuterExecutor.execute(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        RegisterBrokerResult result = registerBroker(namesrvAddr, oneway, timeoutMills, requestHeader, body);
+                        if (result != null) {
+                            registerBrokerResultList.add(result);
+                        }
+
+                        log.info("register broker[{}]to name server {} OK", brokerId, namesrvAddr);
+                    } catch (Exception e) {
+                        log.warn("registerBroker Exception, {}", namesrvAddr, e);
+                    } finally {
+                        countDownLatch.countDown();
+                    }
+                }
+            });
+        }
+
+        try {
+            countDownLatch.await(timeoutMills, TimeUnit.MILLISECONDS);
+        } catch (InterruptedException e) {
+        }
+    }
+
+    return registerBrokerResultList;
+}
+
+```
+
+
+
+NameServer��������
+
+
+
+```
+//NameServer��������ĺ��Ĵ���
+@Override
+    public RemotingCommand processRequest(ChannelHandlerContext ctx,
+                                          RemotingCommand request) throws RemotingCommandException {
+
+    if (ctx != null) {
+        log.debug("receive request, {} {} {}",
+                  request.getCode(),
+                  RemotingHelper.parseChannelRemoteAddr(ctx.channel()),
+                  request);
+    }
+
+    switch (request.getCode()) {
+        case RequestCode.PUT_KV_CONFIG:
+            return this.putKVConfig(ctx, request);
+        case RequestCode.GET_KV_CONFIG:
+            return this.getKVConfig(ctx, request);
+        case RequestCode.DELETE_KV_CONFIG:
+            return this.deleteKVConfig(ctx, request);
+        case RequestCode.QUERY_DATA_VERSION:
+            return queryBrokerTopicConfig(ctx, request);
+        case RequestCode.REGISTER_BROKER: //Brokerע�����������汾Ĭ���ǵ�ǰ��ܰ汾
+            Version brokerVersion = MQVersion.value2Version(request.getVersion());
+            if (brokerVersion.ordinal() >= MQVersion.Version.V3_0_11.ordinal()) {
+                return this.registerBrokerWithFilterServer(ctx, request); //��ǰ�汾
+            } else {
+                return this.registerBroker(ctx, request);
+            }
+        case RequestCode.UNREGISTER_BROKER:
+            return this.unregisterBroker(ctx, request);
+        case RequestCode.GET_ROUTEINFO_BY_TOPIC:
+            return this.getRouteInfoByTopic(ctx, request);
+        case RequestCode.GET_BROKER_CLUSTER_INFO:
+            return this.getBrokerClusterInfo(ctx, request);
+        case RequestCode.WIPE_WRITE_PERM_OF_BROKER:
+            return this.wipeWritePermOfBroker(ctx, request);
+        case RequestCode.GET_ALL_TOPIC_LIST_FROM_NAMESERVER:
+            return getAllTopicListFromNameserver(ctx, request);
+        case RequestCode.DELETE_TOPIC_IN_NAMESRV:
+            return deleteTopicInNamesrv(ctx, request);
+        case RequestCode.GET_KVLIST_BY_NAMESPACE:
+            return this.getKVListByNamespace(ctx, request);
+        case RequestCode.GET_TOPICS_BY_CLUSTER:
+            return this.getTopicsByCluster(ctx, request);
+        case RequestCode.GET_SYSTEM_TOPIC_LIST_FROM_NS:
+            return this.getSystemTopicListFromNs(ctx, request);
+        case RequestCode.GET_UNIT_TOPIC_LIST:
+            return this.getUnitTopicList(ctx, request);
+        case RequestCode.GET_HAS_UNIT_SUB_TOPIC_LIST:
+            return this.getHasUnitSubTopicList(ctx, request);
+        case RequestCode.GET_HAS_UNIT_SUB_UNUNIT_TOPIC_LIST:
+            return this.getHasUnitSubUnUnitTopicList(ctx, request);
+        case RequestCode.UPDATE_NAMESRV_CONFIG:
+            return this.updateConfig(ctx, request);
+        case RequestCode.GET_NAMESRV_CONFIG:
+            return this.getConfig(ctx, request);
+        default:
+            break;
+    }
+    return null;
+}
+
+```
+
+
+
+ʵ�ʾ��ǽ�broker��Ϣע�ᵽrouteInfo�У�
+
+
+
+```
+public RemotingCommand registerBrokerWithFilterServer(ChannelHandlerContext ctx, RemotingCommand request)
+    throws RemotingCommandException {
+    final RemotingCommand response = RemotingCommand.createResponseCommand(RegisterBrokerResponseHeader.class);
+    final RegisterBrokerResponseHeader responseHeader = (RegisterBrokerResponseHeader) response.readCustomHeader();
+    final RegisterBrokerRequestHeader requestHeader =
+        (RegisterBrokerRequestHeader) request.decodeCommandCustomHeader(RegisterBrokerRequestHeader.class);
+
+    if (!checksum(ctx, request, requestHeader)) {
+        response.setCode(ResponseCode.SYSTEM_ERROR);
+        response.setRemark("crc32 not match");
+        return response;
+    }
+
+    RegisterBrokerBody registerBrokerBody = new RegisterBrokerBody();
+
+    if (request.getBody() != null) {
+        try {
+            registerBrokerBody = RegisterBrokerBody.decode(request.getBody(), requestHeader.isCompressed());
+        } catch (Exception e) {
+            throw new RemotingCommandException("Failed to decode RegisterBrokerBody", e);
+        }
+    } else {
+        registerBrokerBody.getTopicConfigSerializeWrapper().getDataVersion().setCounter(new AtomicLong(0));
+        registerBrokerBody.getTopicConfigSerializeWrapper().getDataVersion().setTimestamp(0);
+    }
+    //routeInfoManager���ǹ���·����Ϣ�ĺ��������
+    RegisterBrokerResult result = this.namesrvController.getRouteInfoManager().registerBroker(
+        requestHeader.getClusterName(),
+        requestHeader.getBrokerAddr(),
+        requestHeader.getBrokerName(),
+        requestHeader.getBrokerId(),
+        requestHeader.getHaServerAddr(),
+        registerBrokerBody.getTopicConfigSerializeWrapper(),
+        registerBrokerBody.getFilterServerList(),
+        ctx.channel());
+
+    responseHeader.setHaServerAddr(result.getHaServerAddr());
+    responseHeader.setMasterAddr(result.getMasterAddr());
+
+    byte[] jsonValue = this.namesrvController.getKvConfigManager().getKVListByNamespace(NamesrvUtil.NAMESPACE_ORDER_TOPIC_CONFIG);
+    response.setBody(jsonValue);
+
+    response.setCode(ResponseCode.SUCCESS);
+    response.setRemark(null);
+    return response;
+}
+
+```
+
+
+
+### �塢Producer������Ϣ
+
+Դ����ڣ�DefaultMQProducer#start
+1.this.defaultMQProducerImpl.start(); ����������
+
+
+
+```
+public void start(final boolean startFactory) throws MQClientException {
+    switch (this.serviceState) {
+        case CREATE_JUST:
+            // Ĭ�Ͼ���CREATE_JUST
+            this.serviceState = ServiceState.START_FAILED;
+
+            this.checkConfig();
+            //�޸ĵ�ǰ��instanceNameΪ��ǰ����ID
+            if (!this.defaultMQProducer.getProducerGroup().equals(MixAll.CLIENT_INNER_PRODUCER_GROUP)) {
+                this.defaultMQProducer.changeInstanceNameToPID();
+            }
+            //�ͻ��˺��ĵ�MQ�ͻ��˹��� ����������Ϣ�����ߣ�������������������Ϣ�ķ����ߵķ���ע��
+            this.mQClientFactory = MQClientManager.getInstance().getOrCreateMQClientInstance(this.defaultMQProducer, rpcHook);
+            //ע��MQ�ͻ��˹���ʾ��
+            boolean registerOK = mQClientFactory.registerProducer(this.defaultMQProducer.getProducerGroup(), this);
+            if (!registerOK) {
+                this.serviceState = ServiceState.CREATE_JUST;
+                throw new MQClientException("The producer group[" + this.defaultMQProducer.getProducerGroup()
+                                            + "] has been created before, specify another name please." + FAQUrl.suggestTodo(FAQUrl.GROUP_NAME_DUPLICATE_URL),
+                                            null);
+            }
+
+            this.topicPublishInfoTable.put(this.defaultMQProducer.getCreateTopicKey(), new TopicPublishInfo());
+            //����ʾ�� --���пͻ������������mQClientFactory����
+            if (startFactory) {
+                mQClientFactory.start();
+            }
+
+            log.info("the producer [{}] start OK. sendMessageWithVIPChannel={}", this.defaultMQProducer.getProducerGroup(),
+                     this.defaultMQProducer.isSendMessageWithVIPChannel());
+            this.serviceState = ServiceState.RUNNING;
+            break;
+        case RUNNING:
+        case START_FAILED:
+        case SHUTDOWN_ALREADY:
+            throw new MQClientException("The producer service state not OK, maybe started once, "
+                                        + this.serviceState
+                                        + FAQUrl.suggestTodo(FAQUrl.CLIENT_SERVICE_NOT_OK),
+                                        null);
+        default:
+            break;
+    }
+    // �����е�broker��������
+    this.mQClientFactory.sendHeartbeatToAllBrokerWithLock();
+
+    this.startScheduledTask();
+
+}
+
+```
+
+
+
+### ����Consumer������Ϣ
+
+���Ѷ���ڣ�DefaultMQPushConsumer#start
+this.defaultMQPushConsumerImpl.start();
+
+
+
+```
+public synchronized void start() throws MQClientException {
+    switch (this.serviceState) {
+        case CREATE_JUST:
+            log.info("the consumer [{}] start beginning. messageModel={}, isUnitMode={}", this.defaultMQPushConsumer.getConsumerGroup(),
+                     this.defaultMQPushConsumer.getMessageModel(), this.defaultMQPushConsumer.isUnitMode());
+            this.serviceState = ServiceState.START_FAILED;
+
+            this.checkConfig();
+
+            this.copySubscription();
+
+            if (this.defaultMQPushConsumer.getMessageModel() == MessageModel.CLUSTERING) {
+                this.defaultMQPushConsumer.changeInstanceNameToPID();
+            }
+            //�ͻ���ʾ��������������Ҳ�ǽ���������������ġ�
+            this.mQClientFactory = MQClientManager.getInstance().getOrCreateMQClientInstance(this.defaultMQPushConsumer, this.rpcHook);
+            //���ؾ������
+            this.rebalanceImpl.setConsumerGroup(this.defaultMQPushConsumer.getConsumerGroup());
+            this.rebalanceImpl.setMessageModel(this.defaultMQPushConsumer.getMessageModel());
+            this.rebalanceImpl.setAllocateMessageQueueStrategy(this.defaultMQPushConsumer.getAllocateMessageQueueStrategy());
+            this.rebalanceImpl.setmQClientFactory(this.mQClientFactory);
+
+            this.pullAPIWrapper = new PullAPIWrapper(
+                mQClientFactory,
+                this.defaultMQPushConsumer.getConsumerGroup(), isUnitMode());
+            this.pullAPIWrapper.registerFilterMessageHook(filterMessageHookList);
+
+            if (this.defaultMQPushConsumer.getOffsetStore() != null) {
+                this.offsetStore = this.defaultMQPushConsumer.getOffsetStore();
+            } else {
+                //��������Կ������㲥ģʽ�뼯Ⱥģʽ������������offset�洢�ĵط���һ����
+                switch (this.defaultMQPushConsumer.getMessageModel()) {
+                        //�㲥ģʽ���������߱��ش洢offset
+                    case BROADCASTING:
+                        this.offsetStore = new LocalFileOffsetStore(this.mQClientFactory, this.defaultMQPushConsumer.getConsumerGroup());
+                        break;
+                        //��Ⱥģʽ����BrokerԶ�˴洢offset
+                    case CLUSTERING:
+                        this.offsetStore = new RemoteBrokerOffsetStore(this.mQClientFactory, this.defaultMQPushConsumer.getConsumerGroup());
+                        break;
+                    default:
+                        break;
+                }
+                this.defaultMQPushConsumer.setOffsetStore(this.offsetStore);
+            }
+            this.offsetStore.load();
+            //˳�����Ѽ�������ConsumeMessageOrderlyService
+            if (this.getMessageListenerInner() instanceof MessageListenerOrderly) {
+                this.consumeOrderly = true;
+                this.consumeMessageService =
+                    new ConsumeMessageOrderlyService(this, (MessageListenerOrderly) this.getMessageListenerInner());
+                //�������Ѽ�������ConsumeMessageConcurrentlyService
+            } else if (this.getMessageListenerInner() instanceof MessageListenerConcurrently) {
+               this.consumeOrderly = false;
+               this.consumeMessageService =
+               new ConsumeMessageConcurrentlyService(this, (MessageListenerConcurrently) this.getMessageListenerInner());
+            }
+
+           this.consumeMessageService.start();
+           //ע�������ߡ������������ƣ��ͻ���ֻҪ��Ҫ��ע�ἴ�ɣ���������mQClientFactoryһ��������
+           boolean registerOK = mQClientFactory.registerConsumer(this.defaultMQPushConsumer.getConsumerGroup(), this);
+           if (!registerOK) {
+               this.serviceState = ServiceState.CREATE_JUST;
+               this.consumeMessageService.shutdown(defaultMQPushConsumer.getAwaitTerminationMillisWhenShutdown());
+               throw new MQClientException("The consumer group[" + this.defaultMQPushConsumer.getConsumerGroup()
+               + "] has been created before, specify another name please." + FAQUrl.suggestTodo(FAQUrl.GROUP_NAME_DUPLICATE_URL),
+               null);
+           }
+
+           mQClientFactory.start();
+           log.info("the consumer [{}] start OK.", this.defaultMQPushConsumer.getConsumerGroup());
+           this.serviceState = ServiceState.RUNNING;
+           break;
+           case RUNNING:
+           case START_FAILED:
+           case SHUTDOWN_ALREADY:
+            throw new MQClientException("The PushConsumer service state not OK, maybe started once, "
+                + this.serviceState
+                + FAQUrl.suggestTodo(FAQUrl.CLIENT_SERVICE_NOT_OK),null);
+           default:
+                break;
+           }
+
+               this.updateTopicSubscribeInfoWhenSubscriptionChanged();
+               this.mQClientFactory.checkClientInBroker();
+               this.mQClientFactory.sendHeartbeatToAllBrokerWithLock();
+               this.mQClientFactory.rebalanceImmediately();
+           }
+
+```
+
+
+
+**1��consumer�˵�����ģʽ��**
+�� ��Ⱥģʽ����Ⱥģʽ��ÿ��consumer������䲻ͬ����Ϣ
+�� �㲥ģʽ���㲥ģʽ��ÿ����Ϣ�����͸�����consumer
+**2������offset�洢��**
+�� �㲥ģʽ��this.offsetStore = new LocalFileOffsetStore(); �洢��ÿ��consumer��
+�� ��Ⱥģʽ��this.offsetStore = new RemoteBrokerOffsetStore(); �洢��broker��
+
+
+
+���ߣ���Ҷ�컨
+���ӣ�https://www.jianshu.com/p/8dd4cfeae39d
+��Դ������
+����Ȩ���������С���ҵת������ϵ���߻����Ȩ������ҵת����ע��������
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudSeata\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudSeata\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..19ce963
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudSeata\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,1005 @@
+���� | һ��ߣJava
+��Դ |����ͷ��
+
+**ѧϰĿ��**
+
+*   Seata ATģʽԴ������
+    **��1�� ATģʽ����**
+    **1.1 ˼ά�����Ƶ�**
+    �������Ѿ�����ATģʽ�Ĵ���ԭ������Դ���У�ͨ��READMEҲ�ܿ�����ATģʽ��ʹ�ã��DZ��Ľ��ӵײ�Դ�����ȥ����ATģʽ��ԭ�����ڷ���ԭ��֮ǰ��������������ͼ������һ�����Ĺ���˼·��ģʽ��
+
+�ȿ���˼ά�Ƶ�ͼ![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/0388859932ccee17ed32246e2e5f4e0a88dee6.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������")1.2 ��ʼ�������Ƶ�
+![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/f24e8bd05e84b683e3f3227490146155bf5b17.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������")1.3 ִ�������Ƶ�
+![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/93dea0538eba8be5778699ea2af8f71c0e396c.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������")**��2�� Դ�����**
+**2.1 SeataAutoConfiguration**
+����seataԴ����о���Ҫ��seata�������ҵ��SQL����undo_log���ݣ������һ�׶���ɺ��ύȫ�����������һ�׶�ҵ��ʧ�ܺ�ͨ��undo_log�ع����񣬽������񲹳���
+
+seataҲ����spring����ʹ�õģ����SpringBoot��seataҲ������һЩ�Զ�����![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/719ef4a775ece0688c929227415e97f68f1c58.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������")seata���Զ������������dz���ֱ�ӣ��ͽ�����SeataAutoConfiguration�����Ǵ������
+
+
+
+```
+@ComponentScan(basePackages = "io.seata.spring.boot.autoconfigure.properties")@ConditionalOnProperty(prefix = StarterConstants.SEATA_PREFIX, name = "enabled", havingValue = "true", matchIfMissing = true)@Configuration@EnableConfigurationProperties({SeataProperties.class})public class SeataAutoConfiguration {    }
+```
+
+
+
+
+
+
+
+
+
+���ȣ�@ComponentScanɨ����һ��properties����������һ�������SeataProperties��Bean����
+
+@ConditionalOnProperty����������Ч��������Ϊseata.enabled=true��Ĭ��ֵ��true�����Կ��Կ��طֲ�ʽ�����ܣ���client�˵�file.conf����������ã���
+
+@Configuration������SeataAutoConfiguration������Ϊ��spring�������ࡣ
+
+@EnableConfigurationProperties�����ð�ת����һ��SeataProperties��Bean������ʹ�á�
+
+�������Ķ�SeataAutoConfiguration���ڲ�����
+
+
+
+```
+@Bean@DependsOn({BEAN_NAME_SPRING_APPLICATION_CONTEXT_PROVIDER, BEAN_NAME_FAILURE_HANDLER})@ConditionalOnMissingBean(GlobalTransactionScanner.class)public GlobalTransactionScanner globalTransactionScanner(SeataProperties seataProperties, FailureHandler failureHandler) {    if (LOGGER.isInfoEnabled()) {        LOGGER.info("Automatically configure Seata");    }    return new GlobalTransactionScanner(seataProperties.getApplicationId(), seataProperties.getTxServiceGroup(), failureHandler);}
+```
+
+
+
+
+
+
+
+
+
+�Զ����õĺ��ĵ������������һ��Bean��GlobalTransactionScanner��
+
+���ǿ����������Bean�dz��ļ򵥣����췽��ֻ��Ҫһ��applicationId��txServiceGroup��
+
+applicationId: ����spring.application.name=�㶨��ĵ�ǰӦ�õ����֣����磺userService
+
+txServiceGroup: ������applicationId ���� -seata-service-group�����ģ����磺
+userService-seata-service-group������汾�ϵ͵Ļ�����ʱ����ܻ�����seata����fescar�����Ĭ������������fescarΪ��׺��
+
+new��һ��GlobalTransactionScanner����SeataAutoConfiguration����Զ�����������þͽ����ˡ�SeataAutoConfigurationֻ������һ���������������á�
+
+**2.2 GlobalTransactionScanner**
+��Ȼ���ĵ�����GlobalTransactionScanner����࣬���Ǽ�����ע���������������ʵ�Ϳ��Բ²⵽һ���������ã�ɨ��@GlobalTransactional���ע�⣬���Դ�����������������ǿ����Ĺ��ܡ�
+
+Ҫ�˽�����࣬���ò����Ķ�һ������UMLͼ![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/83cb3ed76073a33cb19242ffe542b615346d16.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������")���Կ�����GlobalTransactionScanner��Ҫ��4����ֵ�ù�ע��
+
+1��ApplicationContextAware��ʾ�����õ�spring����
+
+2��InitializingBean�ӿڣ������˳�ʼ����ʱ������һЩ����
+
+3��AbstractAutoProxyCreator��ʾ�����spring�����е�Bean����������ǿ��Ҳ�����������������������ǿ�IJ²⡣
+
+4��Disposable�ӿڣ�������spring�������ٵ�ʱ������һЩ����
+
+����������΢��עһ����4����ִ��˳��
+
+ApplicationContextAware -> InitializingBean -> AbstractAutoProxyCreator -> DisposableBean
+
+**2.3 InitializingBean**
+
+
+
+```
+@Overridepublic void afterPropertiesSet() {    if (disableGlobalTransaction) {        if (LOGGER.isInfoEnabled()) {            LOGGER.info("Global transaction is disabled.");        }        return;    }    initClient();}
+```
+
+
+
+
+
+
+
+
+
+��ʼ��Seata��Client�˵Ķ�����Client����Ҫ����TransactionManager��ResourceManager��������Ϊ�˼򻯰ɣ���û�а�initClient����´�GlobalTransactionScanner�����������һ���ࡣ
+
+����initClient����
+
+
+
+```
+private void initClient() {    //init TM    TMClient.init(applicationId, txServiceGroup);       //init RM    RMClient.init(applicationId, txServiceGroup);      registerSpringShutdownHook();}
+```
+
+
+
+
+
+
+
+
+
+initClient�߼��������ӣ���������TMClient.init��ʼ��TransactionManager��RPC�ͻ��ˣ�RMClient.init��ʼ��ResourceManager��RPC�ͻ��ˡ�seata��RPC����netty��ʵ�֣�seata��װ����һ��ʹ�á���ע����һ��Spring��ShutdownHook���Ӻ���
+
+**2.3.1 TMClient��ʼ��**
+
+
+
+```
+@Overridepublic void init() {    timerExecutor.scheduleAtFixedRate(new Runnable() {        @Override        public void run() {            clientChannelManager.reconnect(getTransactionServiceGroup());        }    }, SCHEDULE_DELAY_MILLS, SCHEDULE_INTERVAL_MILLS, TimeUnit.MILLISECONDS);...}
+```
+
+
+
+
+
+
+
+
+
+������һ����ʱ�����Ͻ�����������������
+clientChannelManager.reconnect������������
+
+
+
+```
+void reconnect(String transactionServiceGroup) {    List<String> availList = null;    try {        availList = getAvailServerList(transactionServiceGroup);    } catch (Exception e) {       ...    }   ...    for (String serverAddress : availList) {        try {            acquireChannel(serverAddress);        } catch (Exception e) {            ...        }    }}
+```
+
+
+
+
+
+
+
+
+
+����transactionServiceGroup��ȡseata-server��ip��ַ�б���Ȼ���������
+
+
+
+```
+private List<String> getAvailServerList(String transactionServiceGroup) throws Exception {    List<InetSocketAddress> availInetSocketAddressList = RegistryFactory.getInstance()        .lookup(transactionServiceGroup);    if (CollectionUtils.isEmpty(availInetSocketAddressList)) {        return Collections.emptyList();    }     return availInetSocketAddressList.stream()        .map(NetUtil::toStringAddress)        .collect(Collectors.toList());}
+```
+
+
+
+
+
+
+
+
+
+RegistryFactory.getInstance().lookup(transactionServiceGroup);�ǶԲ�ͬע��������������ģ�Ĭ�Ͽ���Nacos��ʽ��ʵ��![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/745b802128d80980a6e082f91406451526cbb3.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������")�ȸ�����������ҵ�����������server��Ⱥ���ƣ�������default��Ȼ����ݼ�Ⱥ�����ҵ�server��Ӧip�˿ڵ�ַ
+
+
+
+```
+@Overridepublic List<InetSocketAddress> lookup(String key) throws Exception {    //default    String clusterName = getServiceGroup(key);    if (clusterName == null) {        return null;    }    if (!LISTENER_SERVICE_MAP.containsKey(clusterName)) {        synchronized (LOCK_OBJ) {            if (!LISTENER_SERVICE_MAP.containsKey(clusterName)) {                List<String> clusters = new ArrayList<>();                clusters.add(clusterName);                List<Instance> firstAllInstances = getNamingInstance().getAllInstances(getServiceName(), getServiceGroup(), clusters);                if (null != firstAllInstances) {                    List<InetSocketAddress> newAddressList = firstAllInstances.stream()                        .filter(instance -> instance.isEnabled() && instance.isHealthy())                        .map(instance -> new InetSocketAddress(instance.getIp(), instance.getPort()))                        .collect(Collectors.toList());                    CLUSTER_ADDRESS_MAP.put(clusterName, newAddressList);                }                subscribe(clusterName, event -> {                    List<Instance> instances = ((NamingEvent) event).getInstances();                    if (null == instances && null != CLUSTER_ADDRESS_MAP.get(clusterName)) {                        CLUSTER_ADDRESS_MAP.remove(clusterName);                    } else if (!CollectionUtils.isEmpty(instances)) {                        List<InetSocketAddress> newAddressList = instances.stream()                            .filter(instance -> instance.isEnabled() && instance.isHealthy())                            .map(instance -> new InetSocketAddress(instance.getIp(), instance.getPort()))                            .collect(Collectors.toList());                        CLUSTER_ADDRESS_MAP.put(clusterName, newAddressList);                    }                });            }        }    }    return CLUSTER_ADDRESS_MAP.get(clusterName);}
+```
+
+
+
+
+
+
+
+
+
+Seata-server��IP��ַ�ѻ�ȡ��,Ȼ�����acquireChannel
+
+
+
+```
+Channel acquireChannel(String serverAddress) {    Channel channelToServer = channels.get(serverAddress);    if (channelToServer != null) {        channelToServer = getExistAliveChannel(channelToServer, serverAddress);        if (channelToServer != null) {            return channelToServer;        }    }...    channelLocks.putIfAbsent(serverAddress, new Object());    synchronized (channelLocks.get(serverAddress)) {        return doConnect(serverAddress);    }}
+```
+
+
+
+
+
+
+
+
+
+��󽫻�ȡ����seata-server��IP��ַ�ŵ�Netty�з�װ��TmClient�ͳ�ʼ�����
+
+TmClient��ʼ���ܽ᣺
+
+*   ������ʱ�������Խ���һ������seata-server
+*   ����ʱ���ȴ�nacos�������������ã��и��ݷ�������(service_group)�ҵ���Ⱥ����(cluster_name)
+*   �ٸ��ݼ�Ⱥ�����ҵ���Ⱥip�˿��б�
+*   ��ip�б���ѡ��һ����netty��������
+    **2.3.2 RMClient��ʼ��**
+
+
+
+```
+public static void init(String applicationId, String transactionServiceGroup) {    // ��ȡ��������    RmRpcClient rmRpcClient = RmRpcClient.getInstance(applicationId, transactionServiceGroup);    // ����ResourceManager�ĵ�������    rmRpcClient.setResourceManager(DefaultResourceManager.get());    // ���Ӽ�����������Server�˵���Ϣ����    rmRpcClient.setClientMessageListener(new RmMessageListener(DefaultRMHandler.get()));    // ��ʼ��RPC    rmRpcClient.init();}
+```
+
+
+
+
+
+
+
+
+
+��TMClient��ȣ�RMClient�����һ������Server����Ϣ�������Ļ��ơ�Ҳ����˵TM��ְ��������������Server��ͨ�ţ����磺ȫ�������begin��commit��rollback�ȡ�
+
+��RM������������������Դ�⣬������Ϊȫ�������commit��rollback�ȵ���Ϣ���ͣ��Ӷ��Ա�����Դ������ز�����
+
+������Դ������resourceManager��������Ϣ�ص����������ڽ���TC�ڶ��׶η������ύ���߻ع�����Seata�ж�ResourceManager��AbstractRMHandler����SPI���䣬��ResouceManagerΪ����
+
+
+
+```
+public class DefaultResourceManager implements ResourceManager {    protected void initResourceManagers() {        //init all resource managers        List<ResourceManager> allResourceManagers = EnhancedServiceLoader.loadAll(ResourceManager.class);        if (CollectionUtils.isNotEmpty(allResourceManagers)) {            for (ResourceManager rm : allResourceManagers) {                resourceManagers.put(rm.getBranchType(), rm);            }        }    }}
+```
+
+
+
+
+
+
+
+
+
+���Կ�����ʼ��DefaultResouceManagerʱ��ʹ��ClassLoaderȥ���ض�ӦJar�µ�ʵ�֣���Ĭ��ATģʽʹ�õ�ʵ�������ݿ⣬Ҳ����rm-datasource���µ�ʵ�֣���ʵ����·����Ҫ��λ��/resources/META-INF/��չ�ӿ�ȫ·��ȥ�ң��ͻ��ҵ���Ӧ��ʵ���� ![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/84399f558194f3dce18275c72cb9a92219db25.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������ϣ�-��Դ������������")ResourceManager��Ӧʵ����ȫ·��
+io.seata.rm.datasource.DataSourceManager��������ָ�������ύ�ͻع��ķ�����DefaultRMHandler��Ӧʵ����ȫ·��io.seata.rm.RMHandlerAT���Ǹ�����server��Ϣ������Ӧ�ύ���߻ع������Ļص������ࡣ
+
+RMClinet��init()������TMClient����һ��
+
+**2.3.3 �ܽ�**
+
+*   Spring����ʱ����ʼ����2���ͻ���TmClient��RmClient
+*   TmClient��seata-serverͨ��Netty�������Ӳ�������Ϣ
+*   RmClient��seata-serverͨ��Netty�������ӣ�������ն��׶��ύ���ع���Ϣ���ڻص���(RmHandler)��������
+
+���� | һ��ߣJava
+��Դ |����ͷ��
+
+**2.4 AbstractAutoProxyCreator**
+GlobalTransactionScanner��ʼ������TM��RM�Ժ������ٹ�עһ��AbstractAutoProxyCreator���Զ�������
+
+�Զ�������������ɶ�����أ�����˵����spring�е�Bean��ǿ��ʲô���ܣ�
+
+GlobalTransactionScanner��Ҫ��չ��AbstractAutoProxyCreator��wrapIfNecessary
+
+������ǿ��ǰ���жϴ�������ʾ�Ƿ��Bean��Ҫ��ǿ�������ǿ�Ļ�����������
+
+**2.4.1 wrapIfNecessary**
+
+
+
+```
+@Overrideprotected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {    if (disableGlobalTransaction) {        return bean;    }    try {        synchronized (PROXYED_SET) {            // ��ͬBean����            if (PROXYED_SET.contains(beanName)) {                return bean;            }             interceptor = null;            // �ж��Ƿ���TCCģʽ            if (TCCBeanParserUtils.isTccAutoProxy(bean, beanName, applicationContext)) {                // TCCʵ�ֵ�������                interceptor = new TccActionInterceptor(TCCBeanParserUtils.getRemotingDesc(beanName));            } else {                Class<?> serviceInterface = SpringProxyUtils.findTargetClass(bean);                Class<?>[] interfacesIfJdk = SpringProxyUtils.findInterfaces(bean);                 // �ж��Ƿ����@GlobalTransactional����@GlobalLockע��                if (!existsAnnotation(new Class[]{serviceInterface})                    && !existsAnnotation(interfacesIfJdk)) {                    return bean;                }                 if (interceptor == null) {                    // ��TCC��������                    if (globalTransactionalInterceptor == null) {                        globalTransactionalInterceptor = new GlobalTransactionalInterceptor(failureHandlerHook);                        ConfigurationCache.addConfigListener(                            ConfigurationKeys.DISABLE_GLOBAL_TRANSACTION,                            (ConfigurationChangeListener)globalTransactionalInterceptor);                    }                    interceptor = globalTransactionalInterceptor;                }            }            // �жϵ�ǰBean�Ƿ��Ѿ���spring�Ĵ�������            if (!AopUtils.isAopProxy(bean)) {                // ��������ǣ���ô��һ��spring�Ĵ������̼���                bean = super.wrapIfNecessary(bean, beanName, cacheKey);            } else {                // �����һ��spring�Ĵ����࣬��ô�����ȡ���������Ѿ����ڵ����������ϣ�Ȼ�����ӵ��ü��ϵ���                AdvisedSupport advised = SpringProxyUtils.getAdvisedSupport(bean);                Advisor[] advisor = buildAdvisors(beanName, getAdvicesAndAdvisorsForBean(null, null, null));                for (Advisor avr : advisor) {                    advised.addAdvisor(0, avr);                }            }             PROXYED_SET.add(beanName);            return bean;        }    } catch (Exception exx) {}}
+```
+
+
+
+
+
+
+
+
+
+wrapIfNecessary�����ϳ����Ƿֲ��迴��
+
+1��isTccAutoProxy�ж��Ƿ���tccģʽ�������Ļ�ѡ����TccActionInterceptor����������tccģʽѡ��
+GlobalTransactionalInterceptor��������Ĭ�ϲ�����
+
+2��existAnnotation�жϵ�ǰBean�Ƿ�������߽ӿڵķ�������@GlobalTransactional����@GlobalLockע�⣬���û����ֱ�ӷ���
+
+3��isAopProxy�������жϵ�ǰ��Bean�Ƿ��Ѿ���spring�Ĵ������ˣ�������JDK��̬��������Cglib��������������ͨ��Bean����ԭ�е����ɴ����߼����ɣ�����Ѿ��Ǵ����࣬��ôҪͨ�������ȡ���������ڵ�����������Ҳ����Advisor��ֱ�����ӵ��ü��ϵ��С�
+
+wrapIfNecessary�ķ����������ӣ���������Դ������Ǻ���Ϥ������ϸ�ڵ����Щ����
+
+**2.4.1.1 ATһ�׶ο���ȫ������**
+����Ҫ����ȫ����������Ľӿ��ϣ����@GlobalTransactionalע�⣬���ע�����һ����Ӧ����������������
+GlobalTransactionalInterceptor��invoke�������ط���
+
+
+
+```
+@Overridepublic Object invoke(final MethodInvocation methodInvocation) throws Throwable {    Class<?> targetClass =        methodInvocation.getThis() != null ? AopUtils.getTargetClass(methodInvocation.getThis()) : null;    Method specificMethod = ClassUtils.getMostSpecificMethod(methodInvocation.getMethod(), targetClass);    if (specificMethod != null && !specificMethod.getDeclaringClass().equals(Object.class)) {        final Method method = BridgeMethodResolver.findBridgedMethod(specificMethod);        //��ȡ�����ϵ�ȫ������ע��        final GlobalTransactional globalTransactionalAnnotation =            getAnnotation(method, targetClass, GlobalTransactional.class);        //��ȡ�����ϵ�ȫ����ע��        final GlobalLock globalLockAnnotation = getAnnotation(method, targetClass, GlobalLock.class);        boolean localDisable = disable || (degradeCheck && degradeNum >= degradeCheckAllowTimes);        if (!localDisable) {            //�����������ȫ������ע�⣬����handleGlobalTransaction����ȫ������            if (globalTransactionalAnnotation != null) {                return handleGlobalTransaction(methodInvocation, globalTransactionalAnnotation);            //�����������ȫ����ע�⣬����handleGlobalLock����ȫ����            } else if (globalLockAnnotation != null) {                return handleGlobalLock(methodInvocation);            }        }    }    //���ɶ��û�У�����ͨ����ִ�У���������    return methodInvocation.proceed();}
+```
+
+
+
+
+
+
+
+
+
+��handleGlobalTransaction���������
+transactionalTemplate.execute����
+
+
+
+```
+// 2\. ����ȫ������beginTransactionbeginTransaction(txInfo, tx); Object rs = null;try {     // ִ��ҵ�񷽷�business.execute()    rs = business.execute(); } catch (Throwable ex) {     // 3.�����쳣ִ��completeTransactionAfterThrowing�ع�    completeTransactionAfterThrowing(txInfo, tx, ex);    throw ex;} // 4\. û���쳣�ύ����commitTransactioncommitTransaction(tx);
+```
+
+
+
+
+
+
+
+
+
+����ȫ���������յ���
+io.seata.tm.api.DefaultGlobalTransaction#begin(int, java.lang.String)����
+
+
+
+```
+@Overridepublic void begin(int timeout, String name) throws TransactionException {    //�˴��Ľ�ɫ�ж��йؼ�������//������ǰ��ȫ������ķ����ߣ�Launcher�����Dz����ߣ�Participant��//����ڷֲ�ʽ���������ϵͳ������Ҳ����GlobalTransactionalע��//��ô���Ľ�ɫ����Participant��������Ժ����begin���˳���    //���ж��Ƿ����ߣ�Launcher�����Dz����ߣ�Participant���Ǹ��ݵ�ǰ�������Ƿ��Ѵ���XID���ж�    //û��XID�ľ���Launcher���Ѿ�����XID�ľ���Participant    if (role != GlobalTransactionRole.Launcher) {        assertXIDNotNull();        if (LOGGER.isDebugEnabled()) {            LOGGER.debug("Ignore Begin(): just involved in global transaction [{}]", xid);        }        return;    }    assertXIDNull();    if (RootContext.getXID() != null) {        throw new IllegalStateException();    }    xid = transactionManager.begin(null, null, name, timeout);    status = GlobalStatus.Begin;    RootContext.bind(xid);    if (LOGGER.isInfoEnabled()) {        LOGGER.info("Begin new global transaction [{}]", xid);    } }
+```
+
+
+
+
+
+
+
+
+
+����seata-server��ȡȫ������XID
+
+
+
+```
+@Overridepublic String begin(String applicationId, String transactionServiceGroup, String name, int timeout)    throws TransactionException {    GlobalBeginRequest request = new GlobalBeginRequest();    request.setTransactionName(name);    request.setTimeout(timeout);    //����    GlobalBeginResponse response = (GlobalBeginResponse) syncCall(request);    if (response.getResultCode() == ResultCode.Failed) {        throw new TmTransactionException(TransactionExceptionCode.BeginFailed, response.getMsg());    }    return response.getXid();}
+private AbstractTransactionResponse syncCall(AbstractTransactionRequest request) throws TransactionException {    try {        //TMClient��װ��Netty����        return (AbstractTransactionResponse) TmNettyRemotingClient.getInstance().sendSyncRequest(request);    } catch (TimeoutException toe) {        throw new TmTransactionException(TransactionExceptionCode.IO, "RPC timeout", toe);    }}
+```
+
+
+
+
+
+
+
+
+
+��XID����RootContext�У��ɴ˿��Կ���ȫ����������TM����ģ�TM����ȫ�����������seata-server����seata-server������ܵ����������������seata������룩��
+
+
+
+```
+@Overrideprotected void doGlobalBegin(GlobalBeginRequest request, GlobalBeginResponse response, RpcContext rpcContext)    throws TransactionException {    //����begin    response.setXid(core.begin(rpcContext.getApplicationId(), rpcContext.getTransactionServiceGroup(),                               request.getTransactionName(), request.getTimeout()));    if (LOGGER.isInfoEnabled()) {        LOGGER.info("Begin new global transaction applicationId: {},transactionServiceGroup: {}, transactionName: {},timeout:{},xid:{}",                    rpcContext.getApplicationId(), rpcContext.getTransactionServiceGroup(), request.getTransactionName(), request.getTimeout(), response.getXid());    }}
+```
+
+
+
+
+
+
+
+
+
+io.seata.server.coordinator.DefaultCoordinator#doGlobalBegin�������ܿͻ��˿���ȫ����������󣬵���io.seata.server.coordinator.DefaultCore#begin����ȫ������
+
+
+
+```
+@Overridepublic String begin(String applicationId, String transactionServiceGroup, String name, int timeout)    throws TransactionException {    GlobalSession session = GlobalSession.createGlobalSession(applicationId, transactionServiceGroup, name,                                                              timeout);    MDC.put(RootContext.MDC_KEY_XID, session.getXid());    session.addSessionLifecycleListener(SessionHolder.getRootSessionManager());//�����Ự    session.begin();     // transaction start event    eventBus.post(new GlobalTransactionEvent(session.getTransactionId(), GlobalTransactionEvent.ROLE_TC,                                             session.getTransactionName(), applicationId, transactionServiceGroup, session.getBeginTime(), null, session.getStatus()));     return session.getXid();}
+```
+
+
+
+
+
+
+
+
+
+ͨ����ǰ�Ự����
+
+
+
+```
+@Overridepublic void begin() throws TransactionException {    this.status = GlobalStatus.Begin;    this.beginTime = System.currentTimeMillis();    this.active = true;    for (SessionLifecycleListener lifecycleListener : lifecycleListeners) {        lifecycleListener.onBegin(this);    }}
+```
+
+
+
+
+
+
+
+
+
+![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/e7c784186f75581eba83325a0fc4708602dadf.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������")
+
+����
+io.seata.server.session.AbstractSessionManager#onBegin�������ֵ���io.seata.server.storage.db.session.DataBaseSessionManager#addGlobalSession����
+
+
+
+```
+@Overridepublic void addGlobalSession(GlobalSession session) throws TransactionException {    if (StringUtils.isBlank(taskName)) {        //����        boolean ret = transactionStoreManager.writeSession(LogOperation.GLOBAL_ADD, session);        if (!ret) {            throw new StoreException("addGlobalSession failed.");        }    } else {        boolean ret = transactionStoreManager.writeSession(LogOperation.GLOBAL_UPDATE, session);        if (!ret) {            throw new StoreException("addGlobalSession failed.");        }    }}
+```
+
+
+
+
+
+
+
+
+
+���������ݿ���д������
+
+
+
+```
+@Overridepublic boolean writeSession(LogOperation logOperation, SessionStorable session) {    if (LogOperation.GLOBAL_ADD.equals(logOperation)) {        return logStore.insertGlobalTransactionDO(SessionConverter.convertGlobalTransactionDO(session));    } else if (LogOperation.GLOBAL_UPDATE.equals(logOperation)) {        return logStore.updateGlobalTransactionDO(SessionConverter.convertGlobalTransactionDO(session));    } else if (LogOperation.GLOBAL_REMOVE.equals(logOperation)) {        return logStore.deleteGlobalTransactionDO(SessionConverter.convertGlobalTransactionDO(session));    } else if (LogOperation.BRANCH_ADD.equals(logOperation)) {        return logStore.insertBranchTransactionDO(SessionConverter.convertBranchTransactionDO(session));    } else if (LogOperation.BRANCH_UPDATE.equals(logOperation)) {        return logStore.updateBranchTransactionDO(SessionConverter.convertBranchTransactionDO(session));    } else if (LogOperation.BRANCH_REMOVE.equals(logOperation)) {        return logStore.deleteBranchTransactionDO(SessionConverter.convertBranchTransactionDO(session));    } else {        throw new StoreException("Unknown LogOperation:" + logOperation.name());    }}
+```
+
+
+
+
+
+
+
+
+
+������seata��global_tab�������ݣ�����ȫ�������ѿ���
+
+**2.4.1.2 ATһ�׶�ִ��ҵ��SQL**
+ȫ�������ѿ�����������Ҫִ��ҵ��SQL������undo_log���ݣ�ȫ���������سɹ������ջ���ִ����ҵ�񷽷��ģ���������Seata������Դ���˴���������sql������undo_log��������������Դ������ִ�еģ���������Seata��DataSource��Connection��Statement���Ĵ�����װ��
+
+
+
+```
+/*** ����datasource���������滻ԭ���ĵ�datasource*/@Primary@Bean("dataSource")public DataSourceProxy dataSourceProxy(DataSource druidDataSource){    return new DataSourceProxy(druidDataSource);}
+```
+
+
+
+
+
+
+
+
+
+��Ŀ��ʹ�õ�����Դ����seata��DataSourceProxy����![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/c8a7a189816e282015a950bfd3c13b7d859974.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������")���ն�Sql���н���������������StatementProxy����
+
+
+
+```
+@Overridepublic boolean execute(String sql) throws SQLException {    this.targetSQL = sql;    return ExecuteTemplate.execute(this, (statement, args) -> statement.execute((String) args[0]), sql);}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+public static <T, S extends Statement> T execute(List<SQLRecognizer> sqlRecognizers,                                                     StatementProxy<S> statementProxy,                                                     StatementCallback<T, S> statementCallback,                                                     Object... args) throws SQLException {         if (!RootContext.requireGlobalLock() && !StringUtils.equals(BranchType.AT.name(), RootContext.getBranchType())) {            //����ȫ�������ֱ��ִ�У���������            return statementCallback.execute(statementProxy.getTargetStatement(), args);        }         String dbType = statementProxy.getConnectionProxy().getDbType();        if (CollectionUtils.isEmpty(sqlRecognizers)) {            sqlRecognizers = SQLVisitorFactory.get(                    statementProxy.getTargetSQL(),                    dbType);        }        Executor<T> executor;        if (CollectionUtils.isEmpty(sqlRecognizers)) {            executor = new PlainExecutor<>(statementProxy, statementCallback);        } else {            if (sqlRecognizers.size() == 1) {                SQLRecognizer sqlRecognizer = sqlRecognizers.get(0);                //��ͬSQL���ͣ���ͬ����                switch (sqlRecognizer.getSQLType()) {                    case INSERT:                        executor = EnhancedServiceLoader.load(InsertExecutor.class, dbType,                                new Class[]{StatementProxy.class, StatementCallback.class, SQLRecognizer.class},                                new Object[]{statementProxy, statementCallback, sqlRecognizer});                        break;                    case UPDATE:                        executor = new UpdateExecutor<>(statementProxy, statementCallback, sqlRecognizer);                        break;                    case DELETE:                        executor = new DeleteExecutor<>(statementProxy, statementCallback, sqlRecognizer);                        break;                    case SELECT_FOR_UPDATE:                        executor = new SelectForUpdateExecutor<>(statementProxy, statementCallback, sqlRecognizer);                        break;                    default:                        executor = new PlainExecutor<>(statementProxy, statementCallback);                        break;                }            } else {                executor = new MultiExecutor<>(statementProxy, statementCallback, sqlRecognizers);            }        }        T rs;        try {            //ִ��SQL            rs = executor.execute(args);        } catch (Throwable ex) {            if (!(ex instanceof SQLException)) {                // Turn other exception into SQLException                ex = new SQLException(ex);            }            throw (SQLException) ex;        }        return rs;    }
+```
+
+
+
+
+
+
+
+
+
+*   ���ж��Ƿ�����ȫ���������û�У����ߴ�����������sql����������
+*   ����SQLVisitorFactory��Ŀ��sql���н���
+*   ����ض�����sql����(INSERT,UPDATE,DELETE,SELECT_FOR_UPDATE)�Ƚ����������
+*   ִ��sql�����ؽ��
+    ��ͬ���͵�SQL����������һ����������insertΪ��
+
+![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/b1eb1b610beb647b230995f19ecbb4bbc98602.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������")insertʹ�õ���InsertExecutor.execute����������ʵ���ջ���ʹ��
+io.seata.rm.datasource.exec.BaseTransactionalExecutor#execute����
+
+
+
+```
+@Overridepublic T execute(Object... args) throws Throwable {    if (RootContext.inGlobalTransaction()) {        String xid = RootContext.getXID();        statementProxy.getConnectionProxy().bind(xid);    }     statementProxy.getConnectionProxy().setGlobalLockRequire(RootContext.requireGlobalLock());    return doExecute(args);}
+```
+
+
+
+
+
+
+
+
+
+���������е�xid�󶨵���statementProxy�У���������doExecute����������AbstractDMLBaseExecutor�е�doExecute����
+
+
+
+```
+@Overridepublic T doExecute(Object... args) throws Throwable {    AbstractConnectionProxy connectionProxy = statementProxy.getConnectionProxy();    if (connectionProxy.getAutoCommit()) {        return executeAutoCommitTrue(args);    } else {        return executeAutoCommitFalse(args);    }}
+```
+
+
+
+
+
+
+
+
+
+���������
+executeAutoCommitTrue/executeAutoCommitFalse
+
+
+
+```
+protected T executeAutoCommitTrue(Object[] args) throws Throwable {    ConnectionProxy connectionProxy = statementProxy.getConnectionProxy();    try {        connectionProxy.setAutoCommit(false);        return new LockRetryPolicy(connectionProxy).execute(() -> {            T result = executeAutoCommitFalse(args);            connectionProxy.commit();            return result;        });    } catch (Exception e) {        ...    } finally {        connectionProxy.getContext().reset();        connectionProxy.setAutoCommit(true);    }}
+```
+
+
+
+
+
+
+
+
+
+����ϸ���֣����ն��ǵ���executeAutoCommitFalse����
+
+
+
+```
+protected T executeAutoCommitFalse(Object[] args) throws Exception {    //����getTableMeta����    if (!JdbcConstants.MYSQL.equalsIgnoreCase(getDbType()) && getTableMeta().getPrimaryKeyOnlyName().size() > 1)    {        throw new NotSupportYetException("multi pk only support mysql!");    }    //��ȡbeforeImage    TableRecords beforeImage = beforeImage();    //ִ��ҵ��sql    T result = statementCallback.execute(statementProxy.getTargetStatement(), args);    //��ȡafterImage    TableRecords afterImage = afterImage(beforeImage);    //����image    prepareUndoLog(beforeImage, afterImage);    return result;}
+```
+
+
+
+
+
+
+
+
+
+��ȡbeforeImage
+
+
+
+```
+//tableMeta�������������������������protected TableMeta getTableMeta(String tableName) {    if (tableMeta != null) {        return tableMeta;    }    ConnectionProxy connectionProxy = statementProxy.getConnectionProxy();    tableMeta = TableMetaCacheFactory.getTableMetaCache(connectionProxy.getDbType())        .getTableMeta(connectionProxy.getTargetConnection(), tableName, connectionProxy.getDataSourceProxy().getResourceId());    return tableMeta;}
+```
+
+
+
+
+
+
+
+
+
+ִ��ҵ��sql����ʹ��
+com.alibaba.druid.pool.DruidPooledPreparedStatement#execute����ִ��
+
+��ȡafterImage![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/540ff5c254dde029bed208247025e97bd1f497.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������")���ύ����ʱ������undo_log��־
+
+
+
+```
+protected T executeAutoCommitTrue(Object[] args) throws Throwable {    ConnectionProxy connectionProxy = statementProxy.getConnectionProxy();    try {        connectionProxy.setAutoCommit(false);        return new LockRetryPolicy(connectionProxy).execute(() -> {            T result = executeAutoCommitFalse(args);            //����            connectionProxy.commit();            return result;        });    } catch (Exception e) {        ...    } finally {        connectionProxy.getContext().reset();        connectionProxy.setAutoCommit(true);    }}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+public void commit() throws SQLException {    try {        LOCK_RETRY_POLICY.execute(() -> {            //����            doCommit();            return null;        });    } catch (SQLException e) {        throw e;    } catch (Exception e) {        throw new SQLException(e);    }}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+private void doCommit() throws SQLException {    if (context.inGlobalTransaction()) {        //����        processGlobalTransactionCommit();    } else if (context.isGlobalLockRequire()) {        processLocalCommitWithGlobalLocks();    } else {        targetConnection.commit();    }}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+private void processGlobalTransactionCommit() throws SQLException {    try {        //��seata-serverע���֧��Ϣ        register();    } catch (TransactionException e) {        recognizeLockKeyConflictException(e, context.buildLockKeys());    }    try {        //�ύ����֮ǰ������undo_log,����flushUndoLogs        UndoLogManagerFactory.getUndoLogManager(this.getDbType()).flushUndoLogs(this);        targetConnection.commit();    } catch (Throwable ex) {       ...    }    if (IS_REPORT_SUCCESS_ENABLE) {        report(true);    }    context.reset();}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+public void flushUndoLogs(ConnectionProxy cp) throws SQLException {    ConnectionContext connectionContext = cp.getContext();    if (!connectionContext.hasUndoLog()) {        return;    }     String xid = connectionContext.getXid();    long branchId = connectionContext.getBranchId();     ...//�÷�������undo_log    insertUndoLogWithNormal(xid, branchId, buildContext(parser.getName()), undoLogContent,                            cp.getTargetConnection());}
+```
+
+
+
+
+
+
+
+
+
+�ڸ÷�����ע���֧����![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/92309a950c73829078a3170c585fc58fb03b0d.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������")�ύ������seata-serverע���֧��Ϣ��seata-server���յ�����seataԴ�룩![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/c116df5929a1116e61e683298e14b953450bb7.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������")
+
+io.seata.server.coordinator.DefaultCoordinator#doBranchRegister����
+
+
+
+```
+public Long branchRegister(BranchType branchType, String resourceId, String clientId, String xid,                           String applicationData, String lockKeys) throws TransactionException {    GlobalSession globalSession = assertGlobalSessionNotNull(xid, false);    return SessionHolder.lockAndExecute(globalSession, () -> {        ...        try {            //����ע��            globalSession.addBranch(branchSession);        } catch (RuntimeException ex) {            ...        }        ...        return branchSession.getBranchId();    });}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+@Overridepublic void addBranch(BranchSession branchSession) throws TransactionException {    for (SessionLifecycleListener lifecycleListener : lifecycleListeners) {        //����onAddBranch��ѡ��AbstractSessionManager        lifecycleListener.onAddBranch(this, branchSession);    }    branchSession.setStatus(BranchStatus.Registered);    add(branchSession);}
+```
+
+
+
+
+
+
+
+
+
+io.seata.server.storage.db.session.DataBaseSessionManager#addBranchSession����
+
+
+
+```
+@Overridepublic void onAddBranch(GlobalSession globalSession, BranchSession branchSession) throws TransactionException {    //���룬ѡ��DataBaseSessionManager    addBranchSession(globalSession, branchSession);}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+@Overridepublic void addBranchSession(GlobalSession globalSession, BranchSession session) throws TransactionException {    if (StringUtils.isNotBlank(taskName)) {        return;    }    //����    boolean ret = transactionStoreManager.writeSession(LogOperation.BRANCH_ADD, session);    if (!ret) {        throw new StoreException("addBranchSession failed.");    }}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+@Overridepublic boolean writeSession(LogOperation logOperation, SessionStorable session) {    if (LogOperation.GLOBAL_ADD.equals(logOperation)) {        return logStore.insertGlobalTransactionDO(SessionConverter.convertGlobalTransactionDO(session));    } else if (LogOperation.GLOBAL_UPDATE.equals(logOperation)) {        return logStore.updateGlobalTransactionDO(SessionConverter.convertGlobalTransactionDO(session));    } else if (LogOperation.GLOBAL_REMOVE.equals(logOperation)) {        return logStore.deleteGlobalTransactionDO(SessionConverter.convertGlobalTransactionDO(session));    } else if (LogOperation.BRANCH_ADD.equals(logOperation)) {        return logStore.insertBranchTransactionDO(SessionConverter.convertBranchTransactionDO(session));    } else if (LogOperation.BRANCH_UPDATE.equals(logOperation)) {        return logStore.updateBranchTransactionDO(SessionConverter.convertBranchTransactionDO(session));    } else if (LogOperation.BRANCH_REMOVE.equals(logOperation)) {        return logStore.deleteBranchTransactionDO(SessionConverter.convertBranchTransactionDO(session));    } else {        throw new StoreException("Unknown LogOperation:" + logOperation.name());    }}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+@Overridepublic boolean insertBranchTransactionDO(BranchTransactionDO branchTransactionDO) {    String sql = LogStoreSqlsFactory.getLogStoreSqls(dbType).getInsertBranchTransactionSQL(branchTable);    Connection conn = null;    PreparedStatement ps = null;    try {        int index = 1;        conn = logStoreDataSource.getConnection();        conn.setAutoCommit(true);        ps = conn.prepareStatement(sql);        ps.setString(index++, branchTransactionDO.getXid());        ps.setLong(index++, branchTransactionDO.getTransactionId());        ps.setLong(index++, branchTransactionDO.getBranchId());        ps.setString(index++, branchTransactionDO.getResourceGroupId());        ps.setString(index++, branchTransactionDO.getResourceId());        ps.setString(index++, branchTransactionDO.getBranchType());        ps.setInt(index++, branchTransactionDO.getStatus());        ps.setString(index++, branchTransactionDO.getClientId());        ps.setString(index++, branchTransactionDO.getApplicationData());        return ps.executeUpdate() > 0;    } catch (SQLException e) {        throw new StoreException(e);    } finally {        IOUtil.close(ps, conn);    }}
+```
+
+
+
+
+
+
+
+
+
+Seata-server���ӷ�֧��Ϣ��ɣ������һ�׶ν�����ҵ�����ݣ�undo_log����֧��Ϣ���Ѿ�д�����ݿ�
+
+**2.4.1.3 AT���׶��ύ**
+�ص�handleGlobalTransaction�����У�������
+transactionalTemplate.execute����
+
+
+
+```
+// 2\. ����ȫ������beginTransactionbeginTransaction(txInfo, tx); Object rs = null;try {     // ִ��ҵ�񷽷�business.execute()    rs = business.execute(); } catch (Throwable ex) {     //������һ�׶�    //�����Ƕ��׶�    // 3.�����쳣ִ��completeTransactionAfterThrowing�ع�    completeTransactionAfterThrowing(txInfo, tx, ex);    throw ex;} // 4\. û���쳣�ύ����commitTransactioncommitTransaction(tx);
+```
+
+
+
+
+
+
+
+
+
+���׶��ύ
+
+commitTransaction(tx);����
+
+
+
+```
+private void commitTransaction(GlobalTransaction tx) throws TransactionalExecutor.ExecutionException {    try {        triggerBeforeCommit();        //����        tx.commit();        triggerAfterCommit();    } catch (TransactionException txe) {        // 4.1 Failed to commit        throw new TransactionalExecutor.ExecutionException(tx, txe,                                                           TransactionalExecutor.Code.CommitFailure);    }}
+```
+
+
+
+
+
+
+
+
+
+![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/61b35980530bd17bff9025f1112baa9e3e93e5.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������")
+
+
+
+```
+@Overridepublic GlobalStatus commit(String xid) throws TransactionException {    GlobalCommitRequest globalCommit = new GlobalCommitRequest();    globalCommit.setXid(xid);    //����syncCall    GlobalCommitResponse response = (GlobalCommitResponse) syncCall(globalCommit);    return response.getGlobalStatus();}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+private AbstractTransactionResponse syncCall(AbstractTransactionRequest request) throws TransactionException {    try {        return (AbstractTransactionResponse) TmNettyRemotingClient.getInstance().sendSyncRequest(request);    } catch (TimeoutException toe) {        throw new TmTransactionException(TransactionExceptionCode.IO, "RPC timeout", toe);    }}
+```
+
+
+
+
+
+
+
+
+
+����ͨ��TM����seata-server��Seata-server���յ�ȫ���ύ����seataԴ�룩
+
+DefaultCoordinator��
+
+
+
+```
+@Overrideprotected void doGlobalCommit(GlobalCommitRequest request, GlobalCommitResponse response, RpcContext rpcContext)    throws TransactionException {    MDC.put(RootContext.MDC_KEY_XID, request.getXid());    //����commit    response.setGlobalStatus(core.commit(request.getXid()));}
+```
+
+
+
+
+
+
+
+
+
+![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/185262d74acd3a723a7770d5771c19fa9fa5cf.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������")![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/51249f8944b29b9ffc82897a818cb4c33ed06a.png "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������")![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/14a2f2b58ad3f11be518376d5e6f68cc678af9.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������")
+Seata-server���յ��ͻ���ȫ���ύ������Ȼص��ͻ��ˣ�ɾ��undo_log��seata��ɾ����֧��ȫ������
+
+֮ǰ˵��RMClient�ڳ�ʼ��ʱ��������Դ������resourceManager��������Ϣ�ص����������ڽ���TC�ڶ��׶η������ύ���߻ع�����![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/884c07085b1230a1aab1883d691532ccf6b79c.png "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������")Seata-serverɾ����֧���ݼ�ȫ����������
+
+
+
+```
+@Overridepublic void removeBranch(BranchSession branchSession) throws TransactionException {    // do not unlock if global status in (Committing, CommitRetrying, AsyncCommitting),    // because it's already unlocked in 'DefaultCore.commit()'    if (status != Committing && status != CommitRetrying && status != AsyncCommitting) {        if (!branchSession.unlock()) {            throw new TransactionException("Unlock branch lock failed, xid = " + this.xid + ", branchId = " + branchSession.getBranchId());        }    }    for (SessionLifecycleListener lifecycleListener : lifecycleListeners) {        //����        lifecycleListener.onRemoveBranch(this, branchSession);    }    remove(branchSession);}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+private void writeSession(LogOperation logOperation, SessionStorable sessionStorable) throws TransactionException {    if (!transactionStoreManager.writeSession(logOperation, sessionStorable)) {        if (LogOperation.GLOBAL_ADD.equals(logOperation)) {            throw new GlobalTransactionException(TransactionExceptionCode.FailedWriteSession,                                                 "Fail to store global session");        } else if (LogOperation.GLOBAL_UPDATE.equals(logOperation)) {            throw new GlobalTransactionException(TransactionExceptionCode.FailedWriteSession,                                                 "Fail to update global session");        } else if (LogOperation.GLOBAL_REMOVE.equals(logOperation)) {            throw new GlobalTransactionException(TransactionExceptionCode.FailedWriteSession,                                                 "Fail to remove global session");        } else if (LogOperation.BRANCH_ADD.equals(logOperation)) {            throw new BranchTransactionException(TransactionExceptionCode.FailedWriteSession,                                                 "Fail to store branch session");        } else if (LogOperation.BRANCH_UPDATE.equals(logOperation)) {            throw new BranchTransactionException(TransactionExceptionCode.FailedWriteSession,                                                 "Fail to update branch session");        } else if (LogOperation.BRANCH_REMOVE.equals(logOperation)) {            throw new BranchTransactionException(TransactionExceptionCode.FailedWriteSession,                                                 "Fail to remove branch session");        } else {            throw new BranchTransactionException(TransactionExceptionCode.FailedWriteSession,                                                 "Unknown LogOperation:" + logOperation.name());        }    }}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+public static void endCommitted(GlobalSession globalSession) throws TransactionException {    globalSession.changeStatus(GlobalStatus.Committed);    //ɾ��ȫ������    globalSession.end();}
+```
+
+
+
+
+
+
+
+
+
+�ͻ���ɾ��undo_log����
+
+�ڽ����ύ����
+
+
+
+```
+protected void doBranchCommit(BranchCommitRequest request, BranchCommitResponse response)    throws TransactionException {    String xid = request.getXid();    long branchId = request.getBranchId();    String resourceId = request.getResourceId();    String applicationData = request.getApplicationData();    if (LOGGER.isInfoEnabled()) {        LOGGER.info("Branch committing: " + xid + " " + branchId + " " + resourceId + " " + applicationData);    }    //����    BranchStatus status = getResourceManager().branchCommit(request.getBranchType(), xid, branchId, resourceId,                                                            applicationData);    response.setXid(xid);    response.setBranchId(branchId);    response.setBranchStatus(status);    if (LOGGER.isInfoEnabled()) {        LOGGER.info("Branch commit result: " + status);    } }
+```
+
+
+
+
+
+
+
+
+
+getResourceManager��ȡ�ľ���RMClient��ʼ��ʱ���õ���Դ������DataSourceManager
+
+
+
+```
+public BranchStatus branchCommit(BranchType branchType, String xid, long branchId, String resourceId,                                 String applicationData) throws TransactionException {    return asyncWorker.branchCommit(branchType, xid, branchId, resourceId, applicationData);}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+@Overridepublic BranchStatus branchCommit(BranchType branchType, String xid, long branchId, String resourceId,                                 String applicationData) throws TransactionException {    if (!ASYNC_COMMIT_BUFFER.offer(new Phase2Context(branchType, xid, branchId, resourceId, applicationData))) {        LOGGER.warn("Async commit buffer is FULL. Rejected branch [{}/{}] will be handled by housekeeping later.", branchId, xid);    }    return BranchStatus.PhaseTwo_Committed;}
+```
+
+
+
+
+
+
+
+
+
+���ֻ����һ��ASYNC_COMMIT_BUFFER����List��������һ�����׶��ύ��context���������ύ��AsyncWorker��init()����
+
+
+
+```
+public synchronized void init() {    LOGGER.info("Async Commit Buffer Limit: {}", ASYNC_COMMIT_BUFFER_LIMIT);    ScheduledExecutorService timerExecutor = new ScheduledThreadPoolExecutor(1, new NamedThreadFactory("AsyncWorker", 1, true));    timerExecutor.scheduleAtFixedRate(() -> {        try {//����            doBranchCommits();         } catch (Throwable e) {            LOGGER.info("Failed at async committing ... {}", e.getMessage());         }    }, 10, 1000 * 1, TimeUnit.MILLISECONDS);}
+```
+
+
+
+
+
+
+
+
+
+![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/a730eb7781ec4bd3ad2578fb7855aa02d45fbc.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������")ɾ��Undo_log
+
+**���׶λع�**
+
+���׶λع�seata-server�˴�������׶��ύ���ƣ�����ʡ��
+
+
+
+```
+protected void doGlobalRollback(GlobalRollbackRequest request, GlobalRollbackResponse response,                                RpcContext rpcContext) throws TransactionException {    MDC.put(RootContext.MDC_KEY_XID, request.getXid());    //ȫ�ֻع�sea����������    response.setGlobalStatus(core.rollback(request.getXid()));}
+```
+
+
+
+
+
+
+
+
+
+��Ҫ���ع��ͻ�����ν������񲹳�
+
+
+
+```
+@Overridepublic BranchRollbackResponse handle(BranchRollbackRequest request) {    BranchRollbackResponse response = new BranchRollbackResponse();    exceptionHandleTemplate(new AbstractCallback<BranchRollbackRequest, BranchRollbackResponse>() {        @Override        public void execute(BranchRollbackRequest request, BranchRollbackResponse response)            throws TransactionException {            //����            doBranchRollback(request, response);        }    }, request, response);    return response;}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+public BranchStatus branchRollback(BranchType branchType, String xid, long branchId, String resourceId,                                   String applicationData) throws TransactionException {    DataSourceProxy dataSourceProxy = get(resourceId);    if (dataSourceProxy == null) {        throw new ShouldNeverHappenException();    }    try {        UndoLogManagerFactory.getUndoLogManager(dataSourceProxy.getDbType()).undo(dataSourceProxy, xid, branchId);    } catch (TransactionException te) {        StackTraceLogger.info(LOGGER, te,                              "branchRollback failed. branchType:[{}], xid:[{}], branchId:[{}], resourceId:[{}], applicationData:[{}]. reason:[{}]",                              new Object[]{branchType, xid, branchId, resourceId, applicationData, te.getMessage()});        if (te.getCode() == TransactionExceptionCode.BranchRollbackFailed_Unretriable) {            return BranchStatus.PhaseTwo_RollbackFailed_Unretryable;        } else {            return BranchStatus.PhaseTwo_RollbackFailed_Retryable;        }    }    return BranchStatus.PhaseTwo_Rollbacked; }
+```
+
+
+
+
+
+
+
+
+
+���ջع��������õ���UndoLogManager.undo(dataSourceProxy, xid, branchId);![SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/4842a0701546824cf2720855d8310a1274c576.jpg "SpringCloud Alibabaϵ�С���17Seata ATģʽԴ��������£�-��Դ������������")�ж�undolog�Ƿ���ڣ�������ɾ����Ӧundolog����һ���ύ������seata��ATģʽԴ�������ϡ�
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudSentinel\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudSentinel\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..9fc4976
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloudAlibaba\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudSentinel\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,659 @@
+���� | һ��ߣJava
+��Դ |����ͷ��
+
+**ѧϰĿ��**
+
+*   Sentinel�Ĺ���ԭ��
+    **��1�� ����ԭ��**
+    ��Sentinel�У����е���Դ����Ӧһ����Դ�����Լ�һ��Entry��ÿһ��entry���Ա�ʾһ�����󡣶�Sentinel�У�����Ե�ǰ������ڹ�����ж���ʵ�����صĿ��ƣ�ԭ������ͼ��ʾ��
+
+![SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1296c955070646bbc74310e726679bbabfe585.jpg "SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������")��ͼ����Ϊ���˼���չʾ��ͼ�� Slot ��˳���Ѻ����°� Sentinel Slot Chain ˳��һ��
+��һ���ⲿ�������֮�󣬻ᴴ��һ��Entry��������Entry��ͬʱ��Ҳ�ᴴ��һϵ�е�slot ���һ����������ÿ��slot�в�ͬ�Ĺ���ְ��
+
+*   NodeSelectorSlot �����ռ���Դ��·����������Щ��Դ�ĵ���·��������״�ṹ�洢���������ڸ��ݵ���·��������������
+*   ClusterBuilderSlot �����ڴ洢��Դ��ͳ����Ϣ�Լ���������Ϣ���������Դ�� RT, QPS,thread count �ȵȣ���Щ��Ϣ������Ϊ��ά�����������������ݣ�
+*   StatisticSlot �����ڼ�¼��ͳ�Ʋ�ͬγ�ȵ� runtime ָ������Ϣ��
+*   FlowSlot �����ڸ���Ԥ������������Լ�ǰ�� slot ͳ�Ƶ�״̬���������������ƣ�
+*   AuthoritySlot ��������õĺڰ������͵�����Դ��Ϣ�������ڰ��������ƣ�
+*   DegradeSlot ��ͨ��ͳ����Ϣ�Լ�Ԥ��Ĺ��������۶Ͻ�����
+*   SystemSlot ��ͨ��ϵͳ��״̬������ load1 �ȣ��������ܵ����������
+*   LogSlot �ڳ����������۶ϡ�ϵͳ����ʱ�����¼��־
+*   ...
+    Sentinel �� ProcessorSlot ��Ϊ SPI �ӿڽ�����չ��1.7.2 �汾��ǰ SlotChainBuilder ��ΪSPI����ʹ�� Slot Chain �߱�����չ�����������������м����Զ���� slot ������ slot ���˳�򣬴Ӷ����Ը� Sentinel �����Զ���Ĺ��ܡ�
+
+![SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/d65c2688084bf5be06d3687ce8663cb1b7167b.jpg "SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������")**Spring Cloud ����Sentinel��ԭ��**
+
+Spring Cloud �м���Sentinel�������ǻ�����������ʵ�֣������ʵ��·�����¡�
+
+SentinelWebAutoConfiguration����>addInterceptors����>SentinelWebInterceptor->AbstractSentinelInterceptor
+
+
+
+```
+public boolean preHandle(HttpServletRequest request, HttpServletResponseresponse, Object handler) throws Exception {  try {    String resourceName = this.getResourceName(request);    if (StringUtil.isEmpty(resourceName)) {      return true;   } else if (this.increaseReferece(request,this.baseWebMvcConfig.getRequestRefName(), 1) != 1) {      return true;   } else {      String origin = this.parseOrigin(request);      String contextName = this.getContextName(request);      ContextUtil.enter(contextName, origin);      Entry entry = SphU.entry(resourceName, 1, EntryType.IN);     request.setAttribute(this.baseWebMvcConfig.getRequestAttributeName(), entry);      return true;   } } catch (BlockException var12) {    BlockException e = var12;    try {      this.handleBlockException(request, response, e);   } finally {      ContextUtil.exit();   }    return false; }}
+```
+
+
+
+
+
+
+
+
+
+> ��Դ���õ��������ͣ������������ EntryType.IN �����dz��������� EntryType.OUT ����ע��ϵͳ����ֻ�� IN ��Ч
+
+**��2�� SphU.entry**
+�����Ǽ���dubboҲ�ã����Ǽ��ɵ�spring cloud��Ҳ�ã����ն��ǵ���SphU.entry������������������жϵģ����������Ǵ�SphU.entry���������ȥ�˽�����ʵ��ԭ����
+
+���������ǿ���Ψһ�ɻ�ģ�Ҳ����ؼ���һ���� SphU.entry(resource) �� ���Ǵ���ȥ��һ����Դ�������Դ�����Ƿ������������ǽӿڣ���ô����������ʲô�أ���������һ�����ҿ�����������ɴ��
+
+
+
+```
+public static Entry entry(String name) throws BlockException {    return Env.sph.entry(name, EntryType.OUT, 1, OBJECTS0);}public class Env {    public static final Sph sph = new CtSph();    ......//ʡ�Բ��ִ���}
+```
+
+
+
+
+
+
+
+
+
+�� SphU.entry() ��������ִ�л���뵽 Sph.entry() ��Sph��Ĭ��ʵ������ CtSph,�����ջ����CtSph ��entry ������
+
+
+
+```
+@Overridepublic Entry entry(String name, EntryType type, int count, Object... args) throws BlockException {���� //��װ��һ����Դ����    StringResourceWrapper resource = new StringResourceWrapper(name, type);    return entry(resource, count, args);}
+```
+
+
+
+
+
+
+
+
+
+�������Ҫ������ͨ�����Ǹ�������Դȥ��װ��һ�� StringResourceWrapper ��Ȼ�����Լ������ط������̶����� entryWithPriority(resourceWrapper, count, false, args)��
+
+*   ResourceWrapper ��ʾsentinel����Դ�����˷�װ
+*   count��ʾ���������ռ�õIJ���������Ĭ����1
+*   prioritized�����ȼ�
+
+
+
+```
+private Entry entryWithPriority(ResourceWrapper resourceWrapper, int count,boolean prioritized, Object... args)    throws BlockException {    //��ȡ�����Ļ������洢��ThreadLocal�У�context�л�洢����������    Context context = ContextUtil.getContext();    //����� NullContext����ô˵�� context name ������ 2000 �����μ� ContextUtil#trueEnter    //���ʱ��Sentinel ���ٽ��ܴ����µ� context ���ã�Ҳ���Dz�����Щ�µĽӿڵ�ͳ�ơ������۶ϵ�    if (context instanceof NullContext) {        // The {@link NullContext} indicates that the amount of context has exceeded the threshold,        // so here init the entry only. No rule checking will be done.        return new CtEntry(resourceWrapper, null, context);    }    if (context == null) {//ʹ��Ĭ��context        // ����Context�IJ���        context = InternalContextUtil.internalEnter(Constants.CONTEXT_DEFAULT_NAME);    }    // Global switch is close, no rule checking will do.    if (!Constants.ON) {//ȫ�����������Ƿ��Ѿ�����������ر��ˣ��Ͳ���������������        return new CtEntry(resourceWrapper, null, context);    }    //���ģʽ�е�������ģʽ��    //����һ��slot����    ProcessorSlot<Object> chain = lookProcessChain(resourceWrapper);    //���� lookProcessChain ����������֪������ resource ���� Constants.MAX_SLOT_CHAIN_SIZE��    // Ҳ���� 6000 ��ʱ��Sentinel ��ʼ�������µ�������ô����Ҫ��Ϊ�� Sentinel �����ܿ���    if (chain == null) {        return new CtEntry(resourceWrapper, null, context);    }    //���������������ʼ�����ɸ�entry    Entry e = new CtEntry(resourceWrapper, chain, context);    try {        //��ʼ�����������        chain.entry(context, resourceWrapper, null, count, prioritized, args);    } catch (BlockException e1) {        e.exit(count, args); //���������׳��쳣��        throw e1;    } catch (Throwable e1) {        // This should not happen, unless there are errors existing in Sentinel internal.        RecordLog.info("Sentinel unexpected exception", e1);    }    return e;//���������Ľ��}
+```
+
+
+
+
+
+
+
+
+
+������Ĵ������ǿ���֪�����÷�������Ҫ�ǻ�ȡ���˱���Դ����Ӧ����Դ���������������� lookProcessChain �з��֣�����ȥ��ȡ��һ����������ȥִ����Դ�����ϴ�������Ȼ�����ﴦ�������Ļ����£���ô����������϶��Ƕ��ڵ�ǰ�������������������������صĴ��������Է�Ϊ���¼������֣�
+
+*   �Բ�ȫ������������⣬���������Ҫ���ֱ�ӷ�����һ��CtEntry���󣬲����ٽ��к����������⣬�����������ļ�����̡����ݰ�װ������Դ�����ȡ��Ӧ��SlotChain
+*   ִ��SlotChain��entry���������SlotChain��entry�����׳���BlockException���򽫸��쳣���������׳������SlotChain��entry��������ִ���ˣ������Ὣ��entry���󷵻�
+*   ����ϲ㷽��������BlockException����˵�����������ˣ���������������ִ��
+    **2.1 ����Context**
+    InternalContextUtil.internalEnter--->trueEnter
+
+
+
+```
+protected static Context trueEnter(String name, String origin) {    //��ThreadLocal�л�ȡ����һ�ο϶���null    Context context = contextHolder.get();    if (context == null) {        //�����Ǹ���Context�����ֻ�ȡNode        Map<String, DefaultNode> localCacheNameMap = contextNameNodeMap;        DefaultNode node = localCacheNameMap.get(name);        if (node == null) {            if (localCacheNameMap.size() > Constants.MAX_CONTEXT_NAME_SIZE) {                setNullContext();                return NULL_CONTEXT;            } else {                LOCK.lock();                try {                    node = contextNameNodeMap.get(name);                    if (node == null) {                        if (contextNameNodeMap.size() > Constants.MAX_CONTEXT_NAME_SIZE) {                            setNullContext();                            return NULL_CONTEXT;                        } else {                            //������EntranceNode                            node = new EntranceNode(new StringResourceWrapper(name, EntryType.IN), null);                            //����ȫ�ֵĽڵ�                            // Add entrance node.                            Constants.ROOT.addChild(node);//����map��                            Map<String, DefaultNode> newMap = new HashMap<>(contextNameNodeMap.size() + 1);                            newMap.putAll(contextNameNodeMap);                            newMap.put(name, node);                            contextNameNodeMap = newMap;                        }                    }                } finally {                    LOCK.unlock();                }            }        }        context = new Context(node, name);        context.setOrigin(origin);        //����ThreadLocal��        contextHolder.set(context);    }    return context;}
+```
+
+
+
+
+
+
+
+
+
+������߼����DZȽϼ򵥵�
+
+*   ������ThreadLocal��ȡ����ȡ�����ʹ�������Ȼ�ͷ���
+*   Ȼ����Map�и���ContextName��һ��Node
+*   û���ҵ�Node�ͼ����ķ�ʽ������һ��EntranceNode��Ȼ�����Map��
+*   ����Context������node��name��origin���ٷ���ThreadLocal��
+    ����Context�ʹ������
+
+ĿǰContext�����״̬����ͼ![SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/a114ee154527b7fcf24169d5291c7bac87ac93.png "SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������")**2.2 ����slot��**
+����һ��slot������·�����Ϊ
+
+> DefaultProcessorSlotChain -> NodeSelectorSlot -> ClusterBuilderSlot -> LogSlot ->StatisticSlot -> AuthoritySlot -> SystemSlot -> ParamFlowSlot -> FlowSlot -> DegradeSlot
+
+
+
+```
+ProcessorSlot<Object> lookProcessChain(ResourceWrapper resourceWrapper) {    //���Կ�����chain��������Դ����Ϊkey����ͬ����Դ�϶��Dz�ͬchain��    ProcessorSlotChain chain = chainMap.get(resourceWrapper);    if (chain == null) {////������spring(����bean) dubbo(˫�ؼ����)�����һ�ޣ����û������        synchronized (LOCK) {            chain = chainMap.get(resourceWrapper);            if (chain == null) {                //chainMap��С����һ��ֵ��Ҳ����entry������С�����ˣ�һ��chain��Ӧһ��entry                if (chainMap.size() >= Constants.MAX_SLOT_CHAIN_SIZE) {                    return null;                }                //����һ��slot chain                chain = SlotChainProvider.newSlotChain();                //������߼��ǣ��½�һ��Map��С��oldMap+1                Map<ResourceWrapper, ProcessorSlotChain> newMap = new                    HashMap<ResourceWrapper, ProcessorSlotChain>(                    chainMap.size() + 1);                //Ȼ�����������oldMap���ٷ��½���chain                newMap.putAll(chainMap);                newMap.put(resourceWrapper, chain); //���ӵ�newMap�� ����Ӧ���ǿ��DZ���Ƶ������                chainMap = newMap;            }        }    }    return chain;}
+```
+
+
+
+
+
+
+
+
+
+����Ĵ�����������Է��֣����ȴӻ����л�ȡ�ô�����������һ�ν����϶���û�еģ������������ SlotChainProvider ȥ���촦������������ɺ�����뻺���Ա��´�ʹ�ã�
+
+
+
+```
+public static ProcessorSlotChain newSlotChain() {    if (slotChainBuilder != null) {        return slotChainBuilder.build();    }    // ����ͨ��spi����ȥ������������������Լ�����slot�Ļ�ֻ��Ҫ����SPI����ʵ��SlotChainBuilder�ӿھͺ�    //SentinelĬ�ϵ�����sentinel-core���µ�META-INF.services��    slotChainBuilder = SpiLoader.loadFirstInstanceOrDefault(SlotChainBuilder.class, DefaultSlotChainBuilder.class);    if (slotChainBuilder == null) {        // Should not go through here.        RecordLog.warn("[SlotChainProvider] Wrong state when resolving slot chain builder, using default");        slotChainBuilder = new DefaultSlotChainBuilder();    } else {        RecordLog.info("[SlotChainProvider] Global slot chain builder resolved: "                       + slotChainBuilder.getClass().getCanonicalName());    }    return slotChainBuilder.build();}
+```
+
+
+
+
+
+
+
+
+
+������������˶�ε�У�飬ȷ��builder ��Ϊ�գ�Ȼ��ͨ����ȥ���������������
+
+
+
+```
+public class DefaultSlotChainBuilder implements SlotChainBuilder {    @Override    public ProcessorSlotChain build() {        ProcessorSlotChain chain = new DefaultProcessorSlotChain();        chain.addLast(new NodeSelectorSlot());        chain.addLast(new ClusterBuilderSlot());        chain.addLast(new LogSlot());        chain.addLast(new StatisticSlot());        chain.addLast(new SystemSlot());        chain.addLast(new AuthoritySlot());        chain.addLast(new FlowSlot());        chain.addLast(new DegradeSlot());        return chain;    }}
+```
+
+
+
+
+
+
+
+
+
+���������������ڷ����������������������������Ҳ�ж������˵�����Ͼ���Sentinel�����������㷨��ʵ�ָ��أ����ǿ�һ�¹����Ľ��ܣ�
+
+�� Sentinel ���棬���е���Դ����Ӧһ����Դ���ƣ�resourceName����ÿ����Դ���ö��ᴴ��һ�� Entry ����Entry ����ͨ����������ܵ������Զ�������Ҳ����ͨ��ע��ķ�ʽ����� SphU API ��ʽ������Entry ������ʱ��ͬʱҲ�ᴴ��һϵ�й��ܲ�ۣ�slot chain������Щ����в�ͬ��ְ�𡣾���ְ���������Ѿ��ᵽ�ˡ�
+
+**��������**
+
+�����ִ���������¡�
+
+* NodeSelectorSlot����Ҫ���ڹ�����������
+
+* ClusterBuilderSlot�����ڼ�Ⱥ�������۶ϡ�
+
+* LogSlot�����ڼ�¼��־��
+
+* StatisticSlot������ʵʱ�ռ�ʵʱ��Ϣ��
+
+* AuthoritySlot������Ȩ��У��ġ�
+
+* SystemSlot��������֤ϵͳ����Ĺ���
+
+* FlowSlot��ʵ���������ơ�
+
+* DegradeSlot��ʵ���۶ϻ��ơ�
+  **2.3 ����Entry**
+
+  > Entry e = new CtEntry(resourceWrapper, chain, context);
+
+
+
+```
+CtEntry(ResourceWrapper resourceWrapper, ProcessorSlot<Object> chain, Context context) {    super(resourceWrapper);    this.chain = chain;    this.context = context;    setUpEntryFor(context);}private void setUpEntryFor(Context context) {    // The entry should not be associated to NullContext.    if (context instanceof NullContext) {        return;    }    this.parent = context.getCurEntry();    if (parent != null) {        ((CtEntry) parent).child = this;    }    context.setCurEntry(this);}
+
+```
+
+
+
+
+
+
+
+
+
+����һ��Entry���ɵ�ʱ��context.getCurEntry�ض���NULL����ôֱ��ִ��Context.setCurEntry����
+
+Ȼ�����Context��״̬����ͼ  ![SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/57273a794d51cfc587c923de97943491e9da0b.jpg "SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������")��ִ��һ���µ�Sphu.entry����ٴ��½�һ��Entry�����ʱ��curEntry����null����ôִ��((CtEntry)parent).child = this;
+
+�������ͼ![SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/c3c36f101ef031102dd270287bf7635e715229.jpg "SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������")���Կ�����ԭ����CtEntry���Ƴ�Context���½���CtEntry�;�CtEntryͨ���ڲ���parent��child��������
+
+**2.4 NodeSelectorSlot**
+�������Ҫ���ڹ����������������Ҫ����һ�£��ں��������л�ȽϹؼ����������¡�
+
+
+
+```
+@Overridepublic void entry(Context context, ResourceWrapper resourceWrapper, Object obj,                  int count, boolean prioritized, Object... args)    throws Throwable {    //�����и����棬����context�����ֻ���node    DefaultNode node = map.get(context.getName());    //˫�ؼ�⣬�̰߳�ȫ    if (node == null) {        synchronized (this) {            node = map.get(context.getName());            if (node == null) {                //�������ɵ���DefaultNode�ڵ�                node = new DefaultNode(resourceWrapper, null);                //������Щ�߼��Ƿ���map���߼�����Ϊ����map�Ƚϴ������������룬���ܻ��һЩ                HashMap<String, DefaultNode> cacheMap = new HashMap<String,DefaultNode>(map.size());                cacheMap.putAll(map);                cacheMap.put(context.getName(), node);                map = cacheMap;                // �ؼ����⣬�����޸ĵ��������ĵط�                ((DefaultNode) context.getLastNode()).addChild(node);            }        }    }    //�滻context�е�curEntry�е�curNode    context.setCurNode(node);    fireEntry(context, resourceWrapper, node, count, prioritized, args);}
+```
+
+
+
+
+
+
+
+
+
+��ѯ�������Ƿ������node������߼�Ҳ�ܼ�
+
+*   ����ContextName��ѯ�����Ƿ������Node
+*   û�о��������DefaultNode�����뻺�棬Ȼ�����������
+*   Context��curEntry�е�curnode����Ϊ���node
+    �����м�������Ҫ����˵����
+
+1��context����ʾ�����ģ�һ���̶߳�Ӧһ��context�����а���һЩ��������
+
+*   name������
+*   entranceNode�����������
+*   curEntry����ǰentry
+*   origin����������Դ
+*   async���첽
+    2��Node�� ��ʾһ���ڵ㣬����ڵ�ᱣ��ij����Դ�ĸ���ʵʱͳ�����ݣ�ͨ������ij���ڵ㣬�Ϳ��Ի�ö�Ӧ��Դ��ʵʱ״̬�����������Ϣ�����������ͽ��������м��ֽڵ�����
+*   StatisticNode��ʵ����Node�ӿڣ���װ�˻���������ͳ�ƺͻ�ȡ����
+*   DefaultNode��Ĭ�Ͻڵ㣬NodeSelectorSlot�д����ľ�������ڵ㣻����ͬ����Դ�ڲ�ͬ�������и��Ե��������
+*   ClusterNode����Ⱥ�ڵ㣬����ͬ����Դ�ڲ�ͬ��������������������
+*   EntranceNode���ýڵ��ʾһ�õ�����������ڽڵ㣬ͨ�������Ի�ȡ�������������е��ӽڵ㣻ÿ�������Ķ�����һ����ڽڵ㣬����ͳ�Ƶ�ǰ�����ĵ������������
+*   OriginNode����һ��StatisticNode���͵Ľڵ㣬������ͬ����Դ������Դ���������
+    **2.5 StatisticSlot**
+    ������slot��·�У��Ƚ���Ҫ�ģ�������������ͳ���Լ�����������������slot��������������һ��StatisticSlot�������
+
+StatisticSlot�� Sentinel �ĺ��Ĺ��ܲ��֮һ������ͳ��ʵʱ�ĵ������ݡ�
+
+*   clusterNode����ԴΨһ��ʶ�� ClusterNode �� runtime ͳ��
+*   origin���������Բ�ͬ�����ߵ�ͳ����Ϣ
+*   defaultnode: ������������Ŀ���ƺ���Դ ID �� runtime ͳ��
+*   ��ڵ�ͳ��
+
+
+
+```
+public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,                  boolean prioritized, Object... args) throws Throwable {    try {        // �Ƚ��ɺ���������&������processorSlot������Ȼ����ݴ����������ͳ��        // Sentinel�������ľ�������ʹ�� for ѭ���������� ProcessorSlot ��ԭ��        fireEntry(context, resourceWrapper, node, count, prioritized, args);        //ִ�е������ʾͨ����飬��������        // Request passed, add thread count and pass count.        node.increaseThreadNum(); //��ǰ�ڵ�������߳�����1        node.addPassRequest(count);        //��Բ�ͬ���͵�node��¼�߳�����������ͨ��������ͳ�ơ�        if (context.getCurEntry().getOriginNode() != null) {            // Add count for origin node.            context.getCurEntry().getOriginNode().increaseThreadNum();            context.getCurEntry().getOriginNode().addPassRequest(count);        }        if (resourceWrapper.getEntryType() == EntryType.IN) {            // Add count for global inbound entry node for global statistics.            Constants.ENTRY_NODE.increaseThreadNum();            Constants.ENTRY_NODE.addPassRequest(count);        }        //�ɵ��� StatisticSlotCallbackRegistry#addEntryCallback ��̬����ע��ProcessorSlotEntryCallback        for (ProcessorSlotEntryCallback<DefaultNode> handler :             StatisticSlotCallbackRegistry.getEntryCallbacks()) {            handler.onPass(context, resourceWrapper, node, count, args);        }        //���ȼ��ȴ��쳣�������FlowRule�л����漰����    } catch (PriorityWaitException ex) {//�����߳�ͳ��        node.increaseThreadNum();        if (context.getCurEntry().getOriginNode() != null) {            // Add count for origin node.            context.getCurEntry().getOriginNode().increaseThreadNum();        }        if (resourceWrapper.getEntryType() == EntryType.IN) {            // Add count for global inbound entry node for global statistics.            Constants.ENTRY_NODE.increaseThreadNum();        }        // Handle pass event with registered entry callback handlers.        for (ProcessorSlotEntryCallback<DefaultNode> handler :             StatisticSlotCallbackRegistry.getEntryCallbacks()) {            handler.onPass(context, resourceWrapper, node, count, args);        }    } catch (BlockException e) {        // Blocked, set block exception to current entry.        context.getCurEntry().setBlockError(e); //���������쳣����ǰentry��        // Add block count.        node.increaseBlockQps(count); //���ӱ�����������        //���ݲ�ͬNode�����������������Ĵ���        if (context.getCurEntry().getOriginNode() != null) {            context.getCurEntry().getOriginNode().increaseBlockQps(count);        }        if (resourceWrapper.getEntryType() == EntryType.IN) {            // Add count for global inbound entry node for global statistics.            Constants.ENTRY_NODE.increaseBlockQps(count);        }        // Handle block event with registered entry callback handlers.        for (ProcessorSlotEntryCallback<DefaultNode> handler :             StatisticSlotCallbackRegistry.getEntryCallbacks()) {            handler.onBlocked(e, context, resourceWrapper, node, count, args);        }        throw e;    } catch (Throwable e) {        // Unexpected internal error, set error to current entry.        context.getCurEntry().setError(e);        throw e;    }}
+```
+
+
+
+
+
+
+
+
+
+����ֳ��������֣���һ������entry�������÷������Ȼᴥ������slot��entry��������SystemSlot��FlowSlot��DegradeSlot�ȵĹ����������ͨ�����ͻ��׳�BlockException�������node��ͳ�Ʊ�block����������֮����node��ͳ��ͨ�������������߳�������Ϣ���ڶ���������exit�����У����˳���Entry���ʱ����ͳ��rt��ʱ�䣬�������߳�����
+
+���ǿ��Կ��� node.addPassRequest() ��δ�������fireEntryִ��֮��ִ�еģ�����ζ�ţ���ǰ����ͨ����sentinel�����صȹ��򣬴�ʱ��Ҫ�����������¼������Ҳ����ִ�� node.addPassRequest()���д��룬���Ǹ���ȥ������
+
+**2.5.1 addPassRequest**
+@Overridepublic void addPassRequest(int count) {    // ���ø��ࣨStatisticNode��������ͳ��    super.addPassRequest(count);    // ����clusterNode ����ͳ�ƣ�����Ҳ�ǵ��ø���StatisticNode��    this.clusterNode.addPassRequest(count);}
+��������֪�������node��һ�� DefaultNode ʵ�����ڵ�һ��NodeSelectorSlot ��entry�����ж���Դ�����˷�װ����װ����һ��DefaultNode��
+
+*   DefaultNode��������ij��resource��ij��context�е�ʵʱָ�꣬ÿ��DefaultNode��ָ��һ��ClusterNode
+*   ClusterNode��������ij��resource�����е�context��ʵʱָ����ܺͣ�ͬ����resource�Ṳ��ͬһ��ClusterNode�����������ĸ�context��
+    �ֱ��������ʱ�䴰������������������
+
+�ڲ�ʵ�ʵ��õ���ArrayMetric����������������ͳ��
+
+
+
+```
+//��������ͳ�ƣ��ֳ��������ڣ�ÿ������500ms������ͳ��QPSprivate transient volatile Metric rollingCounterInSecond = new ArrayMetric(SampleCountProperty.SAMPLE_COUNT,        IntervalProperty.INTERVAL);//���շ���ͳ�ƣ�����60�����ڣ�ÿ������1000msprivate transient Metric rollingCounterInMinute = new ArrayMetric(60, 60 * 1000, false);public void addPassRequest(int count) {    rollingCounterInSecond.addPass(count);    rollingCounterInMinute.addPass(count);}
+```
+
+
+
+
+
+
+
+
+
+������õ��ǻ������ڵķ�ʽ����¼����Ĵ�����![SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/e4624bb214fd8020d1447098c8cde98a554e59.jpg "SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������")������Ĺ�ϵͼʵ�����DZȽ������ģ�ArrayMetricʵ������һ����װ�࣬�ڲ�ͨ��LeapArray��ʵ�־����ͳ���߼�����LeapArray��ά���˶��WindowWrap���������ڣ�����WindowWrap�в�����MetricBucket������ָ�����ݵ�ͳ�ơ�
+
+*   Metric: ָ���ռ��Ľӿڣ����廬�������гɹ��������쳣����������������TPS����Ӧʱ�������
+*   ArrayMetric �������ں���ʵ����
+*   LeapArray
+*   WindowWrap ÿһ���������ڵİ�װ�࣬�ڲ������ݽṹ����MetricBucket
+*   MetricBucket�� ��ʾָ��Ͱ�����������������쳣�������ɹ�������Ӧʱ���
+*   MetricEvent ָ�����ͣ�ͨ���������������쳣�����ɹ�����
+    **2.5.2 ArrayMetric.addPass**
+    �������Ŵ������¿������뵽ArrayMetric.addPass������
+*   ��LeapArray�и��ݵ�ǰʱ���õ���Ӧ�Ĵ���
+*   ����MetricBucket�е�addPass���������ӵ�ǰ�����е�ͳ�ƴ���
+
+�Ӵ��������ǿ��Կ���������ָ����� addPass ��ͨ��һ���� ArrayMetric ���࣬���������ڽ��� ArrayMetric �п�һ�¡�����Ĵ���������ʾ��
+
+
+
+```
+private final LeapArray<MetricBucket> data;// SAMPLE_COUNT=2  INTERVAL=1000public ArrayMetric(int sampleCount, int intervalInMs) {  //������������ʾ���������ڵĴ�С��2����ÿһ���������ڵ�ʱ�䵥λ��500ms    this.data = new OccupiableBucketLeapArray(sampleCount, intervalInMs);}public void addPass(int count) {    WindowWrap<MetricBucket> wrap = data.currentWindow();    wrap.value().addPass(count);}
+```
+
+
+
+
+
+
+
+
+
+�������ڳ������뻬����������ô������� window�ˣ�window�����Ǵ��������ͨ�� data ����ȡ��ǰ���ڡ�������Ĵ��ڴ�СΪ sampleCount=2.���ǿ��Կ�����������ͨ�� MetricBucket ���������ָ�꣬����ά����һ��ͳ��������LongAdder[] counters �����棬�� WindowWrap�����ǿ��Կ���ÿһ�� WindowWrap����������������ɣ�
+
+
+
+```
+public class WindowWrap<T> {����// ʱ�䴰�ڵij���    private final long windowLengthInMs;����// ʱ�䴰�ڵĿ�ʼʱ�䣬��λ�Ǻ���    private long windowStart;���� //ʱ�䴰�ڵ����ݣ��� WindowWrap �����÷��ͱ�ʾ���ֵ�ģ���ʵ���Ͼ��� MetricBucket ��    private T value;    //......ʡ�Բ��ִ���}
+```
+
+
+
+
+
+
+
+
+
+�ٿ� LeapArray ����ࣺ
+
+
+
+```
+public abstract class LeapArray<T> {    // ʱ�䴰�ڵij���    protected int windowLength;    // �������ڵĸ���    protected int sampleCount;    // �Ժ���Ϊ��λ��ʱ����    protected int intervalInMs;    // ������ʱ�䴰������    protected AtomicReferenceArray<WindowWrap<T>> array;    /**     * LeapArray����     * @param windowLength ʱ�䴰�ڵij��ȣ���λ������     * @param intervalInSec ͳ�Ƶļ������λ����     */    public LeapArray(int windowLength, int intervalInSec) {        this.windowLength = windowLength;        // ʱ�䴰�ڵIJ���������Ĭ��Ϊ2����������        this.sampleCount = intervalInSec * 1000 / windowLength;        this.intervalInMs = intervalInSec * 1000;//������Ϊ��λ��ʱ�䴰���У����ʼ���������ȵ����飺`AtomicReferenceArray<WindowWrap<T>>array`����������ʾ�������ڵĴ�С�����У�ÿ�����ڻ�ռ��500ms��ʱ�䡣        this.array = new AtomicReferenceArray<WindowWrap<T>>(sampleCount);    }}
+```
+
+
+
+
+
+
+
+
+
+���Ժ������Ŀ������� LeapArray �д�����һ�� AtomicReferenceArray ���飬������ʱ�䴰���е�ͳ��ֵ���в�����ͨ��������ͳ��ֵ�ټ����ƽ��ֵ������������Ҫ�����յ�ʵʱָ���ֵ�ˡ����Կ�����������Ĵ�����ͨ��ע�ͣ�������Ĭ�ϲ�����ʱ�䴰�ڵĸ�����2�������ֵ����ô�õ����أ����ǻ���һ�� LeapArray ���󴴽�����ͨ���� StatisticNode �У�new��һ�� ArrayMetric��Ȼ�󽫲���һ·���ϴ��ݺ󴴽��ģ�
+
+
+
+```
+private transient volatile Metric rollingCounterInSecond = new ArrayMetric(SampleCountProperty.SAMPLE_COUNT,IntervalProperty.INTERVAL);
+```
+
+
+
+
+
+
+
+
+
+**2.5.3 currentWindow**
+���Ǹ�����ȡ��ǰ���ڵķ��� data.currentWindow() �У�
+
+
+
+```
+@Overridepublic WindowWrap<Window> currentWindow(long time) {    .....//ʡ�Բ��ִ���    //���㵱ǰʱ���ڻ��������е����������㷽ʽ�Ƚϼ򵥣���ǰʱ����Ե���ʱ�䴰�ڵ�ʱ�䳤�ȣ��ٴ�����ʱ�䴰�ڳ��Ƚ���ȡģ���� int idx = calculateTimeIdx(timeMillis);    //���㵱ǰʱ����ʱ�䴰���еĿ�ʼʱ��    long windowStart = calculateWindowStart(timeMillis);    // timeÿ����һ��windowLength�ij��ȣ�timeId�ͻ�����1��ʱ�䴰�ھͻ���ǰ����һ��        while (true) {        // �Ӳ��������и���������ȡ�����ʱ�䴰��        WindowWrap<Window> old = array.get(idx);        // array���鳤�Ȳ��˹��󣬷���old�ܶ�����¶����в��ˣ��ͻᴴ���ܶ��WindowWrap����        //���Ϊ�գ�˵���˴���δ��ʼ��        if (old == null) {            // ���û�л�ȡ�����򴴽�һ���µ�            WindowWrap<Window> window = new WindowWrap<Window>(windowLength, currentWindowStart, new Window());            // ͨ��CAS���´������õ�������ȥ            if (array.compareAndSet(idx, null, window)) {                // ��������óɹ����򽫸ô��ڷ���                return window;            } else {                // ����ǰ�߳��ó�ʱ��Ƭ���ȴ�                Thread.yield();            }        // �����ǰ���ڵĿ�ʼʱ����old�Ŀ�ʼʱ����ȣ���ֱ�ӷ���old����        } else if (currentWindowStart == old.windowStart()) {            return old;        // �����ǰʱ�䴰�ڵĿ�ʼʱ���Ѿ�������old���ڵĿ�ʼʱ�䣬�����old����        // ����time����Ϊ�µ�ʱ�䴰�ڵĿ�ʼʱ�䣬��ʱ������ǰ����        } else if (currentWindowStart > old.windowStart()) {            if (addLock.tryLock()) {                try {                    // if (old is deprecated) then [LOCK] resetTo currentTime.                    return resetWindowTo(old, currentWindowStart);                } finally {                    addLock.unlock();                }            } else {                Thread.yield();            }        // ������������ܴ���        } else if (currentWindowStart < old.windowStart()) {            // Cannot go through here.            return new WindowWrap<Window>(windowLength, currentWindowStart, new Window());        }    }}
+```
+
+
+
+
+
+
+
+
+
+����ܳ��������𲽽���ֽ⣬����ʵ�ʿ��԰����ֳ����¼�����
+
+1.  ���ݵ�ǰʱ�䣬�����ʱ���timeId��������timeId�����ǰ�����ڲ������������е�����idx��
+2.  ���ݵ�ǰʱ�������ǰ���ڵ�Ӧ�ö�Ӧ�Ŀ�ʼʱ��time���Ժ���Ϊ��λ��
+3.  ��������idx���ڲ�������������ȡ��һ��ʱ�䴰�ڡ�
+4.  ѭ���ж�ֱ����ȡ��һ����ǰʱ�䴰�� old ��
+
+*   ���oldΪ�գ��򴴽�һ��ʱ�䴰�ڣ����������뵽array�ĵ�idx��λ�ã�array�����Ѿ��������ˣ���һ�� AtomicReferenceArray��
+*   �����ǰ���ڵĿ�ʼʱ��time��old�Ŀ�ʼʱ����ȣ���ô˵��old���ǵ�ǰʱ�䴰�ڣ�ֱ�ӷ���old��
+*   �����ǰ���ڵĿ�ʼʱ��time����old�Ŀ�ʼʱ�䣬��˵��old�����Ѿ���ʱ�ˣ���old�Ŀ�ʼʱ�����Ϊ����ֵ��time��������һ�ε�ѭ�����жϵ�ǰ���ڵĿ�ʼʱ��time��old�Ŀ�ʼʱ����ȵ�ʱ�򷵻ء�
+*   �����ǰ���ڵĿ�ʼʱ��timeС��old�Ŀ�ʼʱ�䣬ʵ������������Dz����ܴ��ڵģ���Ϊtime�ǵ�ǰʱ�䣬old�ǹ�ȥ��һ��ʱ�䡣
+    ����timeId�ǻ�����ʱ������������ӣ���ǰʱ��ÿ����һ��windowLength�ij��ȣ�timeId�ͼ�1������idx����������ֻ����0��1֮��任����Ϊarray����ij�����2��ֻ����������ʱ�䴰�ڡ�����ΪʲôĬ��ֻ�������������ڣ����˾�����Ϊsentinel�DZȽ������Ŀ�ܡ�ʱ�䴰���б����źܶ�ͳ�����ݣ����ʱ�䴰�ڹ���Ļ���һ�����ռ�ù����ڴ棬��һ����ʱ�䴰�ڹ������ζ��ʱ�䴰�ڵij��Ȼ��С�����ʱ�䴰�ڳ��ȱ�С���ͻᵼ��ʱ�䴰�ڹ���Ƶ���Ļ�����������һ�����еĵ�һ�����ڶ�����
+
+
+
+```
+private int calculateTimeIdx(/*@Valid*/ long timeMillis) {    // timeÿ����һ��windowLength�ij��ȣ�timeId�ͻ�����1��ʱ�䴰�ھͻ���ǰ����һ��    long timeId = timeMillis / windowLengthInMs;     // idx���ֳ�[0,arrayLength-1]�е�ijһ��������Ϊarray�����е�����    return (int)(timeId % array.length());}protected long calculateWindowStart(/*@Valid*/ long timeMillis) {    return timeMillis - timeMillis % windowLengthInMs;}
+```
+
+
+
+
+
+
+
+
+
+���ݵ�ǰʱ����� windowLength �õ�һ�� timeId(���500ms���������ֵ����һ�µ�),����timeId��ȡ�����ڵij��Ƚ���һ��ȡģ����ô��һ�������� 0��1����λ�õ�����һ����Ȼ����ݵ�ǰʱ�������ǰ���ڵ�Ӧ�ö�Ӧ�Ŀ�ʼʱ��time�����ڸոտ�ʼ��ʱ�� array �ǿյģ���ô����ȡ����oldӦ����null����ô���ᴴ��һ���µ�ʵ����������ͼ��һ�³�ʼ���� LeapArray��
+
+��Ӧ���� currentWindow ������ 4.1 ����(����idx=0)��![SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/95b0b64926eae4d2753986af9c978da9980da0.jpg "SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������")����ȡ������null,��ô��ʼ��ʱ��arrays������ֻ��һ������(�����ǵ�һ��(idx=0)��Ҳ�����ǵڶ���(idx=1))��ÿ��ʱ�䴰�ڵij�����500ms�������ζ��ֻҪ��ǰʱ����ʱ�䴰�ڵIJ�ֵ��500ms֮�ڣ�ʱ�䴰�ھͲ�����ǰ���������磬���統ǰʱ���ߵ�300����500ʱ����ǰʱ�䴰����Ȼ����ͬ���Ǹ���
+
+��Ӧ���� currentWindow ������ 4.2 ���裺![SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/85c047336a2c2186bcc7737a4c28da852cb603.jpg "SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������")ʱ�������ǰ�ߣ�������500msʱ��ʱ�䴰�ھͻ���ǰ��������һ������ʱ�ͻ���µ�ǰ���ڵĿ�ʼʱ��,ʱ�������ǰ�ߣ�ֻҪ������1000ms����ǰ���ڲ��ᷢ���仯�����д���ʵ���� resetWindowTo ������
+
+
+
+```
+protected WindowWrap<MetricBucket> resetWindowTo(WindowWrap<MetricBucket> w, long time) {    // Update the start time and reset value.    // ����windowStart    w.resetTo(time);    MetricBucket borrowBucket = borrowArray.getWindowValue(time);    if (borrowBucket != null) {        w.value().reset();        w.value().addPass((int)borrowBucket.pass());    } else {        w.value().reset();    }    return w;}
+```
+
+
+
+
+
+
+
+
+
+��Ӧ���� currentWindow ������ 4.3 ����![SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/03d6e3886f95f5768e05969d7eb8307c26f381.jpg "SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������")��ʱ�������ǰ�ߣ���ǰʱ�䳬��1000msʱ���ͻ��ٴν�����һ��ʱ�䴰�ڣ���ʱarrays�����еĴ��ڽ�����һ��ʧЧ��������һ���µĴ��ڽ����滻��![SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/241926a53c2a5b06938844199046d31e593d62.jpg "SpringCloud Alibabaϵ�С���15Sentinelԭ������-��Դ������������")�Դ���������ʱ������ţ�ʱ�䴰��Ҳ�ڷ����仯���ڵ�ǰʱ����н�������󣬻ᱻͳ�Ƶ���ǰʱ���Ӧ��ʱ�䴰���У��ص�addpass �����У�
+
+
+
+```
+public void addPass(int count) {    WindowWrap<MetricBucket> wrap = data.currentWindow();    wrap.value().addPass(count);}
+```
+
+
+
+
+
+
+
+
+
+��ȡ�������Ժ����뵽 wrap.value().addPass(count); QPS�����ӡ�������� wrap.value() �õ�����֮ǰ�ᵽ�� MetricBucket ���� Sentinel ��QPS������ݵ�ͳ�ƽ����ά���������� LongAdder[] �У����������ָ����������ʵ�����úõĹ������ƥ�䣬�鿴�Ƿ�������Ҳ���� StatisticSlot��entry �����е� fireEntry(context, resourceWrapper, node, count, prioritized, args); ��Ҫ�Ƚ��뵽 FlowSlot��entry���������������ˣ�
+
+
+
+```
+public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,                  boolean prioritized, Object... args) throws Throwable {    checkFlow(resourceWrapper, context, node, count, prioritized);    fireEntry(context, resourceWrapper, node, count, prioritized, args);}
+```
+
+
+
+
+
+
+
+
+
+���Կ��������и�����Ҫ�ķ��� checkFlow ����ȥ������
+
+
+
+```
+public void checkFlow(Function<String, Collection<FlowRule>> ruleProvider, ResourceWrapper resource,                      Context context, DefaultNode node, int count, boolean prioritized) throws BlockException {    if (ruleProvider == null || resource == null) {        return;    }    Collection<FlowRule> rules = ruleProvider.apply(resource.getName());    if (rules != null) {        for (FlowRule rule : rules) {            if (!canPassCheck(rule, context, node, count, prioritized)) {                throw new FlowException(rule.getLimitApp(), rule);            }        }    }}
+```
+
+
+
+
+
+
+
+
+
+������һ�ж�Ӧ�������ˣ������õ����������õ� FlowRule ѭ��ƥ����Դ�����������ˡ������Sentinel ������������ԭ��
+
+**2.6 FlowRuleSlot**
+��� slot ��Ҫ����Ԥ�����Դ��ͳ����Ϣ�����չ̶��Ĵ���������Ч�����һ����Դ��Ӧ�������߶������ع������������´������μ��飬ֱ��ȫ��ͨ��������һ��������ЧΪֹ:
+
+*   ָ��Ӧ����Ч�Ĺ��򣬼���Ե��÷������ģ�
+*   ���÷�Ϊ other �Ĺ���
+*   ���÷�Ϊ default �Ĺ���
+
+
+
+```
+@Overridepublic void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,                  boolean prioritized, Object... args) throws Throwable {    checkFlow(resourceWrapper, context, node, count, prioritized);    fireEntry(context, resourceWrapper, node, count, prioritized, args);}
+```
+
+
+
+
+
+
+
+
+
+**2.6.1 checkFlow**
+���뵽FlowRuleChecker.checkFlow�����С�
+
+*   ������Դ���ƣ��ҵ����������б�
+*   �����������Ϊ�գ���������򣬵���canPassCheck��������У�顣
+
+
+
+```
+public void checkFlow(Function<String, Collection<FlowRule>> ruleProvider,ResourceWrapper resource,                      Context context, DefaultNode node, int count, boolean prioritized) throws BlockException {    if (ruleProvider == null || resource == null) {        return;    }    Collection<FlowRule> rules = ruleProvider.apply(resource.getName());    if (rules != null) {        for (FlowRule rule : rules) {            if (!canPassCheck(rule, context, node, count, prioritized)) {                throw new FlowException(rule.getLimitApp(), rule);            }        }    }}
+```
+
+
+
+
+
+
+
+
+
+**2.6.2 canPassCheck**
+�ж��Ƿ��Ǽ�Ⱥ����ģʽ������ǣ�����passClusterCheck�����򣬵���passLocalCheck������
+
+
+
+```
+public boolean canPassCheck(/*@NonNull*/ FlowRule rule, Context context,DefaultNode node, int acquireCount,                            boolean prioritized) {    String limitApp = rule.getLimitApp();    if (limitApp == null) {        return true;    }    if (rule.isClusterMode()) {        return passClusterCheck(rule, context, node, acquireCount, prioritized);    }    return passLocalCheck(rule, context, node, acquireCount, prioritized);}
+```
+
+
+
+
+
+
+
+
+
+**2.6.3 passLocalCheck**
+
+*   selectNodeByRequesterAndStrategy����������Ͳ��������Node
+*   rule.getRater(), ���ݲ�ͬ������������Ϊ��������canPass����У�顣
+
+
+
+```
+private static boolean passLocalCheck(FlowRule rule, Context context,DefaultNode node, int acquireCount,                                      boolean prioritized) {    Node selectedNode = selectNodeByRequesterAndStrategy(rule, context, node);    if (selectedNode == null) {        return true;    }    return rule.getRater().canPass(selectedNode, acquireCount, prioritized);}
+```
+
+
+
+
+
+
+
+
+
+**2.6.4 DefaultController.canPass**
+ͨ��Ĭ�ϵ�������Ϊ��ֱ�Ӿܾ��������������жϡ�
+
+
+
+```
+@Overridepublic boolean canPass(Node node, int acquireCount, boolean prioritized) {    //�ȸ���node��ȡ��Դ��ǰ��ʹ����������������qps���߲����������������ص�ֵ    int curCount = avgUsedTokens(node);    //��ǰ��ʹ�õ����������ϱ�������������Ƿ������ֵ    if (curCount + acquireCount > count) {//���Ϊtrue��˵��Ӧ�ñ�����        // �����������һ�������ȼ����󣬲�����������Ϊqps���򲻻�����ʧ�ܣ�����ȥռ��δ����ʱ�䴰�ڣ��ȵ���һ��ʱ�䴰��ͨ������        if (prioritized && grade == RuleConstant.FLOW_GRADE_QPS) { //            long currentTime;            long waitInMs;            currentTime = TimeUtil.currentTimeMillis();            waitInMs = node.tryOccupyNext(currentTime, acquireCount, count);            if (waitInMs < OccupyTimeoutProperty.getOccupyTimeout()) {                node.addWaitingRequest(currentTime + waitInMs, acquireCount);                node.addOccupiedPass(acquireCount);                sleep(waitInMs);                // PriorityWaitException indicates that the request will pass after waiting for {@link @waitInMs}.                throw new PriorityWaitException(waitInMs);            }        }        return false;    }    return true;}
+```
+
+
+
+
+
+
+
+
+
+һ�����ܾ������׳� FlowException �쳣��
+
+**2.7 PriorityWait**
+��DefaultController.canPass�У��������´���ȥ������Ĵ���
+
+
+
+```
+node.addWaitingRequest(currentTime + waitInMs, acquireCount);node.addOccupiedPass(acquireCount);
+```
+
+
+
+
+
+
+
+
+
+> addWaitingRequest -> ArrayMetric.addWaiting->OccupiableBucketLeapArray.addWaiting
+
+borrowArray������һ��FutureBucketLeapArray�������ﶨ�����δ����ʱ�䴰�ڣ�Ȼ����δ��ʱ��Ĵ���ȥ���Ӽ���
+
+
+
+```
+@Overridepublic void addWaiting(long time, int acquireCount) {    WindowWrap<MetricBucket> window = borrowArray.currentWindow(time);    window.value().add(MetricEvent.PASS, acquireCount);}
+```
+
+
+
+
+
+
+
+
+
+���գ���StatisticSlot.entry�У������쳣
+
+����������ȼ��Ƚϸߵ����񣬲��ҵ�ǰ�������Ѿ��ﵽ��ֵ���׳�����쳣��ʵ������ȥռ��δ����һ��ʱ�䴰��ȥ���м������׳�����쳣֮�󣬻���뵽StatisticSlot�н��в���Ȼ��ֱ��ͨ��
+
+
+
+```
+public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,                  boolean prioritized, Object... args) throws Throwable {    try{        //...    } catch (PriorityWaitException ex) {        node.increaseThreadNum();        if (context.getCurEntry().getOriginNode() != null) {            // Add count for origin node.            context.getCurEntry().getOriginNode().increaseThreadNum();        }        if (resourceWrapper.getEntryType() == EntryType.IN) {            // Add count for global inbound entry node for global statistics.            Constants.ENTRY_NODE.increaseThreadNum();        }        // Handle pass event with registered entry callback handlers.        for (ProcessorSlotEntryCallback<DefaultNode> handler :             StatisticSlotCallbackRegistry.getEntryCallbacks()) {            handler.onPass(context, resourceWrapper, node, count, args);        }    }}
+```
+
+
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudConfig\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudConfig\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..4ae8cc8
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudConfig\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,1049 @@
+Ҫ���˽�spring cloud config�����Ǿͱ����˽�springboot��environment�����ļ��ع��̡�
+
+
+
+```
+SpringApplication.run(AppApiApplication.class, args);
+
+public static ConfigurableApplicationContext run(Class<?>[] primarySources,
+            String[] args) {
+    return new SpringApplication(primarySources).run(args);
+}
+
+```
+
+
+
+��`SpringApplication�Ĺ��췽����`������ôһ�δ���
+
+
+
+```
+setInitializers((Collection) getSpringFactoriesInstances(
+                ApplicationContextInitializer.class));
+        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
+
+```
+
+
+
+
+
+```
+Set<String> names = new LinkedHashSet<>(
+                SpringFactoriesLoader.loadFactoryNames(type, classLoader));
+
+```
+
+
+
+��δ����о��Ǵ�META-INFĿ¼�����ȡ`ApplicationListener��ApplicationContextInitializer`���͵������ࡣ
+��spring-boot.jar����spring.factories��������`ConfigFileApplicationListener`����࣬���û���Ҳ����application�ļ��ļ��ض���ͨ�������
+
+
+
+```
+# Application Listeners
+org.springframework.context.ApplicationListener=\
+org.springframework.boot.context.config.ConfigFileApplicationListener,\
+
+# Run Listeners
+org.springframework.boot.SpringApplicationRunListener=\
+org.springframework.boot.context.event.EventPublishingRunListener
+
+```
+
+
+
+��������springboot�����׶�
+
+
+
+```
+    public ConfigurableApplicationContext run(String... args) {
+        StopWatch stopWatch = new StopWatch();
+        stopWatch.start();
+        ConfigurableApplicationContext context = null;
+        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
+        configureHeadlessProperty();
+        SpringApplicationRunListeners listeners = getRunListeners(args);
+        listeners.starting();
+        try {
+            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
+                    args);
+            ConfigurableEnvironment environment = prepareEnvironment(listeners,
+                    applicationArguments);
+            configureIgnoreBeanInfo(environment);
+            Banner printedBanner = printBanner(environment);
+            context = createApplicationContext();
+            exceptionReporters = getSpringFactoriesInstances(
+                    SpringBootExceptionReporter.class,
+                    new Class[] { ConfigurableApplicationContext.class }, context);
+            prepareContext(context, environment, listeners, applicationArguments,
+                    printedBanner);
+            refreshContext(context);
+            afterRefresh(context, applicationArguments);
+            stopWatch.stop();
+            if (this.logStartupInfo) {
+                new StartupInfoLogger(this.mainApplicationClass)
+                        .logStarted(getApplicationLog(), stopWatch);
+            }
+            listeners.started(context);
+            callRunners(context, applicationArguments);
+        }
+        catch (Throwable ex) {
+            handleRunFailure(context, ex, exceptionReporters, listeners);
+            throw new IllegalStateException(ex);
+        }
+
+        try {
+            listeners.running(context);
+        }
+        catch (Throwable ex) {
+            handleRunFailure(context, ex, exceptionReporters, null);
+            throw new IllegalStateException(ex);
+        }
+        return context;
+    }
+
+```
+
+
+
+
+
+```
+ConfigurableEnvironment environment = prepareEnvironment(listeners,
+                    applicationArguments);
+prepareContext(context, environment, listeners, applicationArguments,
+                    printedBanner);
+
+```
+
+
+
+���������δ������װ�ػ����Ĵ���
+��`prepareEnvironment`�����г�ʼ����`environment`��
+
+
+
+```
+    private ConfigurableEnvironment getOrCreateEnvironment() {
+        if (this.environment != null) {
+            return this.environment;
+        }
+        switch (this.webApplicationType) {
+        case SERVLET:
+            return new StandardServletEnvironment();
+        case REACTIVE:
+            return new StandardReactiveWebEnvironment();
+        default:
+            return new StandardEnvironment();
+        }
+    }
+
+```
+
+
+
+��Ϊ����servlet��������`Environment`Ϊ`StandardServletEnvironment`�������ڸ���ĵĹ�������ִ����`customizePropertySources`����
+
+
+
+```
+    public AbstractEnvironment() {
+        customizePropertySources(this.propertySources);
+        if (logger.isDebugEnabled()) {
+            logger.debug("Initialized " + getClass().getSimpleName() + " with PropertySources " + this.propertySources);
+        }
+    }
+
+```
+
+
+
+
+
+```
+    protected void customizePropertySources(MutablePropertySources propertySources) {
+        propertySources.addLast(new StubPropertySource(SERVLET_CONFIG_PROPERTY_SOURCE_NAME));
+        propertySources.addLast(new StubPropertySource(SERVLET_CONTEXT_PROPERTY_SOURCE_NAME));
+        if (JndiLocatorDelegate.isDefaultJndiEnvironmentAvailable()) {
+            propertySources.addLast(new JndiPropertySource(JNDI_PROPERTY_SOURCE_NAME));
+        }
+        super.customizePropertySources(propertySources);
+    }
+
+```
+
+
+
+
+
+```
+    @Override
+    protected void customizePropertySources(MutablePropertySources propertySources) {
+        propertySources.addLast(new MapPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
+        propertySources.addLast(new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
+    }
+
+```
+
+
+
+������,���ǵõ���`StandardServletEnvironment`���Ҽ��ص�����˳����
+
+1.  servletConfigInitParams
+2.  servletContextInitParams
+3.  jndiProperties
+4.  systemProperties
+5.  systemEnvironment
+
+
+
+```
+    protected void configureEnvironment(ConfigurableEnvironment environment,
+            String[] args) {
+        configurePropertySources(environment, args);
+        configureProfiles(environment, args);
+    }
+
+    protected void configurePropertySources(ConfigurableEnvironment environment,
+            String[] args) {
+        MutablePropertySources sources = environment.getPropertySources();
+        if (this.defaultProperties != null && !this.defaultProperties.isEmpty()) {
+            sources.addLast(
+                    new MapPropertySource("defaultProperties", this.defaultProperties));
+        }
+        if (this.addCommandLineProperties && args.length > 0) {
+            String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
+            if (sources.contains(name)) {
+                PropertySource<?> source = sources.get(name);
+                CompositePropertySource composite = new CompositePropertySource(name);
+                composite.addPropertySource(new SimpleCommandLinePropertySource(
+                        "springApplicationCommandLineArgs", args));
+                composite.addPropertySource(source);
+                sources.replace(name, composite);
+            }
+            else {
+                sources.addFirst(new SimpleCommandLinePropertySource(args));
+            }
+        }
+    }
+
+```
+
+
+
+���������ǿ��Կ����ּ�����`defaultProperties`������������Լ�`SimpleCommandLinePropertySource`�����в�������ǰ�档��ˣ����ڵ�˳����
+
+1.  SimpleCommandLinePropertySourcem����������
+2.  servletConfigInitParams
+3.  servletContextInitParams
+4.  jndiProperties
+5.  systemProperties
+6.  systemEnvironment
+7.  defaultProperties
+
+
+
+```
+    public void environmentPrepared(ConfigurableEnvironment environment) {
+        for (SpringApplicationRunListener listener : this.listeners) {
+            listener.environmentPrepared(environment);
+        }
+    }
+
+    @Override
+    public void environmentPrepared(ConfigurableEnvironment environment) {
+        this.initialMulticaster.multicastEvent(new ApplicationEnvironmentPreparedEvent(
+                this.application, this.args, environment));
+    }
+
+```
+
+
+
+������`SpringApplicationRunListener`Ϊ`EventPublishingRunListener`,������ǰ���`getRunListeners`
+
+
+
+```
+    private SpringApplicationRunListeners getRunListeners(String[] args) {
+        Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
+        return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(
+                SpringApplicationRunListener.class, types, this, args));
+    }
+
+```
+
+
+
+��ͨ�����췽����ʼ����ʱ������this����������`initialMulticaster`�е�listenerΪapplication�е�listener
+
+
+
+```
+    public EventPublishingRunListener(SpringApplication application, String[] args) {
+        this.application = application;
+        this.args = args;
+        this.initialMulticaster = new SimpleApplicationEventMulticaster();
+        for (ApplicationListener<?> listener : application.getListeners()) {
+            this.initialMulticaster.addApplicationListener(listener);
+        }
+    }
+
+```
+
+
+
+��������ᷢ�͸��¼�֪ͨ��������`ConfigFileApplicationListener`
+
+
+
+```
+    @Override
+    public void onApplicationEvent(ApplicationEvent event) {
+        if (event instanceof ApplicationEnvironmentPreparedEvent) {
+            onApplicationEnvironmentPreparedEvent(
+                    (ApplicationEnvironmentPreparedEvent) event);
+        }
+        if (event instanceof ApplicationPreparedEvent) {
+            onApplicationPreparedEvent(event);
+        }
+    }
+
+```
+
+
+
+
+
+```
+    private void onApplicationEnvironmentPreparedEvent(
+            ApplicationEnvironmentPreparedEvent event) {
+        List<EnvironmentPostProcessor> postProcessors = loadPostProcessors();
+        postProcessors.add(this);
+        AnnotationAwareOrderComparator.sort(postProcessors);
+        for (EnvironmentPostProcessor postProcessor : postProcessors) {
+            postProcessor.postProcessEnvironment(event.getEnvironment(),
+                    event.getSpringApplication());
+        }
+    }
+
+    List<EnvironmentPostProcessor> loadPostProcessors() {
+        return SpringFactoriesLoader.loadFactories(EnvironmentPostProcessor.class,
+                getClass().getClassLoader());
+    }
+
+```
+
+
+
+���������и���չ�㣬ͨ����ȡ`spring.factories`�ļ������õ�`EnvironmentPostProcessor`�����`postProcessEnvironment`�������Լ�����Ҳ���뵽��`postProcessors`�����У����������ֻ��ߵ�`postProcessors`����
+
+
+
+```
+    @Override
+    public void postProcessEnvironment(ConfigurableEnvironment environment,
+            SpringApplication application) {
+        addPropertySources(environment, application.getResourceLoader());
+    }
+
+```
+
+
+
+
+
+```
+    protected void addPropertySources(ConfigurableEnvironment environment,
+            ResourceLoader resourceLoader) {
+        RandomValuePropertySource.addToEnvironment(environment);
+        new Loader(environment, resourceLoader).load();
+    }
+
+    public static void addToEnvironment(ConfigurableEnvironment environment) {
+        environment.getPropertySources().addAfter(
+                StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME,
+                new RandomValuePropertySource(RANDOM_PROPERTY_SOURCE_NAME));
+        logger.trace("RandomValuePropertySource add to Environment");
+    }
+
+        public void load() {
+            this.profiles = new LinkedList<>();
+            this.processedProfiles = new LinkedList<>();
+            this.activatedProfiles = false;
+            this.loaded = new LinkedHashMap<>();
+            initializeProfiles();
+            while (!this.profiles.isEmpty()) {
+                Profile profile = this.profiles.poll();
+                if (profile != null && !profile.isDefaultProfile()) {
+                    addProfileToEnvironment(profile.getName());
+                }
+                load(profile, this::getPositiveProfileFilter,
+                        addToLoaded(MutablePropertySources::addLast, false));
+                this.processedProfiles.add(profile);
+            }
+            resetEnvironmentProfiles(this.processedProfiles);
+            load(null, this::getNegativeProfileFilter,
+                    addToLoaded(MutablePropertySources::addFirst, true));
+            addLoadedPropertySources();
+        }
+
+```
+
+
+
+������ֽ�random���ü��뵽systemEnvironment֮���������ǵ����ü���˳�����
+defaultProperties
+
+1.  SimpleCommandLinePropertySourcem����������
+2.  servletConfigInitParams
+3.  servletContextInitParams
+4.  jndiProperties
+5.  systemProperties
+6.  systemEnvironment
+7.  RandomValuePropertySource
+8.  defaultProperties
+
+·��
+
+> classpath:/,classpath:/config/,file:./,file:./config/
+> spring.config.location=
+> spring.config.additional-location=
+
+�ļ���Ĭ��Ϊapplication
+
+> ���������spring.config.name=
+> �ļ�����Ϊspring.config.name���õ�����
+
+����ͨ��`load`����������·�����ļ������ļ����뵽`environment��`�����������`spring.profiles.active`�����Ҽ���prefix + "-" + profile + fileExtension�ļ���Ҳ����`application-<spring.profiles.active>.properties`��`y`�ļ�
+
+
+
+```
+        private void load(Profile profile, DocumentFilterFactory filterFactory,
+                DocumentConsumer consumer) {
+            getSearchLocations().forEach((location) -> {
+                boolean isFolder = location.endsWith("/");
+                Set<String> names = isFolder ? getSearchNames() : NO_SEARCH_NAMES;
+                names.forEach(
+                        (name) -> load(location, name, profile, filterFactory, consumer));
+            });
+        }
+
+        private void load(String location, String name, Profile profile,
+                DocumentFilterFactory filterFactory, DocumentConsumer consumer) {
+            if (!StringUtils.hasText(name)) {
+                for (PropertySourceLoader loader : this.propertySourceLoaders) {
+                    if (canLoadFileExtension(loader, location)) {
+                        load(loader, location, profile,
+                                filterFactory.getDocumentFilter(profile), consumer);
+                        return;
+                    }
+                }
+            }
+            Set<String> processed = new HashSet<>();
+            for (PropertySourceLoader loader : this.propertySourceLoaders) {
+                for (String fileExtension : loader.getFileExtensions()) {
+                    if (processed.add(fileExtension)) {
+                        loadForFileExtension(loader, location + name, "." + fileExtension,
+                                profile, filterFactory, consumer);
+                    }
+                }
+            }
+        }
+
+```
+
+
+
+������ͨ��`this.propertySourceLoaders`�����ж��Ƿ���ϸ�SourceLoader�ĺ�׺��������ϣ��ͽ���Դ���ؽ���,��`propertySourceLoaders`������`Loader`���췽��
+
+
+
+```
+        Loader(ConfigurableEnvironment environment, ResourceLoader resourceLoader) {
+            this.environment = environment;
+            this.resourceLoader = (resourceLoader != null) ? resourceLoader
+                    : new DefaultResourceLoader();
+            this.propertySourceLoaders = SpringFactoriesLoader.loadFactories(
+                    PropertySourceLoader.class, getClass().getClassLoader());
+        }
+
+```
+
+
+
+
+
+```
+# PropertySource Loaders
+org.springframework.boot.env.PropertySourceLoader=\
+org.springframework.boot.env.PropertiesPropertySourceLoader,\
+org.springframework.boot.env.YamlPropertySourceLoader
+
+```
+
+
+
+��˿��Լ���`yml`�ļ���`properties`�ļ�
+
+
+
+```
+        private void addLoadedPropertySources() {
+            MutablePropertySources destination = this.environment.getPropertySources();
+            List<MutablePropertySources> loaded = new ArrayList<>(this.loaded.values());
+            Collections.reverse(loaded);
+            String lastAdded = null;
+            Set<String> added = new HashSet<>();
+            for (MutablePropertySources sources : loaded) {
+                for (PropertySource<?> source : sources) {
+                    if (added.add(source.getName())) {
+                        addLoadedPropertySource(destination, lastAdded, source);
+                        lastAdded = source.getName();
+                    }
+                }
+            }
+        }
+
+```
+
+
+
+���շ��뵽��`environment`
+
+���������Ǿ�������Spring cloud config
+
+��`spring-cloud-context`��jar�У�`spring.factories`�������˸�`BootstrapApplicationListener`
+���Ҹ�����������`ConfigFileApplicationListener`������������������springcloud�������ô
+�¼�������������`BootstrapApplicationListener`
+
+
+
+```
+# Application Listeners
+org.springframework.context.ApplicationListener=\
+org.springframework.cloud.bootstrap.BootstrapApplicationListener,\
+
+```
+
+
+
+
+
+```
+    @Override
+    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
+        ConfigurableEnvironment environment = event.getEnvironment();
+        if (!environment.getProperty("spring.cloud.bootstrap.enabled", Boolean.class,
+                true)) {
+            return;
+        }
+        // don't listen to events in a bootstrap context
+        if (environment.getPropertySources().contains(BOOTSTRAP_PROPERTY_SOURCE_NAME)) {
+            return;
+        }
+        ConfigurableApplicationContext context = null;
+        String configName = environment
+                .resolvePlaceholders("${spring.cloud.bootstrap.name:bootstrap}");
+        for (ApplicationContextInitializer<?> initializer : event.getSpringApplication()
+                .getInitializers()) {
+            if (initializer instanceof ParentContextApplicationContextInitializer) {
+                context = findBootstrapContext(
+                        (ParentContextApplicationContextInitializer) initializer,
+                        configName);
+            }
+        }
+        if (context == null) {
+            context = bootstrapServiceContext(environment, event.getSpringApplication(),
+                    configName);
+        }
+        apply(context, event.getSpringApplication(), environment);
+    }
+
+```
+
+
+
+
+
+```
+    private ConfigurableApplicationContext bootstrapServiceContext(
+            ConfigurableEnvironment environment, final SpringApplication application,
+            String configName) {
+        StandardEnvironment bootstrapEnvironment = new StandardEnvironment();
+        MutablePropertySources bootstrapProperties = bootstrapEnvironment
+                .getPropertySources();
+        for (PropertySource<?> source : bootstrapProperties) {
+            bootstrapProperties.remove(source.getName());
+        }
+        String configLocation = environment
+                .resolvePlaceholders("${spring.cloud.bootstrap.location:}");
+        Map<String, Object> bootstrapMap = new HashMap<>();
+        bootstrapMap.put("spring.config.name", configName);
+        // if an app (or test) uses spring.main.web-application-type=reactive, bootstrap will fail
+        // force the environment to use none, because if though it is set below in the builder
+        // the environment overrides it
+        bootstrapMap.put("spring.main.web-application-type", "none");
+        if (StringUtils.hasText(configLocation)) {
+            bootstrapMap.put("spring.config.location", configLocation);
+        }
+        bootstrapProperties.addFirst(
+                new MapPropertySource(BOOTSTRAP_PROPERTY_SOURCE_NAME, bootstrapMap));
+        for (PropertySource<?> source : environment.getPropertySources()) {
+            if (source instanceof StubPropertySource) {
+                continue;
+            }
+            bootstrapProperties.addLast(source);
+        }
+        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+        // Use names and ensure unique to protect against duplicates
+        List<String> names = new ArrayList<>(SpringFactoriesLoader
+                .loadFactoryNames(BootstrapConfiguration.class, classLoader));
+        for (String name : StringUtils.commaDelimitedListToStringArray(
+                environment.getProperty("spring.cloud.bootstrap.sources", ""))) {
+            names.add(name);
+        }
+        // TODO: is it possible or sensible to share a ResourceLoader?
+        SpringApplicationBuilder builder = new SpringApplicationBuilder()
+                .profiles(environment.getActiveProfiles()).bannerMode(Mode.OFF)
+                .environment(bootstrapEnvironment)
+                // Don't use the default properties in this builder
+                .registerShutdownHook(false).logStartupInfo(false)
+                .web(WebApplicationType.NONE);
+        final SpringApplication builderApplication = builder.application();
+        if(builderApplication.getMainApplicationClass() == null){
+            // gh_425:
+            // SpringApplication cannot deduce the MainApplicationClass here
+            // if it is booted from SpringBootServletInitializer due to the
+            // absense of the "main" method in stackTraces.
+            // But luckily this method's second parameter "application" here
+            // carries the real MainApplicationClass which has been explicitly
+            // set by SpringBootServletInitializer itself already.
+            builder.main(application.getMainApplicationClass());
+        }
+        if (environment.getPropertySources().contains("refreshArgs")) {
+            // If we are doing a context refresh, really we only want to refresh the
+            // Environment, and there are some toxic listeners (like the
+            // LoggingApplicationListener) that affect global static state, so we need a
+            // way to switch those off.
+            builderApplication
+                    .setListeners(filterListeners(builderApplication.getListeners()));
+        }
+        List<Class<?>> sources = new ArrayList<>();
+        for (String name : names) {
+            Class<?> cls = ClassUtils.resolveClassName(name, null);
+            try {
+                cls.getDeclaredAnnotations();
+            }
+            catch (Exception e) {
+                continue;
+            }
+            sources.add(cls);
+        }
+        AnnotationAwareOrderComparator.sort(sources);
+        builder.sources(sources.toArray(new Class[sources.size()]));
+        final ConfigurableApplicationContext context = builder.run();
+        // gh-214 using spring.application.name=bootstrap to set the context id via
+        // `ContextIdApplicationContextInitializer` prevents apps from getting the actual
+        // spring.application.name
+        // during the bootstrap phase.
+        context.setId("bootstrap");
+        // Make the bootstrap context a parent of the app context
+        addAncestorInitializer(application, context);
+        // It only has properties in it now that we don't want in the parent so remove
+        // it (and it will be added back later)
+        bootstrapProperties.remove(BOOTSTRAP_PROPERTY_SOURCE_NAME);
+        mergeDefaultProperties(environment.getPropertySources(), bootstrapProperties);
+        return context;
+    }
+
+```
+
+
+
+������Ҫ��������������
+
+1.  ����Environment��������spring.config.name=bootstrap
+2.  ����һ���µ�SpringApplication����������������sourcesΪ��չ���µ�BootstrapConfiguration������
+
+
+
+```
+List<String> names = new ArrayList<>(SpringFactoriesLoader
+                .loadFactoryNames(BootstrapConfiguration.class, classLoader));
+
+```
+
+
+
+�򵥵ľ��ǿ�������Ϊ������һ���µ���������������ΪBootstrapConfiguration���õ��ࡣ����ͨ��run�����õ��˳�ʼ�����BeanFactory�������ҽ�contenxt��װ��AncestorInitializer���뵽�������Լ���SpringApplication��
+
+
+
+```
+application.addInitializers(new AncestorInitializer(context));
+
+```
+
+
+
+����`apply`������,��ȡ��`ApplicationContextInitializer`���͵����ж�����뵽�����ǵ�ǰ��`SpringApplication`��
+
+
+
+```
+    private void apply(ConfigurableApplicationContext context,
+            SpringApplication application, ConfigurableEnvironment environment) {
+        @SuppressWarnings("rawtypes")
+        List<ApplicationContextInitializer> initializers = getOrderedBeansOfType(context,
+                ApplicationContextInitializer.class);
+        application.addInitializers(initializers
+                .toArray(new ApplicationContextInitializer[initializers.size()]));
+        addBootstrapDecryptInitializer(application);
+    }
+
+```
+
+
+
+��`spring-cloud-context`����`spring.factories`�������������
+
+
+
+```
+org.springframework.cloud.bootstrap.BootstrapConfiguration=\
+org.springframework.cloud.bootstrap.config.PropertySourceBootstrapConfiguration,\
+
+```
+
+
+
+����������������`SpringApplication`���Ѿ�����`AncestorInitializer,PropertySourceBootstrapConfiguration`����ApplicationContextInitializer
+
+���ص�����������
+
+
+
+```
+    private void prepareContext(ConfigurableApplicationContext context,
+            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
+            ApplicationArguments applicationArguments, Banner printedBanner) {
+        context.setEnvironment(environment);
+        postProcessApplicationContext(context);
+        applyInitializers(context);
+        listeners.contextPrepared(context);
+        if (this.logStartupInfo) {
+            logStartupInfo(context.getParent() == null);
+            logStartupProfileInfo(context);
+        }
+
+        // Add boot specific singleton beans
+        context.getBeanFactory().registerSingleton("springApplicationArguments",
+                applicationArguments);
+        if (printedBanner != null) {
+            context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
+        }
+
+        // Load the sources
+        Set<Object> sources = getAllSources();
+        Assert.notEmpty(sources, "Sources must not be empty");
+        load(context, sources.toArray(new Object[0]));
+        listeners.contextLoaded(context);
+    }
+
+```
+
+
+
+
+
+```
+    protected void applyInitializers(ConfigurableApplicationContext context) {
+        for (ApplicationContextInitializer initializer : getInitializers()) {
+            Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
+                    initializer.getClass(), ApplicationContextInitializer.class);
+            Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
+            initializer.initialize(context);
+        }
+    }
+
+```
+
+
+
+������ͻ���õ�`ApplicationContextInitializer.initialize`����
+�ͻ�������`AncestorInitializer`
+
+
+
+```
+        @Override
+        public void initialize(ConfigurableApplicationContext context) {
+            while (context.getParent() != null && context.getParent() != context) {
+                context = (ConfigurableApplicationContext) context.getParent();
+            }
+            reorderSources(context.getEnvironment());
+            new ParentContextApplicationContextInitializer(this.parent)
+                    .initialize(context);
+        }
+
+    @Override
+    public void initialize(ConfigurableApplicationContext applicationContext) {
+        if (applicationContext != this.parent) {
+            applicationContext.setParent(this.parent);
+            applicationContext.addApplicationListener(EventPublisher.INSTANCE);
+        }
+    }
+
+```
+
+
+
+���Կ������ｫBootStrap������������Ϊ���ǵ�ǰ�����ĸ����������Ҹ������еĶ��󶼳�ʼ�����ˣ�`PropertySourceBootstrapConfiguration`��Ҳ��ʼ������,���Ҹ�`ApplicationContextInitializer`���뵽�������Լ������������棬��˻���ó�ʼ�����˵�`PropertySourceBootstrapConfiguration.initialize`,��`PropertySourceLocator`��ע�������
+
+
+
+```
+# Bootstrap components
+org.springframework.cloud.bootstrap.BootstrapConfiguration=\
+org.springframework.cloud.config.client.ConfigServiceBootstrapConfiguration,\
+
+```
+
+
+
+
+
+```
+    @Bean
+    @ConditionalOnMissingBean(ConfigServicePropertySourceLocator.class)
+    @ConditionalOnProperty(value = "spring.cloud.config.enabled", matchIfMissing = true)
+    public ConfigServicePropertySourceLocator configServicePropertySource(ConfigClientProperties properties) {
+        ConfigServicePropertySourceLocator locator = new ConfigServicePropertySourceLocator(
+                properties);
+        return locator;
+    }
+
+```
+
+
+
+
+
+```
+    @Autowired(required = false)
+    private List<PropertySourceLocator> propertySourceLocators = new ArrayList<>();
+
+    @Override
+    public void initialize(ConfigurableApplicationContext applicationContext) {
+        CompositePropertySource composite = new CompositePropertySource(
+                BOOTSTRAP_PROPERTY_SOURCE_NAME);
+        AnnotationAwareOrderComparator.sort(this.propertySourceLocators);
+        boolean empty = true;
+        ConfigurableEnvironment environment = applicationContext.getEnvironment();
+        for (PropertySourceLocator locator : this.propertySourceLocators) {
+            PropertySource<?> source = null;
+            source = locator.locate(environment);
+            if (source == null) {
+                continue;
+            }
+            logger.info("Located property source: " + source);
+            composite.addPropertySource(source);
+            empty = false;
+        }
+        if (!empty) {
+            MutablePropertySources propertySources = environment.getPropertySources();
+            String logConfig = environment.resolvePlaceholders("${logging.config:}");
+            LogFile logFile = LogFile.get(environment);
+            if (propertySources.contains(BOOTSTRAP_PROPERTY_SOURCE_NAME)) {
+                propertySources.remove(BOOTSTRAP_PROPERTY_SOURCE_NAME);
+            }
+            insertPropertySources(propertySources, composite);
+            reinitializeLoggingSystem(environment, logConfig, logFile);
+            setLogLevels(applicationContext, environment);
+            handleIncludedProfiles(environment);
+        }
+    }
+
+```
+
+
+
+������ջ�����`ConfigServicePropertySourceLocator`��
+
+
+
+```
+    private Environment getRemoteEnvironment(RestTemplate restTemplate,
+            ConfigClientProperties properties, String label, String state) {
+        String path = "/{name}/{profile}";
+        String name = properties.getName();
+        String profile = properties.getProfile();
+        String token = properties.getToken();
+        int noOfUrls = properties.getUri().length;
+        if (noOfUrls > 1) {
+            logger.info("Multiple Config Server Urls found listed.");
+        }
+
+        Object[] args = new String[] { name, profile };
+        if (StringUtils.hasText(label)) {
+            if (label.contains("/")) {
+                label = label.replace("/", "(_)");
+            }
+            args = new String[] { name, profile, label };
+            path = path + "/{label}";
+        }
+        ResponseEntity<Environment> response = null;
+
+        for (int i = 0; i < noOfUrls; i++) {
+            Credentials credentials = properties.getCredentials(i);
+            String uri = credentials.getUri();
+            String username = credentials.getUsername();
+            String password = credentials.getPassword();
+
+            logger.info("Fetching config from server at : " + uri);
+
+            try {
+                HttpHeaders headers = new HttpHeaders();
+                addAuthorizationToken(properties, headers, username, password);
+                if (StringUtils.hasText(token)) {
+                    headers.add(TOKEN_HEADER, token);
+                }
+                if (StringUtils.hasText(state) && properties.isSendState()) {
+                    headers.add(STATE_HEADER, state);
+                }
+
+                final HttpEntity<Void> entity = new HttpEntity<>((Void) null, headers);
+                response = restTemplate.exchange(uri + path, HttpMethod.GET, entity,
+                        Environment.class, args);
+            }
+            catch (HttpClientErrorException e) {
+                if (e.getStatusCode() != HttpStatus.NOT_FOUND) {
+                    throw e;
+                }
+            }
+            catch (ResourceAccessException e) {
+                logger.info("Connect Timeout Exception on Url - " + uri
+                        + ". Will be trying the next url if available");
+                if (i == noOfUrls - 1)
+                    throw e;
+                else
+                    continue;
+            }
+
+            if (response == null || response.getStatusCode() != HttpStatus.OK) {
+                return null;
+            }
+
+            Environment result = response.getBody();
+            return result;
+        }
+
+        return null;
+    }
+
+```
+
+
+
+���Կ��������ǵ��÷���˵Ľӿڻ�ȡ���µ����á�
+������ⲿ��������ŵ�systemEnvironment֮ǰ����˾ͻḲ�DZ������ã����ǿ���ͨ����������
+
+
+
+```
+@ConfigurationProperties("spring.cloud.config")
+public class PropertySourceBootstrapProperties {
+
+    /**
+     * Flag to indicate that the external properties should override system properties.
+     * Default true.
+     */
+    private boolean overrideSystemProperties = true;
+
+    /**
+     * Flag to indicate that {@link #isOverrideSystemProperties()
+     * systemPropertiesOverride} can be used. Set to false to prevent users from changing
+     * the default accidentally. Default true.
+     */
+    private boolean allowOverride = true;
+
+    /**
+     * Flag to indicate that when {@link #setAllowOverride(boolean) allowOverride} is
+     * true, external properties should take lowest priority, and not override any
+     * existing property sources (including local config files). Default false.
+     */
+    private boolean overrideNone = false;
+
+```
+
+
+
+
+
+```
+if (!remoteProperties.isAllowOverride() || (!remoteProperties.isOverrideNone()
+                && remoteProperties.isOverrideSystemProperties())) {
+            propertySources.addFirst(composite);
+            return;
+        }
+        if (remoteProperties.isOverrideNone()) {
+            propertySources.addLast(composite);
+            return;
+        }
+        if (propertySources
+                .contains(StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME)) {
+            if (!remoteProperties.isOverrideSystemProperties()) {
+                propertySources.addAfter(
+                        StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME,
+                        composite);
+            }
+            else {
+                propertySources.addBefore(
+                        StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME,
+                        composite);
+            }
+        }
+        else {
+            propertySources.addLast(composite);
+        }
+
+```
+
+
+
+**�ܽ�**
+
+1.  ��չ��
+    1.1 `EnvironmentPostProcessor`
+    �Ի���������
+    1.2 `PropertySourceLoader`
+    ������ͬ�ĸ�ʽ���ļ�
+    1.2 `ApplicationListener`
+    spring-cloud����ͨ��������չBootstrapApplicationListener
+    1.3 `BootstrapConfiguration`
+    ͨ����չ�����������
+
+2.  �ļ����ع���
+    ͨ��ApplicationListener�¼�����һ���µ�SpringApliction�����ཫBootstrapConfiguration��չ����Ϊ���������࣬Ȼ������һ����ʼ���˵�BootStrap����������������װ��AncestorInitializer����뵽�����Լ����������У����þ��ǽ������Լ������ĸ���������ΪBootStrap������ͨ��BootStrap������ó�ʼ���ú��ApplicationContextInitializer���Ͷ��󣬶�����������PropertySourceBootstrapConfiguration���������࣬��������ע����PropertySourceLocator�࣬����ConfigServiceBootstrapConfiguration����������������bean����
+    ConfigServicePropertySourceLocator���������ջὫBootStrap�г�ʼ�õ�PropertySourceBootstrapConfiguration���뵽�����Լ����������е��ã����յ���initialize����Ȼ�����ConfigServicePropertySourceLocator.locate����ȥConfig server�����ȡ���á�
+
+
+
+���ߣ�ӵ���¶�_to
+���ӣ�https://www.jianshu.com/p/60c6ab0e79d5
+��Դ������
+����Ȩ���������С���ҵת������ϵ���߻����Ȩ������ҵת����ע��������
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudEureka\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudEureka\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..0236a13
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudEureka\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,1784 @@
+EurekaԴ�����
+
+**��1�� ��������**
+**1.1 Eureka����ʲô��**
+
+�������Ƕ����ף�Eureka������������ע��ģ���ע������Ҫʵ��ʲô�����أ����������ȷ�ˡ�
+
+1.  ��Ȼ��ע�����ģ�������Ҫ�ܱ�������ip��port����Ϣ�ɣ�����Eureka-server�����ṩ�Ļ������ܡ�
+2.  ����ע������֮�󣬻�Ҫ�ṩһЩ��̬��֪���������ߵĹ��ܰɣ����һ�����������ߣ�Eureka-server����֪����������������һ�IJ�ֵ�ˡ�
+3.  ��Eureka-server�˸�֪������ı仯֮���ܵ�֪ͨ���Ѷ˰ɣ������ǣ����ʱserver������֪ͨclient���ػ���client���Լ�ȥ��ȡ��Ϣ�أ�������ڲ�֪�����Ȼ�ȥ��Դ����֤��
+4.  OK������Ĺ��ܶ�ʵ���ˣ�Eureka�����ϸ��ˣ��ǻ���һ������Ȼ�����ip�Ͷ˿ڶ���Eureka-server���棬�������Ѷ˵��÷���˵�ʱ��ͨ�����õ�OpenFeign����OpenFeign����ô֪�������ĸ�����ģ�֮ǰ����д����application.properties�����<servicename>.ribbon.listOfServers�У�����Eureka��ô�Զ�д��ȥ���أ�
+5.  ����4�����ܻ����������ע�����ĸ��еĹ��ܣ������ʱ����������˼��һ�£�ע����������΢������Ŀ�У���ע������Ҳ��Ϊһ��������Ҳ��Ҫ����Ⱥ�ģ����ʱ�����Ǿ�Ҫ��һ�£�����Ⱥ��ô��֤����һ���ԣ��û���ʲô���ۣ�
+    ������EurekaҪʵ�ֵ�����ĵĹ��ܣ�����Щ�����ṩ�����ˣ�����Ŀ��ôȥ�����أ�����ֱ��ȥ��API�ɣ�����鷳������ȥѧһ��Eureka��api���궿���ˡ�
+
+���ʱ�����Ǿͻ����뵽SpringBoot���Զ�װ���Starter��������������������������˺���bean���Զ�ע�룬�ײ����ֱ���õ�bean��Ȼ����Starter�����Ӧ���Զ������ǵ�����API�ģ�OK���ǻع�ͷ���ҷ��֣��ҵ�Eureka-client����һ��starter������ٺ٣��е㶫���ˡ����client�˺����߼��϶��ǰ����Ƿ�װ�˸���bean��Ȼ������ǵ����˺���api�ˡ�
+
+�������Eureka�ĺ��Ĺ�����������һ���������ܽ᣺
+
+1.  ʵ��ע�ᣬ�������ڴ���
+2.  ��̬��֪����Ľ���״̬
+3.  ����ķ��֣�����̬��֪����ı仯
+    **1.2 ���������Ƶ�**
+    ��ȷ�˺��Ĺ��ܣ��Լ���ε��õģ��������������󵨵��Ƶ�һ�º�������ͼ��
+
+![SpringCloudϵ�С�Spring Cloud Դ�����֮Eureka-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/f15564313c2406546821713bcaf3eb0e9ac73d.jpg "SpringCloudϵ�С�Spring Cloud Դ�����֮Eureka-��Դ������������")���������Ƶ�����֮����������ͨ��Դ����һ����֤��
+
+**��2�� Դ�����**
+**2.1 ����ע������**
+����ע������spring bootӦ��������ʱ����ġ������ִ��·���������Ҳ������Ȼع�һ��ǰ�����ǽ�����֪ʶ��
+
+����˵spring cloud��һ����̬�����ṩ��һ�ױ�׼�����ױ�׼����ͨ����ͬ�������ʵ�֣����оͰ�������ע��/���֡��۶ϡ����ؾ���ȣ���spring-cloud-common������У�
+org.springframework.cloud.client.serviceregistry ·���£����Կ���һ������ע��Ľӿڶ� �� ServiceRegistry �������Ƕ�����spring cloud�з���ע���һ���ӿڡ�
+
+���ǿ�һ���������ϵͼ������ӿ���һ��Ψһ��ʵ�� EurekaServiceRegistry ����ʾ���õ���Eureka Server��Ϊ����ע�����ġ�
+
+![SpringCloudϵ�С�Spring Cloud Դ�����֮Eureka-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/49d085328febfffcbae4030dac151db2d0bfcb.jpg "SpringCloudϵ�С�Spring Cloud Դ�����֮Eureka-��Դ������������")**2.1.1 ע���ʱ��**
+����ע��ķ������ǿ��Բ²�һ��Ӧ����ʲôʱ����ɣ������Ҫ������ʵӦ�ò��Ѳ²⵽�������ע��ȡ���ڷ����Ƿ��Ѿ��������ˡ�����spring boot�У���ȵ�spring ���������������е����ö����֮��������ע�ᡣ�����������spring boot�����������е�refreshContext����ɡ�
+
+���ǹ۲�һ��finishRefresh����������������Ͽ��Կ������������������ˢ�µIJ�����Ҳ����ˢ�����֮��Ҫ���ĺ��õIJ���������Ҫ����������
+
+* ��ջ���
+
+* ��ʼ��һ��LifecycleProcessor����Spring������ʱ������bean����spring������ʱ������bean
+
+* ����LifecycleProcessor��onRefresh����������ʵ����Lifecycle�ӿڵ�bean
+
+* ����ContextRefreshedEvent
+
+* ע��Bean��ͨ��JMX���м�غ͹���
+
+
+
+  ```
+  protected void finishRefresh() {
+      // Clear context-level resource caches (such as ASM metadata from scanning).
+      clearResourceCaches();
+      // Initialize lifecycle processor for this context.
+      initLifecycleProcessor();
+      // Propagate refresh to lifecycle processor first.
+      getLifecycleProcessor().onRefresh();
+      // Publish the final event.
+      publishEvent(new ContextRefreshedEvent(this));
+      // Participate in LiveBeansView MBean, if active.
+      LiveBeansView.registerApplicationContext(this);
+  }
+  ```
+
+
+
+
+
+
+
+
+
+����������У������ص��ע getLifecycleProcessor().onRefresh() �����ǵ����������ڴ�������onrefresh�������ҵ�SmartLifecycle�ӿڵ�����ʵ���ಢ����start������
+
+**2.1.2 SmartLifeCycle**
+����չһ��SmartLifeCycle����֪ʶ�� SmartLifeCycle��һ���ӿڣ���Spring�������������е�Bean���ҳ�ʼ��֮�󣬻�����ص�ʵ����SmartLifeCycle�ӿڵ����ж�Ӧ�ķ��������磨start����
+
+ʵ���������Լ�Ҳ������չ��������springboot���̵�main����ͬ��Ŀ¼�£�дһ�������࣬ʵ��SmartLifeCycle�ӿڣ�����ͨ�� @Service ����Ϊһ��bean����ΪҪ��springȥ���أ����ȵ���bean��
+
+
+
+```
+@Service
+public class TestSmartLifeCycle implements SmartLifecycle {
+    /**
+     * ����������ִ��.������ʾ����start����.
+     * ��������isAutoStartup()����ֵ,ֻ��isAutoStartup()����true��ʱ��,start()�Żᱻִ��
+     */
+    @Override
+    public void start() {
+        System.out.println("----------start-----------");
+    }
+    /**
+     * ����ֹͣǰִ�з���
+     * ǰ������: isRunning()����true�Żᱻִ��
+     */
+    @Override
+    public void stop() {
+        System.out.println("----------stop-----------");
+    }
+    /**
+     * ���ط�������״̬,Ӱ�쵽�����Ƿ����stop����
+     * @return
+     */
+    @Override
+    public boolean isRunning() {
+        return false;
+    }
+    /**
+     * �Ƿ����start����,��Ҫע��
+     * ��ǰ��������false�Dz���ִ��start()
+     * @return
+     */
+    @Override
+    public boolean isAutoStartup() {
+        return true;
+    }
+    @Override
+    public void stop(Runnable runnable) {
+        stop();
+        runnable.run();
+    }
+    /**
+     * ָ��ִ��˳��
+     * ��ǰ��������ж����ʵ����SmartLifecycle,�򰴴˷���������ֵ����ִ��
+     * @return
+     */
+    @Override
+    public int getPhase() {
+        return 0;
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+���ţ���������spring bootӦ�ú󣬿��Կ�������̨����� start �ַ�����
+
+������DefaultLifecycleProcessor.startBeans�����ϼ�һ��debug�����Ժ����ԵĿ��������Լ������TestSmartLifeCycle��ɨ�赽�ˣ�����������ø�bean��start������![SpringCloudϵ�С�Spring Cloud Դ�����֮Eureka-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/75b18e528ba1879148c106d9bd3fb61ab9b5bb.jpg "SpringCloudϵ�С�Spring Cloud Դ�����֮Eureka-��Դ������������")��startBeans�����У����ǿ��Կ��������Ȼ�������ʵ����SmartLifeCycle��Bean��Ȼ���ѭ������ʵ����SmartLifeCycle��bean��start�������������¡�
+
+
+
+```
+private void startBeans(boolean autoStartupOnly) {
+    Map<String, Lifecycle> lifecycleBeans = this.getLifecycleBeans();
+    Map<Integer, DefaultLifecycleProcessor.LifecycleGroup> phases = new HashMap();
+    lifecycleBeans.forEach((beanName, bean) -> {
+        if (!autoStartupOnly || bean instanceof SmartLifecycle &&
+            ((SmartLifecycle)bean).isAutoStartup()) {
+            int phase = this.getPhase(bean);
+            DefaultLifecycleProcessor.LifecycleGroup group =
+                (DefaultLifecycleProcessor.LifecycleGroup)phases.get(phase);
+            if (group == null) {
+                group = new DefaultLifecycleProcessor.LifecycleGroup(phase,this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
+                phases.put(phase, group);
+            }
+            group.add(beanName, bean);
+        }
+    });
+    if (!phases.isEmpty()) {
+        List<Integer> keys = new ArrayList(phases.keySet());
+        Collections.sort(keys);
+        Iterator var5 = keys.iterator();
+        while(var5.hasNext()) {
+            Integer key = (Integer)var5.next();
+            ((DefaultLifecycleProcessor.LifecycleGroup)phases.get(key)).start();
+        }
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.1.3 doStart**
+
+
+
+```
+private void doStart(Map<String, ? extends Lifecycle> lifecycleBeans, String beanName, boolean autoStartupOnly) {
+    Lifecycle bean = (Lifecycle)lifecycleBeans.remove(beanName);
+    if (bean != null && bean != this) {
+        String[] dependenciesForBean = this.getBeanFactory().getDependenciesForBean(beanName);
+        String[] var6 = dependenciesForBean;
+        int var7 = dependenciesForBean.length;
+        for(int var8 = 0; var8 < var7; ++var8) {
+            String dependency = var6[var8];
+            this.doStart(lifecycleBeans, dependency, autoStartupOnly);
+        }
+        if (!bean.isRunning() && (!autoStartupOnly || !(bean instanceof SmartLifecycle) || ((SmartLifecycle)bean).isAutoStartup())) {
+            if (this.logger.isTraceEnabled()) {
+                this.logger.trace("Starting bean '" + beanName + "' of type [" + bean.getClass().getName() + "]");
+            }
+            try {
+                bean.start(); //��ʱ Bean��ʵ��Ӧ����EurekaAutoServiceRegistration
+            } catch (Throwable var10) {
+                throw new ApplicationContextException("Failed to start bean '" + beanName + "'", var10);
+            }
+            if (this.logger.isDebugEnabled()) {
+                this.logger.debug("Successfully started bean '" + beanName + "'");
+            }
+        }
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+��ʱ��bean.start()�����õĿ�����
+EurekaAutoServiceRegistration�е�start��������Ϊ����Ȼ����ʵ����SmartLifeCycle�ӿڡ�
+
+
+
+```
+public class EurekaAutoServiceRegistration implements AutoServiceRegistration,SmartLifecycle, Ordered, SmartApplicationListener {
+    @Override
+    public void start() {
+        // only set the port if the nonSecurePort or securePort is 0 and this.port != 0
+        if (this.port.get() != 0) {
+            if (this.registration.getNonSecurePort() == 0) {
+                this.registration.setNonSecurePort(this.port.get());
+            }
+            if (this.registration.getSecurePort() == 0 &&
+                this.registration.isSecure()) {
+                this.registration.setSecurePort(this.port.get());
+            }
+        }
+        // only initialize if nonSecurePort is greater than 0 and it isn't already running
+        // because of containerPortInitializer below
+        if (!this.running.get() && this.registration.getNonSecurePort() > 0) {
+            this.serviceRegistry.register(this.registration);
+            this.context.publishEvent(new InstanceRegisteredEvent<>(this,
+                                                                    this.registration.getInstanceConfig()));
+            this.running.set(true);
+        }
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+��start�����У����ǿ��Կ���
+this.serviceRegistry.register �����������ʵ���Ͼ��Ƿ������ע��Ļ��ơ�
+
+��ʱthis.serviceRegistry��ʵ����Ӧ���� EurekaServiceRegistry �� ԭ����
+EurekaAutoServiceRegistration�Ĺ��췽���У�����һ����ֵ��������������췽������EurekaClientAutoConfiguration ����Զ�װ�����б�װ��ͳ�ʼ���ģ��������¡�
+
+
+
+```
+@Bean
+@ConditionalOnBean(AutoServiceRegistrationProperties.class)
+@ConditionalOnProperty(value = "spring.cloud.service-registry.auto-registration.enabled", matchIfMissing = true)
+public EurekaAutoServiceRegistration eurekaAutoServiceRegistration(
+    ApplicationContext context, EurekaServiceRegistry registry,
+    EurekaRegistration registration) {
+    return new EurekaAutoServiceRegistration(context, registry, registration);
+}
+```
+
+
+
+
+
+
+
+
+
+**2.2 �����ע������**
+���������Ƿ�������ע�������
+
+
+
+```
+public class EurekaAutoServiceRegistration implements AutoServiceRegistration,
+SmartLifecycle, Ordered, SmartApplicationListener {
+    @Override
+    public void start() {
+        //ʡ��...
+        this.serviceRegistry.register(this.registration);
+        this.context.publishEvent(new InstanceRegisteredEvent<> this,this.registration.getInstanceConfig()));
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+this.serviceRegistry.register(this.registration); �������ջ����
+
+EurekaServiceRegistry ���е� register ������ʵ�ַ���ע��
+
+**2.2.1 register**
+
+
+
+```
+@Override
+public void register(EurekaRegistration reg) {
+    maybeInitializeClient(reg);
+    if (log.isInfoEnabled()) {
+        log.info("Registering application "
+                 + reg.getApplicationInfoManager().getInfo().getAppName()
+                 + " with eureka with status "
+                 + reg.getInstanceConfig().getInitialStatus());
+    }
+    //���õ�ǰʵ����״̬��һ�����ʵ����״̬�����仯��ֻҪ״̬����DOWN����ô�ͻᱻ��������������ִ�з���ע�ᡣ
+    reg.getApplicationInfoManager().setInstanceStatus(reg.getInstanceConfig().getInitialStatus());
+    //���ý������Ĵ���
+    reg.getHealthCheckHandler().ifAvailable(healthCheckHandler -> reg.getEurekaClient().registerHealthCheck(healthCheckHandler));
+}
+```
+
+
+
+
+
+
+
+
+
+����������������ע�᷽���в�û����������Eureka�ķ���ȥִ��ע�ᣬ���ǽ���������һ��״̬�Լ����ý�����鴦���������Ǽ�����һ��
+reg.getApplicationInfoManager().setInstanceStatus������
+
+
+
+```
+public synchronized void setInstanceStatus(InstanceStatus status) {
+    InstanceStatus next = instanceStatusMapper.map(status);
+    if (next == null) {
+        return;
+    }
+    InstanceStatus prev = instanceInfo.setStatus(next);
+    if (prev != null) {
+        for (StatusChangeListener listener : listeners.values()) {
+            try {
+                listener.notify(new StatusChangeEvent(prev, next));
+            } catch (Exception e) {
+                logger.warn("failed to notify listener: {}", listener.getId(),e);
+            }
+        }
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+����������У�����ͨ��������������һ��״̬����¼���ok����ʱlistener��ʵ����StatusChangeListener ��Ҳ���ǵ��� StatusChangeListener ��notify����������¼��Ǵ���һ������״̬�����Ӧ�����еط����������¼���Ȼ���������¼�����ע�ᡣ
+
+���ʱ��������Ϊ�ҵ��˷���Ȼ������ȥһ������������һ���ӿڡ��������Ƿ������Ǿ�̬���ڲ��ӿڣ����޷�ֱ�ӿ�������ʵ���ࡣ
+
+���Ҷ���Դ���Ķ����飬�����������ң���Ϊ�һ������ܲ²⵽һ������ij���ط����˳�ʼ���Ĺ��������ǣ������ҵ�
+EurekaServiceRegistry.register�����е� reg.getApplicationInfoManager ���ʵ����ʲô���������Ƿ���ApplicationInfoManager��������EurekaRegistration������е����ԡ���EurekaRegistration������EurekaAutoServiceRegistration�������ʵ�����ġ��������룬�Dz������Զ�װ��������ʲô�����������ҵ�EurekaClientAutoConfiguration����࣬��Ȼ������Bean��һЩ�Զ�װ�䣬���а��� EurekaClient �� ApplicationInfoMangager �� EurekaRegistration �ȡ�
+
+**2.2.2 EurekaClientConfiguration**
+
+
+
+```
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnMissingRefreshScope
+protected static class EurekaClientConfiguration {
+    @Autowired
+    private ApplicationContext context;
+    @Autowired
+    private AbstractDiscoveryClientOptionalArgs<?> optionalArgs;
+    @Bean(destroyMethod = "shutdown")
+    @ConditionalOnMissingBean(value = EurekaClient.class,search = SearchStrategy.CURRENT)
+    public EurekaClient eurekaClient(ApplicationInfoManager manager,EurekaClientConfig config) {
+        return new CloudEurekaClient(manager, config, this.optionalArgs,this.context);
+    }
+    @Bean
+    @ConditionalOnMissingBean(value = ApplicationInfoManager.class,search = SearchStrategy.CURRENT)
+    public ApplicationInfoManager eurekaApplicationInfoManager(
+        EurekaInstanceConfig config) {
+        InstanceInfo instanceInfo = new InstanceInfoFactory().create(config);
+        return new ApplicationInfoManager(config, instanceInfo);
+    }
+    @Bean
+    @ConditionalOnBean(AutoServiceRegistrationProperties.class)
+    @ConditionalOnProperty(
+        value = "spring.cloud.service-registry.auto-registration.enabled",
+        matchIfMissing = true)
+    public EurekaRegistration eurekaRegistration(EurekaClient eurekaClient,CloudEurekaInstanceConfig
+                                                 instanceConfig,ApplicationInfoManager applicationInfoManager, @Autowired(required = false)
+                                                 ObjectProvider<HealthCheckHandler> healthCheckHandler) {
+        return EurekaRegistration.builder(instanceConfig).with(applicationInfoManager).with(eurekaClient).with(healthCheckHandler).build();
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+���ѷ��֣������ƺ�������һ������Ҫ��Bean��������ʱ�������Զ�װ�䣬Ҳ����CloudEurekaClient �����������������ҿ��Ժ����׵�ʶ�𲢲²������Eureka�ͻ��˵�һ�������࣬����ʵ�ֺͷ���˵�ͨ���Լ�����������Ǻܶ�Դ��һ�����·��Ҫô�ڹ��췽������ȥ���ܶ�ij�ʼ����һЩ��ִ̨�еij��������Ҫô����ͨ���첽�¼��ķ�ʽ�����������ţ����ǿ�һ��CloudEurekaClient�ij�ʼ�����̣����Ĺ��췽���л�ͨ�� super ���ø���Ĺ��췽����Ҳ����DiscoveryClient�Ĺ��졣
+
+**2.2.3 CloudEurekaClient**
+super(applicationInfoManager, config, args);���ø���Ĺ��췽������CloudEurekaClient�ĸ�����DiscoveryClient.
+
+
+
+```
+public CloudEurekaClient(ApplicationInfoManager applicationInfoManager,EurekaClientConfig config,AbstractDiscoveryClientOptionalArgs<?> args,ApplicationEventPublisher publisher) {
+    super(applicationInfoManager, config, args);
+    this.applicationInfoManager = applicationInfoManager;
+    this.publisher = publisher;
+    this.eurekaTransportField = ReflectionUtils.findField(DiscoveryClient.class,"eurekaTransport");
+    ReflectionUtils.makeAccessible(this.eurekaTransportField);
+}
+```
+
+
+
+
+
+
+
+
+
+**2.2.4 DiscoveryClient����**
+���ǿ��Կ��������յ�DiscoveryClient���췽���У��зdz����Ĵ��롣��ʵ�ܶ������Բ���Ҫ���ģ��󲿷ֶ���һЩ��ʼ�������������ʼ���˼�����ʱ����
+
+* scheduler
+
+* heartbeatExecutor ������ʱ����
+
+* cacheRefreshExecutor ��ʱȥͬ������˵�ʵ���б�
+
+
+
+  ```
+  DiscoveryClient(ApplicationInfoManager applicationInfoManager,EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args,Provider<BackupRegistry> backupRegistryProvider,EndpointRandomizer endpointRandomizer) {
+      //ʡ�Բ��ִ���...
+      //�Ƿ�Ҫ��eureka server�ϻ�ȡ�����ַ��Ϣ
+      if (config.shouldFetchRegistry()) {
+          this.registryStalenessMonitor = new ThresholdLevelsMetric(this,METRIC_REGISTRY_PREFIX + "lastUpdateSec_", new long[]{15L, 30L, 60L, 120L, 240L,480L});
+      } else {
+          this.registryStalenessMonitor = ThresholdLevelsMetric.NO_OP_METRIC;
+      }
+      //�Ƿ�Ҫע�ᵽeureka server��
+      if (config.shouldRegisterWithEureka()) {
+          this.heartbeatStalenessMonitor = new ThresholdLevelsMetric(this,METRIC_REGISTRATION_PREFIX + "lastHeartbeatSec_", new long[]{15L, 30L, 60L,120L, 240L, 480L});
+      } else {
+          this.heartbeatStalenessMonitor = ThresholdLevelsMetric.NO_OP_METRIC;
+      }
+      //�������Ҫע�Ტ�Ҳ���Ҫ���·����ַ
+      if (!config.shouldRegisterWithEureka() && !config.shouldFetchRegistry()) {
+  
+          return;  // no need to setup up an network tasks and we are done
+      }
+      try {
+          // default size of 2 - 1 each for heartbeat and cacheRefresh
+          scheduler = Executors.newScheduledThreadPool(2,new ThreadFactoryBuilder()       .setNameFormat("DiscoveryClient-%d")
+                                                       .setDaemon(true)
+                                                       .build());
+          heartbeatExecutor = new ThreadPoolExecutor(1, clientConfig.getHeartbeatExecutorThreadPoolSize(), 0,
+                                                     TimeUnit.SECONDS,
+                                                     new SynchronousQueue<Runnable>(),
+                                                     new ThreadFactoryBuilder()
+                                                     .setNameFormat("DiscoveryClient-HeartbeatExecutor-%d")
+                                                     .setDaemon(true)
+                                                     .build()
+                                                    );  // use direct handoff
+          cacheRefreshExecutor = new ThreadPoolExecutor(
+              1, clientConfig.getCacheRefreshExecutorThreadPoolSize(), 0,
+              TimeUnit.SECONDS,
+              new SynchronousQueue<Runnable>(),
+              new ThreadFactoryBuilder()
+              .setNameFormat("DiscoveryClient-CacheRefreshExecutor-%d")
+              .setDaemon(true)
+              .build()
+          );  // use direct handoff
+          eurekaTransport = new EurekaTransport();
+          scheduleServerEndpointTask(eurekaTransport, args);
+          AzToRegionMapper azToRegionMapper;
+          if (clientConfig.shouldUseDnsForFetchingServiceUrls()) {
+              azToRegionMapper = new DNSBasedAzToRegionMapper(clientConfig);
+          } else {
+              azToRegionMapper = new PropertyBasedAzToRegionMapper(clientConfig);
+          }
+          if (null != remoteRegionsToFetch.get()) {
+  
+              azToRegionMapper.setRegionsToFetch(remoteRegionsToFetch.get().split(","));
+          }
+          instanceRegionChecker = new InstanceRegionChecker(azToRegionMapper,
+                                                            clientConfig.getRegion());
+      } catch (Throwable e) {
+          throw new RuntimeException("Failed to initialize DiscoveryClient!", e);
+      }
+      //�����Ҫע�ᵽEureka server�����ǿ����˳�ʼ����ʱ��ǿ��ע�ᣬ�����register()�������ע��
+      if (clientConfig.shouldRegisterWithEureka() &&
+          clientConfig.shouldEnforceRegistrationAtInit()) {
+          try {
+              if (!register() ) {
+                  throw new IllegalStateException("Registration error at startup.Invalid server response.");
+              }
+          } catch (Throwable th) {
+              logger.error("Registration error at startup: {}", th.getMessage());
+              throw new IllegalStateException(th);
+          }
+      }
+      // finally, init the schedule tasks (e.g. cluster resolvers, heartbeat,instanceInfo replicator, fetch
+      initScheduledTasks();
+  }
+  ```
+
+
+
+
+
+
+
+
+
+**2.2.5 initScheduledTasks**
+initScheduledTasks ȥ����һ����ʱ����
+
+*   ��������˿�����ע������ˢ�·����б�����Ὺ��cacheRefreshExecutor�����ʱ����
+*   ��������˷���ע�ᵽEureka����ͨ����Ҫ����������.
+
+1.  ��������������
+
+ͨ���ڲ�����ʵ����StatusChangeListener ʵ��״̬��ؽӿڣ��������ǰ�������ڷ��������������������ģ�����notify�ķ�����ʵ���ϻ����������֡�
+
+
+
+```
+private void initScheduledTasks() {
+    //��������˿�����ע������ˢ�·����б�����Ὺ��cacheRefreshExecutor�����ʱ����
+    if (clientConfig.shouldFetchRegistry()) {
+        // registry cache refresh timer
+        int registryFetchIntervalSeconds =
+            clientConfig.getRegistryFetchIntervalSeconds();
+        int expBackOffBound =
+            clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
+        scheduler.schedule(
+            new TimedSupervisorTask(
+                "cacheRefresh",
+                scheduler,
+                cacheRefreshExecutor,
+                registryFetchIntervalSeconds,
+                TimeUnit.SECONDS,
+                expBackOffBound,
+                new CacheRefreshThread()
+            ),
+            registryFetchIntervalSeconds, TimeUnit.SECONDS);
+    }
+    //��������˷���ע�ᵽEureka����ͨ����Ҫ����������
+    if (clientConfig.shouldRegisterWithEureka()) {
+        int renewalIntervalInSecs =
+            instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
+        int expBackOffBound =
+            clientConfig.getHeartbeatExecutorExponentialBackOffBound();
+        logger.info("Starting heartbeat executor: " + "renew interval is: {}",
+                    renewalIntervalInSecs);
+        // Heartbeat timer
+        scheduler.schedule(
+            new TimedSupervisorTask(
+                "heartbeat",
+                scheduler,
+                heartbeatExecutor,
+                renewalIntervalInSecs,
+                TimeUnit.SECONDS,
+                expBackOffBound,
+                new HeartbeatThread()
+            ),
+            renewalIntervalInSecs, TimeUnit.SECONDS);
+        // InstanceInfo replicator ��ʼ��һ��:instanceInfoReplicator
+        instanceInfoReplicator = new InstanceInfoReplicator(
+            this,
+            instanceInfo,
+            clientConfig.getInstanceInfoReplicationIntervalSeconds(),
+            2); // burstSize
+        statusChangeListener = new ApplicationInfoManager.StatusChangeListener()
+        {
+            @Override
+            public String getId() {
+                return "statusChangeListener";
+            }
+            @Override
+            public void notify(StatusChangeEvent statusChangeEvent) {
+                if (InstanceStatus.DOWN == statusChangeEvent.getStatus() ||
+                    InstanceStatus.DOWN ==
+                    statusChangeEvent.getPreviousStatus()) {
+                    // log at warn level if DOWN was involved
+                    logger.warn("Saw local status change event {}",
+                                statusChangeEvent);
+                } else {
+                    logger.info("Saw local status change event {}",
+                                statusChangeEvent);
+                }
+                instanceInfoReplicator.onDemandUpdate();
+            }
+        };
+        //ע��ʵ��״̬�仯�ļ���
+        if (clientConfig.shouldOnDemandUpdateStatusChange()) {
+            applicationInfoManager.registerStatusChangeListener(statusChangeListener);
+        }
+        //����һ��ʵ����Ϣ����������Ҫ����Ϊ�˿���һ����ʱ�̣߳�ÿ40���ж�ʵ����Ϣ�Ƿ�������������������ע��
+        instanceInfoReplicator.start(clientConfig.getInitialInstanceInfoReplicationInte
+                                     rvalSeconds());
+    } else {
+        logger.info("Not registering with Eureka server per configuration");
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.2.6 onDemandUpdate**
+�����������Ҫ�����Ǹ���ʵ�������Ƿ����仯������������ע�����ĵ����ݡ�
+
+
+
+```
+public boolean onDemandUpdate() {
+    //�����ж�
+    if (rateLimiter.acquire(burstSize, allowedRatePerMinute)) {
+        if (!scheduler.isShutdown()) {
+            //�ύһ������
+            scheduler.submit(new Runnable() {
+                @Override
+                public void run() {
+                    logger.debug("Executing on-demand update of local InstanceInfo");
+                    //ȡ��֮ǰ�Ѿ��ύ������Ҳ������start�������ύ�ĸ��������������û��ִ����ɣ���ȡ��֮ǰ������
+                    Future latestPeriodic = scheduledPeriodicRef.get();
+                    if (latestPeriodic != null && !latestPeriodic.isDone()) {
+                        logger.debug("Canceling the latest scheduled update, it will be rescheduled at the end of on demand update");
+                        latestPeriodic.cancel(false);//���������δ��ɣ�������ȡ��
+                    }
+                    //ͨ������run����������������ʱ��ִ�У��൱�������������е�һ��
+                    InstanceInfoReplicator.this.run();
+                }
+            });
+            return true;
+        } else {
+            logger.warn("Ignoring onDemand update due to stopped scheduler");
+            return false;
+        }
+    } else {
+        logger.warn("Ignoring onDemand update due to rate limiter");
+        return false;
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.2.7 run**
+run����ʵ���Ϻ�ǰ���Զ�װ����ִ�еķ���ע�᷽����һ���ģ�Ҳ���ǵ��� register �������з���ע�ᣬ������finally�У�ÿ30s�ᶨʱִ��һ�µ�ǰ��run �������м�顣
+
+
+
+```
+public void run() {
+    try {
+        discoveryClient.refreshInstanceInfo();
+        Long dirtyTimestamp = instanceInfo.isDirtyWithTime();
+        if (dirtyTimestamp != null) {
+            discoveryClient.register();
+            instanceInfo.unsetIsDirty(dirtyTimestamp);
+        }
+    } catch (Throwable t) {
+        logger.warn("There was a problem with the instance info replicator", t);
+    } finally {
+        Future next = scheduler.schedule(this, replicationIntervalSeconds,
+                                         TimeUnit.SECONDS);
+        scheduledPeriodicRef.set(next);
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.2.8 register**
+���գ����������ҵ�����ע�������ˣ�
+eurekaTransport.registrationClient.register ���յ��õ��� AbstractJerseyEurekaHttpClient#register(...)`�� ��Ȼ�������Լ�ȥ�����룬�ͻᷢ��ȥ����֮ǰ�кܶ�������ȥ�Ĵ��룬���繤��ģʽ��װ����ģʽ�ȡ�
+
+
+
+```
+boolean register() throws Throwable {
+    logger.info(PREFIX + "{}: registering service...", appPathIdentifier);
+    EurekaHttpResponse<Void> httpResponse;
+    try {
+        httpResponse = eurekaTransport.registrationClient.register(instanceInfo);
+    } catch (Exception e) {
+        logger.warn(PREFIX + "{} - registration failed {}", appPathIdentifier,e.getMessage(), e);
+        throw e;
+    }
+    if (logger.isInfoEnabled()) {
+        logger.info(PREFIX + "{} - registration status: {}", appPathIdentifier,httpResponse.getStatusCode());
+    }
+    return httpResponse.getStatusCode() == Status.NO_CONTENT.getStatusCode();
+}
+```
+
+
+
+
+
+
+
+
+
+����Ȼ�������Ƿ�����һ��http���󣬷���Eureka-Server��apps/${APP_NAME}�ӿڣ�����ǰ����ʵ������Ϣ���͵�Eureka Server���б��档
+
+���ˣ����ǻ������Ѿ�֪��Spring Cloud Eureka �������������ʱ��ѷ�����Ϣע�ᵽEureka Server�ϵ��ˡ�
+
+
+
+```
+public EurekaHttpResponse<Void> register(InstanceInfo info) {
+    String urlPath = "apps/" + info.getAppName();
+    ClientResponse response = null;
+    try {
+        Builder resourceBuilder =
+            jerseyClient.resource(serviceUrl).path(urlPath).getRequestBuilder();
+        addExtraHeaders(resourceBuilder);
+        response = resourceBuilder
+            .header("Accept-Encoding", "gzip")
+            .type(MediaType.APPLICATION_JSON_TYPE)
+            .accept(MediaType.APPLICATION_JSON)
+            .post(ClientResponse.class, info);
+        return
+            anEurekaHttpResponse(response.getStatus()).headers(headersOf(response)).build();
+    } finally {
+        if (logger.isDebugEnabled()) {
+            logger.debug("Jersey HTTP POST {}/{} with instance {}; statusCode={}", serviceUrl, urlPath, info.getId(),
+                         response == null ? "N/A" : response.getStatus());
+        }
+        if (response != null) {
+            response.close();
+        }
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+���ǣ��ƺ��ʼ�����⻹û�н����Ҳ����Spring BootӦ��������ʱ�������start���������յ���
+StatusChangeListener.notify ȥ���·����һ��״̬����û��ֱ�ӵ���register����ע�ᡣ�������Ǽ���ȥ��һ�� statusChangeListener.notify ������
+
+**2.2.9 �����ܽ�**
+���ˣ�����֪��Eureka Client�������ע��ʱ���������ط���ִ�з���ע�������
+
+1.  ��Spring Boot����ʱ�������Զ�װ����ƽ�CloudEurekaClientע�뵽������������ִ���˹��췽�������ڹ��췽������һ����ʱ����ÿ40s��ִ��һ���жϣ��ж�ʵ����Ϣ�Ƿ����˱仯���������ᷢ�����ע�������
+2.  ��Spring Boot����ʱ��ͨ��refresh���������յ���StatusChangeListener.notify���з���״̬����ļ���������������ķ����ܵ��¼�֮���ȥִ�з���ע�ᡣ
+    **2.3 Server���߼�**
+    ��û����Դ��ʵ��֮ǰ������һ��֪�����϶�����������ķ���ʵ�����ݽ����˴洢����ô����ȥEureka Server�˿�һ�´������̡�
+
+��������ڣ�
+com.netflix.eureka.resources.ApplicationResource.addInstance() ��
+
+��ҿ��Է��֣��������ṩ��REST���񣬲��õ���jersey��ʵ�ֵġ�Jersey�ǻ���JAX-RS��׼���ṩREST��ʵ�ֵ�֧�֣�����Ͳ�չ�������ˡ�
+
+**2.3.1 addInstance()**
+��EurekaClient����register��������ע��ʱ�������
+ApplicationResource.addInstance������
+
+����ע����Ƿ���һ��POST������ϵ�ǰʵ����Ϣ���� ApplicationResource �� addInstance�������з���ע�ᡣ
+
+
+
+```
+@POST
+@Consumes({"application/json", "application/xml"})
+public Response addInstance(InstanceInfo info, @HeaderParam("x-netflix-discovery-replication") String isReplication) {
+    logger.debug("Registering instance {} (replication={})", info.getId(),
+                 isReplication);
+    DataCenterInfo dataCenterInfo = info.getDataCenterInfo();
+    if (dataCenterInfo instanceof UniqueIdentifier) {
+        String dataCenterInfoId =
+            ((UniqueIdentifier)dataCenterInfo).getId();
+        if (this.isBlank(dataCenterInfoId)) {
+            boolean experimental =            "true".equalsIgnoreCase(this.serverConfig.getExperimental("registration.validation.dataCenterInfoId"));
+            if (experimental) {
+                String entity = "DataCenterInfo of type " +
+                    dataCenterInfo.getClass() + " must contain a valid id";
+                return Response.status(400).entity(entity).build();
+            }
+            if (dataCenterInfo instanceof AmazonInfo) {
+                AmazonInfo amazonInfo = (AmazonInfo)dataCenterInfo;
+                String effectiveId = amazonInfo.get(MetaDataKey.instanceId);
+                if (effectiveId == null) {
+                    amazonInfo.getMetadata().put(MetaDataKey.instanceId.getName(), info.getId());
+                }
+            } else {
+                logger.warn("Registering DataCenterInfo of type {} without an appropriate id", dataCenterInfo.getClass());
+            }
+        }
+    }
+    this.registry.register(info, "true".equals(isReplication));
+    return Response.status(204).build();
+}
+
+```
+
+
+
+
+
+
+
+
+
+**2.3.2 register**
+����������
+PeerAwareInstanceRegistryImpl�����ϵͼ�������ϵͼ���Կ�����PeerAwareInstanceRegistry�����ӿ�ΪLeaseManager��LookupService,
+
+*   ����LookupService������������ķ���ʾ������Ϊ
+*   LeaseManager�����˴����ͻ���ע�ᣬ��Լ��ע���Ȳ���
+
+![SpringCloudϵ�С�Spring Cloud Դ�����֮Eureka-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/897d97d444664479bda0430417ec683f1f079a.jpg "SpringCloudϵ�С�Spring Cloud Դ�����֮Eureka-��Դ������������")�� addInstance �����У����յ��õ���
+PeerAwareInstanceRegistryImpl.register ������
+
+* leaseDuration ��ʾ��Լ����ʱ�䣬Ĭ����90s��Ҳ���ǵ�����˳���90sû���յ��ͻ��˵��������������޳��ýڵ�
+
+* ����super.register����ڵ�ע��
+
+* ����Ϣ���Ƶ�Eureka Server��Ⱥ�е����������ϣ�ͬ����ʵ��Ҳ�ܼ򵥣����ǻ�ü�Ⱥ�е����нڵ㣬Ȼ���������ע��
+
+
+
+  ```
+  public void register(final InstanceInfo info, final boolean isReplication) {
+      int leaseDuration = Lease.DEFAULT_DURATION_IN_SECS;
+      if (info.getLeaseInfo() != null && info.getLeaseInfo().getDurationInSecs() >0) {
+          leaseDuration = info.getLeaseInfo().getDurationInSecs(); //����ͻ������Լ�����������ʱʱ�䣬����ÿͻ��˵�ʱ��
+      }
+      super.register(info, leaseDuration, isReplication); //�ڵ�ע��
+      //���Ƶ�Eureka Server��Ⱥ�е������ڵ�
+      replicateToPeers(Action.Register, info.getAppName(), info.getId(), info,
+                       null, isReplication);
+  }
+  ```
+
+
+
+
+
+
+
+
+
+**2.3.3 AbstractInstanceRegistry.register**
+����˵��Eureka-Server�ķ���ע�ᣬʵ�����ǽ��ͻ��˴��ݹ�����ʵ�����ݱ��浽Eureka-Server�е�ConcurrentHashMap�С�
+
+
+
+```
+public void register(InstanceInfo registrant, int leaseDuration, boolean
+                     isReplication) {
+    try {
+        read.lock();
+        //��registry�л�õ�ǰʵ����Ϣ������appName
+        Map<String, Lease<InstanceInfo>> gMap =
+            registry.get(registrant.getAppName());
+        REGISTER.increment(isReplication); //����ע������������Ϣ��
+        if (gMap == null) {//�����ǰappName�ǵ�һ��ע�ᣬ���ʼ��һ��ConcurrentHashMap
+            final ConcurrentHashMap<String, Lease<InstanceInfo>> gNewMap = new
+                ConcurrentHashMap<String, Lease<InstanceInfo>>();
+            gMap = registry.putIfAbsent(registrant.getAppName(), gNewMap);
+            if (gMap == null) {
+                gMap = gNewMap;
+            }
+        }
+        //��gMap�в�ѯ�Ѿ����ڵ�Lease��Ϣ��Lease���ķ���Ϊ��Լ��ʵ�������ѷ����ṩ�ߵ�ʵ����Ϣ��װ����һ��lease�������ṩ�˶��ڸķ���ʵ������Լ����
+        Lease<InstanceInfo> existingLease = gMap.get(registrant.getId());
+        // ��instance�Ѿ������ǣ��Ϳͻ��˵�instance����Ϣ���Ƚϣ�ʱ�����µ��Ǹ���Ϊ��Чinstance��Ϣ
+        if (existingLease != null && (existingLease.getHolder() != null)) {
+            Long existingLastDirtyTimestamp =
+                existingLease.getHolder().getLastDirtyTimestamp();
+            Long registrationLastDirtyTimestamp =
+                registrant.getLastDirtyTimestamp();
+            logger.debug("Existing lease found (existing={}, provided={}",
+                         existingLastDirtyTimestamp, registrationLastDirtyTimestamp);
+            // this is a > instead of a >= because if the timestamps are equal,we still take the remote transmitted
+            // InstanceInfo instead of the server local copy.
+            if (existingLastDirtyTimestamp > registrationLastDirtyTimestamp) {
+                logger.warn("There is an existing lease and the existing lease's dirty timestamp {} is greater" +
+                            " than the one that is being registered {}",
+                            existingLastDirtyTimestamp, registrationLastDirtyTimestamp);
+                logger.warn("Using the existing instanceInfo instead of the new instanceInfo as the registrant");
+                registrant = existingLease.getHolder();
+            }
+        } else {
+            //��lease������ʱ�����뵽��δ��룬
+            synchronized (lock) {
+                if (this.expectedNumberOfClientsSendingRenews > 0) {
+                    // Since the client wants to register it, increase the number of clients sending renews
+                    this.expectedNumberOfClientsSendingRenews =
+                        this.expectedNumberOfClientsSendingRenews + 1;
+                    updateRenewsPerMinThreshold();
+                }
+            }
+            logger.debug("No previous lease information found; it is new registration");
+        }
+        //����һ��lease
+        Lease<InstanceInfo> lease = new Lease<InstanceInfo>(registrant,
+                                                            leaseDuration);
+        if (existingLease != null) {
+            // ��ԭ������Lease����Ϣʱ������serviceUpTimestamp, ��֤����������ʱ��һֱ�ǵ�һ��ע����Ǹ�
+            lease.setServiceUpTimestamp(existingLease.getServiceUpTimestamp());
+        }
+        gMap.put(registrant.getId(), lease);
+        synchronized (recentRegisteredQueue) {//���ӵ����ע��Ķ�����
+            recentRegisteredQueue.add(new Pair<Long, String>(
+                System.currentTimeMillis(),
+                registrant.getAppName() + "(" + registrant.getId() + ")"));
+        }
+        // ���ʵ��״̬�Ƿ����仯������Dz��Ҵ��ڣ��򸲸�ԭ����״̬
+        if (!InstanceStatus.UNKNOWN.equals(registrant.getOverriddenStatus())) {
+            logger.debug("Found overridden status {} for instance {}. Checking to see if needs to be add to the "
+                         + "overrides", registrant.getOverriddenStatus(),
+                         registrant.getId());
+            if (!overriddenInstanceStatusMap.containsKey(registrant.getId())) {
+                logger.info("Not found overridden id {} and hence adding it",
+                            registrant.getId());
+                overriddenInstanceStatusMap.put(registrant.getId(),
+                                                registrant.getOverriddenStatus());
+            }
+        }
+        InstanceStatus overriddenStatusFromMap =
+            overriddenInstanceStatusMap.get(registrant.getId());
+        if (overriddenStatusFromMap != null) {
+            logger.info("Storing overridden status {} from map",
+                        overriddenStatusFromMap);
+            registrant.setOverriddenStatus(overriddenStatusFromMap);
+        }
+        // Set the status based on the overridden status rules
+        InstanceStatus overriddenInstanceStatus =
+            getOverriddenInstanceStatus(registrant, existingLease, isReplication);
+        registrant.setStatusWithoutDirty(overriddenInstanceStatus);
+        // �õ�instanceStatus���ж��Ƿ���UP״̬��
+        if (InstanceStatus.UP.equals(registrant.getStatus())) {
+            lease.serviceUp();
+        }
+        // ����ע������Ϊ����
+        registrant.setActionType(ActionType.ADDED);
+        // ��Լ�����¼���У���¼��ʵ����ÿ�α仯�� ����ע����Ϣ��������ȡ
+        recentlyChangedQueue.add(new RecentlyChangedItem(lease));
+        registrant.setLastUpdatedTimestamp();
+        //�û���ʧЧ
+        invalidateCache(registrant.getAppName(), registrant.getVIPAddress(),
+                        registrant.getSecureVipAddress());
+        logger.info("Registered instance {}/{} with status {} (replication={})",
+                    registrant.getAppName(), registrant.getId(),
+                    registrant.getStatus(), isReplication);
+    } finally {
+        read.unlock();
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.3.4 ��**
+���ˣ����ǾͰѷ���ע���ڿͻ��˺ͷ���˵Ĵ�����������һ����ϸ�ķ�����ʵ������Eureka Server�ˣ���ѿͻ��˵ĵ�ַ��Ϣ���浽ConcurrentHashMap�д洢�����ҷ����ṩ�ߺ�ע������֮�䣬�Ὠ��һ�����������ơ����ڼ�ط����ṩ�ߵĽ���״̬��
+
+**2.4 Eureka �Ķ༶�������**
+Eureka Server��������������(registry��readWriteCacheMap��readOnlyCacheMap)�������ע����Ϣ��Ĭ������¶�ʱ����ÿ30s��readWriteCacheMapͬ����readOnlyCacheMap��ÿ60s��������90sδ��Լ�Ľڵ㣬Eureka Clientÿ30s��readOnlyCacheMap���·���ע����Ϣ�����ͻ��˷����ע�����registry���·���ע����Ϣ��
+
+**2.4.1 �༶���������**
+����ΪʲôҪ��ƶ༶�����أ�ԭ��ܼ򵥣����ǵ����ڴ��ģ�ķ���ע��͸���ʱ�����ֻ���޸�һ��ConcurrentHashMap���ݣ���ô�Ʊ���Ϊ���Ĵ��ڵ��¾�����Ӱ�����ܡ�
+
+��Eureka����APģ�ͣ�ֻ��Ҫ�������տ��þ��С��������������õ��༶������ʵ�ֶ�д���롣ע�᷽��д��ʱ��ֱ��д�ڴ�ע�����д���֮������ʧЧ��д���档
+
+��ȡע����Ϣ�ӿ��ȴ�ֻ������ȡ��ֻ������û����ȥ��д����ȡ����д����û����ȥ�ڴ�ע�����ȡ����ֻ��ȡ���˴��ϸ��ӣ������ң���д�������»�дֻ������
+
+*   responseCacheUpdateIntervalMs �� readOnlyCacheMap ������µĶ�ʱ��ʱ������Ĭ��Ϊ30��
+*   responseCacheAutoExpirationInSeconds : readWriteCacheMap �������ʱ�䣬Ĭ��Ϊ 180 �롣
+    **2.4.2 ����ע��Ļ���ʧЧ**
+    ��AbstractInstanceRegistry.register��������󣬻����invalidateCache(registrant.getAppName(), registrant.getVIPAddress(),registrant.getSecureVipAddress()); ������ʹ�ö�д����ʧЧ��
+
+
+
+```
+public void invalidate(Key... keys) {
+    for (Key key : keys) {
+        logger.debug("Invalidating the response cache key : {} {} {} {}, {}",
+                     key.getEntityType(), key.getName(), key.getVersion(),
+                     key.getType(), key.getEurekaAccept());
+        readWriteCacheMap.invalidate(key);
+        Collection<Key> keysWithRegions = regionSpecificKeys.get(key);
+        if (null != keysWithRegions && !keysWithRegions.isEmpty()) {
+            for (Key keysWithRegion : keysWithRegions) {
+                logger.debug("Invalidating the response cache key : {} {} {} {} {}",
+                             key.getEntityType(), key.getName(),
+                             key.getVersion(), key.getType(), key.getEurekaAccept());
+                readWriteCacheMap.invalidate(keysWithRegion);
+            }
+        }
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.4.3 ��ʱͬ������**
+ResponseCacheImpl�Ĺ��췽���У�������һ����ʱ�����������ᶨʱ���д�����е����ݱ仯�����и��º�ͬ����
+
+
+
+```
+private TimerTask getCacheUpdateTask() {
+    return new TimerTask() {
+        @Override
+        public void run() {
+            logger.debug("Updating the client cache from response cache");
+            for (Key key : readOnlyCacheMap.keySet()) {
+                if (logger.isDebugEnabled()) {
+                    logger.debug("Updating the client cache from response cache for key : {} {} {} {}",
+                                 key.getEntityType(), key.getName(),
+                                 key.getVersion(), key.getType());
+                }
+                try {
+                    CurrentRequestVersion.set(key.getVersion());
+                    Value cacheValue = readWriteCacheMap.get(key);
+                    Value currentCacheValue = readOnlyCacheMap.get(key);
+                    if (cacheValue != currentCacheValue) {
+                        readOnlyCacheMap.put(key, cacheValue);
+                    }
+                } catch (Throwable th) {
+                    logger.error("Error while updating the client cache from response cache for key {}", key.toStringCompact(), th);
+                } finally {
+                    CurrentRequestVersion.remove();
+                }
+            }
+        }
+    };
+}
+```
+
+
+
+
+
+
+
+
+
+**2.5 ������Լ**
+��ν�ķ�����Լ����ʵ����һ�����������ơ��ͻ��˻ᶨ�ڷ�����������Լ����ô�򵥸���ҿ�һ�´����ʵ��
+
+**2.5.1 initScheduledTasks**
+�ͻ��˻���
+DiscoveryClient.initScheduledTasks �У�����һ���������Ķ�ʱ����
+
+
+
+```
+// Heartbeat timer
+scheduler.schedule(
+    new TimedSupervisorTask(
+        "heartbeat",
+        scheduler,
+        heartbeatExecutor,
+        renewalIntervalInSecs,
+        TimeUnit.SECONDS,
+        expBackOffBound,
+        new HeartbeatThread()
+    ),
+    renewalIntervalInSecs, TimeUnit.SECONDS);
+```
+
+
+
+
+
+
+
+
+
+**2.5.2 HeartbeatThread**
+Ȼ�������ʱ�����У���ִ��һ�� HearbeatThread ���̣߳�����̻߳ᶨʱ����renew()������Լ��
+
+
+
+```
+//ÿ��30s����һ����������
+private class HeartbeatThread implements Runnable {
+    public void run() {
+        if (renew()) {
+            lastSuccessfulHeartbeatTimestamp = System.currentTimeMillis();
+        }
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.5.3 ������յ���������Ĵ���**
+��ApplicationResource.getInstanceInfo����ӿ��У��᷵��һ��InstanceResource��ʵ�����ڸ�ʵ���£�������һ��statusUpdate�Ľӿ�������״̬
+
+
+
+```
+@Path("{id}")
+public InstanceResource getInstanceInfo(@PathParam("id") String id) {
+    return new InstanceResource(this, id, serverConfig, registry);
+}
+```
+
+
+
+
+
+
+
+
+
+**2.5.4 InstanceResource.statusUpdate()**
+�ڸ÷����У������ص��ע registry.statusUpdate ����������������
+AbstractInstanceRegistry.statusUpdate������ָ�������ṩ���ڷ���˴洢����Ϣ�еı仯��
+
+
+
+```
+@PUT
+@Path("status")
+public Response statusUpdate(
+    @QueryParam("value") String newStatus,
+    @HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication,
+    @QueryParam("lastDirtyTimestamp") String lastDirtyTimestamp) {
+    try {
+        if (registry.getInstanceByAppAndId(app.getName(), id) == null) {
+            logger.warn("Instance not found: {}/{}", app.getName(), id);
+            return Response.status(Status.NOT_FOUND).build();
+        }
+        boolean isSuccess = registry.statusUpdate(app.getName(), id,                      
+                                                  InstanceStatus.valueOf(newStatus), lastDirtyTimestamp,
+                                                  "true".equals(isReplication));
+        if (isSuccess) {
+            logger.info("Status updated: {} - {} - {}", app.getName(), id,
+                        newStatus);
+            return Response.ok().build();
+        } else {
+            logger.warn("Unable to update status: {} - {} - {}", app.getName(),
+                        id, newStatus);
+            return Response.serverError().build();
+        }
+    } catch (Throwable e) {
+        logger.error("Error updating instance {} for status {}", id,
+                     newStatus);
+        return Response.serverError().build();
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.5.5 AbstractInstanceRegistry.statusUpdate**
+����������У����õ�Ӧ�ö�Ӧ��ʵ���б���Ȼ�����Lease.renew()ȥ����������Լ��
+
+
+
+```
+public boolean statusUpdate(String appName, String id,
+                            InstanceStatus newStatus, String
+                            lastDirtyTimestamp,
+                            boolean isReplication) {
+    try {
+        read.lock();
+        // ����״̬�Ĵ��� ״̬ͳ��
+        STATUS_UPDATE.increment(isReplication);
+        // �ӱ������������ȡʵ����Ϣ��
+        Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
+        Lease<InstanceInfo> lease = null;
+        if (gMap != null) {
+            lease = gMap.get(id);
+        }
+        // ʵ�������ڣ���ֱ�ӷ��أ���ʾʧ��
+        if (lease == null) {
+            return false;
+        } else {
+            // ִ��һ��lease��renew������������Ҫ�Ǹ��������instance��������ʱ�䡣
+            lease.renew();
+            // ��ȡinstanceʵ����Ϣ
+            InstanceInfo info = lease.getHolder();
+            // Lease is always created with its instance info object.
+            // This log statement is provided as a safeguard, in case this invariant is violated.
+            if (info == null) {
+                logger.error("Found Lease without a holder for instance id {}",
+                             id);
+            }
+            // ��instance��Ϣ��Ϊ��ʱ������ʵ��״̬�����˱仯
+            if ((info != null) && !(info.getStatus().equals(newStatus))) {
+                // �����״̬��UP��״̬����ô����һ��serviceUp() , ��Ҫ�Ǹ��·����ע��ʱ
+                ��
+                    if (InstanceStatus.UP.equals(newStatus)) {
+                        lease.serviceUp();
+                    }
+                // ��instance Id �����״̬��ӳ����Ϣ���븲�ǻ���MAP����ȥ
+                overriddenInstanceStatusMap.put(id, newStatus);
+                // Set it for transfer of overridden status to replica on
+                // ���ø���״̬��ʵ����Ϣ����ȥ
+                info.setOverriddenStatus(newStatus);
+                long replicaDirtyTimestamp = 0;
+                info.setStatusWithoutDirty(newStatus);
+                if (lastDirtyTimestamp != null) {
+                    replicaDirtyTimestamp = Long.valueOf(lastDirtyTimestamp);
+                }
+                // If the replication's dirty timestamp is more than the existing one, just update
+                // it to the replica's.
+                // ���replicaDirtyTimestamp ��ʱ�����instance��getLastDirtyTimestamp() ,�����
+
+                if (replicaDirtyTimestamp > info.getLastDirtyTimestamp()) {
+                    info.setLastDirtyTimestamp(replicaDirtyTimestamp);
+                }
+                info.setActionType(ActionType.MODIFIED);
+                recentlyChangedQueue.add(new RecentlyChangedItem(lease));
+                info.setLastUpdatedTimestamp();
+                //�������
+                invalidateCache(appName, info.getVIPAddress(),
+                                info.getSecureVipAddress());
+            }
+            return true;
+        }
+    } finally {
+        read.unlock();
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+���ˣ�������Լ���ܾͷ�������ˡ�
+
+**2.6 ������**
+���Ǽ������о�����ķ��ֹ��̣����ǿͻ�����Ҫ�ܹ�������������
+
+��������ʱ���ȡָ�������ṩ�ߵĵ�ַ�б�
+Eureka server�˵�ַ�����仯ʱ����Ҫ��̬��֪
+**2.6.1 DiscoveryClient����ʱ��ѯ**
+���췽���У������ǰ�Ŀͻ���Ĭ�Ͽ�����fetchRegistry������eureka-server����ȡ���ݡ�
+
+
+
+```
+DiscoveryClient(ApplicationInfoManager applicationInfoManager,
+                EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args,
+                Provider<BackupRegistry> backupRegistryProvider,
+                EndpointRandomizer endpointRandomizer) {
+    if (clientConfig.shouldFetchRegistry() && !fetchRegistry(false)) {
+        fetchRegistryFromBackup();
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.6.2 fetchRegistry**
+
+
+
+```
+private boolean fetchRegistry(boolean forceFullRegistryFetch) {
+    Stopwatch tracer = FETCH_REGISTRY_TIMER.start();
+    try {
+        // If the delta is disabled or if it is the first time, get all
+        // applications
+        Applications applications = getApplications();
+        if (clientConfig.shouldDisableDelta()
+            ||
+            (!Strings.isNullOrEmpty(clientConfig.getRegistryRefreshSingleVipAddress()))
+            || forceFullRegistryFetch
+            || (applications == null)
+            || (applications.getRegisteredApplications().size() == 0)
+            || (applications.getVersion() == -1)) //Client application does not have latest library supporting delta
+        {
+            logger.info("Disable delta property : {}",
+                        clientConfig.shouldDisableDelta());
+            logger.info("Single vip registry refresh property : {}",
+                        clientConfig.getRegistryRefreshSingleVipAddress());
+            logger.info("Force full registry fetch : {}",
+                        forceFullRegistryFetch);
+            logger.info("Application is null : {}", (applications == null));
+            logger.info("Registered Applications size is zero : {}",
+                        (applications.getRegisteredApplications().size() == 0));
+            logger.info("Application version is -1: {}",
+                        (applications.getVersion() == -1));
+            getAndStoreFullRegistry();
+        } else {
+            getAndUpdateDelta(applications);
+        }
+        applications.setAppsHashCode(applications.getReconcileHashCode());
+        logTotalInstances();
+    } catch (Throwable e) {
+        logger.error(PREFIX + "{} - was unable to refresh its cache! status = {}", appPathIdentifier, e.getMessage(), e);
+        return false;
+    } finally {
+        if (tracer != null) {
+            tracer.stop();
+        }
+    }
+    // Notify about cache refresh before updating the instance remote status
+    onCacheRefreshed();
+    // Update remote status based on refreshed data held in the cache
+    updateInstanceRemoteStatus();
+    // registry was fetched successfully, so return true
+    return true;
+}
+```
+
+
+
+
+
+
+
+
+
+**2.6.3 ��ʱˢ�±��ص�ַ�б�**
+����ÿ��30s����һ��
+��DiscoveryClient�����ʱ�򣬻��ʼ��һЩ���������ǰ�����Ƿ������ˡ�������һ������̬���±��ط����ַ�б����� cacheRefreshTask ��
+
+�����������ִ�е���CacheRefreshThread����̡߳�����һ��������ִ�е����񣬾�����������һ�¡�
+
+
+
+```
+private void initScheduledTasks() {
+    if (clientConfig.shouldFetchRegistry()) {
+        // registry cache refresh timer
+        int registryFetchIntervalSeconds =
+            clientConfig.getRegistryFetchIntervalSeconds();
+        int expBackOffBound =
+            clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
+        cacheRefreshTask = new TimedSupervisorTask(
+            "cacheRefresh",
+            scheduler,
+            cacheRefreshExecutor,
+            registryFetchIntervalSeconds,
+            TimeUnit.SECONDS,
+            expBackOffBound,
+            new CacheRefreshThread()
+        );
+        scheduler.schedule(
+            cacheRefreshTask,
+            registryFetchIntervalSeconds, TimeUnit.SECONDS);
+    }
+```
+
+
+
+
+
+
+
+
+
+**2.6.4 TimedSupervisorTask**
+�������Ͽ���TimedSupervisorTask�ǹ̶����������������һ��������ʱ�ͻὫ��һ�����ڵļ��ʱ��������������ʱ����ôÿ�μ��ʱ�䶼������һ����һֱ�����ⲿ�����趨������Ϊֹ��һ���������ٳ�ʱ�����ʱ���ֻ��Զ��ָ�Ϊ��ʼֵ��������ƻ���ֵ��ѧϰ�ġ�
+
+
+
+```
+public void run() {
+      Future future = null;
+  try {
+    //ʹ��Future�������趨���̵߳ij�ʱʱ�䣬������ǰ�߳̾Ͳ������޵ȴ���
+    future = executor.submit(task);
+    threadPoolLevelGauge.set((long) executor.getActiveCount());
+    //ָ���ȴ����̵߳��ʱ��
+    future.get(timeoutMillis, TimeUnit.MILLISECONDS);  // block until done or timeout
+    //delay�Ǹ������õı�����������õ�������ǵ�ÿ��ִ������ɹ����Ὣdelay����
+    delay.set(timeoutMillis);
+    threadPoolLevelGauge.set((long) executor.getActiveCount());
+ } catch (TimeoutException e) {
+    logger.error("task supervisor timed out", e);
+    timeoutCounter.increment();
+    long currentDelay = delay.get();
+    //�����̳߳�ʱ��ʱ�򣬾Ͱ�delay���������������ᳬ���ⲿ����ʱ�趨�������ʱʱ��
+    long newDelay = Math.min(maxDelay, currentDelay * 2);
+    //����Ϊ���µ�ֵ�����ǵ����̣߳���������CAS
+    delay.compareAndSet(currentDelay, newDelay);
+ } catch (RejectedExecutionException e) {
+    //һ���̳߳ص����������з����˴��������񣬴����˾ܾ����ԣ��ͻὫ������ͣ��
+    if (executor.isShutdown() || scheduler.isShutdown()) {
+      logger.warn("task supervisor shutting down, reject the task", e);
+   } else {
+      logger.error("task supervisor rejected the task", e);
+   }
+    rejectedCounter.increment();
+ } catch (Throwable e) {
+    //һ������δ֪���쳣����ͣ��������
+    if (executor.isShutdown() || scheduler.isShutdown()) {
+      logger.warn("task supervisor shutting down, can't accept the task");
+   } else {
+      logger.error("task supervisor threw an exception", e);
+   }
+    throwableCounter.increment();
+ } finally {
+    //��������Ҫôִ����ϣ�Ҫô�����쳣������cancel��������������
+    if (future != null) {
+      future.cancel(true);
+   }
+    //ֻҪ������û��ֹͣ������ָ���ȴ�ʱ��֮����ִ��һ��ͬ��������
+    if (!scheduler.isShutdown()) {
+      //������������������ԭ��ֻҪû��ֹͣ�����������ٴ���һ��������ִ��ʱ��ʱdealy��ֵ��
+      //�����ⲿ����ʱ����ij�ʱʱ��Ϊ30�루���췽�������timeout���������ʱ��Ϊ50��(���췽�������expBackOffBound)
+      //������һ������û�г�ʱ����ô����30���ʼ������
+      //������һ������ʱ�ˣ���ô����50���ʼ�������쳣�������и����Զ��IJ��������Զ����60�볬���������50�룩
+      scheduler.schedule(this, delay.get(), TimeUnit.MILLISECONDS);
+   }
+ }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.6.5 refreshRegistry**
+��δ�����Ҫ�����߼�
+
+* �ж�remoteRegions�Ƿ����˱仯
+
+* ����fetchRegistry��ȡ���ط����ַ����
+
+
+
+  ```
+  @VisibleForTesting
+  void refreshRegistry() {
+      try {
+          boolean isFetchingRemoteRegionRegistries =
+              isFetchingRemoteRegionRegistries();
+          boolean remoteRegionsModified = false;
+          //���������aws�����ϣ����ж����һ��Զ��������µ���Ϣ�͵�ǰԶ��������Ϣ���бȽϣ��������ȣ������
+          String latestRemoteRegions =
+              clientConfig.fetchRegistryForRemoteRegions();
+          if (null != latestRemoteRegions) {
+              String currentRemoteRegions = remoteRegionsToFetch.get();
+              if (!latestRemoteRegions.equals(currentRemoteRegions)) {
+                  //�ж����һ��
+              }
+              boolean success = fetchRegistry(remoteRegionsModified);
+              if (success) {
+                  registrySize = localRegionApps.get().size();
+                  lastSuccessfulRegistryFetchTimestamp =
+                      System.currentTimeMillis();
+              }
+              // ʡ��
+          } catch (Throwable e) {
+              logger.error("Cannot fetch registry from server", e);
+          }
+      }
+  ```
+
+
+
+
+
+
+
+
+
+**2.6.6 fetchRegistry**
+
+
+
+  ```
+  private boolean fetchRegistry(boolean forceFullRegistryFetch) {
+      Stopwatch tracer = FETCH_REGISTRY_TIMER.start();
+      try {
+          // If the delta is disabled or if it is the first time, get all
+          // applications
+          // ȡ�����ػ���ķ����б���Ϣ
+          Applications applications = getApplications();
+          //�ж϶��������ȷ���Ƿ񴥷�ȫ�����£�������һ�����㶼��ȫ�����£�
+          //1\. �Ƿ�����������£�
+          //2\. �Ƿ��ij��region�ر��ע��
+          //3\. �ⲿ����ʱ�Ƿ�ͨ�����ָ��ȫ�����£�
+          //4\. ���ػ�δ������Ч�ķ����б���Ϣ��
+          if (clientConfig.shouldDisableDelta()
+              ||
+              (!Strings.isNullOrEmpty(clientConfig.getRegistryRefreshSingleVipAddress()))
+              || forceFullRegistryFetch
+              || (applications == null)
+              || (applications.getRegisteredApplications().size() == 0)
+              || (applications.getVersion() == -1)) //Client application does not
+              have latest library supporting delta
+          {
+              //����ȫ������
+              getAndStoreFullRegistry();
+          } else {
+              //������������
+              getAndUpdateDelta(applications);
+          }
+          //���¼��������һ����hash��
+          applications.setAppsHashCode(applications.getReconcileHashCode());
+          logTotalInstances(); //��־��ӡ����Ӧ�õ�����ʵ����֮��
+      } catch (Throwable e) {
+          logger.error(PREFIX + "{} - was unable to refresh its cache! status = {}", appPathIdentifier, e.getMessage(), e);
+          return false;
+      } finally {
+          if (tracer != null) {
+              tracer.stop();
+          }
+      }
+      //�����ػ�����µ��¼��㲥��������ע��ļ�������ע��÷����ѱ�CloudEurekaClient����д
+      onCacheRefreshed();
+      // Update remote status based on refreshed data held in the cache
+      //���ոո��µĻ����У�������Eureka server�ķ����б������а����˵�ǰӦ�õ�״̬��
+      //��ǰʵ���ij�Ա����lastRemoteInstanceStatus����¼�������һ�θ��µĵ�ǰӦ��״̬��
+      //��������״̬��updateInstanceRemoteStatus���������Ƚ� �������һ�£��͸���lastRemoteInstanceStatus�����ҹ㲥��Ӧ���¼�
+      updateInstanceRemoteStatus();
+      // registry was fetched successfully, so return true
+      return true;
+  }
+  ```
+
+
+
+
+
+
+
+
+
+**2.6.7 getAndStoreFullRegistry**
+��eureka server�˻�ȡ����ע�����ĵĵ�ַ��Ϣ��Ȼ����²����õ����ػ��� localRegionApps ��
+
+
+
+```
+private void getAndStoreFullRegistry() throws Throwable {
+    long currentUpdateGeneration = fetchRegistryGeneration.get();
+    logger.info("Getting all instance registry info from the eureka server");
+    Applications apps = null;
+    EurekaHttpResponse<Applications> httpResponse =
+        clientConfig.getRegistryRefreshSingleVipAddress() == null
+        ? eurekaTransport.queryClient.getApplications(remoteRegionsRef.get())
+        :
+    eurekaTransport.queryClient.getVip(clientConfig.getRegistryRefreshSingleVipAddre
+                                       ss(), remoteRegionsRef.get());
+    if (httpResponse.getStatusCode() == Status.OK.getStatusCode()) {
+        apps = httpResponse.getEntity();
+    }
+    logger.info("The response status is {}", httpResponse.getStatusCode());
+    if (apps == null) {
+        logger.error("The application is null for some reason. Not storing this information");
+    } else if (fetchRegistryGeneration.compareAndSet(currentUpdateGeneration,
+                                                     currentUpdateGeneration + 1)) {
+        localRegionApps.set(this.filterAndShuffle(apps));
+        logger.debug("Got full registry with apps hashcode {}",
+                     apps.getAppsHashCode());
+    } else {
+        logger.warn("Not updating applications as another thread is updating it already");
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.6.8 ����˲�ѯ�����ַ����**
+ǰ������֪�����ͻ��˷�������ַ�IJ�ѯ�����֣�һ����ȫ������һ��������������ȫ����ѯ�����󣬻����Eureka-server��ApplicationsResource��getContainers������
+
+�������������󣬻����
+ApplicationsResource.getContainerDifferential��
+
+**2.6.9 ApplicationsResource.getContainers**
+���տͻ��˷��͵Ļ�ȡȫ��ע����Ϣ����
+
+
+
+```
+@GET
+public Response getContainers(@PathParam("version") String version,
+                              @HeaderParam(HEADER_ACCEPT) String acceptHeader,
+                              @HeaderParam(HEADER_ACCEPT_ENCODING) String
+                              acceptEncoding,
+                              @HeaderParam(EurekaAccept.HTTP_X_EUREKA_ACCEPT)
+                              String eurekaAccept,
+                              @Context UriInfo uriInfo,
+                              @Nullable @QueryParam("regions") String
+                              regionsStr) {
+    boolean isRemoteRegionRequested = null != regionsStr &&
+        !regionsStr.isEmpty();
+    String[] regions = null;
+    if (!isRemoteRegionRequested) {
+        EurekaMonitors.GET_ALL.increment();
+    } else {
+        regions = regionsStr.toLowerCase().split(",");
+        Arrays.sort(regions); // So we don't have different caches for same regions queried in different order.
+        EurekaMonitors.GET_ALL_WITH_REMOTE_REGIONS.increment();
+    }
+    // EurekaServer�޷��ṩ���񣬷���403
+    if (!registry.shouldAllowAccess(isRemoteRegionRequested)) {
+        return Response.status(Status.FORBIDDEN).build();
+    }
+    CurrentRequestVersion.set(Version.toEnum(version));
+    KeyType keyType = Key.KeyType.JSON;// ���÷������ݸ�ʽ��Ĭ��JSON
+    String returnMediaType = MediaType.APPLICATION_JSON;
+    if (acceptHeader == null || !acceptHeader.contains(HEADER_JSON_VALUE)) {
+        // ������յ�������ͷ��û�о����ʽ��Ϣ���򷵻ظ�ʽΪXML
+        keyType = Key.KeyType.XML;
+        returnMediaType = MediaType.APPLICATION_XML;
+    }
+    // ���������
+    Key cacheKey = new Key(Key.EntityType.Application,
+                           ResponseCacheImpl.ALL_APPS,
+                           keyType, CurrentRequestVersion.get(),
+                           EurekaAccept.fromString(eurekaAccept), regions
+                          );
+    // ���ز�ͬ�ı������͵����ݣ�ȥ������ȡ���ݵķ�������һ��
+    Response response;
+    if (acceptEncoding != null && acceptEncoding.contains(HEADER_GZIP_VALUE)) {
+        response = Response.ok(responseCache.getGZIP(cacheKey))
+            .header(HEADER_CONTENT_ENCODING, HEADER_GZIP_VALUE)
+            .header(HEADER_CONTENT_TYPE, returnMediaType)
+            .build();
+    } else {
+        response = Response.ok(responseCache.get(cacheKey))
+            .build();
+    }
+    CurrentRequestVersion.remove();
+    return response;
+}
+```
+
+
+
+
+
+
+
+
+
+**2.6.10 responseCache.getGZIP**
+�ӻ����ж�ȡ���ݡ�
+
+
+
+```
+public byte[] getGZIP(Key key) {
+    Value payload = getValue(key, shouldUseReadOnlyResponseCache);
+    if (payload == null) {
+        return null;
+    }
+    return payload.getGzipped();
+}
+Value getValue(final Key key, boolean useReadOnlyCache) {
+    Value payload = null;
+    try {
+        if (useReadOnlyCache) {
+            final Value currentPayload = readOnlyCacheMap.get(key);
+            if (currentPayload != null) {
+                payload = currentPayload;
+            } else {
+                payload = readWriteCacheMap.get(key);
+                readOnlyCacheMap.put(key, payload);
+            }
+        } else {
+            payload = readWriteCacheMap.get(key);
+        }
+    } catch (Throwable t) {
+        logger.error("Cannot get value for key : {}", key, t);
+    }
+    return payload;
+}
+```
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudGateway\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudGateway\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..80db850
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudGateway\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,415 @@
+**ѧϰĿ��**
+
+1.  Gateway����ԭ������
+    **��1�� Bean��׼��**
+    ǰ��Ҳ������ô������ˣ��������Ǽ���
+    spring-cloud-starter-gateway������֣�����һ��starter�����������˵����ȥ��spring.factories�ļ�������һ������Щ��Ҫ��bean���Զ�װ���IoC���������ˡ�
+
+![SpringCloudϵ�С�Spring Cloud Դ�����֮Gateway����-��Դ������������](https://dl-harmonyos.51cto.com/images/202207/788f3c1494307a2ad7d935811c9e62bab2c435.jpg "SpringCloudϵ�С�Spring Cloud Դ�����֮Gateway����-��Դ������������")1.������
+GatewayClassPathWarningAutoConfiguration���������
+
+
+
+```
+@Configuration(proxyBeanMethods = false)
+//��ǰ��������GatewayAutoConfiguration�������������֮ǰ����
+@AutoConfigureBefore(GatewayAutoConfiguration.class)
+public class GatewayClassPathWarningAutoConfiguration {
+	...      
+	@Configuration(proxyBeanMethods = false)
+	@ConditionalOnClass(name = "org.springframework.web.servlet.DispatcherServlet")
+	protected static class SpringMvcFoundOnClasspathConfiguration {
+		public SpringMvcFoundOnClasspathConfiguration() {
+			log.warn(BORDER
+					+ "Spring MVC found on classpath, which is incompatible with Spring Cloud Gateway at this time. "
+					+ "Please remove spring-boot-starter-web dependency." + BORDER);
+		}
+
+	}
+	@Configuration(proxyBeanMethods = false)
+	@ConditionalOnMissingClass("org.springframework.web.reactive.DispatcherHandler")
+	protected static class WebfluxMissingFromClasspathConfiguration {
+
+		public WebfluxMissingFromClasspathConfiguration() {
+			log.warn(BORDER + "Spring Webflux is missing from the classpath, "
+					+ "which is required for Spring Cloud Gateway at this time. "
+					+ "Please add spring-boot-starter-webflux dependency." + BORDER);
+		}
+	}
+}
+```
+
+
+
+
+
+
+
+
+
+������������ܿ���������ʵ���Ͼ�ͨ��ConditionOnClass��ConditionOnMissingClass��������������־��ӡ�Ĺ��ܣ����ClassPath����
+org.springframework.web.servlet.DispatcherServlet��Ļ�����ʵ����һ��Bean����Ȼ���ӡ��־����������spring-boot-starter-web�������Ȼ���ټ��ClassPath���Ƿ�����ȷ������webflux�����û�У����ӡ��־����spring-boot-starter-webflux������
+
+2.����������GatewayAutoConfiguration
+
+��Ϊ����̫��������Ͳ�չʾ�ˣ�������оټ����Ƚ���Ҫ��
+
+*   PropertiesRouteDefinitionLocator�����ڴ������ļ���yml/properties���ж�ȡ·��������Ϣ��
+*   RouteDefinitionLocator���� RouteDefinition ת��Ϊ Route
+*   RoutePredicateHandlerMapping�������� mvc ��HandlerMapping������������ Gatewayʵ�ֵġ�����ƥ���Ӧ������route
+*   GatewayProperties��yml������Ϣ��װ�� GatewayProperties ������
+*   AfterRoutePredicateFactory������·�ɶ��Թ�����������Щ���Թ���������ʱ�Ѿ����ɶ�Ӧ��bean�����Dzſ����� yml ������һ�£�������Ч
+*   RetryGatewayFilterFactory������ Gateway ��������������Щ������������ʱ�Ѿ����ɶ�Ӧ��bean�����Dzſ����� yml ������һ�£�������Ч
+*   GlobalFilterʵ���ࣺȫ�ֹ�����
+
+3.HttpHandlerAutoConfiguration��WebFluxAutoConfiguration�����࣬��GatewayAutoConfiguration֮��ʵ�������ֱ�ʵ������HttpHandler��WebFluxConfigBean
+
+**��2�� ִ������**
+��һ���н���Hystrix��ԭ������Hystrix�к���ҵ���߼�����ͨ����Ӧʽ�����ɵģ���ʵ�ϣ���Gateway��Ҳ���ǻ���ͬ���ı�̷��ͬ���ģ�Gateway������ͬSpringMVC����Ҳ�dz����ơ�
+
+��ǰ�������������ʱ�򣬴�����������£�
+
+1.  ���ȱ�DispatcherHandler���������أ�Ȼ��������URI���н���
+2.  Ȼ�����URIȥ����HandlerMapping����ȡ����Ҫִ�е�WebHandler
+3.  Ȼ��ѡ��һ�����ʵ�������HandlerAdapterִ��
+4.  ִ��WebHandler
+    ������gateway����ʱ�����е����󶼻���뵽DispatcherHandler�е�handle��������������һ�𿴿��������
+
+
+
+```
+@Override
+public Mono<Void> handle(ServerWebExchange exchange) {
+    if (this.handlerMappings == null) {
+        return createNotFoundError();
+    }
+    //�������webFlux����Ӧʽ���
+    return Flux
+        // 1.������DZ������е� handlerMapping
+        .fromIterable(this.handlerMappings)
+        // 2.��ȡ��Ӧ��handlerMapping �����糣�õ� RequestMappingHandlerMapping��RoutePredicateHandlerMapping
+        .concatMap(mapping -> mapping.getHandler(exchange))
+        .next()
+        .switchIfEmpty(createNotFoundError())
+        // 3.��ȡ��Ӧ�������������ö�Ӧ�Ĵ�����
+        .flatMap(handler -> invokeHandler(exchange, handler))
+        // 4.���ش������
+        .flatMap(result -> handleResult(exchange, result));
+}
+```
+
+
+
+
+
+
+
+
+
+**2.1 getHandler**
+������������getHandler������������Gateway�ĺ����߼����ڣ���getHandler�л�ȡ��Ӧ��HandlerMapping��
+
+������
+AbstractHandlerMapping.getHandler��Դ��
+
+
+
+```
+@Override
+public Mono<Object> getHandler(ServerWebExchange exchange) {
+    //��һ�����ȡ·�ɵ�ʵ���࣬����뵽RoutePredicateHandlerMapping
+    return getHandlerInternal(exchange).map(handler -> {
+        if (logger.isDebugEnabled()) {
+            logger.debug(exchange.getLogPrefix() + "Mapped to " + handler);
+        }
+        ServerHttpRequest request = exchange.getRequest();
+        if (hasCorsConfigurationSource(handler) || CorsUtils.isPreFlightRequest(request)) {
+            CorsConfiguration config = (this.corsConfigurationSource != null ? this.corsConfigurationSource.getCorsConfiguration(exchange) : null);
+            CorsConfiguration handlerConfig = getCorsConfiguration(handler, exchange);
+            config = (config != null ? config.combine(handlerConfig) : handlerConfig);
+            if (!this.corsProcessor.process(config, exchange) || CorsUtils.isPreFlightRequest(request)) {
+                return REQUEST_HANDLED_HANDLER;
+            }
+        }
+        return handler;
+    });
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+@Override
+protected Mono<?> getHandlerInternal(ServerWebExchange exchange) {
+    // don't handle requests on management port if set and different than server port
+    if (this.managementPortType == DIFFERENT && this.managementPort != null
+        && exchange.getRequest().getURI().getPort() == this.managementPort) {
+        return Mono.empty();
+    }
+    exchange.getAttributes().put(GATEWAY_HANDLER_MAPPER_ATTR, getSimpleName());
+    //Ѱ�Ҳ�ƥ��·��
+    return lookupRoute(exchange)
+        // .log("route-predicate-handler-mapping", Level.FINER) //name this
+        .flatMap((Function<Route, Mono<?>>) r -> {
+            //�Ƴ��������оɵ�����
+            exchange.getAttributes().remove(GATEWAY_PREDICATE_ROUTE_ATTR);
+            if (logger.isDebugEnabled()) {
+                logger.debug(
+                    "Mapping [" + getExchangeDesc(exchange) + "] to " + r);
+            }
+            //�Ѹ�·���������İ󶨣��������ؾ������
+            exchange.getAttributes().put(GATEWAY_ROUTE_ATTR, r);
+            //���� webHandler
+            return Mono.just(webHandler);
+        }).switchIfEmpty(Mono.empty().then(Mono.fromRunnable(() -> {
+        exchange.getAttributes().remove(GATEWAY_PREDICATE_ROUTE_ATTR);
+        if (logger.isTraceEnabled()) {
+            logger.trace("No RouteDefinition found for ["
+                         + getExchangeDesc(exchange) + "]");
+        }
+    })));
+}
+```
+
+
+
+
+
+
+
+
+
+����lookupRoute�������ҵ�yml�����õ����е�·�ɶ��Թ�����Before��After��Path�ȵȣ�����ִ��apply����������·��ƥ�䣬�ж��Ƿ���������ͨ����ִ��˳����springboot�Զ�����ʱ�Լ��ƶ�
+
+
+
+```
+protected Mono<Route> lookupRoute(ServerWebExchange exchange) {
+    // getRoutes ��ȡ���еĶ��Թ���
+    return this.routeLocator.getRoutes()
+        .concatMap(route -> Mono.just(route).filterWhen(r -> {
+            exchange.getAttributes().put(GATEWAY_PREDICATE_ROUTE_ATTR, r.getId());
+            // �Ȼ�ȡRoute�ڲ���predicate����
+            //Ȼ�����apply���� ִ�ж��ԣ��ж������Ƿ�ͨ��
+            return r.getPredicate().apply(exchange);
+        }).doOnError(e -> logger.error(
+                       "Error applying predicate for route: " + route.getId(),
+                       e))
+                   .onErrorResume(e -> Mono.empty()))
+        .next()
+        .map(route -> {
+            if (logger.isDebugEnabled()) {
+                logger.debug("Route matched: " + route.getId());
+            }
+            validateRoute(route, exchange);
+            return route;
+        });
+}
+```
+
+
+
+
+
+
+
+
+
+����getRoutes()��������ͨ��
+RouteDefinitionRouteLocator�������ļ��л�ȡ����·�ɵģ�Ȼ����ҵ���·��ת����Route
+
+
+
+```
+@Override
+public Flux<Route> getRoutes() {
+    // getRouteDefinitions() �������ļ��л�ȡ����·��
+    Flux<Route> routes = this.routeDefinitionLocator.getRouteDefinitions()
+        // convertToRoute()�����ҵ���·��ת����Route
+        .map(this::convertToRoute);
+    ...
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+public class Route implements Ordered {
+	private final String id;
+	private final URI uri;
+	private final int order;
+	private final AsyncPredicate<ServerWebExchange> predicate;
+	private final List<GatewayFilter> gatewayFilters;
+	private final Map<String, Object> metadata;	
+    ...
+}
+```
+
+
+
+
+
+
+
+
+
+**2.2 invokeHandler**
+Gateway��������һ��ƥ��·�ɺ󷵻ص���webHandler���͵ģ�����Ҳ��Ҫ�ҵ���Ӧ��HandlerAdaptor�������ȡ��Ӧ������������ invokeHandler(exchange, handler)��
+
+
+
+```
+private Mono<HandlerResult> invokeHandler(ServerWebExchange exchange, Object handler) {
+    if (this.handlerAdapters != null) {
+        //�ҵ����е�HandlerAdapterȥƥ��WebFlux����
+        for (HandlerAdapter handlerAdapter : this.handlerAdapters) {
+            if (handlerAdapter.supports(handler)) {
+                return handlerAdapter.handle(exchange, handler);
+            }
+        }
+    }
+    return Mono.error(new IllegalStateException("No HandlerAdapter: " + handler));
+}
+```
+
+
+
+
+
+
+
+
+
+SimpleHandlerAdapter �е�handle��������
+
+
+
+```
+@Override
+public Mono<HandlerResult> handle(ServerWebExchange exchange, Object handler) {
+    //����WebHandler ����
+    WebHandler webHandler = (WebHandler) handler;
+    Mono<Void> mono = webHandler.handle(exchange);
+    return mono.then(Mono.empty());
+}
+```
+
+
+
+
+
+
+
+
+
+����webHandler.handle�������Ǵ������й��������ķ������ù�����������globalFilters��gatewayFilters
+
+
+
+```
+@Override
+public Mono<Void> handle(ServerWebExchange exchange) {
+    // 1\. ����·���������İ󶨹�ϵ����ȡ��Ӧ��·��Route
+    Route route = exchange.getRequiredAttribute(GATEWAY_ROUTE_ATTR);
+    List<GatewayFilter> gatewayFilters = route.getFilters();
+    // 2\. �ռ����е� globalFilters ������List<GatewayFilter>
+    //ע������ʹ����������ģʽ
+    List<GatewayFilter> combined = new ArrayList<>(this.globalFilters);
+    // 3\. �� gatewayFilters Ҳ����List<GatewayFilter>���γ�һ������������
+    combined.addAll(gatewayFilters);
+    // 4\. ����order����
+    AnnotationAwareOrderComparator.sort(combined);
+    if (logger.isDebugEnabled()) {
+        logger.debug("Sorted gatewayFilterFactories: " + combined);
+    }
+    // 5\. ִ�й��������е�ÿһ��������������
+    return new DefaultGatewayFilterChain(combined).filter(exchange);
+}
+```
+
+
+
+
+
+
+
+
+
+ע�⣺����װ����������ʱ���ǰ�globalFilters��gatewayFilters���ֹ��������Ž���List<GatewayFilter>�У�������ô�����أ�
+
+����ʵ�õ���һ�� ������ �����ģʽ��
+
+*   ����������globalFilters�����Ȱ�globalFiltersת����GatewayFilterAdapter�� GatewayFilterAdapter���ڲ�������GlobalFilter��ͬʱҲʵ����GatewayFilter��ʹ globalFilters��gatewayFilters�� ������ ��GatewayFilterAdapter�й��棡
+*   ����������gatewayFilters��ֱ�ӷ��뼴�ɣ�
+    **��3�� ���ؾ�������**
+    Gateway�ĸ��ؾ���ֻ��Ҫ��yml������ uri: lb://user����ʵ�ָ��ؾ��⣬�ײ�����ȫ�ֹ�����LoadBalancerClientFilter��filter����ȥ���ģ�
+
+�Զ��������
+http://localhost:9527/get/3Ϊ����9527Ϊ����Gateway�Ķ˿�
+
+
+
+```
+public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
+    // 1\. ����·���������İ󶨹�ϵ
+    // ��ȡԭʼ��url��http://localhost:9527/get/3
+    URI url = exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR);
+    String schemePrefix = exchange.getAttribute(GATEWAY_SCHEME_PREFIX_ATTR);
+    if (url == null
+        || (!"lb".equals(url.getScheme()) && !"lb".equals(schemePrefix))) {
+        return chain.filter(exchange);
+    }
+    addOriginalRequestUrl(exchange, url);
+    if (log.isTraceEnabled()) {
+        log.trace("LoadBalancerClientFilter url before: " + url);
+    }
+    // 2\. ͨ��ribbon�ĸ��ؾ����㷨�����ݷ�����ȥnacos����Eurekaѡ��һ��ʵ����
+    // ��ʵ������user���������� url ��ַ��http://localhost:8080/get/3
+    final ServiceInstance instance = choose(exchange);
+    if (instance == null) {
+        throw NotFoundException.create(properties.isUse404(),
+                                       "Unable to find instance for " + url.getHost());
+    }
+    // 3\. �õ�ԭ���� uri ��http://localhost:9527/get/3
+    URI uri = exchange.getRequest().getURI();
+    String overrideScheme = instance.isSecure() ? "https" : "http";
+    if (schemePrefix != null) {
+        overrideScheme = url.getScheme();
+    }
+    // 4\. �÷���ʵ��instance��uri�滻ԭ����uri��ַ �õ� �µ�url
+    // �µ�url: http://localhost:8080/get/3
+    URI requestUrl = loadBalancer.reconstructURI(
+        new DelegatingServiceInstance(instance, overrideScheme), uri);
+    if (log.isTraceEnabled()) {
+        log.trace("LoadBalancerClientFilter url chosen: " + requestUrl);
+    }
+    // 5\. �ٴμ�¼�����Ĺ�ϵ
+    exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, requestUrl);
+    // 6\. ִ�й��������е�������������
+    return chain.filter(exchange);
+}
+```
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudHystrix\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudHystrix\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..87b59fb
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudHystrix\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,1192 @@
+ѧϰĿ��
+
+1. ��дMini���Hystrix
+2. RxJava֪ʶ����
+3. Hystrix�ĺ������̷���
+4. Դ����֤
+   ��1�� ��дMini��
+   �������Ѿ�����ҽ��ܹ���Hystrix�ĺ��Ĺ��ܺ�ʹ���ˣ����޷Ǿ����ṩ���۶ϡ�����������ȹ��ܣ������۶Ϻ͸�����Ŀ�ģ������ǽ������ʹ�ù�������ʵ����ĵ�������ע�⣺@EnableHystrix��@HystrixCommand��@HystrixCollapser������ͨ��ע�� @HystrixCommand�����߼̳� HystrixCommand ��ʵ�ֽ������Լ�һЩ����ϲ��Ȳ�����
+
+����ʽ����ԭ��֮ǰ����������Ҫ��ȷһ���㣬������ @HystrixCommand ע����ʵ�ַ��񽵼�����Hystrix ���ڲ��Dz���AOP�ķ�ʽ�������ش�������ģ�������ݣ�����Ҳ����ϸ�������������������ʵ��һ�¼��װ�� Hystrix �����һ�£���Ҫ��Ϊ���²���
+
+- �����Լ���@HystrixCommand ע�⡣
+- ʵ����������Ĵ����߼���
+- ���Ե��á�
+  1.�Զ���ע��
+
+
+
+    @Target({ElementType.METHOD})
+    @Retention(RetentionPolicy.RUNTIME)
+    @Documented
+    public @interface MyHystrixCommand {
+        //Ĭ�ϳ�ʱʱ��
+        int timeout() default 1000;
+        //���˷���
+        String fallback() default "";
+    }
+
+
+
+
+
+
+
+
+
+2.�Զ���������
+
+
+
+    @Aspect  //����Aspect֧�ֲ��ұ��Ϊһ��������
+    @Component
+    public class MyHystrixCommandAspect {
+        ExecutorService executorService= Executors.newFixedThreadPool(10);
+    
+        //�����е�
+        @Pointcut(value = "@annotation(MyHystrixCommand)")
+        public void pointCut(){
+    
+        }
+        //���е㷽���⻷��ִ��  @Around�൱��@Before��@AfterReturning���ܵ��ܺ�
+        @Around(value = "pointCut()&&@annotation(hystrixCommand)")
+        public Object doPointCut(ProceedingJoinPoint joinPoint, MyHystrixCommand hystrixCommand) throws Exception {
+            int timeout=hystrixCommand.timeout();
+            Future future=executorService.submit(()->{
+                try {
+                    //ִ��proceed��������������Ŀ�귽��ִ��
+                    return joinPoint.proceed();
+                } catch (Throwable throwable) {
+                    throwable.printStackTrace();
+                }
+                return null;
+            });
+            Object rs;
+            try {
+                //ͨ��get���첽�ȴ���ʵ�ֳ�ʱ
+                rs=future.get(timeout, TimeUnit.MILLISECONDS);
+            } catch (InterruptedException | ExecutionException | TimeoutException e) {
+                future.cancel(true);
+                if(StringUtils.isBlank(hystrixCommand.fallback())){
+                    throw new Exception("fallback is null");
+                }
+                //����fallback
+                rs=invokeFallback(joinPoint,hystrixCommand.fallback());
+            }
+            return rs;
+        }
+        private Object invokeFallback(ProceedingJoinPoint joinPoint,String fallback) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
+            //��ȡ�������ķ���������Method
+            MethodSignature signature=(MethodSignature)joinPoint.getSignature(); //��ȡ������ͱ����������Ϣ
+            Method method=signature.getMethod();
+            Class<?>[] parameterTypes=method.getParameterTypes();
+            //�õ��ص�����
+            try {
+                Method fallbackMethod=joinPoint.getTarget().getClass().getMethod(fallback,parameterTypes);
+                method.setAccessible(true);
+                //ͨ������ص�
+                return fallbackMethod.invoke(joinPoint.getTarget(),joinPoint.getArgs());
+            } catch (Exception e) {
+                throw e;
+            }
+        }
+    }
+
+
+
+
+
+
+
+
+
+3.�Զ������
+
+
+
+    @RestController
+    public class MyHystrixController {
+        @Autowired
+        OrderServiceClient orderServiceClient;
+        @MyHystrixCommand(fallback = "fallback",timeout = 2000)
+        @GetMapping("/myhystrix/get/{num}")
+        public String get(@PathVariable("num") int num){
+            return orderServiceClient.orderLists(num);
+        }
+        public String fallback(int num){
+            return "�Զ���ע�ⷽ��������";
+        }
+    }
+
+
+
+
+
+
+
+
+
+������http://localhost:8080/myhystrix/get/1ʱ�ᴥ����������Ϊ�ڷ���ˣ���num=1ʱ������3s��
+
+OK���������Ǿ�ʵ����һ�����װ��HystrixCommand����������ֻ��ʵ����Hystrix�ĵ�һ����������һ��ע������棬�������ĵײ��߼�ԶԶû����ô�򵥣��ڽ�Դ��֮ǰ������������һ��RxJava��ʲô����ΪHystrix�ײ��߼��ǻ�����Ӧʽ���ʵ�ֵġ�
+
+��2�� RxJava����
+2.1 RxJava����
+RxJava ��һ����Ӧʽ��̣������������¼����첽�����⡣�����¼�������ʽ���á��߼�������ࡣ
+
+RxJava�۲���ģʽ�ĶԱ�
+
+- ��ͳ�۲�����һ�����۲��߶���۲��ߣ������۲��߷����ı�ʱ��ʱ֪ͨ���й۲���
+- RxJava��һ���۲��߶�����۲��ߣ����۲���������һ���������������ڱ��۲���֮�䳯��һ�����򴫵ݣ�ֱ�����ݸ��۲��� ��
+  ��ʵ˵���ˣ�������RxJava�д���2�ָ��һ���DZ��۲��ߣ�һ���ǹ۲��ߣ���������۲��߶�����ͬһ���۲��ߵ�ʱ����ô���ű��۲������ij���¼���ʱ��ͻ�ȥ�ص��۲��ߡ�
+
+2.2 �۲���
+
+Observer
+
+
+
+    Observer observer = new Observer() {
+        @Override
+        public void onCompleted() {
+            System.out.println("�����۲�������Complete�¼������ø÷���");
+        }
+        @Override
+        public void onError(Throwable throwable) {
+            System.out.println("��Error�¼�������Ӧ");
+        }
+        @Override
+        public void onNext(Object o) {
+            System.out.println("��Next�¼�������Ӧ:" + o);
+        }
+    };
+
+
+
+
+
+
+
+
+
+
+
+    //Subscriber�� = RxJava ���õ�һ��ʵ���� Observer �ij����࣬�� Observer �ӿڽ�������չ
+    Subscriber subscriber = new Subscriber() {
+        @Override
+        public void onCompleted() {
+            System.out.println("�����۲�������Complete�¼������ø÷���");
+        }
+        @Override
+        public void onError(Throwable throwable) {
+            System.out.println("��Error�¼�������Ӧ");
+        }
+        @Override
+        public void onNext(Object o) {
+            System.out.println("��Next�¼�������Ӧ:" + o);
+        }
+    };
+
+
+
+
+
+
+
+
+
+Subscriber ��������Observer �ӿڵ�����
+
+���߻���ʹ�÷�ʽһ�£���RxJava��subscribe�����У�Observer���ȱ�ת����Subscriber��ʹ�ã�
+Subscriber������� Observer �ӿڽ�������չ������������������
+
+- onStart()���ڻ�δ��Ӧ�¼�ǰ���ã�������һЩ��ʼ��������������subscribe ���ڵ��̵߳��ã������л��̣߳����Բ��ܽ��н���UI���±��絯����Щ��
+- unsubscribe()������ȡ�����ġ��ڸ÷��������ú󣬹۲��߽����ٽ�����Ӧ�¼���������onStop�����п��Ե��ô˷����������ġ����ø÷���ǰ����ʹ�� isUnsubscribed() �ж�״̬��ȷ�����۲���Observable�Ƿ񻹳��й۲���Subscriber�����á�
+  2.3 ���۲���
+  RxJava �ṩ�˶��ַ������� �������۲��߶���Observable�������������
+
+
+
+    // ����1��just(T...)��ֱ�ӽ�����IJ������η��ͳ���
+    Observable observable = Observable.just("A", "B", "C");
+    // �������ε��ã�
+    // onNext("A");
+    // onNext("B");
+    // onNext("C");
+    // onCompleted();
+    // ����2��fromArray(T[]) / from(Iterable<? extends T>) : ����������� / Iterable ��ֳɾ����������η��ͳ���
+    String[] words = {"A", "B", "C"};
+    Observable observable = Observable.fromArray(words);
+    // �������ε��ã�
+    // onNext("A");
+    // onNext("B");
+    // onNext("C");
+    // onCompleted();
+
+
+
+
+
+
+
+
+
+2.4 ����
+
+
+
+    observable.subscribe(observer); //�������Ĺ�ϵ
+
+
+
+
+
+
+
+
+
+2.5 ����
+
+
+
+    public class RxJavaDemo {
+        // ReactiveX Java  ��Ӧʽ��̿��(android��
+        // Java stream() java8
+        //�۲���ģʽ
+        public static void main(String[] args) throws ExecutionException, InterruptedException {
+            final String[] datas = new String[]{"�¼�1"};
+            // ����ִ����Ļص����� ��ֹ��������
+            //����Observable����ǰ�����ص���call���������������������쳣��ֹ
+            final Action0 onComplated = new Action0() {
+                @Override
+                public void call() {
+                    System.out.println("���۲���Ҫ������");
+                }
+            };
+            //���۲���
+            Observable<String> observable = Observable.defer(new Func0<Observable<String>>() {
+                @Override
+                public Observable<String> call() {
+                    Observable observable1 = Observable.from(datas);
+                    return observable1.doOnCompleted(onComplated);
+                }
+            });
+    //        Observable<String> observable = Observable.just("�¼�1","�¼�2","����");
+            //�۲���
+            Observer observer = new Observer() {
+                @Override
+                public void onCompleted() {
+                    System.out.println("��Comlate�¼�������Ӧ");
+                }
+                @Override
+                public void onError(Throwable throwable) {
+                    System.out.println("��Error�¼�������Ӧ");
+                }
+                @Override
+                public void onNext(Object o) {
+                    System.out.println("��Next�¼�������Ӧ:" + o);
+                }
+            };
+            observable.subscribe(observer); //�������Ĺ�ϵ
+    
+    //        String s = observable.toBlocking().toFuture().get();//�첽�ȴ����
+    //        System.out.println(s);
+        }
+    }
+
+
+
+
+
+
+
+
+
+OK�������ָ�����ʹ��RxJava����ˣ����������ǿ�ʼߣԴ�롣
+
+��3�� Դ�����
+���Ϲ����ṩ��Դ������ͼ����ͼ�Ͽ��Կ���������ʵ������ȥɨ�����HystrixCommandע��ķ�����Ȼ������������أ�ִ��������߼���������涨��������������execute��queue����ѡһ���е��ã�Ȼ����������������߼������������HystrixCommandע�⣬������Hystrix��@EnableHystrixע�⡣
+
+
+
+    @SpringBootApplication
+    @EnableFeignClients("com.example.clients")
+    //@EnableDiscoveryClient //ע����ʾUser����ע��
+    @EnableHystrix //ע�ⷽʽ����Hystrix
+    public class HystrixEclipseUserApplication {
+    
+        public static void main(String[] args) {
+            SpringApplication.run(HystrixEclipseUserApplication.class, args);
+        }
+    
+    }
+
+
+
+
+
+
+
+
+
+���뵽@EnableHystrixע����
+
+
+
+    @Target({ElementType.TYPE})
+    @Retention(RetentionPolicy.RUNTIME)
+    @Documented
+    @Inherited
+    @EnableCircuitBreaker
+    public @interface EnableHystrix {
+    }
+    //����@EnableHystrix�̳���@EnableCircuitBreaker
+    @Target(ElementType.TYPE)
+    @Retention(RetentionPolicy.RUNTIME)
+    @Documented
+    @Inherited
+    @Import(EnableCircuitBreakerImportSelector.class)
+    public @interface EnableCircuitBreaker {
+    }
+
+
+
+
+
+
+
+
+
+�����ⲽ���룬�����źܶ�ѧ��springboot��ͬѧ������Ϥ�ˣ������õ���Importע�⣬�ǿ϶���������һЩ�������ˣ�Ȼ�������ٽ�
+EnableCircuitBreakerImportSelector����;
+
+
+
+    @Order(Ordered.LOWEST_PRECEDENCE - 100)
+    public class EnableCircuitBreakerImportSelector
+    		extends SpringFactoryImportSelector<EnableCircuitBreaker> {
+    	@Override
+    	protected boolean isEnabled() {
+    		return getEnvironment().getProperty("spring.cloud.circuit.breaker.enabled",
+    				Boolean.class, Boolean.TRUE);
+    	}
+    }
+
+
+
+
+
+
+
+
+
+EnableCircuitBreakerImportSelector�̳���SpringFactoryImportSelector������SpringFactoryImportSelector�������������Ϥ�Ĵ��룬��ʵ����DeferredImportSelector�ӿڣ�ʵ����selectImports������selectImports������������ļ�spring.factories����ض�Ӧ���� org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker������������spring.facotries�ļ���
+
+
+
+    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+    org.springframework.cloud.netflix.hystrix.HystrixAutoConfiguration,\
+    org.springframework.cloud.netflix.hystrix.HystrixCircuitBreakerAutoConfiguration,\
+    org.springframework.cloud.netflix.hystrix.ReactiveHystrixCircuitBreakerAutoConfiguration,\
+    org.springframework.cloud.netflix.hystrix.security.HystrixSecurityAutoConfiguration
+    org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker=\
+    org.springframework.cloud.netflix.hystrix.HystrixCircuitBreakerConfiguration
+
+
+
+
+
+
+
+
+
+��ӦEnableAutoConfiguration����Щʵ������spring������ʱ��ͨ���Զ�װ����ƻ�ȥʵ��������ע�뵽IoC�����У��������Ǻ��Ĺ�ע
+HystrixCircuitBreakerConfiguration�ࡣ
+
+
+
+    @Configuration(proxyBeanMethods = false)
+    public class HystrixCircuitBreakerConfiguration {
+        //�����Ǻ��ĵ�����bean
+    	@Bean
+    	public HystrixCommandAspect hystrixCommandAspect() {
+    		return new HystrixCommandAspect();
+    	}
+    	...
+    }
+
+
+
+
+
+
+
+
+
+���뵽����������лᷢ�֣����������Ҫ���������ע����Ϊ�����@HystrixCommand��@HystrixCollapser����ִ��������ע�����εķ���ʱ���ᱻ����ִ��
+methodsAnnotatedWithHystrixCommand
+
+3.1 HystrixCommandAspect
+
+
+
+    @Aspect
+    public class HystrixCommandAspect {
+        private static final Map<HystrixPointcutType, MetaHolderFactory> META_HOLDER_FACTORY_MAP;
+        static {
+            //ͨ����̬����������ע�����������ʵ����
+            META_HOLDER_FACTORY_MAP = ImmutableMap.<HystrixPointcutType, MetaHolderFactory>builder()
+                .put(HystrixPointcutType.COMMAND, new CommandMetaHolderFactory())
+                .put(HystrixPointcutType.COLLAPSER, new CollapserMetaHolderFactory())
+                .build();
+        }
+        //���������ע��HystrixCommand
+        @Pointcut("@annotation(com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand)")
+        public void hystrixCommandAnnotationPointcut() {
+        }
+        //���������ע��HystrixCollapser������ϲ���
+        @Pointcut("@annotation(com.netflix.hystrix.contrib.javanica.annotation.HystrixCollapser)")
+        public void hystrixCollapserAnnotationPointcut() {
+        }
+        //����֪ͨ
+        @Around("hystrixCommandAnnotationPointcut() || hystrixCollapserAnnotationPointcut()")
+        public Object methodsAnnotatedWithHystrixCommand(final ProceedingJoinPoint joinPoint) throws Throwable {
+            //��ȡĿ�귽��
+            Method method = getMethodFromTarget(joinPoint);
+            Validate.notNull(method, "failed to get method from joinPoint: %s", joinPoint);
+            //ֻ����������ע���ע�ķ���
+            if (method.isAnnotationPresent(HystrixCommand.class) && method.isAnnotationPresent(HystrixCollapser.class)) {
+                throw new IllegalStateException("method cannot be annotated with HystrixCommand and HystrixCollapser " +
+                                                "annotations at the same time");
+            }
+            //���ݲ�ͬ��ע�⣬ѡ���Ӧ��metaHolderFactory, ����MetaHolder, MetaHolder ���������������Ϣ
+            MetaHolderFactory metaHolderFactory = META_HOLDER_FACTORY_MAP.get(HystrixPointcutType.of(method));
+            //��ȡĿ�귽���ĵ�Ԫ���ݣ�����ǩ����������
+            MetaHolder metaHolder = metaHolderFactory.create(joinPoint);
+            /**
+             * ����������CommandCollapser �� GenericCommand ��ͬ���� ��GenericObservableCommand���첽��
+             * GenericCommand���кܶ�super������ͨ��HystrixCommandBuilderFactory.getInstance().create(metaHolder) ������һ��HystrixCommandBuilder��ΪGenericCommad�IJ���
+             * new  GenericCommand ͨ��super��AbstractHystrixCommand��
+             * AbstractHystrixCommand ͨ��super��HystrixCommand��
+             * HystrixCommand���յ���AbstractCommand  һ·����
+             * һ����AbstractCommand�з�����
+             */
+            HystrixInvokable invokable = HystrixCommandFactory.getInstance().create(metaHolder);
+            //���ݷ���ֵ�ƶ�ִ������
+            ExecutionType executionType = metaHolder.isCollapserAnnotationPresent() ?
+                metaHolder.getCollapserExecutionType() : metaHolder.getExecutionType();
+            //���ݲ�ͬ���������ͣ�ִ��������ؽ��
+            Object result;
+            try {
+                //�Ƿ�����Ӧʽ�ģ�����������Щ����ͬ���Ļ�������߼���
+                if (!metaHolder.isObservable()) {
+                    //executeִ��
+                    result = CommandExecutor.execute(invokable, executionType, metaHolder);
+                } else {
+                    result = executeObservable(invokable, executionType, metaHolder);
+                }
+            } catch (HystrixBadRequestException e) {
+                throw e.getCause();
+            } catch (HystrixRuntimeException e) {
+                throw hystrixRuntimeExceptionToThrowable(metaHolder, e);
+            }
+            return result;
+        }
+        //HystrixCommand��ʱ��MetaHolder�Ĵ���
+        private static class CommandMetaHolderFactory extends MetaHolderFactory {
+            @Override
+            public MetaHolder create(Object proxy, Method method, Object obj, Object[] args, final ProceedingJoinPoint joinPoint) {
+                //��ȡע��HystrixCommand
+                HystrixCommand hystrixCommand = method.getAnnotation(HystrixCommand.class);
+                //���ݷ��ؽ���ƶ��������ͣ�����֪�������ַ�ʽִ��
+                ExecutionType executionType = ExecutionType.getExecutionType(method.getReturnType());
+                MetaHolder.Builder builder = metaHolderBuilder(proxy, method, obj, args, joinPoint);
+                if (isCompileWeaving()) {
+                    builder.ajcMethod(getAjcMethodFromTarget(joinPoint));
+                }
+                //����û�ж��ٲ���������Ҫ��һ��hystrixCommand������ע�������ʲô
+                return builder.defaultCommandKey(method.getName())
+                    .hystrixCommand(hystrixCommand)
+                    .observableExecutionMode(hystrixCommand.observableExecutionMode())  //ִ��ģʽ
+                    .executionType(executionType) //ִ�з�ʽ
+                    .observable(ExecutionType.OBSERVABLE == executionType)
+                    .build();
+            }
+        }
+    }
+    //��ö��ExecutionType����
+    public static ExecutionType getExecutionType(Class<?> type) {
+        if (Future.class.isAssignableFrom(type)) {
+            return ExecutionType.ASYNCHRONOUS;
+        } else if (Observable.class.isAssignableFrom(type)) {
+            return ExecutionType.OBSERVABLE;
+        } else {
+            return ExecutionType.SYNCHRONOUS;
+        }
+    }
+
+
+
+
+
+
+
+
+
+�����ص������ͬ��������ͨ���������ǿ��Կ���HystrixInvokable �� GenericCommand������ͬ����Ŀ��� CommandExecutor.execute(invokable, executionType, metaHolder)
+
+
+
+    public class CommandExecutor {
+        public static Object execute(HystrixInvokable invokable, ExecutionType executionType, MetaHolder metaHolder) throws RuntimeException {
+            Validate.notNull(invokable);
+            Validate.notNull(metaHolder);
+    
+            switch (executionType) {
+                case SYNCHRONOUS: {
+                    //�ص㿴ͬ������������Ȱ�GenericCommand ת��HystrixExecutable ��ִ��execute
+                    return castToExecutable(invokable, executionType).execute();
+                }
+                case ASYNCHRONOUS: {
+                    // ǿת��HystrixExecutable  �첽ִ��
+                    HystrixExecutable executable = castToExecutable(invokable, executionType);
+                    // ����� fallback�����������첽ִ�У���ִ�в����ذ�װ���
+                    if (metaHolder.hasFallbackMethodCommand()
+                            && ExecutionType.ASYNCHRONOUS == metaHolder.getFallbackExecutionType()) {
+                        return new FutureDecorator(executable.queue());
+                    }
+                    return executable.queue();
+                }
+                case OBSERVABLE: {
+                    // ǿת�� HystrixObservable
+                    HystrixObservable observable = castToObservable(invokable);
+                    // �ж�ִ��ģʽ�Dz��Ǽ���/���裬��ѡ��ģʽִ��
+                    return ObservableExecutionMode.EAGER == metaHolder.getObservableExecutionMode() ? observable.observe() : observable.toObservable();
+                }
+                default:
+                    throw new RuntimeException("unsupported execution type: " + executionType);
+            }
+        }
+    }
+
+
+
+
+
+
+
+
+
+���������Ҫ����ִ������Ӵ����п��Կ�������������ִ�����ͣ��ֱ���ͬ�����첽���Լ���Ӧʽ�����У���Ӧʽ�ַ�ΪCold Observable��observable.toObservable()�� �� HotObservable��observable.observe()��Ĭ�ϵ�executionType=SYNCHRONOUS ��ͬ������
+
+- execute()��ͬ��ִ�У�����һ����һ�Ķ���������������ʱ�׳��쳣��
+- queue()���첽ִ�У�����һ�� Future ���󣬰�����ִ�н����󷵻صĵ�һ�����
+- observe()�������������һ�� Observable ���������������Ķ������������Ѿ������������ѵ��ˡ�
+- toObservable()�������������һ�� Observable ���������������Ķ���������Ҫ�����Լ��ֶ����IJ����ѵ���
+  ��ͼ��ϵ���£�
+
+ͨ��GenericCommandһ�������Ϸ������ն�λ��HystrixCommand�и�execute()
+
+
+
+    public abstract class HystrixCommand<R> extends AbstractCommand<R> implements HystrixExecutable<R>, HystrixInvokableInfo<R>, HystrixObservable<R> {
+        //ͬ��ִ��
+        public R execute() {
+            try {
+                //ͨ��queue().get()��ͬ��ִ�У���װ�첽�����Ľ����
+                return queue().get();
+            } catch (Exception e) {
+                throw Exceptions.sneakyThrow(decomposeException(e));
+            }
+        }
+       //�첽ִ�У�ʲôʱ��get()���ɵ����߾�����get()��ʱ�������
+       public Future<R> queue() {
+            //���Ĵ��������ն�λ����AbstractCommand���toObservable()��
+            // toObservableת��ΪObservable,toBlockingת��ΪBlockingObservable, 
+            // toFutureת��ΪFuture,�����Observable�Ĵ����Ͷ���
+            final Future<R> delegate = toObservable().toBlocking().toFuture();   	
+            final Future<R> f = new Future<R>() {
+                .....
+                @Override
+                public R get() throws InterruptedException, ExecutionException {
+                    return delegate.get();
+                }
+                @Override
+                public R get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+                    return delegate.get(timeout, unit);
+                }       	
+            };
+            //���⴦�����£��Ѿ�ִ�����ˣ�get()Ҳ����������
+            if (f.isDone()) {
+                try {
+                    f.get();
+                    return f;
+                } catch (Exception e) {
+                    ...
+                }
+            }
+            return f;
+        }
+    }
+
+
+
+
+
+
+
+
+
+�����������У��ص����ˣ�������һ��
+java.util.concurrent.Future ��Ȼ����� get��ʱ��ί�ɸ� delegate���� delegate������ toObservable().toBlocking().toFuture(); ����������������������ô��롣�������ڵ��ص�Ӧ�÷��� toObservable() �����У�
+
+3.2 toObservable
+ͨ��Observable����һ�����۲��ߣ�������۲��߻ᱻtoObservable().toBlocking().toFuture() ��ʵ�������д���ĺ��ĺ������ȥ����һЩ�۶��߼��ж���ִ����ʵ��ҵ���߼�����ִ��fallback�Ļص�������Ȼ�󽫽�����ظ�Future������� run() ��������ִ��������ҵ���߼������������Ҫ�������¼����£�
+
+- ����һ�ѵĶ�������Ҳ��֪����Щ�����Ǹ�ɶ�ģ�����Ҫ��
+- �ж��Ƿ����˻��棬������ˣ�����Ҳ�����ˣ���ȥ����������Observable��ʽ����һ��������
+- ����һ�����۲��ߣ�������۲��ߺ����ȥ�ص���ʵҵ���߼�����fallback��
+
+�����߼���������۲��߻�ȥִ��applyHystrixSemantics����Ķ���
+
+
+
+    public Observable<R> toObservable() {
+        final AbstractCommand<R> _cmd = this;
+        // ����ִ����Ļص����� ��ֹ��������
+        //����Observable����ǰ�����ص���call���������������������쳣��ֹ
+        final Action0 terminateCommandCleanup = new Action0() {
+    		...
+        };
+        // ��������Ϊ��ȡ�����洢�ӳ٣����˱�׼������
+        //ȡ������ʱ�ļ�������лص��� call����
+        final Action0 unsubscribeCommandCleanup = new Action0() {
+            @Override
+            public void call() {
+    			...
+            }
+        };
+        // ִ������ʱ�Ļص�
+        final Func0<Observable<R>> applyHystrixSemantics = new Func0<Observable<R>>() {
+            @Override
+            public Observable<R> call() {
+                if (commandState.get().equals(CommandState.UNSUBSCRIBED)) {
+                    // ������ֹ�������̡�
+                    return Observable.never();
+                }
+                //����ִ�������Observable
+                return applyHystrixSemantics(_cmd);
+            }
+        };
+        final Func1<R, R> wrapWithAllOnNextHooks = new Func1<R, R>() {
+            @Override
+            public R call(R r) {
+    			...
+            }
+        };
+        final Action0 fireOnCompletedHook = new Action0() {
+            @Override
+            public void call() {
+    			...
+            }
+        };
+        // ����Observable,���ø��ִ�������
+        return Observable.defer(new Func0<Observable<R>>() {
+            @Override
+            public Observable<R> call() {
+                // ������������־, CAS��֤����ִֻ��һ��
+                if (!commandState.compareAndSet(CommandState.NOT_STARTED, CommandState.OBSERVABLE_CHAIN_CREATED)) {
+                    IllegalStateException ex = new IllegalStateException("This instance can only be executed once. Please instantiate a new instance.");
+                    //TODO make a new error type for this
+                    throw new HystrixRuntimeException(FailureType.BAD_REQUEST_EXCEPTION, _cmd.getClass(), getLogMessagePrefix() + " command executed multiple times - this is not permitted.", ex, null);
+                }
+                // ���ʼʱ���
+                commandStartTimestamp = System.currentTimeMillis();
+                // ��ӡ��־
+                if (properties.requestLogEnabled().get()) {
+                    // log this command execution regardless of what happened
+                    if (currentRequestLog != null) {
+                        currentRequestLog.addExecutedCommand(_cmd);
+                    }
+                }
+                // ���濪�أ�����KEY�������Hystrix�����󻺴湦�ܣ�hystrix֧�ֽ�һ������������������
+                // ��һ��������ͬkey������ֱ�Ӵӻ�����ȡ�������������������
+                final boolean requestCacheEnabled = isRequestCachingEnabled();
+                final String cacheKey = getCacheKey();
+                // ��������������棬����ͼ�ӻ����ȡ��Ĭ�� false
+                if (requestCacheEnabled) {
+                    HystrixCommandResponseFromCache<R> fromCache = (HystrixCommandResponseFromCache<R>) requestCache.get(cacheKey);
+                    if (fromCache != null) {
+                        isResponseFromCache = true;
+                        return handleRequestCacheHitAndEmitValues(fromCache, _cmd);
+                    }
+                }
+                // ����ִ�������Observable
+                // ����Observable, applyHystrixSemantics() ������Observable
+                Observable<R> hystrixObservable =
+                    Observable.defer(applyHystrixSemantics)
+                    .map(wrapWithAllOnNextHooks);
+                Observable<R> afterCache;
+                // put in cache ������������������
+                if (requestCacheEnabled && cacheKey != null) {
+                    // wrap it for caching
+                    HystrixCachedObservable<R> toCache = HystrixCachedObservable.from(hystrixObservable, _cmd);
+                    HystrixCommandResponseFromCache<R> fromCache = (HystrixCommandResponseFromCache<R>) requestCache.putIfAbsent(cacheKey, toCache);
+                    if (fromCache != null) {
+                        // another thread beat us so we'll use the cached value instead
+                        toCache.unsubscribe();
+                        isResponseFromCache = true;
+                        return handleRequestCacheHitAndEmitValues(fromCache, _cmd);
+                    } else {
+                        // we just created an ObservableCommand so we cast and return it
+                        afterCache = toCache.toObservable();
+                    }
+                } else {
+                    afterCache = hystrixObservable;
+                }
+                // �������ڻص�����
+                return afterCache
+                    //����Observable����ǰ�����ص������������������쳣��ֹ
+                    .doOnTerminate(terminateCommandCleanup)     
+                    //ȡ������ʱ�ļ���
+                    .doOnUnsubscribe(unsubscribeCommandCleanup) 
+                    //Observable������ֹʱ�ļ���
+                    .doOnCompleted(fireOnCompletedHook);
+            }
+        });
+    }
+
+
+
+
+
+
+
+
+
+���������������߼�applyHystrixSemantics
+
+
+
+    Observable<R> hystrixObservable =
+        Observable.defer(applyHystrixSemantics)
+        .map(wrapWithAllOnNextHooks);
+
+
+
+
+
+
+
+
+
+
+
+    final Func0<Observable<R>> applyHystrixSemantics = new Func0<Observable<R>>() {
+        @Override
+        public Observable<R> call() {
+            if (commandState.get().equals(CommandState.UNSUBSCRIBED)) {
+                return Observable.never();
+            }
+            return applyHystrixSemantics(_cmd);
+        }
+    };
+
+
+
+
+
+
+
+
+
+���ﴫ���_cmd��һ��GenericCommand�����ջ�ִ�е����GenericCommand�е�run������
+
+circuitBreaker.allowRequest() ������ж��Ƿ����۶�״̬�ģ�true��ʾû�д����۶�״̬������ִ�У����򣬵��� handleShortCircuitViaFallback ʵ�ַ��񽵼������ջ�ص��������Զ����fallback�����С�
+
+�����ǰhystrix����δ�۶�״̬����
+
+- getExecutionSemaphore �жϵ�ǰ�����Ƿ�Ϊ�ź��������̳߳أ���ȻĬ�����̳߳أ�Ȼ���ٵ���tryAcquireʱд����Ϊtrue��
+
+����executeCommandAndObserve��
+
+
+
+    private Observable<R> applyHystrixSemantics(final AbstractCommand<R> _cmd) {
+    
+        executionHook.onStart(_cmd);
+    
+        // �Ƿ��������󣬼���·���Ƿ��� ������Ҳ�кü������
+        if (circuitBreaker.allowRequest()) {
+            // �ź�����ȡ
+            final TryableSemaphore executionSemaphore = getExecutionSemaphore();
+            final AtomicBoolean semaphoreHasBeenReleased = new AtomicBoolean(false);
+    
+            // �ź��ͷŻص�
+            final Action0 singleSemaphoreRelease = new Action0() {
+                @Override
+                public void call() {
+                    if (semaphoreHasBeenReleased.compareAndSet(false, true)) {
+                        executionSemaphore.release();
+                    }
+                }
+            };
+    
+            // �쳣�ص�
+            final Action1<Throwable> markExceptionThrown = new Action1<Throwable>() {
+                @Override
+                public void call(Throwable t) {
+                    eventNotifier.markEvent(HystrixEventType.EXCEPTION_THROWN, commandKey);
+                }
+            };
+    
+            // ��ȡ�źţ������ض�Ӧ�� Observable
+            // �Ƿ����ź�����Դ���룬δ������ com.netflix.hystrix.AbstractCommand.TryableSemaphoreNoOp#tryAcquire Ĭ�Ϸ���ͨ��
+            if (executionSemaphore.tryAcquire()) {
+                try {
+                    executionResult = executionResult.setInvocationStartTime(System.currentTimeMillis());
+                    return executeCommandAndObserve(_cmd)   // ִ��������������ǻص������Բ���
+                        .doOnError(markExceptionThrown)
+                        .doOnTerminate(singleSemaphoreRelease)
+                        .doOnUnsubscribe(singleSemaphoreRelease);
+                } catch (RuntimeException e) {
+                    return Observable.error(e);
+                }
+            } else {
+                // ��ȡ�ź�ʧ���򽵼�
+                return handleSemaphoreRejectionViaFallback();
+            }
+        } else {
+            // ��·���Ѵ򿪣�ֱ�ӽ���
+            return handleShortCircuitViaFallback();
+        }
+    }
+
+
+
+
+
+
+
+
+
+������һ��ִ��ʧ�ܽ��뽵�����߼�����������ֱ�ӽ��뵽 HystrixCommand#getFallbackObservable
+
+
+
+    public abstract class HystrixCommand<R> extends AbstractCommand<R> implements HystrixExecutable<R>, HystrixInvokableInfo<R>, HystrixObservable<R> {
+        @Override
+        final protected Observable<R> getFallbackObservable() {
+            return Observable.defer(new Func0<Observable<R>>() {
+                @Override
+                public Observable<R> call() {
+                    try {
+                        return Observable.just(getFallback());
+                    } catch (Throwable ex) {
+                        return Observable.error(ex);
+                    }
+                }
+            });
+        }
+    }
+
+
+
+
+
+
+
+
+
+�����getFallback���ջ�ص������Զ���fallback������
+
+�ص�executeCommandAndObserve�����������Ҫ����������������
+
+- ���岻ͬ�Ļص���doOnNext��doOnCompleted��onErrorResumeNext��doOnEach��
+- ����executeCommandWithSpecifiedIsolation��
+
+��ִ�����ʱ���Կ��������� Observable.lift����ʵ��ִ�����ʱ���ܡ�
+
+
+
+    private Observable<R> executeCommandAndObserve(final AbstractCommand<R> _cmd) {
+        final HystrixRequestContext currentRequestContext = HystrixRequestContext.getContextForCurrentThread();
+        // Action��Func���Ƕ����һ��������Action���޷���ֵ��Func���з���ֵ
+        // doOnNext�еĻص���������ִ��֮ǰִ�еIJ���
+        final Action1<R> markEmits = new Action1<R>() {
+            @Override
+            public void call(R r) {
+                if (shouldOutputOnNextEvents()) {
+                    executionResult = executionResult.addEvent(HystrixEventType.EMIT);
+                    eventNotifier.markEvent(HystrixEventType.EMIT, commandKey);
+                }
+                if (commandIsScalar()) {
+                    long latency = System.currentTimeMillis() - executionResult.getStartTimestamp();
+                    eventNotifier.markCommandExecution(getCommandKey(), properties.executionIsolationStrategy().get(), (int) latency, executionResult.getOrderedList());
+                    eventNotifier.markEvent(HystrixEventType.SUCCESS, commandKey);
+                    executionResult = executionResult.addEvent((int) latency, HystrixEventType.SUCCESS);
+                    circuitBreaker.markSuccess();
+                }
+            }
+        };
+        // doOnCompleted�еĻص�������ִ����Ϻ�ִ�еIJ���
+        final Action0 markOnCompleted = new Action0() {
+            @Override
+            public void call() {
+                if (!commandIsScalar()) {
+                    long latency = System.currentTimeMillis() - executionResult.getStartTimestamp();
+                    eventNotifier.markCommandExecution(getCommandKey(), properties.executionIsolationStrategy().get(), (int) latency, executionResult.getOrderedList());
+                    eventNotifier.markEvent(HystrixEventType.SUCCESS, commandKey);
+                    executionResult = executionResult.addEvent((int) latency, HystrixEventType.SUCCESS);
+                    circuitBreaker.markSuccess();
+                }
+            }
+        };
+        // onErrorResumeNext�еĻص�������ִ��ʧ�ܺ�Ļ����߼�
+        final Func1<Throwable, Observable<R>> handleFallback = new Func1<Throwable, Observable<R>>() {
+            @Override
+            public Observable<R> call(Throwable t) {
+                Exception e = getExceptionFromThrowable(t);
+                executionResult = executionResult.setExecutionException(e);
+                if (e instanceof RejectedExecutionException) {
+                    // �̵߳���ʧ�ܻص�
+                    return handleThreadPoolRejectionViaFallback(e);
+                } else if (t instanceof HystrixTimeoutException) {
+                    // ��ʱ�ص�
+                    return handleTimeoutViaFallback();
+                } else if (t instanceof HystrixBadRequestException) {
+                    // HystrixBadRequestException �쳣�ص�
+                    return handleBadRequestByEmittingError(e);
+                } else {
+                    if (e instanceof HystrixBadRequestException) {
+                        eventNotifier.markEvent(HystrixEventType.BAD_REQUEST, commandKey);
+                        return Observable.error(e);
+                    }
+                    // ��������
+                    return handleFailureViaFallback(e);
+                }
+            }
+        };
+        // doOnEach�еĻص���`Observable`ÿ����һ�����ݶ���ִ������ص�����������������
+        final Action1<Notification<? super R>> setRequestContext = new Action1<Notification<? super R>>() {
+            @Override
+            public void call(Notification<? super R> rNotification) {
+                setRequestContextIfNeeded(currentRequestContext);
+            }
+        };
+        // ������Ӧ�� Observable��ʵ�� �̸߳��롢������ �Ȳ���
+        Observable<R> execution;
+        // �ж� ��ʱ��ع����Ƿ��
+        if (properties.executionTimeoutEnabled().get()) {
+            // HystrixObservableTimeoutOperator  ת����Ӧ�� Observable
+            execution = executeCommandWithSpecifiedIsolation(_cmd)
+                .lift(new HystrixObservableTimeoutOperator<R>(_cmd));
+        } else {
+            execution = executeCommandWithSpecifiedIsolation(_cmd);
+        }
+        //���ûص�
+        return execution.doOnNext(markEmits)
+            .doOnCompleted(markOnCompleted)
+            .onErrorResumeNext(handleFallback)
+            .doOnEach(setRequestContext);
+    }
+
+
+
+
+
+
+
+
+
+3.3 executeCommandWithSpecifiedIsolation
+������������Ǹ��ݵ�ǰ��ͬ����Դ�������ִ�в�ͬ���߼���THREAD��SEMAPHORE��
+
+
+
+    private Observable<R> executeCommandWithSpecifiedIsolation(final AbstractCommand<R> _cmd) {
+        // �̸߳���, �Ƿ��� THREAD ��Դ���뽵��
+        if (properties.executionIsolationStrategy().get() == ExecutionIsolationStrategy.THREAD) {
+            //����һ��Observable
+            return Observable.defer(new Func0<Observable<R>>() {
+                @Override
+                public Observable<R> call() {
+                    executionResult = executionResult.setExecutionOccurred();
+                    if (!commandState.compareAndSet(CommandState.OBSERVABLE_CHAIN_CREATED, CommandState.USER_CODE_EXECUTED)) {
+                        return Observable.error(new IllegalStateException("execution attempted while in state : " + commandState.get().name()));
+                    }
+    
+                    metrics.markCommandStart(commandKey, threadPoolKey, ExecutionIsolationStrategy.THREAD);
+    
+                    // �������ڰ�װ�߳��г�ʱ�����������أ����Ҳ��������κμ����������������߼�
+                    if (isCommandTimedOut.get() == TimedOutStatus.TIMED_OUT) {
+                        // the command timed out in the wrapping thread so we will return immediately
+                        // and not increment any of the counters below or other such logic
+                        return Observable.error(new RuntimeException("timed out before executing run()"));
+                    }
+    
+                    // �����߳�����
+                    if (threadState.compareAndSet(ThreadState.NOT_USING_THREAD, ThreadState.STARTED)) {
+                        //we have not been unsubscribed, so should proceed
+                        HystrixCounters.incrementGlobalConcurrentThreads();
+                        threadPool.markThreadExecution();
+                        // store the command that is being run
+                        endCurrentThreadExecutingCommand = Hystrix.startCurrentThreadExecutingCommand(getCommandKey());
+                        executionResult = executionResult.setExecutedInThread();
+    
+                        try {
+                            executionHook.onThreadStart(_cmd);
+                            executionHook.onRunStart(_cmd);
+                            executionHook.onExecutionStart(_cmd);
+                            //���� Observable,����������ջ᷵��һ����װ�����ǵ�run()�߼���Observable
+                            return getUserExecutionObservable(_cmd);
+                        } catch (Throwable ex) {
+                            return Observable.error(ex);
+                        }
+                    } else {
+                        //command has already been unsubscribed, so return immediately
+                        return Observable.error(new RuntimeException("unsubscribed before executing run()"));
+                    }
+                }
+            }).doOnTerminate(new Action0() {
+                @Override
+                public void call() {
+                    if (threadState.compareAndSet(ThreadState.STARTED, ThreadState.TERMINAL)) {
+                        handleThreadEnd(_cmd);
+                    }
+                    if (threadState.compareAndSet(ThreadState.NOT_USING_THREAD, ThreadState.TERMINAL)) {
+                    }
+                }
+            }).doOnUnsubscribe(new Action0() {
+                @Override
+                public void call() {
+                    if (threadState.compareAndSet(ThreadState.STARTED, ThreadState.UNSUBSCRIBED)) {
+                        handleThreadEnd(_cmd);
+                    }
+                    if (threadState.compareAndSet(ThreadState.NOT_USING_THREAD, ThreadState.UNSUBSCRIBED)) {
+                    }
+                }
+            }).subscribeOn(threadPool.getScheduler(new Func0<Boolean>() {
+                @Override
+                public Boolean call() {
+                    return properties.executionIsolationThreadInterruptOnTimeout().get() && _cmd.isCommandTimedOut.get() == TimedOutStatus.TIMED_OUT;
+                }
+            }));
+        } else {
+            // �ź�������
+            return Observable.defer(new Func0<Observable<R>>() {
+                @Override
+                public Observable<R> call() {
+                    executionResult = executionResult.setExecutionOccurred();
+                    if (!commandState.compareAndSet(CommandState.OBSERVABLE_CHAIN_CREATED, CommandState.USER_CODE_EXECUTED)) {
+                        return Observable.error(new IllegalStateException("execution attempted while in state : " + commandState.get().name()));
+                    }
+                    metrics.markCommandStart(commandKey, threadPoolKey, ExecutionIsolationStrategy.SEMAPHORE);
+                    endCurrentThreadExecutingCommand = Hystrix.startCurrentThreadExecutingCommand(getCommandKey());
+                    try {
+                        executionHook.onRunStart(_cmd);
+                        executionHook.onExecutionStart(_cmd);
+                        // ������ִ��
+                        return getUserExecutionObservable(_cmd); 
+                    } catch (Throwable ex) {
+                        //If the above hooks throw, then use that as the result of the run method
+                        return Observable.error(ex);
+                    }
+                }
+            });
+        }
+    }
+
+
+
+
+
+
+
+
+
+- �ж��Ƿ����������������ǻ��ڶ�·��ʵ�֣������·���򿪣�����ж�Ӧ�ص�������ʧ�ܻ򽵼�����
+- ��� ��·�� �رգ�����������Ȼ�ȡ�źţ���ȡʧ��������Ӧ�ص���
+- ��ȡ�ɹ������ɷ��� executeCommandAndObserve ������Ӧ�� Observable ʵ�� �̸߳��롢������ �Ȳ�����ͬʱע���˶�Ӧ�� �������ڻص���
+  3.4 getUserExecutionObservable
+  Ȼ���ִ�� HystrixCommand#getExecutionObservable
+
+
+
+    abstract class AbstractCommand<R> implements HystrixInvokableInfo<R>, HystrixObservable<R> {
+        private Observable<R> getUserExecutionObservable(final AbstractCommand<R> _cmd) {
+            Observable<R> userObservable;
+            try {
+                userObservable = getExecutionObservable();
+            } catch (Throwable ex) {
+                userObservable = Observable.error(ex);
+            }
+            return userObservable
+                    .lift(new ExecutionHookApplication(_cmd))
+                    .lift(new DeprecatedOnRunHookApplication(_cmd));
+        }
+    }
+    public abstract class HystrixCommand<R> extends AbstractCommand<R> implements HystrixExecutable<R>, HystrixInvokableInfo<R>, HystrixObservable<R> {
+        @Override
+        final protected Observable<R> getExecutionObservable() {
+            return Observable.defer(new Func0<Observable<R>>() {
+                @Override
+                public Observable<R> call() {
+                    try {
+                        return Observable.just(run());
+                    } catch (Throwable ex) {
+                        return Observable.error(ex);
+                    }
+                }
+            }).doOnSubscribe(new Action0() {
+                @Override
+                public void call() {
+                    // Save thread on which we get subscribed so that we can interrupt it later if needed
+                    executionThread.set(Thread.currentThread());
+                }
+            });
+        }
+    }
+
+
+
+
+
+
+
+
+
+��� run() �����������Ѿ������ˣ�����������ҵ��ִ�з�����
+
+
+
+    @ThreadSafe
+    public class GenericCommand extends AbstractHystrixCommand<Object> {
+        @Override
+        protected Object run() throws Exception {
+            LOGGER.debug("execute command: {}", getCommandKey().name());
+            return process(new Action() {
+                @Override
+                Object execute() {
+                    return getCommandAction().execute(getExecutionType());
+                }
+            });
+        }
+    }
+
+
+
+
+
+
+
+
+
+���յ��õ������Լ���ҵ���߼���
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudLoadBalancer\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudLoadBalancer\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..f66f6ba
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudLoadBalancer\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,670 @@
+# Spring Cloud LoadBalancer
+
+## ����
+
+> Spring Cloud LoadBalancerĿǰSpring�ٷ��Ƿ���spring-cloud-commons�Spring Cloud���°汾Ϊ2021.0.2
+>
+> [Spring Cloud LoadBalancer �����ĵ���ַ](https://docs.spring.io/spring-cloud-commons/docs/3.1.2/reference/html/#spring-cloud-loadbalancer) [https://docs.spring.io/spring-cloud-commons/docs/3.1.2/reference/html/#spring-cloud-loadbalancer](https://docs.spring.io/spring-cloud-commons/docs/3.1.2/reference/html/#spring-cloud-loadbalancer)
+>
+> [Spring Cloud�����ĵ���ַ](https://docs.spring.io/spring-cloud/docs/current/reference/html/) [https://docs.spring.io/spring-cloud/docs/current/reference/html/](https://docs.spring.io/spring-cloud/docs/current/reference/html/)
+
+һ����Netflix Ribbonֹͣ���£�Spring Cloud LoadBalancer��Spring Cloud�ٷ��Լ��ṩ�Ŀͻ��˸��ؾ�����,�����ʵ�֣��������Ribbon��
+
+*   �������ؾ�������Ϊ����˸��ؾ�����(�����ز���⸺��)�Ϳͻ��˲���⸺�ء�
+    *   ���ز���Ӳ�������F5�����������LVS������nginx�ȡ�
+    *   �ͻ��˲����Spring Cloud LoadBalancer����Ϊһ���ͻ���ȥ���ָ���ά�������б����Զ������ľ��⸺�ز��ԣ��������ѯ��С�����Ľ�˿ȸ�ȵȣ���
+
+Spring Cloud�ṩ���Լ��Ŀͻ��˸���ƽ���������ʵ�֡����ڸ��ؾ�����ƣ�������ReactiveLoadBalancer�ӿڣ����ṩ�˻���round-robin��ѯ��Random�����ʵ�֡�Ϊ�˴���ӦʽServiceInstanceListSupplier��ѡ��ʵ������Ҫʹ��ServiceInstanceListSupplier��Ŀǰ֧��ServiceInstanceListSupplier�Ļ��ڷ����ֵ�ʵ�֣���ʵ��ʹ����·���еķ��ֿͻ��˴�Service Discovery�м������õ�ʵ����
+
+����ͨ����������������Spring Cloud LoadBalance
+
+```
+spring:
+  cloud:
+    loadbalancer:
+      enabled: false
+
+```
+
+## ����ʾ��
+
+ǰ��simple-ecommerce��Ŀ�������ڸ�Pom����������������ϸ���Կ���ǰ�������<<SpringCloudAlibabaע����������������֮����Nacosʵս��Դ�����>>������Spring Cloud�İ汾Ϊ2021.0.1��ǰ������Ҳ��˵����Spring Cloud Alibaba������spring-cloud-starter-alibaba-nacos-discovery����������spring-cloud-loadbalancer��
+
+> ע�������Hoxton֮ǰ�İ汾��Ĭ�ϸ��ؾ�����ΪRibbon����Ҫ�Ƴ�Ribbon���ú���������spring.cloud.loadbalancer.ribbon.enabled: false��
+
+�������Spring Boot��Ŀ�������������������������starterҲ������Spring Boot Caching and Evictor.
+
+```
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            spring-cloud-starter-loadbalancer
+        </dependency>
+
+```
+
+����ʹ��Spring�ٷ��ṩ�˸��ؾ���Ŀͻ���֮һRestTemplate��RestTemplate��Spring�ṩ�����ڷ���Rest����Ŀͻ��ˣ�RestTemplate�ṩ�˶��ֱ�ݷ���Զ��Http����ķ������ܹ������߿ͻ��˵ı�дЧ�ʡ�Ĭ������£�RestTemplateĬ������jdk��HTTP���ӹ��ߡ�����RestTemplateConfig�����࣬��ע @LoadBalancedע�⣬Ĭ��ʹ�õ�ReactiveLoadBalancerʵ����RoundRobinLoadBalancer��
+
+```
+package cn.itxs.ecom.order.config;
+
+import org.springframework.cloud.client.loadbalancer.LoadBalanced;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestTemplate;
+
+@Configuration
+public class RestTemplateConfig {
+    @LoadBalanced
+    @Bean
+    public RestTemplate restTemplate() {
+        return new RestTemplate() ;
+    }
+}
+
+```
+
+����΢�����ж�������������deductRest����
+
+```
+package cn.itxs.ecom.order.controller;
+
+import cn.itxs.ecom.commons.service.OrderService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.client.RestTemplate;
+
+/**
+ * @Name ��OrderController
+ * @Description ������������
+ * @Author ��itxs
+ * @Date ��2022/4/10 20:15
+ * @Version ��1.0
+ * @History ��
+ */
+@RestController
+public class OrderController {
+
+    @Autowired
+    OrderService orderService;
+
+    @Autowired
+    private RestTemplate restTemplate;
+
+    @RequestMapping("/create/{userId}/{commodityCode}/{count}")
+    public String create(@PathVariable("userId") String userId,@PathVariable("commodityCode") String commodityCode, @PathVariable("count") int count){
+        return orderService.create(userId,commodityCode,count).toString();
+    }
+
+    @RequestMapping("/deductRest/{commodityCode}/{count}")
+    public String deductRest(@PathVariable("commodityCode") String commodityCode, @PathVariable("count") int count){
+        String url = "http://ecom-storage-service/deduct/"+commodityCode+"/"+count;
+        return restTemplate.getForObject(url, String.class);
+    }
+}
+
+```
+
+ǰ��server.port�����Ƿ���Nacos�����������������ע��Nacos�������ĵ����÷��ڱ��������ļ�bootstrap.yml��ֱ�����Ϊ4080��4081��4082����3��������ʵ��������������΢����
+
+```
+server:
+  port: 4080
+
+```
+
+![image-20220505191143684](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/938570a0b63b56671a862e8bda11577a.png)
+
+�鿴nacos�������-�����б���������飬���Կ���3�������Ŀ��ʵ����1������΢����ʵ��
+
+![image-20220505182432182](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/33fa03d937354fe00bb0bb2f3dd5c805.png)
+
+����6�ζ���dedect�ӿڣ�[http://localhost:4070/deductRest/1001/1](http://localhost:4070/deductRest/1001/1) ���Ӳ��ԵĽ��Ҳ��֤��LoadBalancerĬ������ѯ���ؾ�����ԡ�
+
+![image-20220505192217715](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1fc20b1d482d2a4e3924c5707ac2ff19.png)
+
+## ���ؾ����㷨�л�
+
+�����Զ��帺�ؾ���������CustomLoadBalancerConfiguration
+
+```
+package cn.itxs.ecom.order.config;
+
+import org.springframework.cloud.client.ServiceInstance;
+import org.springframework.cloud.loadbalancer.core.RandomLoadBalancer;
+import org.springframework.cloud.loadbalancer.core.ReactorLoadBalancer;
+import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
+import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
+import org.springframework.context.annotation.Bean;
+import org.springframework.core.env.Environment;
+
+public class CustomLoadBalancerConfiguration {
+
+    @Bean
+    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment,
+                                                            LoadBalancerClientFactory loadBalancerClientFactory) {
+        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
+        return new RandomLoadBalancer(loadBalancerClientFactory
+                .getLazyProvider(name, ServiceInstanceListSupplier.class),
+                name);
+    }
+}
+
+```
+
+RestTemplateConfig������LoadBalancerClientָ������������࣬value��ֵΪ�ṩ��Ҳ���ǿ��΢�������ơ�
+
+```
+package cn.itxs.ecom.order.config;
+
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.cloud.client.loadbalancer.LoadBalanced;
+import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClient;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestTemplate;
+
+@Configuration
+@LoadBalancerClient(value = "ecom-storage-service", configuration = CustomLoadBalancerConfiguration.class)
+public class RestTemplateConfig {
+
+    @LoadBalanced
+    @Bean
+    public RestTemplate restTemplate(RestTemplateBuilder builder) {
+        return builder.build() ;
+    }
+}
+
+```
+
+��η��ʶ���dedect�ӿڲ���ȷ�����л�Ϊ������ؾ�����ԡ�
+
+## ���ɷ�ʽ
+
+�����ṩ3�м���Spring Cloud LoadBalancer�ķ�ʽ�����˵�һ��������ʹ�ù�����֧��Spring Web Flux��Ӧʽ��̣�WebClient�Ǵ�Spring WebFlux 5.0�汾��ʼ�ṩ��һ���������Ļ�����Ӧʽ��̵Ľ���Http����Ŀͻ��˹��ߡ�������Ӧʽ��̵Ļ���Reactor�ġ�WebClient���ṩ�˱�׼Http����ʽ��Ӧ��get��post��put��delete�ȷ�������������������Ӧ������
+
+![image-20220506233248585](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/ad44f363342f540b1cb1805b20be6ef0.png)
+
+�ڶ���΢����������spring-boot-starter-webflux����
+
+```
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            spring-boot-starter-webflux
+        </dependency>
+
+```
+
+����΢����������WebClientConfig������
+
+```
+package cn.itxs.ecom.order.config;
+
+import org.springframework.cloud.client.loadbalancer.LoadBalanced;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.reactive.function.client.WebClient;
+
+@Configuration
+public class WebClientConfig {
+    @LoadBalanced
+    @Bean
+    WebClient.Builder webClientBuilder() {
+        return WebClient.builder();
+    }
+
+    @Bean
+    WebClient webClient() {
+        return webClientBuilder().build();
+    }
+}
+
+```
+
+����΢���񶩵�������������WebClient�ӿ�ʵ�֣���������
+
+```
+    @Autowired
+    private WebClient webClient;   
+
+	@RequestMapping(value = "/deductWebClient/{commodityCode}/{count}")
+    public Mono<String> deductWebClient(@PathVariable("commodityCode") String commodityCode, @PathVariable("count") int count) {
+        String url = "http://ecom-storage-service/deduct/"+commodityCode+"/"+count;
+        // ����WebClient
+        Mono<String> result = webClient.get().uri(url)
+                .retrieve().bodyToMono(String.class);
+        return result;
+    }
+
+```
+
+������������΢����
+
+![image-20220506234934948](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/ec48e022accfb3298069c96b7e3799e7.png)
+
+���ʶ����������еļ����WebClient�ӿڣ�[http://localhost:4070/deductWebClient/1001/1](http://localhost:4070/deductWebClient/1001/1) ��������سɹ�
+
+![image-20220506234627330](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/5f737fc9d8806dc072ce3e1fdf983de6.png)
+
+���ǻ��������û��ڹ������ķ�ʽ��ͨ��WebClientʹ��ReactiveLoadBalancer�������Ŀ��������Spring Cloud LoadBalancer starter������Spring -webflux����·���У�ReactorLoadBalancerExchangeFilterFunction�����Զ����õġ�
+
+����΢���񶩵�������������WebClientʹ��ReactiveLoadBalancer�ӿ�ʵ�֣���������
+
+```
+    @Autowired
+    private ReactorLoadBalancerExchangeFilterFunction lbFunction;   
+
+    @RequestMapping(value = "/deductWebFluxReactor/{commodityCode}/{count}")
+    public Mono<String> deductWebFluxReactor(@PathVariable("commodityCode") String commodityCode, @PathVariable("count") int count) {
+        String url = "/deduct/"+commodityCode+"/"+count;
+        Mono<String> result = WebClient.builder().baseUrl("http://ecom-storage-service")
+                .filter(lbFunction)
+                .build()
+                .get()
+                .uri(url)
+                .retrieve()
+                .bodyToMono(String.class);
+        return result;
+    }
+
+```
+
+������������΢����
+
+![image-20220507000930179](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/3546b9913f1253a1b23039ad6f7546d1.png)
+
+���ʶ����������еļ����WebClient�ӿڣ�[http://localhost:4070/deductWebFluxReactor/1001/1](http://localhost:4070/deductWebFluxReactor/1001/1) ��������سɹ�
+
+![image-20220507000746900](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/0bc2b04d23d11bc85009c7e040900b2b.png)
+
+����LoadBalancer�������ṩ�ܶ��������ܣ�����Ȥ��������ϸ���ĺͶ���ʵ��
+
+![image-20220507001132987](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1d8f35933945b317a2dd71627fdfa748.png)
+
+## ԭ��
+
+### RestTemplate
+
+Spring Cloud LoadBalancerԴ����������ȴ�RestTemplate���ؾ���ļ�ʵ�����������֣�����֮����֧��Spring Web Flux��Ӧʽ��̵�ʵ��ԭ��˼��Ҳ����ͬ������ͨ���ͻ�������������������������ʵ�ָ��ؾ��⡣��RestTemplate��Դ���п���֪����̳���InterceptingHttpAccessor������
+
+![image-20220508142236428](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/c3ee7af69f54aeed5f1026823779fee8.png)
+
+��InterceptingHttpAccessor���������ṩ��һ������setInterceptors��������������������������Ҫʵ��ClientHttpRequestInterceptor�ӿڼ��ɣ���ʵ��Զ���������˽ӿ�֮ǰ���ȵ�����������intercept������������������൱��Servlet�����е�Filter����
+
+```
+	// ����ʵ���ڳ�����InterceptingHttpAccessor��
+	// RestTemplate.InterceptingHttpAccessor#setInterceptors
+	public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) {
+		Assert.noNullElements(interceptors, "'interceptors' must not contain null elements");
+		// Take getInterceptors() List as-is when passed in here
+		if (this.interceptors != interceptors) {
+			this.interceptors.clear();
+			this.interceptors.addAll(interceptors);
+			AnnotationAwareOrderComparator.sort(this.interceptors);
+		}
+	}
+
+```
+
+![image-20220508142443637](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/5062f793bb2bd7f996eb944f77af7137.png)
+
+### **LoadBalancerAutoConfiguration**
+
+�ӹ�������֪��Spring Cloud LoadBalancer����spring-cloud-commons�����Ҳ��Ϊ����ĵ�@LoadBalancedע��Ҳ������spring-cloud-commons��ʵ�֣�����SpringBoot�Զ�װ���ԭ���Ȳ鿴��������ʵ���߼������ѷ���spring-cloud-commons�������Զ�������LoadBalancerAutoConfiguration��ReactorLoadBalancerClientAutoConfiguration��
+
+![image-20220509001530634](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/b5be12e0dd8d515aa07613738efab122.png)
+
+����������������ʱ��@ConditionalΪ����ע�⣩�����Զ�����LoadBalancerInterceptor��ע�뵽RestTemplate�С�
+
+![image-20220508143752218](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/676f6d81529228511c862c780b0c4532.png)
+
+### **LoadBalancerLnterceptor**
+
+LoadBalancerInterceptorʵ����ClientHttpRequestInterceptor�ӿڣ����Ҳʵ��intercept����������ʵ�ָ��ؾ�������ش�����
+
+![image-20220508144048248](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/bb587d8122fee4973eba2fc00ed1af3f.png)
+
+### **LoadBalancerClient**
+
+LoadBalancerClient���ڽ��и��ؾ����߼����̳���ServiceInstanceChooser�ӿڣ��ӷ����б���ѡ���һ�������ַ���е��á���LoadBalancerClient�ִ�������execute()��������������ִ������ģ�reconstructURI()�������ع�URL��
+
+![image-20220508144435104](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/a3590c0ab24cb5ee04cf1cf513724fc0.png)
+
+����LoadBalancerClient�ӿ�Spring Cloud LoadBalancer���ṩĬ��ʵ��ΪBlockingLoadBalancerClient
+
+![image-20220508144750601](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/256e4815a982966d7d6bfb82e0e97f67.png)
+
+```
+@SuppressWarnings({ "unchecked", "rawtypes" })
+public class BlockingLoadBalancerClient implements LoadBalancerClient {
+
+	private final ReactiveLoadBalancer.Factory<ServiceInstance> loadBalancerClientFactory;
+
+	/**
+	 * @deprecated in favour of
+	 * {@link BlockingLoadBalancerClient#BlockingLoadBalancerClient(ReactiveLoadBalancer.Factory)}
+	 */
+	@Deprecated
+	public BlockingLoadBalancerClient(LoadBalancerClientFactory loadBalancerClientFactory,
+			LoadBalancerProperties properties) {
+		this.loadBalancerClientFactory = loadBalancerClientFactory;
+	}
+
+	public BlockingLoadBalancerClient(ReactiveLoadBalancer.Factory<ServiceInstance> loadBalancerClientFactory) {
+		this.loadBalancerClientFactory = loadBalancerClientFactory;
+	}
+
+	@Override
+	public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
+		String hint = getHint(serviceId);
+		LoadBalancerRequestAdapter<T, DefaultRequestContext> lbRequest = new LoadBalancerRequestAdapter<>(request,
+				new DefaultRequestContext(request, hint));
+		Set<LoadBalancerLifecycle> supportedLifecycleProcessors = getSupportedLifecycleProcessors(serviceId);
+		supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStart(lbRequest));
+		ServiceInstance serviceInstance = choose(serviceId, lbRequest);
+        // ѡ�����
+		if (serviceInstance == null) {
+			supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onComplete(
+					new CompletionContext<>(CompletionContext.Status.DISCARD, lbRequest, new EmptyResponse())));
+			throw new IllegalStateException("No instances available for " + serviceId);
+		}
+		return execute(serviceId, serviceInstance, lbRequest);
+	}
+
+	@Override
+	public <T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request)
+			throws IOException {
+		DefaultResponse defaultResponse = new DefaultResponse(serviceInstance);
+		Set<LoadBalancerLifecycle> supportedLifecycleProcessors = getSupportedLifecycleProcessors(serviceId);
+		Request lbRequest = request instanceof Request ? (Request) request : new DefaultRequest<>();
+		supportedLifecycleProcessors
+				.forEach(lifecycle -> lifecycle.onStartRequest(lbRequest, new DefaultResponse(serviceInstance)));
+		try {
+			T response = request.apply(serviceInstance);
+			Object clientResponse = getClientResponse(response);
+			supportedLifecycleProcessors
+					.forEach(lifecycle -> lifecycle.onComplete(new CompletionContext<>(CompletionContext.Status.SUCCESS,
+							lbRequest, defaultResponse, clientResponse)));
+			return response;
+		}
+		catch (IOException iOException) {
+			supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onComplete(
+					new CompletionContext<>(CompletionContext.Status.FAILED, iOException, lbRequest, defaultResponse)));
+			throw iOException;
+		}
+		catch (Exception exception) {
+			supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onComplete(
+					new CompletionContext<>(CompletionContext.Status.FAILED, exception, lbRequest, defaultResponse)));
+			ReflectionUtils.rethrowRuntimeException(exception);
+		}
+		return null;
+	}
+
+	private <T> Object getClientResponse(T response) {
+		ClientHttpResponse clientHttpResponse = null;
+		if (response instanceof ClientHttpResponse) {
+			clientHttpResponse = (ClientHttpResponse) response;
+		}
+		if (clientHttpResponse != null) {
+			try {
+				return new ResponseData(clientHttpResponse, null);
+			}
+			catch (IOException ignored) {
+			}
+		}
+		return response;
+	}
+
+	private Set<LoadBalancerLifecycle> getSupportedLifecycleProcessors(String serviceId) {
+		return LoadBalancerLifecycleValidator.getSupportedLifecycleProcessors(
+				loadBalancerClientFactory.getInstances(serviceId, LoadBalancerLifecycle.class),
+				DefaultRequestContext.class, Object.class, ServiceInstance.class);
+	}
+
+	@Override
+	public URI reconstructURI(ServiceInstance serviceInstance, URI original) {
+		return LoadBalancerUriTools.reconstructURI(serviceInstance, original);
+	}
+
+	@Override
+	public ServiceInstance choose(String serviceId) {
+		return choose(serviceId, REQUEST);
+	}
+
+    // ͨ����ͬ�ĸ��ؾ���ͻ���ʵ��ѡ��ͬ�ķ���
+	@Override
+	public <T> ServiceInstance choose(String serviceId, Request<T> request) {
+		ReactiveLoadBalancer<ServiceInstance> loadBalancer = loadBalancerClientFactory.getInstance(serviceId);
+		if (loadBalancer == null) {
+			return null;
+		}
+		Response<ServiceInstance> loadBalancerResponse = Mono.from(loadBalancer.choose(request)).block();
+		if (loadBalancerResponse == null) {
+			return null;
+		}
+		return loadBalancerResponse.getServer();
+	}
+
+	private String getHint(String serviceId) {
+		LoadBalancerProperties properties = loadBalancerClientFactory.getProperties(serviceId);
+		String defaultHint = properties.getHint().getOrDefault("default", "default");
+		String hintPropertyValue = properties.getHint().get(serviceId);
+		return hintPropertyValue != null ? hintPropertyValue : defaultHint;
+	}
+
+}
+
+```
+
+### **LoadBalancerClientFactory**
+
+BlockingLoadBalancerClient�г���LoadBalancerClientFactoryͨ��������getInstance������ȡ����ĸ��ؾ���ͻ��ˡ�ͨ��������LoadBalancerClientFactory��ȡ����ĸ��ؾ�����ʵ���������loadBalancer.choose(request)������ӿ�choose()����ʵ�ָ��ݸ��ؾ����㷨ѡ����һ����������ɸ��ؾ��⣬��ReactiveLoadBalancer<t> getInstance(String serviceId) ��Ĭ��ʵ��LoadBalancerClientFactory
+![image-20220508190132565](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/4014445b0c2ea7189a232b5d257fb938.png)</t>
+
+LoadBalancerClientFactory�ͻ���ʵ���˲�ͬ�ĸ��ؾ����㷨��������ѯ������ȡ�LoadBalancerClientFactory�̳���NamedContextFactory��NamedContextFactory�̳�ApplicationContextAware��ʵ��Spring ApplicationContext����������
+
+![image-20220508190412076](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/18f62338fdb636327fcdb2d08d33661b.png)
+
+### ReactiveLoadBalancer
+
+ReactiveLoadBalancer���ؾ�����ʵ�ַ���ѡ��Spring Cloud Balancer��ʵ������ѯRoundRobinLoadBalancer�����RandomLoadBalancer��NacosLoadBalancer�㷨��
+
+![image-20220508235128931](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/f19b9fd0d246dbae37b05e67b1a79805.png)
+
+### LoadBalancerClientConfiguration
+
+���û����ʽָ�����ؾ����㷨��Ĭ��ȱʡֵΪRoundRobinLoadBalancer
+
+```
+	@Bean
+	@ConditionalOnMissingBean
+	public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(Environment environment,
+			LoadBalancerClientFactory loadBalancerClientFactory) {
+		String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
+		return new RoundRobinLoadBalancer(
+				loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
+	}
+
+```
+
+![image-20220508235645313](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/c8ae46d4cedb33f40939edb4f6fde542.png)
+
+### **LoadBalancerRequestFactory**
+
+LoadBalancerRequest���������createRequest�������ڴ���LoadBalancerRequest�����ڲ�����LoadBalancerClient����Ҳ������BlockingLoadBalancerClient��
+
+![image-20220509000049541](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/c928dcb312df87a44c33ee77a296ee84.png)
+
+���ճ���Ŀ�У�һ�㸺�ؾ��ⶼ�ǽ��Feignʹ�ã�����������ʱ����������Feign����LoadBalancer���Զ�������FeignLoadBalancerAutoConfiguration��ʵ��
+
+### ReactorLoadBalancerClientAutoConfiguration
+
+����Ҳ��һ�»���WebClient��@Loadbalanced�����̵����룬�����������ؾ��������ReactorLoadBalancerClientAutoConfiguration��һ���Զ�װ�����࣬����Ŀ�������� WebClient �� ReactiveLoadBalancer ��֮���Զ�װ�����̾Ϳ�ʼ���У������ʼ��һ��ʵ���� ExchangeFilterFunction ��ʵ�����ں����ʵ������Ϊ��������ע�뵽WebClient��������������Ȥ�������о�
+
+![image-20220509001650781](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/869a4ea9a6e1409b84c927db08cebea1.png)
+
+## �Զ��帺�ؾ�����
+
+���������֪��LoadBalancerClientFactory�Ǵ����ͻ��������ؾ������Ϳͻ�������ʵ���Ĺ����������ݿͻ������ƴ���һ��Spring ApplicationContext����������ȡ�����bean����˽��뵽LoadBalancerClientFactory���У���Ҫȥʵ�������ӽӿ�ReactorServiceInstanceLoadBalancer����Ϊȥ��ȡ���ؾ�����ʵ����ʱ����ͨ��ȥ�����в���ReactorServiceInstanceLoadBalancer���͵�bean��ʵ�ֵģ����Բ���RandomLoadBalancerʵ�ִ���
+
+```
+package org.springframework.cloud.loadbalancer.core;
+
+import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import reactor.core.publisher.Mono;
+
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.cloud.client.ServiceInstance;
+import org.springframework.cloud.client.loadbalancer.DefaultResponse;
+import org.springframework.cloud.client.loadbalancer.EmptyResponse;
+import org.springframework.cloud.client.loadbalancer.Request;
+import org.springframework.cloud.client.loadbalancer.Response;
+
+public class RandomLoadBalancer implements ReactorServiceInstanceLoadBalancer {
+
+	private static final Log log = LogFactory.getLog(RandomLoadBalancer.class);
+
+	private final String serviceId;
+
+	private ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
+
+	/**
+	 * @param serviceInstanceListSupplierProvider a provider of
+	 * {@link ServiceInstanceListSupplier} that will be used to get available instances
+	 * @param serviceId id of the service for which to choose an instance
+	 */
+	public RandomLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider,
+			String serviceId) {
+		this.serviceId = serviceId;
+		this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public Mono<Response<ServiceInstance>> choose(Request request) {
+		ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider
+				.getIfAvailable(NoopServiceInstanceListSupplier::new);
+		return supplier.get(request).next()
+				.map(serviceInstances -> processInstanceResponse(supplier, serviceInstances));
+	}
+
+	private Response<ServiceInstance> processInstanceResponse(ServiceInstanceListSupplier supplier,
+			List<ServiceInstance> serviceInstances) {
+		Response<ServiceInstance> serviceInstanceResponse = getInstanceResponse(serviceInstances);
+		if (supplier instanceof SelectedInstanceCallback && serviceInstanceResponse.hasServer()) {
+			((SelectedInstanceCallback) supplier).selectedServiceInstance(serviceInstanceResponse.getServer());
+		}
+		return serviceInstanceResponse;
+	}
+
+	private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances) {
+		if (instances.isEmpty()) {
+			if (log.isWarnEnabled()) {
+				log.warn("No servers available for service: " + serviceId);
+			}
+			return new EmptyResponse();
+		}
+		int index = ThreadLocalRandom.current().nextInt(instances.size());
+
+		ServiceInstance instance = instances.get(index);
+
+		return new DefaultResponse(instance);
+	}
+
+}
+
+```
+
+��������ʵ�ֽ��м򵥷�д����
+
+```
+package cn.itxs.ecom.order.config;
+
+import java.util.List;
+import java.util.Random;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.cloud.client.ServiceInstance;
+import org.springframework.cloud.loadbalancer.core.ReactorServiceInstanceLoadBalancer;
+import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
+import org.springframework.cloud.client.loadbalancer.DefaultResponse;
+import org.springframework.cloud.client.loadbalancer.EmptyResponse;
+import org.springframework.cloud.client.loadbalancer.Request;
+import org.springframework.cloud.client.loadbalancer.Response;
+import reactor.core.publisher.Mono;
+
+public class ItxsRandomLoadBalancerClient implements ReactorServiceInstanceLoadBalancer {
+    // �����б�
+    private ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
+
+    public ItxsRandomLoadBalancerClient(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider) {
+        this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
+    }
+
+    @Override
+    public Mono<Response<ServiceInstance>> choose(Request request) {
+        ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider.getIfAvailable();
+        return supplier.get().next().map(this::getInstanceResponse);
+    }
+
+    /**
+     * ʹ���������ȡ����
+     * @param instances
+     * @return
+     */
+    private Response<ServiceInstance> getInstanceResponse(
+            List<ServiceInstance> instances) {
+        System.out.println("ItxsRandomLoadBalancerClient start");
+        if (instances.isEmpty()) {
+            return new EmptyResponse();
+        }
+
+        System.out.println("ItxsRandomLoadBalancerClient random");
+        // ����㷨
+        int size = instances.size();
+        Random random = new Random();
+        ServiceInstance instance = instances.get(random.nextInt(size));
+
+        return new DefaultResponse(instance);
+    }
+}
+
+```
+
+������CustomLoadBalancerConfiguration�滻Ϊ��������
+
+```
+package cn.itxs.ecom.order.config;
+
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.cloud.loadbalancer.core.ReactorServiceInstanceLoadBalancer;
+import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
+import org.springframework.context.annotation.Bean;
+
+public class CustomLoadBalancerConfiguration {
+
+    @Bean
+    public ReactorServiceInstanceLoadBalancer customLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider) {
+        return new ItxsRandomLoadBalancerClient(serviceInstanceListSupplierProvider);
+    }
+}
+
+```
+
+�������΢����Ͷ���΢���񣬷���http://localhost:4070/deductRest/1001/1 ������̨�Ѵ�ӡ�Զ���ItxsRandomLoadBalancerClient�е���־�ͳɹ����ʽ��
+
+![image-20220509003807968](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/c72e3f02f7e0d5d3343f8ae9c464b69c.png)
+
+![image-20220509003927550](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/59796bbbd6b3524e32759d42b622f1bc.png)
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudOpenFeign\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudOpenFeign\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..17db744
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudOpenFeign\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,902 @@
+���� | ��ľľ��
+��Դ |����ͷ��
+
+**ѧϰĿ��**
+
+1.  Ϊʲô��һ��ע�����ʵ��Զ�̹��̵����أ��Ƶ����ײ��ʵ�������̣�
+2.  OpenFeign��ôʵ��RPC�Ļ������ܵ�
+3.  ͨ��Դ����֤
+    **��1�� OpenFeign�������Ƶ�**
+    Ҫ��ȷOpenFeign���������������ǻ���Ҫ��ȷ���ĺ���Ŀ����ʲô��
+
+˵���ˣ�OpenFeign����ĵ�Ŀ������ÿͻ�����Զ�̵��ù����в���Ҫ��ʲô����IJ�����ֻҪ�õ�һ������Ȼ����øö���ķ����ͺ��ˣ�ʣ�µIJ���������OpenFeignȥ������ɣ���ʣ��һЩʲô�����أ�
+
+1.  ���ȿ϶��DZ�֤����ͨ�ţ������Ǵ󵨵ز²�һ�£�OpenFeign��ʵ�ײ�����Ƿ�װ������ĵ�ַ���˿ڡ���������Լ���Ӧ�IJ�����
+2.  ��Σ�������Ҫ�ö���ȥ���󷽷��������������Զ�̵ķ����������϶����򵥣�����Ҳ�󵨲²�һ�£��ö���Ҳ��OpenFeign�����Ǵ����ġ�
+3.  Ȼ���ڵ��ù����У�����������ɶ�̨�������ṩ�ģ������漰�����ؾ����ˣ���϶�Ҳ��OpenFeign����������ˡ�
+4.  ������������⣬������һ�£���Ȼ���ڷ�����Ǽ�Ⱥ��������Ƿ���˵ĵ�ַ�Ͷ˿ڻ���Ҫһ��ע��������ע�ᣬ��϶�Ҳ�����ɿͻ�������ɣ���Ϊ�ͻ���ֻ��עҵ����롣���붼�����룬Ҳ��OpenFeign������ˡ�
+
+OK�������Ƶ���OpenFeignӦ����ɵ���ҪĿ�꣬����������������������������ô���ġ�
+![SpringCloudϵ�С�Spring Cloud Դ�����֮OpenFeign-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/b45564c706ab4113cc23492cc0796907b851f8.jpg "SpringCloudϵ�С�Spring Cloud Դ�����֮OpenFeign-��Դ������������")֮ǰ�������н���һ�����������ʲô�����ֻҪ�Ǽ���spring����springboot�Ļ�����һ������ͨ��spring����springbootȥ����bean����Ĵ����ģ���ͨ�������õ�����֮����ȥ���ö���ĺ��ķ�������OpenFeign�ڼ���springboot��ʱ������ҲӦ����������
+
+1.  ���Ե�һ����OpenFeign����springboot��ͨ��springboot�õ�����bean����������ͼ�е�userService����
+2.  �������϶����򵥣�������ֻ��getUser�Ĺ��ܡ�����һ�룬spring����������ǿ������ʲô�����أ�����������������������;ͺ�֮�����ˣ���������
+3.  ���ô�������ķ���ʱ�������Ƚ��뵽invoke�У������invoke�У�������ǿ�����˸��ؾ���LoadBalance����Ϊ������������getUser��ʱ��Ҫ֪�������ǵ�����̨�������ķ���
+4.  ���ؾ�������͵�ƴ�Ӿ����http�������������ͷ�������ַ������˿��ˡ�
+    OK�����Ϸ�����OpenFeign�ײ�Ҫʵ�ֵľ��幦�ܣ�Ҳ���������Ĵ������̣���ô����������ͨ��Դ������֤һ�£����Dz�����ô��ġ�
+
+**��2�� Դ����֤**
+
+![SpringCloudϵ�С�Spring Cloud Դ�����֮OpenFeign-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/93070e354fbacedc2b85274846d2dde7dd170a.jpg "SpringCloudϵ�С�Spring Cloud Դ�����֮OpenFeign-��Դ������������")**2.1 EnableFeignClients**
+���Ǵ��������ע��������룬���ע�⿪����FeignClient�Ľ������̡�
+
+
+
+```
+@EnableFeignClients(basePackages = "com.example.client")
+```
+
+
+
+
+
+
+
+
+
+���ע����������£����õ���һ��@Importע�⣬����֪��Import����������һ��������ģ�������ȥ��һ��FeignClientsRegistrar�Ķ��塣
+
+
+
+```
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Documented
+@Import(FeignClientsRegistrar.class)
+public @interface EnableFeignClients {
+}
+```
+
+
+
+
+
+
+
+
+
+FeignClientsRegistrarʵ����
+ImportBeanDefinitionRegistrar������һ����̬ע��bean�Ľӿڣ�Spring Boot������ʱ�򣬻�ȥ����������е�registerBeanDefinitions��ʵ�ֶ�̬Bean��װ�ء�registerBeanDefinitions����spring��������ʱִ��invokeBeanFactoryPostProcessors������Ȼ�����Ӧ������н���ע�ᣬ��������������ImportSelector��
+
+
+
+```
+class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware,EnvironmentAware {
+    @Override
+    public void registerBeanDefinitions(AnnotationMetadata metadata,BeanDefinitionRegistry registry) {
+        registerDefaultConfiguration(metadata, registry);
+        registerFeignClients(metadata, registry);
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.1.1 ImportBeanDefinitionRegistrar**
+�򵥸������ʾһ��
+ImportBeanDefinitionRegistrar�����á�
+
+*   ����һ����Ҫ��װ�ص�IOC�����е���HelloService
+
+
+
+```
+public class HelloService {
+}
+```
+
+
+
+
+
+
+
+
+
+*   ����һ��Registrar��ʵ�֣�����һ��bean��װ�ص�IOC����
+
+
+
+```
+public class FeignImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
+    @Override
+    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
+        BeanDefinition beanDefinition = new GenericBeanDefinition();
+        beanDefinition.setBeanClassName(HelloService.class.getName());
+        registry.registerBeanDefinition("helloService",beanDefinition);
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+* ����һ��ע����
+
+
+
+  ```
+  @Retention(RetentionPolicy.RUNTIME)
+  @Target({ElementType.TYPE})
+  @Documented
+  @Import({FeignImportBeanDefinitionRegistrar.class})
+  public @interface EnableFeignTest {
+  }
+  ```
+
+
+
+
+
+
+
+
+
+* ������
+
+
+
+```
+@EnableFeignClients(basePackages = "com.example.clients")
+@EnableFeignTest
+@SpringBootApplication
+public class OpenfeignUserServiceApplication {
+    public static void main(String[] args) {
+        ConfigurableApplicationContext context = SpringApplication.run(OpenfeignUserServiceApplication.class, args);
+        System.out.println(context.getBean(HelloService.class));
+    }
+
+}
+```
+
+
+
+
+
+
+
+
+
+*   ͨ�������ʾ���Է��֣�HelloService���bean �Ѿ�װ�ص���IOC������
+    ����Ƕ�̬װ�صĹ���ʵ�֣��������@Configuration����ע�룬����˺ܶ������ԡ� ok���ٻص�FeignClient�Ľ���������
+
+**2.1.2 FeignClientsRegistrar**
+
+* registerDefaultConfiguration �����ڲ��� SpringBoot �������ϼ���Ƿ���@EnableFeignClients, �и�ע��Ļ��� ����� Feign �����ص�һЩ��������ע��
+
+* registerFeignClients �����ڲ��� classpath �У� ɨ���� @FeignClient ���ε��࣬ ��������ݽ���Ϊ BeanDefinition , ����ͨ������ Spring ����е�BeanDefinitionReaderUtils.resgisterBeanDefinition �������������� FeignClientBeanDeifinition ���ӵ� spring ������.
+
+
+
+  ```
+  @Override
+  public void registerBeanDefinitions(AnnotationMetadata metadata,BeanDefinitionRegistry registry) {
+      //ע��@EnableFeignClients�ж���defaultConfiguration�����µ��࣬��װ��FeignClientSpecification��ע�ᵽSpring������
+      //��@FeignClient����һ�����ԣ�configuration����������DZ�ʾ����FeignClient�Զ���������࣬����Ҳ��ͨ������registerClientConfiguration������ע���FeignClientSpecification��������
+      //���ԣ����������ȫ������@EnableFeignClients�����õ�����Ϊ���׵����ã��ڸ���@FeignClient���õľ����Զ���������
+      registerDefaultConfiguration(metadata, registry);
+      registerFeignClients(metadata, registry);
+  }
+  ```
+
+
+
+
+
+
+
+
+
+**2.2 registerDefaultConfiguration**
+
+
+
+  ```
+  private void registerDefaultConfiguration(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
+      // ��ȡ��metadata�й���EnableFeignClients������ֵ��ֵ�ԡ�
+      Map<String, Object> defaultAttrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName(), true);
+      //���������defaultConfiguration ��������,���û��ʹ��Ĭ�ϵ�configuration
+      if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
+          String name;
+          if (metadata.hasEnclosingClass()) {
+              name = "default." + metadata.getEnclosingClassName();
+          } else {
+              name = "default." + metadata.getClassName();
+          }
+          //����ע��
+          this.registerClientConfiguration(registry, name, defaultAttrs.get("defaultConfiguration"));
+      }
+  
+  }
+  ```
+
+
+
+
+
+
+
+
+
+
+
+```
+private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name, Object configuration) {
+    //ʹ��BeanDefinitionBuilder������BeanDefinition,����������ע��
+    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(FeignClientSpecification.class);
+    builder.addConstructorArgValue(name);
+    builder.addConstructorArgValue(configuration);
+    registry.registerBeanDefinition(name + "." + FeignClientSpecification.class.getSimpleName(), builder.getBeanDefinition());
+}
+```
+
+
+
+
+
+
+
+
+
+���������BeanDefinitionRegistry��spring������ڶ�̬ע��BeanDefinition��Ϣ�Ľӿڣ�����registerBeanDefinition�������Խ�BeanDefinitionע�ᵽSpring�����У�����name���Ծ���ע���BeanDefinition�����ƣ���������ע����һ��FeignClientSpecification�Ķ���
+
+FeignClientSpecificationʵ����
+NamedContextFactory.Specification�ӿڣ�����Feignʵ��������Ҫһ����������ķ����У��������Զ������õ����ʵ����SpringCloudʹ��NamedContextFactory����һЩ�е�����������ApplicationContext���ö�Ӧ��Specification����Щ�������д���ʵ������
+
+NamedContextFactory��3�����ܣ�
+
+*   ����AnnotationConfigApplicationContext�����ġ�
+*   ���������д�������ȡbeanʵ����
+*   ������������ʱ������е�feignʵ����
+    NamedContextFactory�и��dz���Ҫ������FeignContext�����ڴ洢����OpenFeign�����ʵ����
+
+
+
+```
+public class FeignContext extends NamedContextFactory<FeignClientSpecification> {
+    public FeignContext() {
+       super(FeignClientsConfiguration.class, "feign", "feign.client.name");
+    }
+ }
+```
+
+
+
+
+
+
+
+
+
+FeignContext�����ﹹ�����أ�
+
+���ü���
+pring-cloud-openfeign-core-2.2.3.RELEASE.jar!\META-INF\spring.factories![SpringCloudϵ�С�Spring Cloud Դ�����֮OpenFeign-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/d830f20713aca01438472786f5f84c7058232b.jpg "SpringCloudϵ�С�Spring Cloud Դ�����֮OpenFeign-��Դ������������")**2.2.1 FeignAutoConfiguration**
+
+![SpringCloudϵ�С�Spring Cloud Դ�����֮OpenFeign-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/894c73791fbf7215782217d7132bc57f004085.jpg "SpringCloudϵ�С�Spring Cloud Դ�����֮OpenFeign-��Դ������������")
+
+��Ĭ�ϵ�FeignClientsConfiguration��Ϊ�������ݸ����캯��
+
+FeignContext������ʱ��Ὣ֮ǰFeignClientSpecificationͨ��setConfigurations���ø�context�����ġ�
+
+**2.2.2 createContext**
+���������
+org.springframework.cloud.context.named.NamedContextFactory#createContext������
+
+FeignContext�ĸ����createContext�����Ὣ����
+AnnotationConfigApplicationContextʵ������ʵ������Ϊ��ǰ�����ĵ��������ģ����ڹ���feign����IJ�ͬʵ�����ڵ���FeignClientFactoryBean��getObject����ʱ���á���createContext���������Ļὲ�⣩
+
+
+
+```
+protected AnnotationConfigApplicationContext createContext(String name) {
+    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
+	//��ȡname����Ӧ��configuration,����о�ע�ᵽ��context��
+    if (this.configurations.containsKey(name)) {
+        for (Class<?> configuration : this.configurations.get(name)
+             .getConfiguration()) {
+            context.register(configuration);
+        }
+    }
+    //ע��default��Configuration,Ҳ���� FeignClientsRegistrar����registerDefaultConfiguration������ע���Configuration
+    for (Map.Entry<String, C> entry : this.configurations.entrySet()) {
+        if (entry.getKey().startsWith("default.")) {
+            for (Class<?> configuration : entry.getValue().getConfiguration()) {
+                context.register(configuration);
+            }
+        }
+    }
+    //ע��PropertyPlaceholderAutoConfiguration
+    context.register(PropertyPlaceholderAutoConfiguration.class,
+                     this.defaultConfigType);
+    //��Environment��propertySources����Դ
+    context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(
+        this.propertySourceName,
+        Collections.<String, Object>singletonMap(this.propertyName, name)));
+    if (this.parent != null) {
+        // Uses Environment from parent as well as beans
+        context.setParent(this.parent);
+        // jdk11 issue
+        // https://github.com/spring-cloud/spring-cloud-netflix/issues/3101
+        context.setClassLoader(this.parent.getClassLoader());
+    }
+    context.setDisplayName(generateDisplayName(name));
+    context.refresh();
+    return context;
+}
+```
+
+
+
+
+
+
+
+
+
+����NamedContextFactoryʵ����DisposableBean�����Ե�ʵ��������ʱ������
+
+
+
+```
+@Override
+public void destroy() {
+    Collection<AnnotationConfigApplicationContext> values = this.contexts.values();
+    for (AnnotationConfigApplicationContext context : values) {
+        // This can fail, but it never throws an exception (you see stack traces
+        // logged as WARN).
+        context.close();
+    }
+    this.contexts.clear();
+}
+```
+
+
+
+
+
+
+
+
+
+�ܽ᣺NamedContextFactory�ᴴ����
+AnnotationConfigApplicationContextʵ��������name��ΪΨһ��ʶ��Ȼ��ÿ��AnnotationConfigApplicationContextʵ������ע�Ჿ�������࣬�Ӷ����Ը���һϵ�еĻ������������ɵ����ʵ���������Ϳ��Ի���name������һϵ�е����ʵ����Ϊ��ͬ��FeignClient׼����ͬ�������ʵ����
+
+**2.3 registerFeignClients**
+���������Ҫ��ɨ����·�������е�@FeignClientע�⣬Ȼ����ж�̬Bean��ע�롣�����ջ���� registerFeignClient ������
+
+
+
+```
+public void registerFeignClients(AnnotationMetadata metadata,BeanDefinitionRegistry registry) {
+    //ʡ�Դ���...
+    registerFeignClient(registry, annotationMetadata, attributes);
+}
+```
+
+
+
+
+
+
+
+
+
+����������У�����ȥ��װBeanDefinition��Ҳ����Bean�Ķ��壬Ȼ��ע�ᵽSpring IOC������
+
+
+
+```
+private void registerFeignClient(BeanDefinitionRegistry registry,AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
+    String className = annotationMetadata.getClassName();
+    BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);
+    //ʡ�Դ���...
+    BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition,className,new String[] { alias });
+    BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
+}
+```
+
+
+
+
+
+
+
+
+
+���ǹ�עһ�£�BeanDefinitionBuilder����������һ��BeanDefinition�ģ�����ͨ��genericBeanDefinition �������ģ����Ҵ�����һ��FeignClientFactoryBean���ࡣ
+
+���ǿ��Է��֣�FeignClient����̬ע�����һ��FactoryBean
+
+> Spring Cloud FengnClientʵ����������Spring�Ĵ������������ɴ����࣬����������Ż�����е�FeignClient��BeanDefinition����ΪFeignClientFactoryBean���ͣ���FeignClientFactoryBean�̳���FactoryBean������һ������Bean��
+>
+> ��Spring�У�FactoryBean��һ������Bean��������������Bean��
+>
+> ���� Bean ��һ������� Bean, ���� Bean ����������˵�� ���߼����Ǹ�֪������� Bean ����ͨ�� Bean ���ǹ��� Bean, ֻ�ǰ��������Ļ�ȡ Bean ��ʽȥ���ã� ������bean ��󷵻ص�ʵ�����ǹ���Bean ������ ����ִ�й��� Bean �� getObject �߼����ص�ʾ������Ҳ������ʵ��������Bean��ʱ���ȥ��������getObject������
+
+
+
+```
+public static BeanDefinitionBuilder genericBeanDefinition(Class<?> beanClass) {
+    BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new GenericBeanDefinition());
+    builder.beanDefinition.setBeanClass(beanClass);
+    return builder;
+}
+```
+
+
+
+
+
+
+
+
+
+����˵��FeignClient��ע������ӿڣ���ͨ��
+FeignClientFactoryBean.getObject()����������һ����������
+
+**2.3.1 FeignClientFactoryBean.getObject**
+getObject���õ���getTarget����������applicationContextȡ��FeignContext��FeignContext�̳���NamedContextFactory������������ͳһά��feign�и���feign�ͻ����໥����������ġ�
+
+���ţ�����feign.builder���ڹ���ʱ����FeignContext��ȡ���õ�Encoder��Decoder�ȸ�����Ϣ��FeignContext����ƪ���Ѿ��ᵽ��Ϊÿ��Feign�ͻ��˷�����һ�����������ǵĸ���������spring����
+
+������Feign.Builder֮�����ж��Ƿ���ҪLoadBalance�������Ҫ����ͨ��LoadBalance�ķ��������á�ʵ�����������յ��õ���Target.target()������
+
+
+
+```
+@Override
+public Object getObject() throws Exception {
+    return getTarget();
+}
+<T> T getTarget() {
+    //ʵ����Feign�����Ķ���FeignContext
+    FeignContext context = this.applicationContext.getBean(FeignContext.class);
+    Feign.Builder builder = feign(context);//����Builder����
+    if (!StringUtils.hasText(this.url)) {//���urlΪ�գ����߸��ؾ��⣬�����и��ؾ��⹦�ܵĴ�����
+        if (!this.name.startsWith("http")) {
+            this.url = "http://" + this.name;
+        }
+        else {
+            this.url = this.name;
+        }
+        this.url += cleanPath();
+        return (T) loadBalance(builder, context,new HardCodedTarget<>(this.type, this.name,this.url));
+    }
+    //���ָ����url��������Ĭ�ϵĴ�����
+    if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
+        this.url = "http://" + this.url;
+    }
+    String url = this.url + cleanPath();
+    //����FeignContext��getInstance������ȡClient����
+    Client client = getOptional(context, Client.class);
+    if (client != null) {
+        if (client instanceof LoadBalancerFeignClient) {
+            // not load balancing because we have a url,
+            // but ribbon is on the classpath, so unwrap
+            client = ((LoadBalancerFeignClient) client).getDelegate();
+        }
+        if (client instanceof FeignBlockingLoadBalancerClient) {
+            // not load balancing because we have a url,
+            // but Spring Cloud LoadBalancer is on the classpath, so unwrap
+            client = ((FeignBlockingLoadBalancerClient) client).getDelegate();
+        }
+        builder.client(client);
+    }//����Ĭ�ϴ�����
+    Targeter targeter = get(context, Targeter.class);
+    return (T) targeter.target(this, builder, context,new HardCodedTarget<>(this.type, this.name,url));
+}
+```
+
+
+
+
+
+
+
+
+
+**2.3.2 loadBalance**
+���ɾ߱����ؾ���������feign�ͻ��ˣ�Ϊfeign�ͻ��˹�����󶨸��ؾ���ͻ���.
+
+Client client = (Client)this.getOptional(context, Client.class); ���������л�ȡһ��Client��Ĭ����LoadBalancerFeignClient��
+
+������FeignRibbonClientAutoConfiguration����Զ�װ�����У�ͨ��Importʵ�ֵ�
+
+
+
+```
+@Import({ HttpClientFeignLoadBalancedConfiguration.class,OkHttpFeignLoadBalancedConfiguration.class,DefaultFeignLoadBalancedConfiguration.class })
+```
+
+
+
+
+
+
+
+
+
+
+
+```
+protected <T> T loadBalance(Builder builder, FeignContext context,
+                            HardCodedTarget<T> target) {
+    Client client = (Client)this.getOptional(context, Client.class);
+    if (client != null) {
+        builder.client(client);
+        Targeter targeter = (Targeter)this.get(context, Targeter.class);
+        return targeter.target(this, builder, context, target);
+    } else {
+        throw new IllegalStateException("No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.3.3 DefaultTarget.target**
+
+
+
+```
+@Override
+public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,FeignContext context, Target.HardCodedTarget<T> target) {
+    return feign.target(target);
+}
+```
+
+
+
+
+
+
+
+
+
+**2.3.4 ReflectiveFeign.newInstance**
+�����������������һ����̬�����ķ����������ɶ�̬����֮ǰ�������ContractЭ�飨Э��������򣬽����ӿ����ע����Ϣ���������ڲ���MethodHandler�Ĵ�����ʽ��
+
+��ʵ�ֵĴ����п��Կ�����Ϥ��Proxy.newProxyInstance�������������ࡣ��������Ҫ��ÿ������Ľӿڷ��������ض��Ĵ���ʵ�֣�������������һ��MethodHandler�ĸ�����Ƕ�Ӧ���������InvocationHandler��
+
+
+
+```
+public <T> T newInstance(Target<T> target) {
+    //���ݽӿ����ContractЭ�������ʽ�������ӿ����ϵķ�����ע�⣬ת�����ڲ���MethodHandler������ʽ
+    Map<String, MethodHandler> nameToHandler = this.[targetToHandlersByName.apply(target)];
+    Map<Method, MethodHandler> methodToHandler = new LinkedHashMap();
+    List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList();
+    Method[] var5 = target.type().getMethods();
+    int var6 = var5.length;
+    for(int var7 = 0; var7 < var6; ++var7) {
+        Method method = var5[var7];
+        if (method.getDeclaringClass() != Object.class) {
+            if (Util.isDefault(method)) {
+                DefaultMethodHandler handler = new DefaultMethodHandler(method);
+                defaultMethodHandlers.add(handler);
+                methodToHandler.put(method, handler);
+            } else {
+                methodToHandler.put(method,nameToHandler.get(Feign.configKey(target.type(), method)));
+            }
+        }
+    }
+    InvocationHandler handler = this.factory.create(target, methodToHandler);
+    // ����Proxy.newProxyInstance Ϊ�ӿ��ഴ����̬ʵ�֣������е�����ת����InvocationHandler ������
+    T proxy = Proxy.newProxyInstance(target.type().getClassLoader(), new Class[]{target.type()}, handler);
+    Iterator var12 = defaultMethodHandlers.iterator();
+    while(var12.hasNext()) {
+        DefaultMethodHandler defaultMethodHandler = (DefaultMethodHandler)var12.next();
+        defaultMethodHandler.bindTo(proxy);
+    }
+    return proxy;
+}
+```
+
+
+
+
+
+
+
+
+
+**2.4 �ӿڶ���IJ�������**
+����FeignClient�ӿڵ�������������Ӧ���������ݡ�
+
+**2.4.1 targetToHandlersByName.apply(target)**
+����ContractЭ����򣬽����ӿ����ע����Ϣ���������ڲ����֣�
+
+targetToHandlersByName.apply(target);������ӿڷ����ϵ�ע�⣬�Ӷ��������������ȵ��ض���������Ϣ��Ȼ������һ��SynchronousMethodHandler Ȼ����Ҫά��һ��<method��MethodHandler>��map������InvocationHandler��ʵ��FeignInvocationHandler�С�
+
+
+
+```
+public Map<String, MethodHandler> apply(Target target) {
+    List<MethodMetadata> metadata = contract.parseAndValidateMetadata(target.type());
+    Map<String, MethodHandler> result = new LinkedHashMap<String,MethodHandler>();
+    for (MethodMetadata md : metadata) {
+        BuildTemplateByResolvingArgs buildTemplate;
+        if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null)
+        {
+            buildTemplate = new BuildFormEncodedTemplateFromArgs(md, encoder, queryMapEncoder,target);
+        } else if (md.bodyIndex() != null) {
+            buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder,queryMapEncoder, target);
+        } else {
+            buildTemplate = new BuildTemplateByResolvingArgs(md, queryMapEncoder,target);
+        }
+        if (md.isIgnored()) {
+            result.put(md.configKey(), args -> {
+                throw new IllegalStateException(md.configKey() + " is not a method handled by feign");
+            });
+        } else {
+            result.put(md.configKey(),
+                       factory.create(target, md, buildTemplate, options, decoder,errorDecoder));
+        }
+    }
+    return result;
+}
+```
+
+
+
+
+
+
+
+
+
+**2.4.2 SpringMvcContract**
+��ǰSpring Cloud ΢�����������У�Ϊ�˽���ѧϰ�ɱ���������Spring MVC�IJ���ע������� �����������Ҳ����˵ ��д�ͻ�������ӿں���д����˴���һ�����ͻ��˺ͷ���˿���ͨ��SDK�ķ�ʽ����Լ�����ͻ���ֻ��Ҫ�������˷�����SDK API���Ϳ���ʹ������ӿڵı��뷽ʽ�Խӷ���
+
+����̳���Contract.BaseContract��ʵ����ResourceLoaderAware�ӿڣ�
+
+�����þ��Ƕ�RequestMapping��RequestParam��RequestHeader��ע����н����ġ�
+
+**2.5 OpenFeign���ù���**
+��ǰ��ķ����У�����֪��OpenFeign���շ��ص���һ��#
+ReflectiveFeign.FeignInvocationHandler�Ķ���
+
+��ô���ͻ��˷�������ʱ������뵽
+FeignInvocationHandler.invoke�����У������Ҷ�֪��������һ����̬������ʵ�֡�
+
+
+
+```
+public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+    if (!"equals".equals(method.getName())) {
+        if ("hashCode".equals(method.getName())) {
+            return this.hashCode();
+        } else {
+            return "toString".equals(method.getName()) ? this.toString() :
+            ((MethodHandler)this.dispatch.get(method)).invoke(args);
+        }
+    } else {
+        try {
+            Object otherHandler = args.length > 0 && args[0] != null ?
+                Proxy.getInvocationHandler(args[0]) : null;
+            return this.equals(otherHandler);
+        } catch (IllegalArgumentException var5) {
+            return false;
+        }
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+�����ţ���invoke�����У������ this.dispatch.get(method)).invoke(args) ��this.dispatch.get(method) �᷵��һ��SynchronousMethodHandler,�������ش�����
+
+�����������ݲ���������ɵ�RequestTemplate�������������Http�����ģ�棬�������¡�
+
+
+
+```
+public Object invoke(Object[] argv) throws Throwable {
+    RequestTemplate template = this.buildTemplateFromArgs.create(argv);
+    Options options = this.findOptions(argv);
+    Retryer retryer = this.retryer.clone();
+    while(true) {
+        try {
+            return this.executeAndDecode(template, options);
+        } catch (RetryableException var9) {
+            RetryableException e = var9;
+            try {
+                retryer.continueOrPropagate(e);
+            } catch (RetryableException var8) {
+                Throwable cause = var8.getCause();
+                if (this.propagationPolicy == ExceptionPropagationPolicy.UNWRAP
+                    && cause != null) {
+                    throw cause;
+                }
+                throw var8;
+            }
+            if (this.logLevel != Level.NONE) {
+                this.logger.logRetry(this.metadata.configKey(), this.logLevel);
+            }
+        }
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+**2.5.1 executeAndDecode**
+���������Ĵ��룬�����Ѿ���restTemplateƴװ��ɣ�����Ĵ�������һ�� executeAndDecode() �������÷���ͨ��RequestTemplate����Request�������Ȼ������Http Client��ȡresponse������ȡ��Ӧ��Ϣ��
+
+
+
+```
+Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {
+    //ת��ΪHttp������
+    Request request = this.targetRequest(template);
+    if (this.logLevel != Level.NONE) {
+        this.logger.logRequest(this.metadata.configKey(), this.logLevel,request);
+    }
+    long start = System.nanoTime();
+    Response response;
+    try {
+        //����Զ��ͨ��
+        response = this.client.execute(request, options);
+        //��ȡ���ؽ��
+        response = response.toBuilder().request(request).requestTemplate(template).build();
+    } catch (IOException var16) {
+        if (this.logLevel != Level.NONE) {
+            this.logger.logIOException(this.metadata.configKey(), this.logLevel,var16, this.elapsedTime(start));
+        }
+        throw FeignException.errorExecuting(request, var16);
+    }
+    long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
+    boolean shouldClose = true;
+    Response var10;
+    try {
+        if (this.logLevel != Level.NONE) {
+            response = this.logger.logAndRebufferResponse(this.metadata.configKey(), this.logLevel,response, elapsedTime);
+        }
+        if (Response.class != this.metadata.returnType()) {
+            Object result;
+            Object var21;
+            if (response.status() >= 200 && response.status() < 300) {
+                if (Void.TYPE == this.metadata.returnType()) {
+                    var10 = null;
+                    return var10;
+                }
+                result = this.decode(response);
+                shouldClose = this.closeAfterDecode;
+                var21 = result;
+                return var21;
+            }
+            if (this.decode404 && response.status() == 404 && Void.TYPE != this.metadata.returnType()) {
+                result = this.decode(response);
+                shouldClose = this.closeAfterDecode;
+                var21 = result;
+                return var21;
+            }
+            throw this.errorDecoder.decode(this.metadata.configKey(), response);
+        }
+        if (response.body() == null) {
+            var10 = response;
+            return var10;
+        }
+        if (response.body().length() != null && (long)response.body().length() <= 8192L) {
+            byte[] bodyData = Util.toByteArray(response.body().asInputStream());
+            Response var11 = response.toBuilder().body(bodyData).build();
+            return var11;
+        }
+        shouldClose = false;
+        var10 = response;
+    } catch (IOException var17) {
+        if (this.logLevel != Level.NONE) {
+            this.logger.logIOException(this.metadata.configKey(), this.logLevel,var17, elapsedTime);
+        }
+        throw FeignException.errorReading(request, response, var17);
+    } finally {
+        if (shouldClose) {
+            Util.ensureClosed(response.body());
+        }
+    }
+    return var10;
+}
+```
+
+
+
+
+
+
+
+
+
+**2.5.2 Client.execute**
+Ĭ�ϲ���JDK�� HttpURLConnection ����Զ�̵��á�
+
+
+
+```
+@Override
+public Response execute(Request request, Options options) throws IOException {
+    HttpURLConnection connection = convertAndSend(request, options);
+    return convertResponse(connection, request);
+}
+Response convertResponse(HttpURLConnection connection, Request request) throws IOException {
+    int status = connection.getResponseCode();
+    String reason = connection.getResponseMessage();
+    if (status < 0) {
+        throw new IOException(format("Invalid status(%s) executing %s %s",status,connection.getRequestMethod(),connection.getURL()));
+    }
+    Map<String, Collection<String>> headers = new LinkedHashMap<>();
+    for (Map.Entry<String, List<String>> field :
+         connection.getHeaderFields().entrySet()) {
+        // response message
+        if (field.getKey() != null) {
+            headers.put(field.getKey(), field.getValue());
+        }
+    }
+    Integer length = connection.getContentLength();
+    if (length == -1) {
+        length = null;
+    }
+    InputStream stream;
+    if (status >= 400) {
+        stream = connection.getErrorStream();
+    } else {
+        stream = connection.getInputStream();
+    }
+    return Response.builder()
+        .status(status)
+        .reason(reason)
+        .headers(headers)
+        .request(request)
+        .body(stream, length)
+        .build();
+}
+```
+
+
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudRibbon\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudRibbon\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..d06f945
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringCloud\346\272\220\347\240\201\345\210\206\346\236\220/SpringCloudRibbon\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,955 @@
+**ѧϰĿ��**
+
+1.  �Ƶ�Ribbon�ĺ�������
+2.  ��дһ�����װ��Ribbon
+3.  ͨ��Դ����֤�Ƶ�������
+    **��1�� ���������Ƶ�**
+    ��ʵRibbon�ĺ������̺ܼ򵥣�������ʹ�ù������޷Ǿ���������һ��spring-cloud-starter-netflix-ribbon��jar����Ȼ���ڳ���������ʱ��ע����һ��RestTemplate�����ڸö�������������һ��@LoadBalancedע�⣬Ȼ����ͨ��RestTemplate����ȥ����URL��ʱ����ܸ��ݲ�ͬ�ĸ��ؾ������ȥ����ͬ�ķ��������ע�⣬����˵���jar����������ʲô�����أ�
+
+��������Ҫ���ף�spring-cloud-starter-netflix-ribbon���jar����������������֪�������ǻ���starter����ģ������϶�������springboot���Զ�װ��ԭ����������������ʱ���ṩ��һ���Զ������࣬����������Ҫ�õĶ���ע�뵽IoC��������ȥ�ˣ������ӹ���ɡ�
+
+Ȼ��Ҫ��RestTemplate����ȥ����Ŀ������ʱ�����ʱ�����ǿ϶���Ҫ����ʵ��IP�Ͷ˿����滻����������һ����ʵ���Ǻ��IJ��裬��Ҫ��ô���أ���ô����������֮ǰ����ַ�Ͷ˿���è��̫�ӻ�����ʵ���أ�
+
+�������ճ������У�����Ӧ��֪������һ����������һ����������ʵ������������������԰ɣ����ԣ�ʵ���Ͼ����ڻ�ȡRestTemplate�����ʱ�򣬽��ö�������������һ������������RestTemplate����ִ��ij��������ʱ�򣬶���ȥ����������ִ��һ�顣Ȼ��������ˡ�
+
+���������ͼ�Ƶ����£�![SpringCloudϵ�С�RibbonԴ�����-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1790fb324161913dd79098940f8102d652cd86.jpg "SpringCloudϵ�С�RibbonԴ�����-��Դ������������")**��2�� ���װ�Ribbonʵ��**
+����������Ƶ����̣����ǽ�������ʵ��һ�����װ��Ribbon��
+
+����IJ�������Ҫ��������˼·��
+
+1.����Ҫʵ��һ��starter�������������springboot����springboot��������ʱ������õ���Ӧ��RestTemplate��bean���󡣴���һ��Maven��quickstart��Ŀ
+
+2.Ȼ������
+
+
+
+```
+<?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.example</groupId>
+  myribbon-spring-cloud-starter
+  <version>1.0-SNAPSHOT</version>
+
+  <name>myribbon-spring-cloud-starter</name>
+  <!-- FIXME change it to the project's website -->
+  <url>http://www.example.com</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+    <spring-boot.version>2.3.2.RELEASE</spring-boot.version>
+  </properties>
+
+  <!-- RestTemplate����Ҫ�õ�SpringMVC -->
+  <dependencies>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      spring-boot-starter-web
+      <version>${spring-boot.version}</version>
+    </dependency>
+
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      spring-boot-starter-test
+      <version>${spring-boot.version}</version>
+    </dependency>
+
+    <!-- ��������漯����һЩ���Ľӿ� -->
+    <dependency>
+      <groupId>org.springframework.cloud</groupId>
+      spring-cloud-commons
+      <version>2.2.6.RELEASE</version>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
+      <plugins>
+        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
+        <plugin>
+          maven-clean-plugin
+          <version>3.1.0</version>
+        </plugin>
+        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
+        <plugin>
+          maven-resources-plugin
+          <version>3.0.2</version>
+        </plugin>
+        <plugin>
+          maven-compiler-plugin
+          <version>3.8.0</version>
+        </plugin>
+        <plugin>
+          maven-surefire-plugin
+          <version>2.22.1</version>
+        </plugin>
+        <plugin>
+          maven-jar-plugin
+          <version>3.0.2</version>
+        </plugin>
+        <plugin>
+          maven-install-plugin
+          <version>2.5.2</version>
+        </plugin>
+        <plugin>
+          maven-deploy-plugin
+          <version>2.8.2</version>
+        </plugin>
+        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
+        <plugin>
+          maven-site-plugin
+          <version>3.7.1</version>
+        </plugin>
+        <plugin>
+          maven-project-info-reports-plugin
+          <version>3.0.0</version>
+        </plugin>
+      </plugins>
+    </pluginManagement>
+  </build>
+</project>
+```
+
+
+
+
+
+
+
+
+
+3.����������
+
+
+
+```
+@Configuration
+public class MyRibbonAutoConfiguration {
+    //���װ��Ribbon�ǿ������ȥ��ɸ��ؾ����㷨�Լ���ʵ��ip�Ͷ˿��滻��
+    @Bean
+    public LoadBalancerClient loadBalancerClient(){
+        return new MyLoadBalancerClient();
+    }
+    //�ռ����д�MyLoadBalancedע���RestTemplate����
+    @MyLoadBalanced
+    @Autowired(required = false)
+    private List<RestTemplate> restTemplates = Collections.emptyList();
+    @Bean
+    @ConditionalOnMissingBean
+    public LoadBalancerRequestFactory loadBalancerRequestFactory(
+            LoadBalancerClient loadBalancerClient) {
+        return new LoadBalancerRequestFactory(loadBalancerClient);
+    }
+    //����Ǻ��ĵ�������
+    @Bean
+    public MyLoadBalancerInterceptor myLoadBalancerInterceptor(
+            LoadBalancerClient loadBalancerClient,
+            LoadBalancerRequestFactory requestFactory){
+        return new MyLoadBalancerInterceptor(loadBalancerClient,requestFactory);
+    }
+    //�ռ�����RestTemplate���������ﶼ������һ��������
+    @Bean
+    public SmartInitializingSingleton smartInitializingSingleton(
+            final MyLoadBalancerInterceptor myLoadBalancerInterceptor){
+        return ()->{
+            for (RestTemplate restTemplate : MyRibbonAutoConfiguration.this.restTemplates) {
+                List<ClientHttpRequestInterceptor> list = new ArrayList<>(
+                        restTemplate.getInterceptors());
+                list.add(myLoadBalancerInterceptor);
+                restTemplate.setInterceptors(list);
+            }
+        };
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+4.����MyLoadBalancerClient
+
+
+
+```
+public class MyLoadBalancerClient implements LoadBalancerClient {
+    @Autowired
+    AbstractEnvironment environment;
+    //1.�����������������������
+    @Override
+    public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
+        ServiceInstance server = this.choose(serviceId);
+        return execute(serviceId, server, request);
+    }	
+    //3.����ִ��Http����
+    @Override
+    public <T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException {
+        T returnVal = null;
+        try {
+            returnVal = request.apply(serviceInstance);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return returnVal;
+    } 
+	//4.��һ����������ʵ��ip��port�滻������
+    @Override
+    public URI reconstructURI(ServiceInstance instance, URI original) {
+        String host = instance.getHost();
+        int port = instance.getPort();
+        if (host.equals(original.getHost())
+                && port == original.getPort()
+                ) {
+            return original;
+        }
+        try {
+            StringBuilder sb = new StringBuilder();
+            sb.append("http").append("://");
+            if (!Strings.isNullOrEmpty(original.getRawUserInfo())) {
+                sb.append(original.getRawUserInfo()).append("@");
+            }
+            sb.append(host);
+            if (port >= 0) {
+                sb.append(":").append(port);
+            }
+            sb.append(original.getRawPath());
+            if (!Strings.isNullOrEmpty(original.getRawQuery())) {
+                sb.append("?").append(original.getRawQuery());
+            }
+            if (!Strings.isNullOrEmpty(original.getRawFragment())) {
+                sb.append("#").append(original.getRawFragment());
+            }
+            URI newURI = new URI(sb.toString());
+            return newURI;
+        }catch (URISyntaxException e){
+            throw new RuntimeException(e);
+        }
+    }
+    //2.���ؾ����㷨����һ�����з����ip�Ͷ˿�ѡ���������õ�������㷨
+    @Override
+    public ServiceInstance choose(String serviceId) {
+        Server instance = new Server(serviceId,null,"127.0.0.1",8080);
+        String sr = environment.getProperty(serviceId+".ribbon.listOfServers");
+        if (!StringUtils.isEmpty(sr)){
+            String[] arr = sr.split(",",-1);
+            Random selector = new Random();
+            int next = selector.nextInt(arr.length);
+            String a = arr[next];
+            String[] srr = a.split(":",-1);
+            instance.setHost(srr[0]);
+            instance.setPort(Integer.parseInt(srr[1]));
+        }
+        return instance;
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+5.���������߼���ʵ�ܼ򵥣���������������http����֮ǰ����ִ���ҵ��߼�
+
+
+
+```
+public class MyLoadBalancerInterceptor implements ClientHttpRequestInterceptor {
+    private LoadBalancerClient loadBalancerClient;
+    private LoadBalancerRequestFactory requestFactory;
+    public MyLoadBalancerInterceptor(LoadBalancerClient loadBalancerClient,
+                                   LoadBalancerRequestFactory requestFactory) {
+        this.loadBalancerClient = loadBalancerClient;
+        this.requestFactory = requestFactory;
+    }
+    @Override
+    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
+        final URI originalUri = request.getURI();
+        String serviceName = originalUri.getHost();
+        return this.loadBalancerClient.execute(serviceName,
+                this.requestFactory.createRequest(request, body, execution));
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+6.�����Լ���ע��
+
+
+
+```
+@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@Qualifier
+public @interface MyLoadBalanced {
+}
+```
+
+
+
+
+
+
+
+
+
+7.����һ���Լ���Serverʵ����
+
+
+
+```
+public class Server implements ServiceInstance {
+    private String serviceId;
+    private String instanceId;
+    private String host;
+    private int port;
+    public Server(String serviceId, String instanceId, String host, int port) {
+        this.serviceId = serviceId;
+        this.instanceId = instanceId;
+        this.host = host;
+        this.port = port;
+    }
+    public Server() {
+    }
+    public void setServiceId(String serviceId) {
+        this.serviceId = serviceId;
+    }
+    public void setInstanceId(String instanceId) {
+        this.instanceId = instanceId;
+    }
+    public void setHost(String host) {
+        this.host = host;
+    }
+    public void setPort(int port) {
+        this.port = port;
+    }
+    @Override
+    public String getInstanceId() {
+        return null;
+    }
+    @Override
+    public String getServiceId() {
+        return null;
+    }
+    @Override
+    public String getHost() {
+        return host;
+    }
+    @Override
+    public int getPort() {
+        return port;
+    }
+    @Override
+    public boolean isSecure() {
+        return false;
+    }
+    @Override
+    public URI getUri() {
+        return null;
+    }
+    @Override
+    public Map<String, String> getMetadata() {
+        return null;
+    }
+    @Override
+    public String getScheme() {
+        return null;
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+8.дspring.factories�ļ�
+
+
+
+```
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+    com.example.config.MyRibbonAutoConfiguration
+```
+
+
+
+
+
+
+
+
+
+9.���jar�������ԣ����Ե�ʱ����Ҫ�������ļ�
+
+
+
+```
+<serverName>.ribbon.listOfServers=127.0.0.1:2223,127.0.0.1:2222
+```
+
+
+
+
+
+
+
+
+
+**��3�� Դ����֤**
+**3.1 @LoadBalanced**
+���ϽڿεĴ��뿴������ֻ����RestTemplate�������һ��@LoadBalance,�Ϳ���ʵ�ָ��ؾ����ˣ��������ǵ������@LoadBalance����һ�£������ע��������һ��@Qualifierע�⡣��ע���޶��ĸ�beanӦ�ñ��Զ�ע�롣��Spring�޷��жϳ��ĸ�beanӦ�ñ�ע��ʱ��@Qualifierע����������������bean���Զ�ע�룬���Ӽ����롣
+
+
+
+```
+/**
+ * Annotation to mark a RestTemplate or WebClient bean to be configured to use a
+ * LoadBalancerClient.
+ * @author Spencer Gibb
+ */
+@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@Qualifier
+public @interface LoadBalanced {
+
+}
+```
+
+
+
+
+
+
+
+
+
+��ע���п���֪�������ע����������RestTemplate����ǣ���ʹ�ø��ؾ���ͻ��ˣ�LoadBalancerClient���������������ԣ����������ɵ�RestTemplate��bean��������ôһ��ע�⣬���bean�ͻ�����LoadBalancerClient��
+
+**3.2 LoadBalancerClient**
+��ô�����ٿ���LoadBalancerClient�Ĵ��룺
+
+
+
+```
+public interface LoadBalancerClient extends ServiceInstanceChooser {
+	<T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException;
+	<T> T execute(String serviceId, ServiceInstance serviceInstance,
+			LoadBalancerRequest<T> request) throws IOException;
+	URI reconstructURI(ServiceInstance instance, URI original);
+}
+public interface ServiceInstanceChooser {
+	ServiceInstance choose(String serviceId);
+}
+```
+
+
+
+
+
+
+
+
+
+LoadBalancerClient��һ���ӿڣ�����������������
+
+ServiceInstance choose(String serviceId);�ӷ������ϾͿ��Կ������Ǹ��ݴ����serviceId�������������Ӹ��ؾ�������ѡ��һ������ʵ��������ʵ��ͨ��ServiceInstance������ʾ��
+execute������ʹ�ôӸ��ؾ�������ѡ��ķ���ʵ����ִ���������ݡ�
+URI reconstructURI(ServiceInstance instance, URI original);�����������¹���һ��URI�ģ����ǵ������ڴ����У�ͨ��RestTemplate�������ʱ��д���Ƿ������ɣ���������ͻ����������URI����ת��������host+port��ͨ��host+port����ʽȥ�������
+**3.3 �Զ�װ��**
+��springboot����֮�󣬻�ͨ���Զ�װ���Զ�ȥ
+spring-cloud-netflix-ribbon���jar����META-INFĿ¼��spring.factories�ļ������ҽ�RibbonAutoConfiguration���������ע�롣����RibbonAutoConfiguration����������Ϊ����@AutoConfigureBeforeע�⣬�����ֻ����LoadBalancerAutoConfiguration�����ࡣ��LoadBalancerAutoConfiguration���У�spring�����Ὣ���б�@LoadBalanceע�����ε�beanע�뵽IOC������
+
+
+
+```
+@LoadBalanced
+@Autowired(required = false)
+private List<RestTemplate> restTemplates = Collections.emptyList();
+```
+
+
+
+
+
+
+
+
+
+ͬʱ����LoadBalancerAutoConfiguration�������л���Ϊÿ��RestTemplateʵ������LoadBalancerInterceptor��������
+
+��RibbonAutoConfiguration����ע����LoadBalancerClient�ӿڵ�ʵ����RibbonLoadBalancerClient
+
+
+
+```
+@Bean
+@ConditionalOnMissingBean(LoadBalancerClient.class)
+public LoadBalancerClient loadBalancerClient() {
+    return new RibbonLoadBalancerClient(springClientFactory());
+}
+```
+
+
+
+
+
+
+
+
+
+**3.4 ������**
+�������Զ��������У���restTemplateʵ��������LoadBalancerInterceptor�����������ԣ�����restTemplate����http����ʱ���ͻ�ִ�������������intercept������
+
+intercept�����У������request.getURI()����ȡ�����uri���ٻ�ȡhost�������ڷ���http�����ʱ�����õķ�������Ϊhost�����ԣ�����ͻ��õ����������ٵ��þ���LoadBalancerClientʵ����execute��������������
+
+LoadBalancerClient��ʵ����ΪRibbonLoadBalancerClient�����յĸ��ؾ�������������ִ�У����ԣ�����Ҫ��������RibbonLoadBalancerClient���߼���
+
+�ȿ���RibbonLoadBalancerClient�е�execute������
+
+
+
+```
+public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint)
+    throws IOException {
+    ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
+    Server server = getServer(loadBalancer, hint);
+    if (server == null) {
+        throw new IllegalStateException("No instances available for " + serviceId);
+    }
+    RibbonServer ribbonServer = new RibbonServer(serviceId, server,
+                                                 isSecure(server, serviceId),
+                                                 serverIntrospector(serviceId).getMetadata(server));
+
+    return execute(serviceId, ribbonServer, request);
+}
+
+@Override
+public <T> T execute(String serviceId, ServiceInstance serviceInstance,
+                     LoadBalancerRequest<T> request) throws IOException {
+    Server server = null;
+    if (serviceInstance instanceof RibbonServer) {
+        server = ((RibbonServer) serviceInstance).getServer();
+    }
+    if (server == null) {
+        throw new IllegalStateException("No instances available for " + serviceId);
+    }
+
+    RibbonLoadBalancerContext context = this.clientFactory
+        .getLoadBalancerContext(serviceId);
+    RibbonStatsRecorder statsRecorder = new RibbonStatsRecorder(context, server);
+    try {
+        T returnVal = request.apply(serviceInstance);
+        statsRecorder.recordStats(returnVal);
+        return returnVal;
+    }
+    // catch IOException and rethrow so RestTemplate behaves correctly
+    catch (IOException ex) {
+        statsRecorder.recordStats(ex);
+        throw ex;
+    }
+    catch (Exception ex) {
+        statsRecorder.recordStats(ex);
+        ReflectionUtils.rethrowRuntimeException(ex);
+    }
+    return null;
+}
+```
+
+
+
+
+
+
+
+
+
+��������ΪserviceId�ֶδ���������ͨ��getLoadBalancer��ȡloadBalancer���ٸ���loadBalancer��ȡserver��������getServer�Ĵ��룺
+
+
+
+```
+protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
+    if (loadBalancer == null) {
+        return null;
+    }
+    // Use 'default' on a null hint, or just pass it on?
+    return loadBalancer.chooseServer(hint != null ? hint : "default");
+}
+```
+
+
+
+
+
+
+
+
+
+���loadBalancerΪ�գ���ֱ�ӷ��ؿգ�����͵���loadBalancer��chooseServer��������ȡ��Ӧ��server��
+
+��һ��ILoadBalancer��һ���ӿڣ�����������һϵ�и��ؾ���ʵ�ֵķ�����
+
+
+
+```
+public interface ILoadBalancer {
+	public void addServers(List<Server> newServers);
+	public Server chooseServer(Object key);
+	public void markServerDown(Server server);
+	@Deprecated
+	public List<Server> getServerList(boolean availableOnly);
+    public List<Server> getReachableServers();
+	public List<Server> getAllServers();
+}
+```
+
+
+
+
+
+
+
+
+
+��Щ�������Ƚ�ֱ�ۣ������׾��ܲ³��Ǹ�ɶ�ģ�addServers����������һ��server���ϣ�chooseServer��ѡ��һ��server��markServerDown�������ij���������ߣ�getReachableServers��ȡ���õ�Server���ϣ�getAllServers�ǻ�ȡ���е�server���ϡ�
+ILoadBalancer�кܶ�ʵ�֣��Ǿ������õ��ĸ����أ���RibbonAutoConfiguration����ע��SpringClientFactory��ͨ��RibbonClientConfiguration�࿴��������������ڳ�ʼ����ʱ�򣬷�����ZoneAwareLoadBalancer��Ϊ���ؾ�������
+
+
+
+```
+@Bean
+@ConditionalOnMissingBean
+public ILoadBalancer ribbonLoadBalancer(IClientConfig config,
+                                        ServerList<Server> serverList, ServerListFilter<Server> serverListFilter,
+                                        IRule rule, IPing ping, ServerListUpdater serverListUpdater) {
+    if (this.propertiesFactory.isSet(ILoadBalancer.class, name)) {
+        return this.propertiesFactory.get(ILoadBalancer.class, config, name);
+    }
+    return new ZoneAwareLoadBalancer<>(config, rule, ping, serverList,
+                                       serverListFilter, serverListUpdater);
+}
+```
+
+
+
+
+
+
+
+
+
+**3.5 ZoneAwareLoadBalancer**
+ZoneAwareLoadBalancer�������п��Կ�������������ؾ�������zone���й�ϵ�ġ����濴��ZoneAwareLoadBalancer�е�chooseServer������
+
+> eureka�ṩ��region��zone�������������з��������������������������ѷ��AWS��
+> region�����Լ�����Ϊ�����ϵķ������������޵��������߻����������ٻ��߱����ȵȣ�û�о����С�����ơ�������Ŀ�����������������к�������region��
+> zone�����Լ�����Ϊregion�ڵľ������������˵region����Ϊ������Ȼ�󱱾��������������Ϳ����ڴ�region֮�»��ֳ�zone1,zone2����zone��
+
+
+
+```
+@Override
+public Server chooseServer(Object key) {
+    //ֻ�е����ؾ�������ά����ʵ��������Zone����ĸ�������1��ʱ��Ż�ִ��ѡ�����
+    //������ʹ�ø����ʵ��
+    if (!ENABLED.get() || getLoadBalancerStats().getAvailableZones().size() <= 1) {
+        logger.debug("Zone aware logic disabled or there is only one zone");
+        return super.chooseServer(key);
+    }
+    Server server = null;
+    try {
+        LoadBalancerStats lbStats = getLoadBalancerStats();
+        //Ϊ��ǰ���ؾ������е�����Zone����ֱ𴴽����գ�������zoneSnapshot�У���Щ�����е��������ں������㷨
+        Map<String, ZoneSnapshot> zoneSnapshot = ZoneAvoidanceRule.createSnapshot(lbStats);
+        logger.debug("Zone snapshots: {}", zoneSnapshot);
+        if (triggeringLoad == null) {
+            triggeringLoad = DynamicPropertyFactory.getInstance().getDoubleProperty(
+                "ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".triggeringLoadPerServerThreshold", 0.2d);
+        }
+
+        if (triggeringBlackoutPercentage == null) {
+            triggeringBlackoutPercentage = DynamicPropertyFactory.getInstance().getDoubleProperty(
+                "ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".avoidZoneWithBlackoutPercetage", 0.99999d);
+        }
+        //��ÿ���Zone����ļ��ϣ�getAvailableZones��ͨ��zoneSnapshotʵ�ֿ���������ѡ
+        Set<String> availableZones = ZoneAvoidanceRule.getAvailableZones(zoneSnapshot, triggeringLoad.get(), triggeringBlackoutPercentage.get());
+        logger.debug("Available zones: {}", availableZones);
+        if (availableZones != null &&  availableZones.size() < zoneSnapshot.keySet().size()) {
+            //���ѡ��һ��Zone����
+            String zone = ZoneAvoidanceRule.randomChooseZone(zoneSnapshot, availableZones);
+            logger.debug("Zone chosen: {}", zone);
+            if (zone != null) {
+                //��ö�Ӧ����ĸ��ؾ�����
+                BaseLoadBalancer zoneLoadBalancer = getLoadBalancer(zone);
+                //ѡ�����ķ���ʵ��
+                //��chooseServer�н���ʹ��IRule�ӿڵ�choose������ѡ��������ʵ���������IRule�ӿڵ�ʵ�ֻ�ʵ��ZoneAvoidanceRule����ѡ����ķ���ʵ����
+                server = zoneLoadBalancer.chooseServer(key);
+            }
+        }
+    } catch (Exception e) {
+        logger.error("Error choosing server using zone aware logic for load balancer={}", name, e);
+    }
+    if (server != null) {
+        return server;
+    } else {
+        logger.debug("Zone avoidance logic is not invoked.");
+        return super.chooseServer(key);
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+������������server��zone�Ϳ�������ѡ������ʵ��������һ��Server����
+
+���������ļ���������
+
+1.  setServerListForZones : �������Zone���з��񻮷�
+2.  chooseServer����Ҳ����Ҫ��zone�йصļ��㣬��ȻĬ�ϵ�Zoneֻ��һ��������ֱ���ǵ��õĸ����chooseServer��key)
+3.  getLoadBalancer(String zone) ����zoneȥ��ȡLoadBalancer
+4.  setRule(IRule rule) Ϊÿ�����ؾ��������ù���
+    ������Կ�������ʵ�����Ҫ�����Zone����һЩ���ദ�������ǽ�ԭ������ͬһ����ķ���ʵ�����ٸ��ݵ������л��֡���Ҳ��Ϊ���ܹ�������Ӧ�����õġ�
+
+**3.5.1 DynamicServerListLoadBalancer**
+
+> ZoneAwareLoadBalancer�ĸ���
+
+����ఴ��������˵���Ƕ�̬���ط����б�ʹ�õġ������м����Ƚ���Ҫ�ķ���
+
+1.  updateListOfServers:�����б������±��ػ���ķ����б�
+2.  enableAndInitLearnNewServersFeature:���������б����¶�ʱ����
+3.  ��������:@Monitor
+
+DynamicServerListLoadBalancer�ĺ��ľ��ǻ�ȡ�����б�����Eureka��Ĭ����ͨ��DomainExtractingServerList����ȡ�����������org.springframework.cloud.netflix.ribbon.eureka.EurekaRibbonClientConfiguration#ribbonServerList������û�м���Eureka����ʱ����
+
+**3.5.2 BaseLoadBalancer**
+
+> DynamicServerListLoadBalancer�ĸ���
+
+����Ĭ��ֵ
+
+*   Ĭ�ϵĸ��ؾ������RoundRobinRule
+*   Ĭ�ϵ�Ping����SerialPingStrategy
+*   ���з���ʵ��������allServerList
+*   ���߷���ʵ��������upServerList
+    ![SpringCloudϵ�С�RibbonԴ�����-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/b2db0bc66c3045288a762907ff72e01883bf20.jpg "SpringCloudϵ�С�RibbonԴ�����-��Դ������������")�����๹���н���Ӧ�ĸ��ؾ������ping���ԣ�ping�ȴ��ݹ���
+
+**ping����Щʲô��**
+
+PingTask��Ϊһ���߳����񣬾��Ƕ��ڼ������Ƿ񶼴���ServerListUpdater������»��Ʋ���ͻ������ribbon�Լ�ά����һ�׷�������ƣ���Ҫ��Ϊ�˽��ͷ���ʧ�ܵĸ��ʡ�Ĭ����ʹ��eurekaʱ��ping��ʹ�õ���NIWSDiscoveryPing����ɷ��񱣻��⡣��eureka �� ServerListUpdater��ˢ�·����б���![SpringCloudϵ�С�RibbonԴ�����-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/27db4c518aa7c100d427761832a9fa19fa8f04.jpg "SpringCloudϵ�С�RibbonԴ�����-��Դ������������")�����и����õĶ�ʱ��������˳��ķ������Ҿ����������Լ�д��ʱ��Ҳ����ʹ�á�
+
+������ͬһ����ʱ�������ִ��ʱ�䳬���˶�ʱ���ڣ���ô��һ����ʱ��������һ����ʱ����û��ִ����ʱ������ȡ����![SpringCloudϵ�С�RibbonԴ�����-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/f2d669b11f17530d2e62603d45949e934a5931.jpg "SpringCloudϵ�С�RibbonԴ�����-��Դ������������")����Ҳ���˺ܶ������ƣ��������з���ʵ����һ���µĶ���ʱʹ�õ��Ƕ��������Ǹ���allServers����ֻ�ܶ�����д��![SpringCloudϵ�С�RibbonԴ�����-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/711c81e67b2c1cd3fb91005f53ea1e1352ad9a.png "SpringCloudϵ�С�RibbonԴ�����-��Դ������������")�ڷ���ping�󣬽����ͨ���ķ������newUpList�У����ͨ��д������upServerList��ס��
+
+�������ֻ����һ��д���Ҳ��ܶ���![SpringCloudϵ�С�RibbonԴ�����-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/047543857174aa1130b0747d1d149ffd6d5632.jpg "SpringCloudϵ�С�RibbonԴ�����-��Դ������������")������ping�ڼ������й��ڶ�д����ԭ�����ʹ�á�
+
+��Ҫ���̾��ǣ�
+
+1.  ��ȡȫ������ʵ���б�
+2.  ������ʵ���Ƿ���pingServers
+3.  ������״̬�����ı�ķ���changedServers
+4.  ���������ߵķ���newUpList
+5.  ��newUpList��ֵ��upServerList ���߷���ʵ���б���
+
+������pingServers���Ǽ��������
+
+**BaseLoadBalancer���������ܼ���**
+
+1.  ��allServerList��upServerList�Ķ�д������
+2.  �ṩ��allServerList��upServerList����ɾ�Ĺ���
+3.  �ṩ��PingTask��ping�Ķ�ʱ���񣩣�Pinger��ping��ִ������
+4.  ���ڸ��ؾ������ѡ�����rule.choose(key)
+5.  �ṩĬ�ϵ�ping����SerialPingStrategy
+    **3.6 LoadBalancerRequest**
+    ͨ��ZoneAwareLoadBalancerѡ������Server֮���ٰ�װ��RibbonServer����֮ǰ���ص�server�Ǹö����е�һ���ֶΣ�����֮�⣬���з�����serviceId���Ƿ���Ҫʹ��https����Ϣ�����ͨ��LoadBalancerRequest��apply������������server�����󣬴Ӷ�ʵ���˸��ؾ��⡣
+
+������apply�����Ķ��壺
+
+
+
+```
+public interface LoadBalancerRequest<T> {
+    T apply(ServiceInstance instance) throws Exception;
+}
+```
+
+
+
+
+
+
+
+
+
+������ʱ�������ribbonServer���󣬱�����ServiceInstance���͵Ķ�����н��ա�ServiceInstance��һ���ӿڣ������˷�������ϵͳ�У�ÿ��ʵ����Ҫ�ṩ����Ϣ������serviceId��host��port�ȡ�
+
+LoadBalancerRequest��һ���ӿڣ����ջ�ͨ��ʵ�����apply����ȥִ�У�ʵ��������LoadBalancerInterceptor�е���RibbonLoadBalancerClient��execute����ʱ����������һ�������࣬����ͨ���鿴LoadBalancerInterceptor�Ĵ��뿴����
+
+����LoadBalancerRequest�������ʱ�򣬾���д��apply������apply�����У����½���һ��ServiceRequestWrapper���ڲ��࣬������У�����д��getURI������getURI���������loadBalancer��reconstructURI����������uri��
+
+��������Ѿ����Դ���֪��Ribbonʵ�ָ��ؾ���������ˣ�������RestTemplate������ע�⣬�ͻ���LoadBalancerClient�Ķ�������������Ҳ����RibbonLoadBalancerClient��ͬʱ��
+LoadBalancerAutoConfiguration��������ã�����һ��LoadBalancerInterceptor�������õ���������������restTemplate������ЩrestTemplate������LoadBalancerInterceptor��������
+
+��ͨ��restTemplate��������ʱ���ͻᾭ����������������������У��ͻ����RibbonLoadBalancerClient�еķ�������ȡ�����ݷ�������ͨ�����ؾ��ⷽ����ȡ������ʵ����Ȼ��ȥ�������ʵ����
+
+**3.7 ��ȡ�����б�**
+����˵����Щ������ζ�������и��ؾ���ģ����ǻ��и����⣬���������ʵ�����Ǵ�Eureka Server�ϻ�ȡ���ģ������ʵ���б�����λ�ȡ���أ���ô��֤���ʵ���б��е�ʵ���ǿ��õ��أ�
+
+��RibbonLoadBalancerClientѡ��ʵ����ʱ����ͨ��ILoadBalancer��ʵ������ݸ��ؾ����㷨ѡ�����ʵ���ģ�Ҳ����ZoneAwareLoadBalancer��chooseServer�е��߼����Ǿ����������������鿴ZoneAwareLoadBalancer�ļ̳й�ϵ�����Կ�������ͼ��ʾ��![SpringCloudϵ�С�RibbonԴ�����-��Դ������������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/425d8ff567d9ac6171f6036dab1726a7da04a3.jpg "SpringCloudϵ�С�RibbonԴ�����-��Դ������������")���Կ�������������ILoadBalancer�ӿڣ�AbstractLoadBalancer��̳�������ӿڣ�BaseLoadBalancer�̳���AbstractLoadBalancer�࣬
+DynamicServerListLoadBalancer�̳���BaseLoadBalancer��ZoneAwareLoadBalancer�̳���DynamicServerListLoadBalancer��
+
+ILoadBalancer�ӿڵĴ����Ѿ������ˣ����ڿ���AbstractLoadBalancer�Ĵ��룺
+
+
+
+```
+public abstract class AbstractLoadBalancer implements ILoadBalancer {
+    public enum ServerGroup{
+        ALL,
+        STATUS_UP,
+        STATUS_NOT_UP        
+    }    
+    /**
+     * delegate to {@link #chooseServer(Object)} with parameter null.
+     */
+    public Server chooseServer() {
+    	return chooseServer(null);
+    }
+    /**
+     * List of servers that this Loadbalancer knows about
+     * 
+     * @param serverGroup Servers grouped by status, e.g., {@link ServerGroup#STATUS_UP}
+     */
+    public abstract List<Server> getServerList(ServerGroup serverGroup);
+    /**
+     * Obtain LoadBalancer related Statistics
+     */
+    public abstract LoadBalancerStats getLoadBalancerStats();    
+}
+```
+
+
+
+
+
+
+
+
+
+����һ�������࣬�������һ��ö�٣��������������󷽷��������chooseServer������
+
+�����ٿ�BaseLoadBalancer�࣬BaseLoadBalancer������Ǹ��ؾ�������һ������ʵ���࣬��������Կ�������������list��
+
+
+
+```
+@Monitor(name = PREFIX + "AllServerList", type = DataSourceType.INFORMATIONAL)
+protected volatile List<Server> allServerList = Collections
+    .synchronizedList(new ArrayList<Server>());
+@Monitor(name = PREFIX + "UpServerList", type = DataSourceType.INFORMATIONAL)
+protected volatile List<Server> upServerList = Collections
+    .synchronizedList(new ArrayList<Server>());
+```
+
+
+
+
+
+
+
+
+
+�������Ͽ��������ά�����з����ʵ���б�����ά��״̬Ϊup��ʵ���б���
+���һ����Կ���BaseLoadBalancer��ʵ�ֵ�ILoadBalancer�ӿ��еķ�����������������������ȡ���õķ����б����ͻ��upServerList���أ���ȡ���еķ����б����ͻ��allServerList���ء�
+
+
+
+```
+@Override
+public List<Server> getReachableServers() {
+    return Collections.unmodifiableList(upServerList);
+}
+@Override
+public List<Server> getAllServers() {
+    return Collections.unmodifiableList(allServerList);
+}
+```
+
+
+
+
+
+
+
+
+
+���������ٿ�DynamicServerListLoadBalancer�ࡣ����ͷ�ϵ�ע�Ϳ���֪�����������Զ�̬�Ļ�ȡ�����б�����������filter�Է����б����й��ˡ�
+
+��DynamicServerListLoadBalancer���У��ܿ���������һ��ServerList���͵�serverListImpl�ֶΣ�ServerList��һ���ӿڣ�����������������
+
+
+
+```
+public interface ServerList<T extends Server> {
+    public List<T> getInitialListOfServers();
+    /**
+     * Return updated list of servers. This is called say every 30 secs
+     * (configurable) by the Loadbalancer's Ping cycle
+     * 
+     */
+    public List<T> getUpdatedListOfServers();   
+}
+```
+
+
+
+
+
+
+
+
+
+getInitialListOfServers�ǻ�ȡ��ʼ���ķ����б���
+getUpdatedListOfServers�ǻ�ȡ���µķ����б���
+ServerList�ж��ʵ���࣬�����õ��ĸ��أ�������
+EurekaRibbonClientConfiguration�����ҵ�������Ribbon��Eureka��ϵ��Զ������࣬����Ŀǰ����û������Eureka����ͨ�������ļ����ã����Ի���ConfigurationBasedServerList�ࡣ
+
+# �����
+https://lijunyi.xyz/docs/SpringCloud/SpringCloud.html#_2-2-x-%E5%88%86%E6%94%AF
+https://mp.weixin.qq.com/s/2jeovmj77O9Ux96v3A0NtA
+https://juejin.cn/post/6931922457741770760
+https://github.com/D2C-Cai/herring
+http://c.biancheng.net/springcloud
+https://github.com/macrozheng/springcloud-learning
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\345\233\275\351\231\205\345\214\226\345\212\237\350\203\275.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\345\233\275\351\231\205\345\214\226\345\212\237\350\203\275.md"
new file mode 100644
index 0000000..374388b
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\345\233\275\351\231\205\345\214\226\345\212\237\350\203\275.md"
@@ -0,0 +1,179 @@
+#### ���ʻ�
+
+* * *
+
+�ڿ���Ӧ�ó����ʱ�򣬾���������֧�ֶ����Ե���������֧�ֶ����ԵĹ��ܳ�֮Ϊ���ʻ���Ӣ����internationalization����дΪi18n����Ϊ����ĸi��ĩ��ĸn�м���18����ĸ����
+
+��������ض������ı��ػ����ܣ�Ӣ����localization����дΪL10n�����ػ���ָ���ݵ��������������������ڵ���ʾ�ȡ�
+
+Ҳ�а��������ߺϳ�Ϊȫ�򻯣�Ӣ����globalization����дΪg11n��
+
+��Java�У�֧�ֶ����Ժͱ��ػ���ͨ��`MessageFormat`���`Locale`ʵ�ֵģ�
+
+
+����WebӦ�ó���Ҫʵ�ֹ��ʻ����ܣ���Ҫ����ȾView��ʱ��Ҫ�Ѹ������Ե���Դ�ļ����������������ͬ���û�����ͬһ��ҳ��ʱ����ʾ�����Ծ��Dz�ͬ�ġ�
+
+������������Spring MVCӦ�ó��������ʵ�ֹ��ʻ���
+
+### ��ȡLocale
+
+ʵ�ֹ��ʻ��ĵ�һ���ǻ�ȡ���û���`Locale`����WebӦ�ó����У�HTTP�淶�涨�����������������Я��`Accept-Language`ͷ������ָʾ�û�������趨������˳���磺
+
+```  
+Accept-Language: zh-CN,zh;q=0.8,en;q=0.2  
+  
+```
+
+����HTTP����ͷ��ʾ����ѡ��������ģ����ѡ�����ģ����ѡ��Ӣ�ġ�`q`��ʾȨ�أ����������ǿɻ��һ���������ȼ�����������б�������ת��ΪJava��`Locale`����������û���`Locale`����������ͨ��ֻ����Ȩ����ߵ�`Locale`��
+
+Spring MVCͨ��`LocaleResolver`���Զ���`HttpServletRequest`�л�ȡ`Locale`���ж���`LocaleResolver`��ʵ���࣬������õ���`CookieLocaleResolver`��
+
+```  
+@Primary  
+@Bean  
+LocaleResolver createLocaleResolver() {  
+    var clr = new CookieLocaleResolver();    clr.setDefaultLocale(Locale.ENGLISH);    clr.setDefaultTimeZone(TimeZone.getDefault());    return clr;}  
+  
+```
+
+`CookieLocaleResolver`��`HttpServletRequest`�л�ȡ`Locale`ʱ�����ȸ���һ���ض���Cookie�ж��Ƿ�ָ����`Locale`�����û�У��ʹ�HTTPͷ��ȡ�������û�У��ͷ���Ĭ�ϵ�`Locale`��
+
+���û���һ�η�����վʱ��`CookieLocaleResolver`ֻ�ܴ�HTTPͷ��ȡ`Locale`����ʹ���������Ĭ�����ԡ�ͨ����վҲ�����û��Լ�ѡ�����ԣ���ʱ��`CookieLocaleResolver`�ͻ���û�ѡ������Դ�ŵ�Cookie�У���һ�η���ʱ���ͻ᷵���û��ϴ�ѡ������Զ����������Ĭ�����ԡ�
+
+### ��ȡ��Դ�ļ�
+
+�ڶ����ǰ�д����ģ���е��ַ�������Դ�ļ��ķ�ʽ�洢���ⲿ�����ڶ����ԣ����ļ����������Ϊ`messages`����ô��Դ�ļ����밴���·�ʽ����������classpath�У�
+
+*   Ĭ�����ԣ��ļ�������Ϊ`messages.properties`��
+*   �������ģ�Locale��`zh_CN`���ļ�������Ϊ`messages_zh_CN.properties`��
+*   ���ģ�Locale��`ja_JP`���ļ�������Ϊ`messages_ja_JP.properties`��
+*   �����������ԡ���
+
+ÿ����Դ�ļ�������ͬ��key�����磬Ĭ��������Ӣ�ģ��ļ�`messages.properties`�������£�
+
+```  
+language.select=Language  
+home=Home  
+signin=Sign In  
+copyright=Copyright?{0,number,#}  
+  
+```
+
+�ļ�`messages_zh_CN.properties`�������£�
+
+```  
+language.select=����  
+home=��ҳ  
+signin=��¼  
+copyright=��Ȩ����?{0,number,#}  
+  
+```
+
+### ����MessageSource
+
+�������Ǵ���һ��Spring�ṩ��`MessageSource`ʵ�������Զ���ȡ���е�`.properties`�ļ������ṩһ��ͳһ�ӿ���ʵ�֡����롱��
+
+```  
+// code, arguments, locale:  
+String text = messageSource.getMessage("signin", null, locale);  
+  
+```
+
+���У�`signin`��������`.properties`�ļ��ж����key���ڶ���������`Object[]`������Ϊ��ʽ��ʱ����IJ��������һ���������ǻ�ȡ���û�`Locale`ʵ����
+
+����`MessageSource`���£�
+
+```  
+@Bean("i18n")  
+MessageSource createMessageSource() {  
+    var messageSource = new ResourceBundleMessageSource();    // ָ���ļ���UTF-8����:  
+    messageSource.setDefaultEncoding("UTF-8");    // ָ�����ļ���:  
+    messageSource.setBasename("messages");    return messageSource;}  
+  
+```
+
+ע�⵽`ResourceBundleMessageSource`���Զ��������ļ����Զ�������������Ե���Դ�ļ�����������
+
+��ע�⵽Spring�����ᴴ����ֻһ��`MessageSource`ʵ���������Լ����������`MessageSource`��ר�Ÿ�ҳ����ʻ�ʹ�õģ��������Ϊ`i18n`������������`MessageSource`ʵ����ͻ��
+
+### ʵ�ֶ�����
+
+Ҫ��View��ʹ��`MessageSource`����`Locale`��������ԣ�����ͨ����дһ��`MvcInterceptor`���������Դע�뵽`ModelAndView`�У�
+
+```  
+@Component  
+public class MvcInterceptor implements HandlerInterceptor {  
+    @Autowired    LocaleResolver localeResolver;  
+    // ע��ע���MessageSource������i18n:  
+    @Autowired    @Qualifier("i18n")    MessageSource messageSource;  
+    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {        if (modelAndView != null) {            // �����û���Locale:  
+            Locale locale = localeResolver.resolveLocale(request);            // ����Model:  
+            modelAndView.addObject("__messageSource__", messageSource);            modelAndView.addObject("__locale__", locale);        }    }}  
+  
+```
+
+��Ҫ������`WebMvcConfigurer`��ע��`MvcInterceptor`�����ڣ��Ϳ�����View�е���`MessageSource.getMessage()`������ʵ�ֶ����ԣ�
+
+```  
+{{ __messageSource__.getMessage('signin', null, __locale__) }}  
+  
+```
+
+��������д����Ȼ���У�����ʽ̫�����ˡ�ʹ��Viewʱ��Ҫ����ÿ���ض���View���涨�ƹ��ʻ���������Pebble�У����ǿ��Է�װһ�����ʻ����������ƾ����»���`_`������һ�´���`ViewResolver`�Ĵ��룺
+
+```  
+@Bean  
+ViewResolver createViewResolver(@Autowired ServletContext servletContext, @Autowired @Qualifier("i18n") MessageSource messageSource) {  
+    var engine = new PebbleEngine.Builder()            .autoEscaping(true)            .cacheActive(false)            .loader(new Servlet5Loader(servletContext))            // ������չ:  
+            .extension(createExtension(messageSource))            .build();    var viewResolver = new PebbleViewResolver();    viewResolver.setPrefix("/WEB-INF/templates/");    viewResolver.setSuffix("");    viewResolver.setPebbleEngine(engine);    return viewResolver;}  
+  
+private Extension createExtension(MessageSource messageSource) {  
+    return new AbstractExtension() {        @Override        public Map<String, Function> getFunctions() {            return Map.of("_", new Function() {                public Object execute(Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) {                    String key = (String) args.get("0");                    List<Object> arguments = this.extractArguments(args);                    Locale locale = (Locale) context.getVariable("__locale__");                    return messageSource.getMessage(key, arguments.toArray(), "???" + key + "???", locale);                }                private List<Object> extractArguments(Map<String, Object> args) {                    int i = 1;                    List<Object> arguments = new ArrayList<>();                    while (args.containsKey(String.valueOf(i))) {                        Object param = args.get(String.valueOf(i));                        arguments.add(param);                        i++;                    }                    return arguments;                }                public List<String> getArgumentNames() {                    return null;                }            });        }    };}  
+  
+```
+
+���������ǿ��԰Ѷ�����ҳ���дΪ��
+
+```  
+{{ _('signin') }}  
+  
+```
+
+����Ǵ������Ķ����ԣ���Ҫ�Ѳ�������ȥ��
+
+```  
+<h5>{{ _('copyright', 2020) }}</h5>  
+  
+```
+
+ʹ������View����ʱ��ҲӦ����������ӿ�ʵ�ָ�������﷨��
+
+### �л�Locale
+
+���������Ҫ�����û��ֶ��л�`Locale`����дһ��`LocaleController`��ʵ�ָù��ܣ�
+
+```  
+@Controller  
+public class LocaleController {  
+    final Logger logger = LoggerFactory.getLogger(getClass());  
+    @Autowired    LocaleResolver localeResolver;  
+    @GetMapping("/locale/{lo}")    public String setLocale(@PathVariable("lo") String lo, HttpServletRequest request, HttpServletResponse response) {        // ���ݴ����lo����Localeʵ��:  
+        Locale locale = null;        int pos = lo.indexOf('_');        if (pos > 0) {            String lang = lo.substring(0, pos);            String country = lo.substring(pos + 1);            locale = new Locale(lang, country);        } else {            locale = new Locale(lo);        }        // �趨��Locale:  
+        localeResolver.setLocale(request, response, locale);        logger.info("locale is set to {}.", locale);        // ˢ��ҳ��:  
+        String referer = request.getHeader("Referer");        return "redirect:" + (referer == null ? "/" : referer);    }}  
+  
+```
+
+��ҳ������У�ͨ�������ϽǸ��û��ṩһ������ѡ���б���������Ч����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416194544.png)
+
+�л������ģ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230416194602.png)
+
+### ��
+
+������֧����Ҫ��HTTP�����н����û���Locale��Ȼ����Բ�ͬLocale��ʾ��ͬ�����ԣ�
+
+Spring MVCӦ�ó���ͨ��`MessageSource`��`LocaleResolver`�����Viewʵ�ֹ��ʻ���
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\345\270\270\347\224\250\345\212\237\350\203\275.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\345\270\270\347\224\250\345\212\237\350\203\275.md"
new file mode 100644
index 0000000..6b1c4bb
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\345\270\270\347\224\250\345\212\237\350\203\275.md"
@@ -0,0 +1,594 @@
+
+
+
+
+# Spring MVC ʹ��@Controllerע�ⶨ��һ��������
+
+
+
+2018-07-26 14:02 ����
+
+
+
+
+
+
+
+<section>
+
+> [Original] The `@Controller` annotation indicates that a particular class serves the role of a controller. Spring does not require you to extend any controller base class or reference the Servlet API. However, you can still reference Servlet-specific features if you need to.
+
+`@Controller`ע�������һ��������Ϊ�������Ľ�ɫ�����ڵġ�Spring��Ҫ����ȥ�̳��κο��������࣬Ҳ��Ҫ����ȥʵ��Servlet������API����Ȼ���������Ҫ�Ļ�Ҳ����ȥʹ���κ���Servlet��ص����Ժ���ʩ��
+
+> [Original] The `@Controller` annotation acts as a stereotype for the annotated class, indicating its role. The dispatcher scans such annotated classes for mapped methods and detects `@RequestMapping` annotations (see the next section).
+
+`@Controller`ע�������Ϊ�DZ���ע���ԭ�ͣ�stereotype������������������е��Ľ�ɫ����������`DispatcherServlet`����ɨ������ע����`@Controller`���࣬�������ͨ��`@RequestMapping`ע�����õķ����������һС�ڣ���
+
+> [Original] You can define annotated controller beans explicitly, using a standard Spring bean definition in the dispatcher��s context. However, the `@Controller` stereotype also allows for autodetection, aligned with Spring general support for detecting component classes in the classpath and auto-registering bean definitions for them.
+
+��Ȼ����Ҳ���Բ�ʹ��`@Controller`ע�����ʽ��ȥ���屻ע���bean�����ͨ����׼��Spring bean�Ķ��巽ʽ����dispather�����������������ü�������������`@Controller`ԭ���ǿ��Ա�����Զ����ģ�Spring֧��classpath·�����������Զ���⣬�Լ����Ѷ���bean���Զ�ע�ᡣ
+
+> [Original] To enable autodetection of such annotated controllers, you add component scanning to your configuration. Use the spring-context schema as shown in the following XML snippet:
+
+����Ҫ�������м������ɨ������ô�����������ܶ�ע����������Զ���⡣��ʹ������XML������ʾ��spring-context schema��
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:p="http://www.springframework.org/schema/p"
+    xmlns:context="http://www.springframework.org/schema/context"
+    xsi:schemaLocation="
+        http://www.springframework.org/schema/beans
+        http://www.springframework.org/schema/beans/spring-beans.xsd
+        http://www.springframework.org/schema/context
+        http://www.springframework.org/schema/context/spring-context.xsd">
+
+    <context:component-scan base-package="org.springframework.samples.petclinic.web"/>
+
+    <!-- ... -->
+
+</beans>
+```
+
+</section>
+
+
+
+
+
+
+
+# Spring MVC ʹ��@RequestMappingע��ӳ������·��
+
+
+
+2018-07-26 15:29 ����
+
+
+
+
+
+
+
+�����ʹ��`@RequestMapping`ע����������URL����`/appointments`�ȣ�ӳ�䵽�������ϻ�ij���ض��Ĵ����������ϡ�һ����˵���༶���ע�⸺��һ���ض��������ij��ģʽ��������·��ӳ�䵽һ���������ϣ�ͬʱͨ�����������ע����ϸ��ӳ�䣬�������ض���HTTP���󷽷�����GET����POST�������ȣ���HTTP�������Ƿ�Я���ض�������������������ӳ�䵽ƥ��ķ����ϡ�
+
+<section>
+
+������δ���ʾ������Petcare����չʾ����Spring MVC������ڿ�������ʹ��`@RequestMapping`ע�⣺
+
+```
+@Controller
+@RequestMapping("/appointments")
+public class AppointmentsController {
+
+    private final AppointmentBook appointmentBook;
+
+    @Autowired
+    public AppointmentsController(AppointmentBook appointmentBook) {
+        this.appointmentBook = appointmentBook;
+    }
+
+    @RequestMapping(method = RequestMethod.GET)
+    public Map<String, Appointment> get() {
+        return appointmentBook.getAppointmentsForToday();
+    }
+
+    @RequestMapping(path = "/{day}", method = RequestMethod.GET)
+    public Map<String, Appointment> getForDay(@PathVariable @DateTimeFormat(iso=ISO.DATE) Date day, Model model) {
+        return appointmentBook.getAppointmentsForDay(day);
+    }
+
+    @RequestMapping(path = "/new", method = RequestMethod.GET)
+    public AppointmentForm getNewForm() {
+        return new AppointmentForm();
+    }
+
+    @RequestMapping(method = RequestMethod.POST)
+    public String add(@Valid AppointmentForm appointment, BindingResult result) {
+        if (result.hasErrors()) {
+            return "appointments/new";
+        }
+        appointmentBook.addAppointment(appointment);
+        return "redirect:/appointments";
+    }
+}
+
+```
+
+�������ʾ���У�����ط���ʹ�õ���`@RequestMapping`ע�⡣��һ��ʹ�õ����������༶��ģ���ָʾ������`/appointments`��ͷ��·�����ᱻӳ�䵽�������¡�`get()`�����ϵ�`@RequestMapping`ע�������·�������˽�һ��ϸ������������GET����������������һ������·��Ϊ`/appointments`��HTTP����ΪGET�����󣬽������ս��뵽���������������`add()`����Ҳ�������Ƶ�ϸ������`getNewForm()`������ͬʱע�����ܹ����ܵ������HTTP������·������������£�һ��·��Ϊ`appointments/new`��HTTP����ΪGET�����󽫻ᱻ���������������
+
+`getForDay()`������չʾ��ʹ��`@RequestMapping`ע�����һ�����ɣ�URIģ�塣������URIģ�壬�����С�ڣ�
+
+�༶���`@RequestMapping`ע�Ⲣ���DZ���ġ������õĻ������е�·�����Ǿ���·�����������·�������µĴ���ʾ������PetClinic����չʾ��һ�����ж�������������Ŀ�������
+
+```
+@Controller
+public class ClinicController {
+
+    private final Clinic clinic;
+
+    @Autowired
+    public ClinicController(Clinic clinic) {
+        this.clinic = clinic;
+    }
+
+    @RequestMapping("/")
+    public void welcomeHandler() {
+    }
+
+    @RequestMapping("/vets")
+    public ModelMap vetsHandler() {
+        return new ModelMap(this.clinic.getVets());
+    }
+}
+
+```
+
+���ϴ���û��ָ�����������GET��������PUT/POST������������`@RequestMapping`ע��Ĭ�ϻ�ӳ�����е�HTTP���󷽷�������������ij�����󷽷�������ע����ָ��֮`@RequestMapping(method=GET)`����С��Χ��
+
+## @Controller���������棨AOP������
+
+��ʱ������ϣ��������ʱʹ��AOP������װ�ο����������統��ֱ���ڿ�������ʹ��`@Transactional`ע��ʱ����������£������Ƽ�ʹ���༶���ڿ�������ʹ�ã��Ĵ�����ʽ����һ���Ǵ�����������Ĭ���������������������ʵ��һЩ�ӿڣ����ýӿ��ֲ�֧��Spring Context�Ļص�������`InitializingBean`, `*Aware`�Ƚӿڣ�����Ҫ�����༶��Ĵ����ͱ����ֶ������ˡ����磬ԭ���������ļ�`<tx:annotation-driven/>`��Ҫ��ʽ����Ϊ`<tx:annotation-driven proxy-target-/>`��
+
+## Spring MVC 3.1������֧��@RequestMapping��һЩ��
+
+> They are recommended for use and even required to take advantage of new features in Spring MVC 3.1 and going forward.
+
+Spring 3.1��������һ����������ǿ`@RequestMapping`���ֱ���`RequestMappingHandlerMapping`��`RequestMappingHandlerAdapter`�������Ƽ�����һ�á��в���Spring MVC 3.1֮�����������ԣ�������ע�������DZ���ġ���MVC�����ռ��MVC Java������÷�ʽ�£������༰��������Ĭ���ǿ����ġ�������ʹ���������÷�ʽ��������Ա����ֶ����ò���ʹ�á���С�ڽ���Ҫ����һ�£��������֮ǰ��һЩ��Ҫ�仯��
+
+��Spring 3.1֮ǰ����ܻ���������ͬ�Ľ׶ηֱ����༶��ͷ������������ӳ�䡪�����ȣ�`DefaultAnnotationHanlderMapping`�������༶����ѡ��һ����������Ȼ����ͨ��`AnnotationMethodHandlerAdapter`��λ������Ҫ���õķ�����
+
+> [Original] With the new support classes in Spring 3.1, the `RequestMappingHandlerMapping` is the only place where a decision is made about which method should process the request. Think of controller methods as a collection of unique endpoints with mappings for each method derived from type and method-level `@RequestMapping` information.
+
+��������Spring 3.1��������������࣬`RequestMappingHandlerMapping`��Ϊ������������ʵ�ʷ�����Ψһһ���ط�������԰ѿ������е�һϵ�д�������������һϵ�ж����ķ���ڵ㣬ÿ�����༶��ͷ��������`@RequestMapping`ע���л�ȡ���㹻����1·��ӳ����Ϣ��
+
+> [Original] This enables some new possibilities. For once a `HandlerInterceptor` or a `HandlerExceptionResolver` can now expect the Object-based handler to be a `HandlerMethod`, which allows them to examine the exact method, its parameters and associated annotations. The processing for a URL no longer needs to be split across different controllers.
+
+�����µĴ�����ʽ�������µĿ����ԡ�֮ǰ��`HandlerInterceptor`��`HandlerExceptionResolver`���ڿ���ȷ���õ�������������϶���һ��`HandlerMethod`���ͣ�������ܹ���ȷ���˽����������������Ϣ���������IJ�����Ӧ�������ϵ�ע��ȡ��������ڲ�����һ��URL�Ĵ���������Ҳ����Ҫ�ָ�����ͬ�Ŀ���������ȥִ���ˡ�
+
+> [Original] There are also several things no longer possible: [Original] _Select a controller first with a `SimpleUrlHandlerMapping` or `BeanNameUrlHandlerMapping` and then narrow the method based on `@RequestMapping` annotations. [Original] _Rely on method names as a fall-back mechanism to disambiguate between two `@RequestMapping` methods that don��t have an explicit path mapping URL path but otherwise match equally, e.g. by HTTP method. In the new support classes `@RequestMapping` methods have to be mapped uniquely. [Original] * Have a single default method (without an explicit path mapping) with which requests are processed if no other controller method matches more concretely. In the new support classes if a matching method is not found a 404 error is raised.
+
+ͬʱ��Ҳ��������һЩ�仯��������Щ�����û����ô����ˣ�
+
+*   ��ͨ��`SimpleUrlHandlerMapping`��`BeanNameUrlHandlerMapping`���õ�����������Ŀ�������Ȼ��ͨ��`@RequestMapping`ע�����õ���Ϣ����λ������Ĵ���������
+*   ����������������Ϊѡ���������ı�׼������˵������ע����`@RequestMapping`�ķ������˷�������ӵ����ȫ��ͬ��URLӳ���HTTP���󷽷������°汾�£�`@RequestMapping`ע��ķ����������Ψһ������ӳ�䣻
+*   ����һ��Ĭ�Ϸ�������û������·��ӳ�䣩��������·���޷���ӳ�䵽�������¸���ȷ�ķ�����ȥʱ��Ϊ�������ṩĬ�ϴ��������°汾�У�����޷�Ϊһ�������ҵ����ʵĴ�����������ôһ��404���󽫱��׳���
+
+> [Original] The above features are still supported with the existing support classes. However to take advantage of new Spring MVC 3.1 features you��ll need to use the new support classes.
+
+���ʹ��ԭ�����࣬���ϵĹ��ܻ��ǿ������������ǣ����Ҫ����Spring MVC 3.1�汾�����ķ������ԣ������Ҫȥʹ���µ��ࡣ
+
+> [Original] ## URI Template Patterns
+
+## URIģ��
+
+> [Original] URI templates can be used for convenient access to selected parts of a URL in a `@RequestMapping` method.
+
+URIģ�����Ϊ���ٷ���`@RequestMapping`��ָ����URL��һ���ض��IJ����ṩ�ܴ�ı�����
+
+> [Original] A URI Template is a URI-like string, containing one or more variable names. When you substitute values for these variables, the template becomes a URI. The proposed RFC for URI Templates defines how a URI is parameterized. For example, the URI Template `http://www.example.com/users/{userId}` contains the variable userId. Assigning the value fred to the variable yields `http://www.example.com/users/fred`.
+
+URIģ����һ��������URI���ַ�����ֻ�������а�����һ�������ı�����������ʹ��ʵ�ʵ�ֵȥ�����Щ��������ʱ��ģ����˻�����һ��URI����URIģ���RFC�����ж�����һ��URI����ν��в������ġ�����˵��һ�����URIģ��`http://www.example.com/users/{userId}`�Ͱ�����һ��������_userId_����ֵ_fred_������������������ͱ����һ��URI��`http://www.example.com/users/fred`��
+
+> [Original] In Spring MVC you can use the `@PathVariable` annotation on a method argument to bind it to the value of a URI template variable:
+
+��Spring MVC��������ڷ���������ʹ��`@PathVariable`ע�⣬������URIģ���еIJ�����������
+
+```
+@RequestMapping(path="/owners/{ownerId}", method=RequestMethod.GET)
+public String findOwner(@PathVariable String ownerId, Model model) {
+    Owner owner = ownerService.findOwner(ownerId);
+    model.addAttribute("owner", owner);
+    return "displayOwner";
+}
+
+```
+
+> [Original] The URI Template "`/owners/{ownerId}`" specifies the variable name `ownerId`. When the controller handles this request, the value of `ownerId` is set to the value found in the appropriate part of the URI. For example, when a request comes in for `/owners/fred`, the value of `ownerId` is `fred`.
+
+URIģ��"`/owners/{ownerId}`"ָ����һ����������Ϊ`ownerId`����������������������ʱ��`ownerId`��ֵ�ͻᱻURIģ���ж�Ӧ���ֵ�ֵ����䡣����˵����������URI��`/owners/fred`����ʱ����`ownerId`��ֵ����`fred`. `
+
+> Ϊ�˴���`@PathVariables`ע�⣬Spring MVC����ͨ�����������ҵ�URIģ�������Ӧ�ı������������ע����ֱ��������
+>
+> ```
+> @RequestMapping(path="/owners/{ownerId}}", method=RequestMethod.GET)
+> public String findOwner(@PathVariable("ownerId") String theOwner, Model model) {
+>     // ����ķ������롭
+> }
+> 
+> ```
+>
+> ���ߣ����URIģ���еı������뷽���IJ���������ͬ�ģ�������Բ�����ָ��һ�Ρ�ֻҪ���ڱ����ʱ������debug��Ϣ��Spring MVC�Ϳ����Զ�ƥ��URLģ�����뷽����������ͬ�ı�������
+>
+> ```
+> @RequestMapping(path="/owners/{ownerId}", method=RequestMethod.GET)
+> public String findOwner(@PathVariable String ownerId, Model model) {
+>     // ����ķ������롭
+> }
+> 
+> ```
+>
+> [Original] A method can have any number of `@PathVariable` annotations:
+
+һ����������ӵ������������`@PathVariable`ע�⣺
+
+```
+@RequestMapping(path="/owners/{ownerId}/pets/{petId}", method=RequestMethod.GET)
+public String findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {
+    Owner owner = ownerService.findOwner(ownerId);
+    Pet pet = owner.getPet(petId);
+    model.addAttribute("pet", pet);
+    return "displayPet";
+}
+
+```
+
+> [Original] When a `@PathVariable` annotation is used on a `Map<String, String>` argument, the map is populated with all URI template variables.
+
+��`@PathVariable`ע�ⱻӦ����`Map<String, String>`���͵IJ�����ʱ����ܻ�ʹ������URIģ�������������map��
+
+> [Original] A URI template can be assembled from type and path level _@RequestMapping_ annotations. As a result the `findPet()` method can be invoked with a URL such as `/owners/42/pets/21`.
+
+URIģ����Դ��༶��ͷ�������� _@RequestMapping_ ע���ȡ���ݡ���ˣ���������`findPet()`�������Ա�������`/owners/42/pets/21`������URL·�ɲ����õ���
+
+```
+_@Controller_
+@RequestMapping("/owners/{ownerId}")
+public class RelativePathUriTemplateController {
+
+    @RequestMapping("/pets/{petId}")
+    public void findPet(_@PathVariable_ String ownerId, _@PathVariable_ String petId, Model model) {
+        // ����ʵ�����������
+    }
+
+}
+
+```
+
+> [Original] A `@PathVariable` argument can be of _any simple type_ such as int, long, Date, etc. Spring automatically converts to the appropriate type or throws a `TypeMismatchException` if it fails to do so. You can also register support for parsing additional data types. See [the section called "Method Parameters And Type Conversion"](https://linesh.gitbooks.io/spring-mvc-documentation-linesh-translation/content/publish/21-3/mvc.html#mvc-ann-typeconversion) and [the section called "Customizing WebDataBinder initialization"](https://linesh.gitbooks.io/spring-mvc-documentation-linesh-translation/content/publish/21-3/mvc.html#mvc-ann-webdatabinder).
+
+`@PathVariable`���Ա�Ӧ�������� _������_ �IJ����ϣ�����int��long��Date�����͡�Spring���Զ��ذ���Ѳ���ת���ɺ��ʵ����ͣ����ת��ʧ�ܣ����׳�һ��`TypeMismatchException`���������Ҫ���������������͵�ת����Ҳ����ע���Լ����ࡣ����Ҫ����ϸ����Ϣ���Բο�[����������������ת����һ��](http://docs.spring.io/spring-framework/docs/current/spring-framework-reference/html/mvc.html#mvc-ann-typeconversion)��[������WebDataBinder��ʼ�����̡�һ��](http://docs.spring.io/spring-framework/docs/current/spring-framework-reference/html/mvc.html#mvc-ann-webdatabinder)
+
+## ���������ʽ��URIģ��
+
+> [Original] Sometimes you need more precision in defining URI template variables. Consider the URL `"/spring-web/spring-web-3.0.5.jar"`. How do you break it down into multiple parts?
+
+��ʱ���������Ҫ��׼ȷ������һ��URIģ��ı���������˵���URL��`"/spring-web/spring-web-3.0.5.jar`����Ҫ��ô�����ֽ�ɼ���������IJ����أ�
+
+> [Original] The `@RequestMapping` annotation supports the use of regular expressions in URI template variables. The syntax is `{varName:regex}` where the first part defines the variable name and the second - the regular expression.For example:
+
+`@RequestMapping`ע��֧������URIģ�������ʹ���������ʽ���﷨��`{varName:regex}`�����е�һ���ֶ����˱��������ڶ����־�������ҪӦ�õ��������ʽ����������Ĵ���������
+
+```
+@RequestMapping("/spring-web/{symbolicName:[a-z-]+}-{version:\\d\\.\\d\\.\\d}{extension:\\.[a-z]+}")
+    public void handle(@PathVariable String version, @PathVariable String extension) {
+        // ���벿��ʡ��...
+    }
+}
+
+```
+
+## Path Patterns�����÷������׵���ζ��
+
+> [Original] In addition to URI templates, the `@RequestMapping` annotation also supports Ant-style path patterns (for example, `/myPath/*.do`). A combination of URI template variables and Ant-style globs is also supported (e.g. `/owners/*/pets/{petId}`).
+
+����URIģ���⣬`@RequestMapping`ע�⻹֧��Ant����·��ģʽ����`/myPath/*.do`�ȣ���������ˣ������԰�URIģ�������Ant����glob�������ʹ�ã�����`/owners/*/pets/{petId}`�������÷��ȣ���
+
+## ·����ʽ��ƥ��(Path Pattern Comparison)
+
+> [Original] When a URL matches multiple patterns, a sort is used to find the most specific match.
+
+��һ��URLͬʱƥ����ģ�壨pattern��ʱ�����ǽ���Ҫһ���㷨������������ƥ���һ����
+
+> [Original] A pattern with a lower count of URI variables and wild cards is considered more specific. For example `/hotels/{hotel}/*` has 1 URI variable and 1 wild card and is considered more specific than `/hotels/{hotel}/**` which as 1 URI variable and 2 wild cards.
+
+URIģ���������Ŀ��ͨ����������ܺ����ٵ��Ǹ�·��ģ���׼ȷ���ٸ����ӣ�`/hotels/{hotel}/*`���·��ӵ��һ��URI������һ��ͨ�������`/hotels/{hotel}/**`���·����ӵ��һ��URI����������ͨ�������ˣ�������Ϊǰ���Ǹ�׼ȷ��·��ģ�塣
+
+> [Original] If two patterns have the same count, the one that is longer is considered more specific. For example `/foo/bar*` is longer and considered more specific than `/foo/*`.
+
+�������ģ���URIģ��������ͨ��������ܺ�һ�£���·���������Ǹ�ģ���׼ȷ���ٸ����ӣ�`/foo/bar*`�ͱ���Ϊ��`/foo/*`��׼ȷ����Ϊǰ�ߵ�·��������
+
+> [Original] When two patterns have the same count and length, the pattern with fewer wild cards is considered more specific. For example `/hotels/{hotel}` is more specific than `/hotels/*`.
+
+�������ģ��������ͳ��Ⱦ�һ�£����Ǹ����и���ͨ�����ģ���Ǹ���׼ȷ�ġ����磬`/hotels/{hotel}`�ͱ�`/hotels/*`����ȷ��
+
+> [Original] There are also some additional special rules:
+
+����֮�⣬����һЩ�����Ĺ���
+
+> [Original] _The **default mapping pattern** `/*_`is less specific than any other pattern. For example`/api/{a}/{b}/{c}` is more specific.
+>
+> [Original] _A **prefix pattern** such as `/public/*_`is less specific than any other pattern that doesn't contain double wildcards. For example`/public/path3/{a}/{b}/{c}` is more specific.
+
+*   **Ĭ�ϵ�ͨ��ģʽ**`/**`���������е�ģʽ��������׼ȷ�����ȷ�˵��`/api/{a}/{b}/{c}`�ͱ�Ĭ�ϵ�ͨ��ģʽ`/**`Ҫ��׼ȷ
+*   **ǰ׺ͨ��**������`/public/**`)����Ϊ�������κβ�����˫ͨ�����ģʽ����׼ȷ������˵��`/public/path3/{a}/{b}/{c}`�ͱ�`/public/**`��׼ȷ
+
+> [Original] For the full details see `AntPatternComparator` in `AntPathMatcher`. Note that the PathMatcher can be customized (see [Section 21.16.11, "Path Matching"](https://linesh.gitbooks.io/spring-mvc-documentation-linesh-translation/content/publish/21-3/mvc.html#mvc-config-path-matching) in the section on configuring Spring MVC).
+
+�����ϸ����ο��������ࣺ`AntPatternComparator`��`AntPathMatcher`��ֵ��һ����ǣ�PathMatcher���ǿ������õģ���������Spring MVC��һ���е�[·����ƥ��](https://www.w3cschool.cn/spring_mvc_documentation_linesh_translation/spring_mvc_documentation_linesh_translation-cgvo27t2.html)һ��)��
+
+## ��ռλ����·��ģʽ��path patterns��
+
+> [Original] Patterns in `@RequestMapping` annotations support ${��} placeholders against local properties and/or system properties and environment variables. This may be useful in cases where the path a controller is mapped to may need to be customized through configuration. For more information on placeholders, see the javadocs of the `PropertyPlaceholderConfigurer` class.
+
+`@RequestMapping`ע��֧����·����ʹ��ռλ������ȡ��һЩ�������á�ϵͳ���á����������ȡ����������ʱ�����ã�����˵��������ӳ��·����Ҫͨ�����������Ƶij�����������˽�������ռλ������Ϣ�����Բο�`PropertyPlaceholderConfigurer`�������ĵ���
+
+## Suffix Pattern Matching
+
+## ��׺ģʽƥ��
+
+> [Original] By default Spring MVC performs `".*"` suffix pattern matching so that a controller mapped to `/person` is also implicitly mapped to `/person.*`. This makes it easy to request different representations of a resource through the URL path (e.g. `/person.pdf`, `/person.xml`).
+
+Spring MVCĬ�ϲ���`".*"`�ĺ�׺ģʽƥ��������·��ƥ�䣬��ˣ�һ��ӳ�䵽`/person`·���Ŀ�����Ҳ����ʽ�ر�ӳ�䵽`/person.*`����ʹ��ͨ��URL������ͬһ��Դ�ļ��IJ�ͬ��ʽ��ø��򵥣�����`/person.pdf`��`/person.xml`����
+
+> [Original] Suffix pattern matching can be turned off or restricted to a set of path extensions explicitly registered for content negotiation purposes. This is generally recommended to minimize ambiguity with common request mappings such as `/person/{id}` where a dot might not represent a file extension, e.g. `/person/joe@email.com` vs `/person/joe@email.com.json)`. Furthermore as explained in the note below suffix pattern matching as well as content negotiation may be used in some circumstances to attempt malicious attacks and there are good reasons to restrict them meaningfully.
+
+����Թر�Ĭ�ϵĺ�׺ģʽƥ�䣬������ʽ�ؽ�·����׺�޶���һЩ�ض���ʽ��for content negotiation purpose�������Ƽ����������������Լ���ӳ������ʱ���Դ�����һЩ�����ԣ�������������·��`/person/{id}`ʱ��·���еĵ�ź�����Ŀ��ܲ����������ݸ�ʽ������`/person/joe@email.com` vs `/person/joe@email.com.json`������������������Ҫ�ᵽ�ģ���׺ģʽͨ���Լ�����Э����ʱ���ܻᱻ�ڿ��������й�������ˣ��Ժ�׺ͨ�������������޶����кô��ġ�
+
+> [Original] See [Section 21.16.11, "Path Matching"](https://linesh.gitbooks.io/spring-mvc-documentation-linesh-translation/content/publish/21-3/mvc.html#mvc-config-path-matching) for suffix pattern matching configuration and also [Section 21.16.6, "Content Negotiation"](https://linesh.gitbooks.io/spring-mvc-documentation-linesh-translation/content/publish/21-3/mvc.html#mvc-config-content-negotiation) for content negotiation configuration.
+
+���ں�׺ģʽƥ����������⣬���Բο�[Spring MVC·��ƥ������](https://www.w3cschool.cn/spring_mvc_documentation_linesh_translation/spring_mvc_documentation_linesh_translation-cgvo27t2.html)����������Э�̵��������⣬���Բο�[Spring MVC ����Э��"](https://www.w3cschool.cn/spring_mvc_documentation_linesh_translation/spring_mvc_documentation_linesh_translation-h8br27sx.html)�����ݡ�
+
+## ��׺ģʽƥ����RFD
+
+> [Original] Reflected file download (RFD) attack was first described in a [paper by Trustwave](https://www.trustwave.com/Resources/SpiderLabs-Blog/Reflected-File-Download---A-New-Web-Attack-Vector/) in 2014\. The attack is similar to XSS in that it relies on input (e.g. query parameter, URI variable) being reflected in the response. However instead of inserting JavaScript into HTML, an RFD attack relies on the browser switching to perform a download and treating the response as an executable script if double-clicked based on the file extension (e.g. .bat, .cmd).
+
+RFD(Reflected file download)����������2014����[Trustwave��һƪ����](https://www.trustwave.com/Resources/SpiderLabs-Blog/Reflected-File-Download---A-New-Web-Attack-Vector/)�б�����ġ�����XSS������Щ���ƣ���Ϊ���ֹ�����ʽҲ������ijЩ����������Ҫ������루�����ѯ������URI�����ȣ���Ҳ�������response������ij����ʽ���֡���ͬ���ǣ�RFD����������ͨ����HTML��д��JavaScript������У��������������������ת������ҳ�棬�����ض���ʽ������.bat��.cmd�ȣ���response�����ǿ�ִ�нű���˫�����ͻ�ִ�С�
+
+> [Original] In Spring MVC `@ResponseBody` and `ResponseEntity` methods are at risk because they can render different content types which clients can request including via URL path extensions. Note however that neither disabling suffix pattern matching nor disabling the use of path extensions for content negotiation purposes alone are effective at preventing RFD attacks.
+
+Spring MVC��`@ResponseBody`��`ResponseEntity`�������з��յģ���Ϊ���ǻ���ݿͻ������󡪡�����URL��·����׺������Ⱦ��ͬ���������͡���ˣ����ú�׺ģʽƥ����߽��ý�Ϊ����Э�̿�����·���ļ���׺��Я�������Ƿ���RFD��������Ч��ʽ��
+
+> [Original] For comprehensive protection against RFD, prior to rendering the response body Spring MVC adds a `Content-Disposition:inline;filename=f.txt` header to suggest a fixed and safe download file filename. This is done only if the URL path contains a file extension that is neither whitelisted nor explicitly registered for content negotiation purposes. However it may potentially have side effects when URLs are typed directly into a browser.
+
+��Ҫ������RFD���߼��ı���ģʽ��������Spring MVC��Ⱦ��ʼ��������֮ǰ��������ͷ������һ������`Content-Disposition:inline;filename=f.txt`��ָ���̶��������ļ����ļ����������URL·���а�����һ���ļ�����������������չ��ʱ���ã�����չ���Ȳ��������б������������У�Ҳû�б���ʽ�ر�ע��������Э��ʱʹ�á���������������������һЩ�����ã����磬��URL��ͨ��������ֶ������ʱ��
+
+> [Original] Many common path extensions are whitelisted by default. Furthermore REST API calls are typically not meant to be used as URLs directly in browsers. Nevertheless applications that use custom `HttpMessageConverter` implementations can explicitly register file extensions for content negotiation and the Content-Disposition header will not be added for such extensions. See [Section 21.16.6, "Content Negotiation"](https://linesh.gitbooks.io/spring-mvc-documentation-linesh-translation/content/publish/21-3/mvc.html#mvc-config-content-negotiation).
+
+�ܶೣ�õ�·���ļ���׺Ĭ���DZ����εġ����⣬REST��APIһ���Dz�Ӧ��ֱ������URL�ġ�������������Լ�����`HttpMessageConverter`��ʵ�֣�Ȼ����ʽ��ע����������Э�̵��ļ����ͣ�����������Content-Dispositionͷ�����ᱻ���뵽����ͷ�С����[Spring MVC ����Э��](https://www.w3cschool.cn/spring_mvc_documentation_linesh_translation/spring_mvc_documentation_linesh_translation-h8br27sx.html)��
+
+> [Original] This was originally introduced as part of work for [CVE-2015-5211](http://pivotal.io/security/cve-2015-5211). Below are additional recommendations from the report:
+>
+> *   Encode rather than escape JSON responses. This is also an OWASP XSS recommendation. For an example of how to do that with Spring see [spring-jackson-owasp](https://github.com/rwinch/spring-jackson-owasp).
+> *   Configure suffix pattern matching to be turned off or restricted to explicitly registered suffixes only.
+> *   Configure content negotiation with the properties "useJaf" and "ignoreUnknownPathExtensions" set to false which would result in a 406 response for URLs with unknown extensions. Note however that this may not be an option if URLs are naturally expected to have a dot towards the end.
+> *   Add `X-Content-Type-Options: nosniff` header to responses. Spring Security 4 does this by default.
+
+�о���ڵķ������������ޣ���Ҫ�����˽�XSS������RFD������ϸ���ٷ���
+
+## �������
+
+> [Original] The URI specification [RFC 3986](http://tools.ietf.org/html/rfc3986#section-3.3) defines the possibility of including name-value pairs within path segments. There is no specific term used in the spec. The general "URI path parameters" could be applied although the more unique ["Matrix URIs"](http://www.w3.org/DesignIssues/MatrixURIs.html), originating from an old post by Tim Berners-Lee, is also frequently used and fairly well known. Within Spring MVC these are referred to as matrix variables.
+
+ԭ����URI�淶[RFC 3986](http://tools.ietf.org/html/rfc3986#section-3.3)��������·��������Я����ֵ�ԣ����淶û����ȷ�������ļ�ֵ�Զ���������˽С�URI·����������Ҳ�н�[������URI��](http://www.w3.org/DesignIssues/MatrixURIs.html)�ġ�������Tim Berners-Lee�������䲩�����ᵽ�������ʹ�õ�Ҫ����Ƶ��һЩ��֪����Ҳ����Щ������Spring MVC�У����dz������ļ�ֵ��Ϊ���������
+
+> [Original] Matrix variables can appear in any path segment, each matrix variable separated with a ";" (semicolon). For example: `"/cars;color=red;year=2012"`. Multiple values may be either "," (comma) separated `"color=red,green,blue"` or the variable name may be repeated `"color=red;color=green;color=blue"`.
+
+��������������κ�·�������г��֣�ÿ�Ծ������֮��ʹ��һ���ֺš�;������������������URI��`"/cars;color=red;year=2012"`�����ֵ�����ö��Ÿ���`"color=red,green,blue"`�������ظ����������`"color=red;color=green;color=blue"`��
+
+> [Original] If a URL is expected to contain matrix variables, the request mapping pattern must represent them with a URI template. This ensures the request can be matched correctly regardless of whether matrix variables are present or not and in what order they are provided.
+
+���һ��URL�п�����Ҫ���������������ô������·����ӳ�������Ͼ���Ҫʹ��URIģ����������һ�㡣��������ȷ��������Ա���ȷ��ӳ�䣬�����ܾ��������URI���Ƿ���֡����ֵĴ����������ȡ�
+
+> [Original] Below is an example of extracting the matrix variable "q":
+
+������һ�����ӣ�չʾ��������δӾ�������л�ȡ��������q����ֵ��
+
+```
+// GET /pets/42;q=11;r=22
+
+@RequestMapping(path = "/pets/{petId}", method = RequestMethod.GET)
+public void findPet(@PathVariable String petId, @MatrixVariable int q) {
+
+    // petId == 42
+    // q == 11
+
+}
+
+```
+
+> [Original] Since all path segments may contain matrix variables, in some cases you need to be more specific to identify where the variable is expected to be:
+
+��������·�������ж����Ժ��о����������ijЩ�����£�����Ҫ�ø���ȷ����Ϣ��ָ��һ�����������λ�ã�
+
+```
+// GET /owners/42;q=11/pets/21;q=22
+
+@RequestMapping(path = "/owners/{ownerId}/pets/{petId}", method = RequestMethod.GET)
+public void findPet(
+    @MatrixVariable(name="q", pathVar="ownerId") int q1,
+    @MatrixVariable(name="q", pathVar="petId") int q2) {
+
+    // q1 == 11
+    // q2 == 22
+
+}
+
+```
+
+> [Original] A matrix variable may be defined as optional and a default value specified:
+
+��Ҳ��������һ������������DZ�����ֵģ���������һ��Ĭ��ֵ��
+
+```
+// GET /pets/42
+
+@RequestMapping(path = "/pets/{petId}", method = RequestMethod.GET)
+public void findPet(@MatrixVariable(required=false, defaultValue="1") int q) {
+
+    // q == 1
+
+}
+
+```
+
+> [Original] All matrix variables may be obtained in a Map:
+
+Ҳ����ͨ��һ��Map���洢���еľ��������
+
+```
+// GET /owners/42;q=11;r=12/pets/21;q=22;s=23
+
+@RequestMapping(path = "/owners/{ownerId}/pets/{petId}", method = RequestMethod.GET)
+public void findPet(
+    @MatrixVariable Map<String, String> matrixVars,
+    @MatrixVariable(pathVar="petId") Map<String, String> petMatrixVars) {
+
+    // matrixVars: ["q" : [11,22], "r" : 12, "s" : 23]
+    // petMatrixVars: ["q" : 11, "s" : 23]
+
+}
+
+```
+
+> [Original] Note that to enable the use of matrix variables, you must set the `removeSemicolonContent`property of `RequestMappingHandlerMapping` to `false`. By default it is set to `true`.
+
+���Ҫ�������������ʹ�ã�������`RequestMappingHandlerMapping`���`removeSemicolonContent`��������Ϊ`false`����ֵĬ����`true`�ġ�
+
+> [Original] The MVC Java config and the MVC namespace both provide options for enabling the use of matrix variables.
+>
+> MVC��Java������ú������ռ����ö��ṩ�����þ�������ķ�ʽ��
+>
+> [Original] If you are using Java config, The [Advanced Customizations with MVC Java Config](https://linesh.gitbooks.io/spring-mvc-documentation-linesh-translation/content/publish/21-3/mvc.html#mvc-config-advanced-java) section describes how the `RequestMappingHandlerMapping` can be customized.
+>
+> �������ʹ��Java��̵ķ�ʽ��[��MVC Java�߼����ƻ����á�һ��](http://docs.spring.io/spring-framework/docs/current/spring-framework-reference/html/mvc.html#mvc-config-advanced-java)��������ζ�`RequestMappingHandlerMapping`���ж��ơ�
+>
+> [Original] In the MVC namespace, the `<mvc:annotation-driven>` element has an `enable-matrix-variables` attribute that should be set to `true`. By default it is set to `false`.
+>
+> ��ʹ��MVC�������ռ�����ʱ������԰�`<mvc:annotation-driven>`Ԫ���µ�`enable-matrix-variables`��������Ϊ`true`����ֵĬ�������������Ϊ`false`�ġ�
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:mvc="http://www.springframework.org/schema/mvc"
+    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
+        http://www.springframework.org/schema/mvc
+        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
+
+    <mvc:annotation-driven enable-matrix-variables="true"/>
+
+</beans>
+
+```
+
+## �����ѵ�ý������
+
+> [Original] You can narrow the primary mapping by specifying a list of consumable media types. The request will be matched only if the _Content-Type_ request header matches the specified media type. For example:
+
+�����ָ��һ������ѵ�ý�����ͣ���Сӳ��ķ�Χ������ֻ�е�����ͷ�� _Content-Type_ ��ֵ��ָ�������ѵ�ý������������ͬ��ʱ������Żᱻƥ�䡣��������������ӣ�
+
+```
+@Controller
+@RequestMapping(path = "/pets", method = RequestMethod.POST, consumes="application/json")
+public void addPet(@RequestBody Pet pet, Model model) {
+    // ����ʵ��ʡ��
+}
+
+```
+
+> [Original] Consumable media type expressions can also be negated as in _!text/plain_ to match to all requests other than those with _Content-Type_ of _text/plain_. Also consider using constants provided in `MediaType` such as `APPLICATION_JSON_VALUE` and `APPLICATION_JSON_UTF8_VALUE`.
+
+ָ��������ý�����͵ı���ʽ�л�����ʹ�÷񶨣����磬����ʹ�� _!text/plain_ ��ƥ����������ͷ _Content-Type_ �в��� _text/plain_ ������ͬʱ����`MediaType`���л�������һЩ����������`APPLICATION_JSON_VALUE`��`APPLICATION_JSON_UTF8_VALUE`�ȣ��Ƽ������ʹ�����ǡ�
+
+> [Original] The _consumes_ condition is supported on the type and on the method level. Unlike most other conditions, when used at the type level, method-level consumable types override rather than extend type-level consumable types.
+>
+> _consumes_ �����ṩ���Ƿ�����������֧�֡����������Բ�ͬ���������ͼ�ʹ��ʱ�����������������ͽ��������ͼ������ã����Ǽ̳й�ϵ��
+
+## ��������ý������
+
+> [Original] You can narrow the primary mapping by specifying a list of producible media types. The request will be matched only if the _Accept_ request header matches one of these values. Furthermore, use of the _produces_ condition ensures the actual content type used to generate the response respects the media types specified in the _produces_ condition. For example:
+
+�����ָ��һ���������ý�����ͣ���Сӳ��ķ�Χ������ֻ�е�����ͷ�� _Accept_ ��ֵ��ָ����������ý������������ͬ��ʱ������Żᱻƥ�䡣���ң�ʹ�� _produces_ ��������ȷ������������Ӧ��response����������ָ���Ŀ�������ý����������ͬ�ġ��ٸ����ӣ�
+
+```
+@Controller
+@RequestMapping(path = "/pets/{petId}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
+@ResponseBody
+public Pet getPet(@PathVariable String petId, Model model) {
+    // ����ʵ��ʡ��
+}
+
+```
+
+> [Original] Be aware that the media type specified in the _produces_ condition can also optionally specify a character set. For example, in the code snippet above we specify the same media type than the default one configured in `MappingJackson2HttpMessageConverter`, including the `UTF-8`charset.
+>
+> Ҫע����ǣ�ͨ�� _condition_ ����ָ����ý������Ҳ����ָ���ַ����������������С�δ����У����ǻ��Ǹ�д��`MappingJackson2HttpMessageConverter`����Ĭ�����õ�ý�����ͣ�ͬʱ����ָ����ʹ��`UTF-8`���ַ�����
+>
+> [Original] Just like with _consumes_, producible media type expressions can be negated as in _!text/plain_ to match to all requests other than those with an _Accept_ header value of _text/plain_. Also consider using constants provided in `MediaType` such as `APPLICATION_JSON_VALUE` and `APPLICATION_JSON_UTF8_VALUE`.
+
+�� _consumes_ �������ƣ���������ý�����ͱ���ʽҲ����ʹ�÷񶨡����磬����ʹ�� _!text/plain_ ��ƥ����������ͷ _Accept_ �в��� _text/plain_ ������ͬʱ����`MediaType`���л�������һЩ����������`APPLICATION_JSON_VALUE`��`APPLICATION_JSON_UTF8_VALUE`�ȣ��Ƽ������ʹ�����ǡ�
+
+> [Original] The _produces_ condition is supported on the type and on the method level. Unlike most other conditions, when used at the type level, method-level producible types override rather than extend type-level producible types.
+>
+> _produces_ �����ṩ���Ƿ�����������֧�֡����������Բ�ͬ���������ͼ�ʹ��ʱ�����������������ͽ��������ͼ������ã����Ǽ̳й�ϵ��
+
+## �������������ͷ��ֵ
+
+> [Original] You can narrow request matching through request parameter conditions such as `"myParam"`, `"!myParam"`, or `"myParam=myValue"`. The first two test for request parameter presence/absence and the third for a specific parameter value. Here is an example with a request parameter value condition:
+
+�����ɸѡ�����������������С����ƥ�䷶Χ������`"myParam"`��`"!myParam"`��`"myParam=myValue"`�ȡ�ǰ������������ɸѡ����/������ijЩ������������󣬵���������ɸѡ�����ض�����ֵ�����������и����ӣ�չʾ�����ʹ���������ֵ��ɸѡ������
+
+```
+@Controller
+@RequestMapping("/owners/{ownerId}")
+public class RelativePathUriTemplateController {
+
+    @RequestMapping(path = "/pets/{petId}", method = RequestMethod.GET, params="myParam=myValue")
+    public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {
+        // ʵ��ʵ��ʡ��
+    }
+
+}
+
+```
+
+> [Original] The same can be done to test for request header presence/absence or to match based on a specific request header value:
+
+ͬ�������������ͬ��������ɸѡ����ͷ�ij�����񣬻���ɸѡ��һ�������ض�ֵ������ͷ��
+
+```
+@Controller
+@RequestMapping("/owners/{ownerId}")
+public class RelativePathUriTemplateController {
+
+    @RequestMapping(path = "/pets", method = RequestMethod.GET, headers="myHeader=myValue")
+    public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {
+        // ������ʵ��ʡ��
+    }
+
+}
+
+```
+
+> [Original] Although you can match to _Content-Type_ and _Accept_ header values using media type wild cards (for example _"content-type=text/*"_ will match to _"text/plain"_ and _"text/html"_), it is recommended to use the _consumes_ and _produces_ conditions respectively instead. They are intended specifically for that purpose.
+>
+> ���ܣ������ʹ��ý�����͵�ͨ��������� _"content-type=text/*"_����ƥ������ͷ _Content-Type_�� _Accept_��ֵ�������Ǹ��Ƽ�����ʹ�� _consumes_�� _produces_������ɸѡ���Ե�������Ϊ���Ǿ���ר��Ϊ���������ֲ�ͬ�ij��������ġ�
+
+</section>
+
+
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\345\274\202\345\270\270\345\244\204\347\220\206\345\231\250.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\345\274\202\345\270\270\345\244\204\347\220\206\345\231\250.md"
new file mode 100644
index 0000000..604e246
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\345\274\202\345\270\270\345\244\204\347\220\206\345\231\250.md"
@@ -0,0 +1,235 @@
+
+
+
+
+# Spring MVC �������쳣������
+
+
+
+2018-07-26 14:32 ����
+
+
+
+
+
+
+
+Spring�Ĵ������쳣������`HandlerExceptionResolver`�ӿڵ�ʵ�ָ��������������ִ�й����г��ֵ��쳣��ij�̶ֳ��Ͻ���`HandlerExceptionResolver`������webӦ��������`web.xml`�ļ����ܶ�����쳣ӳ�䣨exception mapping�������񣬲������Ⱥ����ṩ�˸����ķ�ʽ�����������ṩ�쳣���׳�ʱ����ִ�е����ĸ���������������Ϣ�����ң�һ������programmatic�����쳣������ʽ����Ϊ���ṩ����ѡ��ʹ��������ֱ��ת����һ��URL֮ǰ������ʹ��Servlet�淶���쳣ӳ����һ���ģ��и���ķ�ʽ�������쳣��
+
+<section>
+
+ʵ��`HandlerExceptionResolver`�ӿڲ���ʵ���쳣������Ψһ��ʽ����ֻ���ṩ��`resolveException(Exception, Hanlder)`������һ��ʵ�ֶ��ѣ������᷵��һ��`ModelAndView`������֮�⣬�㻹���Կ���ṩ��`SimpleMappingExceptionResolver`�����쳣����������ע��`@ExceptionHandler`��`SimpleMappingExceptionResolver`�������ȡ�����׳����쳣������֣�������ӳ�䵽һ����ͼ����ȥ������Servlet API�ṩ���쳣ӳ�������ǹ��ܵȼ۵ģ�����Ҳ���Ի��ڴ�ʵ�����ȸ���ϸ���쳣ӳ�䡣��`@ExceptionHandler`ע��ķ���������쳣�׳�ʱ�������Դ������쳣�������ķ������Զ�����`@Controller`ע��Ŀ��������Ҳ���Զ�����`@ControllerAdvice`���У����߿���ʹ���쳣����������Ӧ�õ������`@Controller`�������С���һС�ڽ��ṩ��Ϊ��ϸ����Ϣ��
+
+</section>
+
+
+
+
+
+
+
+# Spring MVC ʹ��@ExceptionHandlerע��
+
+
+
+2018-07-26 14:33 ����
+
+
+
+
+
+
+
+<section>
+
+`HandlerExceptionResolver`�ӿ��Լ�`SimpleMappingExceptionResolver`���������ʵ��ʹ����������ʽ�ؽ��쳣ӳ�䵽�ض�����ͼ�ϣ����������쳣��ת����forward������Ӧ����ͼǰʹ��Java������Щ�жϺ��߼���������һЩ�������ر�������`@ResponseBody`������Ӧ����������ͼ�������Ƶij����£�ֱ��������Ӧ��״̬�벢���ͻ�����Ҫ�Ĵ�����Ϣֱ��д����Ӧ���У������Ǹ�����ķ�����
+
+��Ҳ����ʹ��`@ExceptionHandler`������������㡣���`@ExceptionHandler`�������ڿ������ڲ�����ģ���ô������ղ������ɿ������������κ����ࣩ�е�`@RequestMapping`�����׳����쳣������㽫`@ExceptionHandler`����������`@ControllerAdvice`���У���ô���ᴦ����ؿ��������׳����쳣������Ĵ����չʾ��һ�������ڿ������ڲ���`@ExceptionHandler`������
+
+```
+@Controller
+public class SimpleController {
+
+    // @RequestMapping methods omitted ...
+
+    @ExceptionHandler(IOException.class)
+    public ResponseEntity<String> handleIOException(IOException ex) {
+        // prepare responseEntity
+        return responseEntity;
+    }
+
+}
+
+```
+
+���⣬`@ExceptionHandler`ע�⻹���Խ���һ���쳣���͵�������Ϊ����ֵ�����׳��������б����������쳣����ô��Ӧ��`@ExceptionHandler`�������ᱻ���á����û�и�ע���κβ���ֵ����ôĬ�ϴ������쳣���ͽ��Ƿ�����������������Щ�쳣��
+
+���׼�Ŀ�����`@RequestMapping`ע�⴦������һ����`@ExceptionHandler`�����ķ��������ͷ���ֵҲ���Ժ������磬��Servlet�����·������Խ���`HttpServletRequest`��������Portlet�����·������Խ���`PortletRequest`����������ֵ������`String`���͡�����������»ᱻ����Ϊ��ͼ������������`ModelAndView`���͵Ķ���Ҳ������`ResponseEntity`�������㻹�����ڷ���������`@ResponseBody`ע����ʹ����Ϣת������ת����ϢΪ�ض����͵����ݣ�Ȼ�������д�ص���Ӧ���С�
+
+</section>
+
+
+
+
+
+
+
+# Spring MVC ����һ����쳣
+
+
+
+2018-07-26 14:34 ����
+
+
+
+
+
+
+
+��������Ĺ����У�Spring MVC���ܻ��׳�һЩ���쳣��`SimpleMappingExceptionResolver`���Ը�����Ҫ�ܷ���ؽ��κ��쳣ӳ�䵽һ��Ĭ�ϵĴ�����ͼ����������ͻ�����ͨ���Զ������Ӧ�ķ�ʽ���ַ������쳣�ģ���ô��˾���ҪΪ��Ӧ���ö�Ӧ��״̬�롣�����׳��쳣�����Ͳ�ͬ��������Ҫ���ò�ͬ��״̬������ʶ�ǿͻ��˴���4xx�����Ƿ������˴���5xx����
+
+<section>
+
+Ĭ�ϴ������쳣������`DefaultHandlerExceptionResolver`�ὫSpring MVC�׳����쳣ת���ɶ�Ӧ�Ĵ���״̬�롣�ý�������MVC�����ռ����û�MVC Java���õķ�ʽ��Ĭ���Ѿ���ע���ˣ����⣬ͨ��`DispatcherServlet`ע��Ҳ�ǿ��еģ�����ʹ��MVC�����ռ��Java��̷�ʽ�������õ�ʱ�򣩡��±��г��˸ý������ܴ�����һЩ�쳣�������Ƕ�Ӧ��״̬�롣
+
+| �쳣 | HTTP״̬�� |
+| --- | --- |
+| `BindException` | 400 (������) |
+| `ConversionNotSupportedException` | 500 (�������ڲ�����) |
+| `HttpMediaTypeNotAcceptableException` | 406 (������) |
+| `HttpMediaTypeNotSupportedException` | 415 (��֧�ֵ�ý������) |
+| `HttpMessageNotReadableException` | 400 (������) |
+| `HttpMessageNotWritableException` | 500 (�������ڲ�����) |
+| `HttpRequestMethodNotSupportedException` | 405 (��֧�ֵķ���) |
+| `MethodArgumentNotValidException` | 400 (������) |
+| `MissingServletRequestParameterException` | 400 (������) |
+| `MissingServletRequestPartException` | 400 (������) |
+| `NoHandlerFoundException` | 404 (����δ�ҵ�) |
+| `NoSuchRequestHandlingMethodException` | 404 (����δ�ҵ�) |
+| `TypeMismatchException` | 400 (������) |
+| `MissingPathVariableException` | 500 (�������ڲ�����) |
+| `NoHandlerFoundException` | 404 (����δ�ҵ�) |
+
+���´����롣
+
+The `DefaultHandlerExceptionResolver` works transparently by setting the status of the response. However, it stops short of writing any error content to the body of the response while your application may need to add developer- friendly content to every error response for example when providing a REST API. You can prepare a `ModelAndView` and render error content through view resolution?--?i.e. by configuring a `ContentNegotiatingViewResolver`, `MappingJackson2JsonView`, and so on. However, you may prefer to use`@ExceptionHandler` methods instead.
+
+If you prefer to write error content via `@ExceptionHandler` methods you can extend `ResponseEntityExceptionHandler` instead. This is a convenient base for `@ControllerAdvice` classes providing an `@ExceptionHandler` method to handle standard Spring MVC exceptions and return `ResponseEntity`. That allows you to customize the response and write error content with message converters. See the `ResponseEntityExceptionHandler` javadocs for more details.
+
+</section>
+
+
+
+
+
+
+
+# Spring MVC ʹ��@ResponseStatusע��ҵ���쳣
+
+
+
+2020-07-31 10:52 ����
+
+
+
+
+
+
+
+ҵ���쳣����ʹ��`@ResponseStatus`��ע�⡣���쳣���׳�ʱ��`ResponseStatusExceptionResolver`��������Ӧ����Ӧ״̬�롣`DispatcherServlet`��Ĭ��ע��һ��`ResponseStatusExceptionResolver` �Թ�ʹ�á�
+
+ResponseStatusע���ʹ�÷dz��򵥣����Ǵ���һ���쳣�࣬����ע��
+
+```
+package com.zj.exception;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@ResponseStatus(value=HttpStatus.FORBIDDEN,reason="�û���ƥ��")
+public class UserNotMatchException extends RuntimeException{
+}
+```
+
+> ResponseStatusע�����������
+> �����������ԣ�value������http״̬�룬����404��500�ȡ�reason�Ǵ�����Ϣ
+
+дһ��Ŀ�귽���׳����쳣
+
+```
+@RequestMapping("/testResponseStatus")
+public String testResponseStatus(int i){
+    if(i==0)
+        throw new UserNotMatchException();
+    return "hello";
+}
+```
+
+> ʹ����ResponseStatusע��֮���û��������쳣�������������Լ�������쳣����������һ����û��������Ĵ��롣
+
+
+
+
+
+
+
+# Spring MVC ��ServletĬ����������ҳ��Ķ��ƻ�
+
+
+
+2018-07-26 14:36 ����
+
+
+
+
+
+
+
+����Ӧ��״̬�뱻����Ϊ����״̬�룬������Ӧ����û������ʱ��Servlet����ͨ������Ⱦһ��HTML����ҳ������Ҫ��������Ĭ���ṩ�Ĵ���ҳ���������`web.xml`�ж���һ������ҳ��`<error-page>`Ԫ�ء���Servlet 3�淶����֮ǰ���ô���ҳԪ�ر��뱻��ʽָ��ӳ�䵽һ������Ĵ������һ���쳣���͡���Servlet 3��ʼ������ҳ������Ҫӳ�䵽������Ϣ�ˣ�����ζ�ţ���ָ����λ�þ��Ƕ�Servlet����Ĭ�ϴ���ҳ���Զ����ˡ�
+
+<section>
+
+```
+<error-page>
+    <location>/error</location>
+</error-page>
+
+```
+
+�������ҳ��λ�����ڿ�����һ��JSPҳ�棬����������һЩURL��ֻҪ��ָ������������һ��`@Controller`�������µĴ�����������
+
+д��`HttpServletResponse`�Ĵ�����Ϣ�ʹ���״̬������ڿ�������ͨ��������������ȡ��
+
+```
+@Controller
+public class ErrorController {
+
+    @RequestMapping(path = "/error", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
+    @ResponseBody
+    public Map<String, Object> handle(HttpServletRequest request) {
+
+        Map<String, Object> map = new HashMap<String, Object>();
+        map.put("status", request.getAttribute("javax.servlet.error.status_code"));
+        map.put("reason", request.getAttribute("javax.servlet.error.message"));
+
+        return map;
+    }
+
+}
+
+```
+
+������JSP����ôʹ��:
+
+```
+<%@ page contentType="application/json" pageEncoding="UTF-8"%>
+{
+    status:<%=request.getAttribute("javax.servlet.error.status_code") %>,
+    reason:<%=request.getAttribute("javax.servlet.error.message") %>
+}
+```
+
+</section>
+
+
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\346\213\246\346\210\252\345\231\250.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\346\213\246\346\210\252\345\231\250.md"
new file mode 100644
index 0000000..ba66314
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\346\213\246\346\210\252\345\231\250.md"
@@ -0,0 +1,88 @@
+
+
+
+
+# Spring MVC ʹ��HandlerInterceptor��������
+
+
+
+2018-07-26 14:07 ����
+
+
+
+
+
+
+
+Spring�Ĵ�����ӳ����ư����˴�������������������������ҪΪ�ض����͵�����Ӧ��һЩ����ʱ���ܺ����ã����磬����û����ݵȡ�
+
+<section>
+
+������ӳ�䴦���������õ�������������ʵ�� `org.springframework.web.servlet`���µ� `HandlerInterceptor`�ӿڡ�����ӿڶ��������������� `preHandle(..)`�����ڴ�����ʵ��ִ�� _֮ǰ_ �ᱻִ�У� `postHandle(..)`�����ڴ�����ִ�� _���_ �Ժ�ִ�У� `afterCompletion(..)`������ _�������������_ ֮��ִ�С�����������Ϊ�������͵�ǰ�����ͺ��������ṩ���㹻������ԡ�
+
+`preHandle(..)`��������һ��booleanֵ�������ͨ����������������Ƿ����ִ�д������еIJ��������������� `true`ʱ���������������ִ�У����������� `false`�� `DispatcherServlet`����Ϊ�����������Ѿ�����˶�����Ĵ���������˵���Ѿ���Ⱦ��һ�����ʵ���ͼ������ô������������Լ�ִ�����е������������Ͳ����ٱ�ִ���ˡ�
+
+����������ͨ��`interceptors`���������ã���ѡ�������м̳���`AbstractHandlerMapping`�Ĵ�����ӳ����`HandlerMapping`���ṩ�����õĽӿڡ����������������ʾ��
+
+```
+<beans>
+    <bean id="handlerMapping" class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping">
+        <property name="interceptors">
+            <list>
+                <ref bean="officeHoursInterceptor"/>
+            </list>
+        </property>
+    </bean>
+
+    <bean id="officeHoursInterceptor" class="samples.TimeBasedAccessInterceptor">
+        <property name="openingTime" value="9"/>
+        <property name="closingTime" value="18"/>
+    </bean>
+<beans>
+
+```
+
+```
+package samples;
+
+public class TimeBasedAccessInterceptor extends HandlerInterceptorAdapter {
+
+    private int openingTime;
+    private int closingTime;
+
+    public void setOpeningTime(int openingTime) {
+        this.openingTime = openingTime;
+    }
+
+    public void setClosingTime(int closingTime) {
+        this.closingTime = closingTime;
+    }
+
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
+            Object handler) throws Exception {
+        Calendar cal = Calendar.getInstance();
+        int hour = cal.get(HOUR_OF_DAY);
+        if (openingTime <= hour && hour < closingTime) {
+            return true;
+        }
+        response.sendRedirect("http://host.com/outsideOfficeHours.html");
+        return false;
+    }
+}
+
+```
+
+������������У����б��˴��������������󶼻ᱻ`TimeBasedAccessInterceptor`���������ء������ǰʱ���ڹ���ʱ�����⣬��ô�û��ͻᱻ�ض���һ��HTML�ļ���ʾ�û���������ʾ����ֻ���ڹ���ʱ��ſ��Է��ʱ���վ��֮�����Ϣ��
+
+> ʹ��`RequestMappingHandlerMapping`ʱ��ʵ�ʵĴ�������һ������������`HandlerMethod`��ʵ��������ʶ��һ���������ڴ���������Ŀ�����������
+
+����������Spring��������������`HandlerInterceptorAdapter`�ü̳�`HandlerInterceptor`�ӿڱ�ø����ˡ�
+
+> ����������У����п������������������󶼻ᱻ���õ������������ص�����������һ����С���ص�URL��Χ�������ͨ��MVC�����ռ��MVC Java��̵ķ�ʽ�����ã����ߣ�����һ��`MappedInterceptor`���͵�beanʵ����������������� [21.16.1 ����MVC Java������û�MVC�����ռ�����](https://www.w3cschool.cn/spring_mvc_documentation_linesh_translation/spring_mvc_documentation_linesh_translation-ouxg27ss.html)һС�ڡ�
+
+��Ҫע����ǣ�`HandlerInterceptor`�ĺ�����`postHandle`������һ������������ע����`@ResponseBody`��`ResponseEntity`�ķ�������Щ�����У�`HttpMessageConverter`������������`postHandle`��������֮ǰ�Ͱ���Ϣд����Ӧ�С��������������޷��ٸı���Ӧ�ˣ�����Ҫ����һ����Ӧͷ֮��ġ���������������������Ӧ��ʵ��`ResponseBodyAdvice`�ӿڣ������䶨��Ϊһ��`@ControllerAdvice`bean��ֱ����`RequestMappingHandlerMapping`�����á�
+
+</section>
+
+
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\350\247\206\345\233\276\350\247\243\346\236\220\345\231\250.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\350\247\206\345\233\276\350\247\243\346\236\220\345\231\250.md"
new file mode 100644
index 0000000..6537078
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\350\247\206\345\233\276\350\247\243\346\236\220\345\231\250.md"
@@ -0,0 +1,181 @@
+
+
+
+
+# Spring MVC ʹ��ViewResolver�ӿڽ�����ͼ
+
+
+
+2018-07-26 15:39 ����
+
+
+
+
+
+
+
+������[Spring MVC ��������ʵ��](https://www.w3cschool.cn/spring_mvc_documentation_linesh_translation/spring_mvc_documentation_linesh_translation-7z6u27rb.html)һ���������۵ģ�Spring MVC�����п������Ĵ��������������뷵��һ���߼���ͼ�����֣���������ʽ���أ����緵��һ��`String`��`View`����`ModelAndView`��������ʽ���أ��������Լ���ķ��أ���Spring�е���ͼ��һ����ͼ����ʶ��������ͼ����������Ⱦ��Spring�зdz������õ���ͼ���������±��г��˴󲿷֣�����Ҳ������һЩ���ӡ�
+
+<section>
+
+**��21.3 ��ͼ������**
+
+| ��ͼ������ | ���� |
+| --- | --- |
+| `AbstractCachingViewResolver` | һ���������ͼ�������࣬�ṩ�˻�����ͼ�Ĺ��ܡ�ͨ����ͼ���ܹ���ʹ��֮ǰ��Ҫ����׼�����̳�����������ͼ�����������Ի�û�����ͼ�������� |
+| `XmlViewResolver` | ��ͼ�������ӿ�`ViewResolver`��һ��ʵ�֣��������һ��XML��ʽ�������ļ�����XML�ļ�������Spring XML��bean��������ͬ��DTD��Ĭ�ϵ������ļ�����`/WEB-INF/views.xml`�� |
+| `ResourceBundleViewResolver` | ��ͼ�������ӿ�`ViewResolver`��һ��ʵ�֣�����bundle��·����ָ����`ResourceBundle`�е�bean������Ϊ���á�һ��bundle��������classpath·���µ�һ�������ļ��С�Ĭ�ϵ������ļ���Ϊ`views.properties`�� |
+| `UrlBasedViewResolver` | `ViewResolver`�ӿڵ�һ����ʵ�֡���ֱ��ʹ��URL���������߼���ͼ��������֮�ⲻ��Ҫ�����κ���ʽ��ӳ���������������߼���ͼ��������������ͼ��Դ����ֱ�Ӷ�Ӧ�ģ���ô����ֱ�ӽ����ķ�ʽ�ͺܷ��㣬����Ҫ����ָ�������ӳ�䡣 |
+| `InternalResourceViewResolver` | `UrlBasedViewResolver`��һ�����õ����ࡣ��֧���ڲ���Դ��ͼ��������˵��Servlet��JSP�����Լ�����`JstlView`��`TilesView`��������ࡣYou can specify the view class for all views generated by this resolver by using `setViewClass(..)`�������ϸ�ڣ����`UrlBasedViewResolver`���java�ĵ��� |
+| `VelocityViewResolver` / `FreeMarkerViewResolver` | `UrlBasedViewResolver`�µ�ʵ�����֧࣬��Velocity��ͼ`VelocityView`��Velocityģ�壩��FreeMarker��ͼ`FreeMarkerView`�Լ����Ƕ�Ӧ���ࡣ |
+| `ContentNegotiatingViewResolver` | ��ͼ�������ӿ�`ViewResolver`��һ��ʵ�֣����������������ļ����������`Accept`ͷ������һ����ͼ������ϸ�����[Spring MVC ����Э����ͼ������](https://www.w3cschool.cn/spring_mvc_documentation_linesh_translation/spring_mvc_documentation_linesh_translation-gal927rn.html)һС�ڡ� |
+
+���ǿ��Ծٸ����ӣ���������ʹ�õ���JSP��ͼ��������ô���ǿ���ʹ��һ������URL����ͼ������`UrlBasedViewResolver`�������ͼ�������ὫURL������һ����ͼ������������ת��������ַ�����������ͼ��Ⱦ��
+
+```
+<bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
+    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
+    <property name="prefix" value="/WEB-INF/jsp/"/>
+    <property name="suffix" value=".jsp"/>
+</bean>
+
+```
+
+������һ��`test`�߼���ͼ������ô����ͼ�������Ὣ����ת����`RequestDispatcher`�����߻Ὣ���󽻸�`/WEB-INF/jsp/test.jsp`��ͼȥ��Ⱦ��
+
+�����Ҫ��Ӧ����ʹ�ö��ֲ�ͬ����ͼ�����������ʹ��`ResourceBundleViewResolver`��
+
+```
+<bean id="viewResolver"
+        class="org.springframework.web.servlet.view.ResourceBundleViewResolver">
+    <property name="basename" value="views"/>
+    <property name="defaultParentView" value="parentView"/>
+</bean>
+
+```
+
+`ResourceBundleViewResolver`�������bundle��·���������õ�`ResourceBundle`������ÿ����ͼ���ԣ�����ͼ����`[viewname].(class)`���Ե�ֵָ��������ͼurl��`[viewname].url`���Ե�ֵָ������һ�ڽ���ϸ������ͼ������������������ҵ��������ӡ��㻹���Կ�������ͼ�������л���ͼ����properties�ļ���������ͼ�����̳С���һ���ļ���ͨ���̳м����������Ϊ�ڶ���ͼָ��һ��Ĭ�ϵ���ͼ���ࡣ
+
+> `AbstractCachingViewResolver`�������ܹ������Ѿ�����������ͼʵ�����رջ�������Ҳ�ǿ��Եģ�ֻ��Ҫ��`cache`��������Ϊ`false`���ɡ����⣬���ʵ����Ҫ������ʱˢ��ij����ͼ�������޸���Velocityģ��ʱ���������ʹ��`removeFromCache(String viewName, Locale loc)`������`
+
+</section>
+
+
+
+
+
+
+
+# Spring MVC ��ͼ��
+
+
+
+2018-07-26 14:11 ����
+
+
+
+
+
+
+
+Spring֧��ͬʱʹ�ö����ͼ����������ˣ����������һ����������������������±��磬���ض������¸�дһ����ͼ�ȡ������ͨ���Ѷ����ͼ���������õ�Ӧ��������(application context)�еķ�ʽ���������ǡ������Ҫָ�����ǵĴ�����ô����`order`���Լ��ɡ����ס��order���Ե�ֵԽ�󣬸���ͼ�����������е�λ�þ�Խ����
+
+<section>
+
+������Ĵ��������У���ͼ���������а�����������������һ����`InternalResourceViewResolver`���������Զ��������ڽ��������������һ����`XmlViewResolver`��������ָ��Excel��ͼ��`InternalResourceViewResolver`��֧��Excel��ͼ��
+
+```
+<bean id="jspViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
+    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
+    <property name="prefix" value="/WEB-INF/jsp/"/>
+    <property name="suffix" value=".jsp"/>
+</bean>
+
+<bean id="excelViewResolver" class="org.springframework.web.servlet.view.XmlViewResolver">
+    <property name="order" value="1"/>
+    <property name="location" value="/WEB-INF/views.xml"/>
+</bean>
+
+<!-- in views.xml -->
+
+<beans>
+    <bean name="report" class="org.springframework.example.ReportExcelView"/>
+</beans>
+
+```
+
+���һ����ͼ���������ܷ���һ����ͼ����ôSpring������������������������ͼ����������ʱ������������Ľ�������Spring������������ǣ�ֱ������һ����ͼ����Ϊֹ��������������ͼ�����������ܷ���һ����ͼ��Spring���׳�һ��`ServletException`��
+
+��ͼ�������Ľӿ���������ˣ�һ����ͼ��������_����_����nullֵ�ģ����ʾ�����ҵ��κκ��ʵ���ͼ���������е���ͼ����������ô��������Ҳ���ڲ��ò���˵ij�������������ȷʵ�޷�����Ӧ����ͼ�Ƿ���ڡ����磬`InternalResourceViewResolver`���ڲ�ʹ����`RequestDispatcher`�����ҽ�����ɹ����Ǽ��һ��JSP��ͼ�Ƿ���ڵ�Ψһ��������������̽����ܷ���Ψһһ�Ρ�ͬ����`VelocityViewResolver`�Ͳ�����������ͼ������Ҳ�������������������������ij���ض�����ͼ��������Java�ĵ��������Ƿ��report�����ڵ���ͼ����ˣ��������`InternalResourceViewResolver`�����ڽ�����������󣬽����ܵ��½��������޷���ȫִ�У���Ϊ`InternalResourceViewResolver`_��Զ����_ ����һ����ͼ��
+
+</section>
+
+
+
+
+
+
+
+# Spring MVC ��ͼ�ض���
+
+
+
+2018-07-26 14:12 ����
+
+
+
+
+
+
+
+��ǰ������������ͨ�����᷵��һ���߼���ͼ����Ȼ����ͼ�����������������һ���������ͼ������ȥ��Ⱦ������һЩ������Servlet��JSP��������������ͼ����������JSP�ȣ������������ͨ������`InternalResourceViewResolver`��`InternalResourceView`Э������ɵģ�����ͨ�������Servlet��API`RequestDispatcher.forward(..)`������`RequestDispatcher.include(..)`������������һ���ڲ���ת����forward�������ã�include������������������ͼ����������Velocity��XSLT�ȣ���ͼ������������ֱ�ӱ�д����Ӧ���еġ�
+
+<section>
+
+��ʱ��������Ҫ����ͼ��Ⱦ֮ǰ���Ȱ�һ��HTTP�ض��������ͻؿͻ��ˡ����磬��һ���������ɹ��ؽ��ܵ���`POST`���������ݣ�����Ӧ������ί����һ��������������������һ�γɹ��ı����ύ��ʱ������ϣ������һ���ض��������ֳ����£����ֻ�Ǽ򵥵�ʹ���ڲ�ת������ô��ζ����һ��������Ҳ�ܿ������`POST`����Я�������ݣ�����ܵ���һЩDZ�ڵ����⣬������ܻ����������������ݻ������ȡ����⣬��һ������Ⱦ��ͼǰ����������ض���������ǣ���ֹ�û�����ύ���������ݡ���ʱ��ʹ���ض�������������ȷ��͵�һ��`POST`�������󱻴�������������յ�һ���ض�����Ӧ��Ȼ�������ֱ�ӱ��ض���һ����ͬ��URL������������ʹ���ض�����Ӧ��Я����URL����һ��`GET`������ˣ���������ĽǶȿ�����ǰ������ҳ�沢����`POST`����Ľ��������һ��`GET`����Ľ������ͷ�ֹ���û���ˢ�µ�ԭ��������ύ�˶��ͬ�������ݡ���ʱˢ�»�����`GET`һ�ν��ҳ�������ǰ�ͬ����`POST`�����ٷ���һ�顣
+
+## �ض�����ͼ RedirectView
+
+ǿ���ض����һ�ַ����ǣ��ڿ������д���������һ��Spring�ض�����ͼ`RedirectView`��ʵ��������ʹ��`DispatcherServlet`����ʹ��һ�����ͼ�������ƣ���Ϊ���Ѿ�����һ�����ض�����ͼ��`DispatcherServlet`�ˣ��������ṹ��һ����ͼ��������Ⱦ�����󡣽�����`RedirectView`�����`HttpServletResponse.sendRedirect()`����������һ��HTTP�ض�����Ӧ���ͻ����������
+
+������������`RedirectView`�����������ͼʵ�����ɿ������ڲ����������ģ������Ǹ��Ƽ����ⲿ�����ض���URLȻ��ע�뵽������������������д�ڿ��������档�������Ϳ�������ͼ��һ���������ļ������á��������ʵ����������ο� [�ض���ǰ׺����redirect:](http://docs.spring.io/spring-framework/docs/4.2.4.RELEASE/spring-framework-reference/html/mvc.html#mvc-redirecting-redirect-prefix)һС�ڡ�
+
+## ���ض���Ŀ�괫������
+
+ģ���е���������Ĭ�϶��ῼ����ΪURIģ����������ӵ��ض���URL�С�ʣ�µ��������ԣ�����ǻ������ͻ��߻������͵ļ��ϻ����飬�����ǽ����Զ����ӵ�URL�IJ�ѯ������ȥ�����model��ר��Ϊ���ض�����׼���ģ���ô�����л������͵��������ӵ���ѯ�����п��������������Ǹ��Ľ�������ǣ��ڰ���ע��Ŀ������У�model���ܰ�����ר����Ϊ��Ⱦ��;�����ԣ�����һ�������б����ֶ�ֵ�ȣ���Ϊ�˱��������������Ҳ��¶��URL�У�`@RequestMapping`������������һ��`RedirectAttributes`���͵ķ���������������ָ��ר�Ź��ض�����ͼ`RedirectView`ȡ�õ����ԡ�����ض���ɹ���������ô`RedirectAttributes`�����е����ݾͻᱻʹ�ã�������ʹ��ģ��model�е����ݡ�
+
+`RequestMappingHandlerAdapter`�ṩ��һ��`"ignoreDefaultModelOnRedirect"`��־�������������Ĭ��`Model`�е�������Զ��Ӧ�ñ����ڿ������������ض����С�����������Ӧ������һ��`RedirectAttributes`��IJ�����������������Ǿ�û�в��������ݵ��ض������ͼ`RedirectView`�С���MVC�����ռ��MVC Java������÷�ʽ�У�Ϊ��ά�����ļ����ԣ������־���Ա�����Ϊ`false`����������Ӧ����һ���µ���Ŀ����ô�����Ƽ�������ֵ���ó�`true`��
+
+��ע�⣬��ǰ����URI�е�ģ�������������ض���URL��ʱ���Զ���Ӧ�ÿɼ���������Ҫ��ʽ����`Model`��`RedirectAttributes`�����������ԡ��뿴��������ӣ�
+
+```
+@RequestMapping(path = "/files/{path}", method = RequestMethod.POST)
+public String upload(...) {
+    // ...
+    return "redirect:files/{path}";
+}
+
+```
+
+����һ�����ض���Ŀ�괫�����ݵķ�����ͨ�� _�������ԣ�Flash Attributes��_���������ض������Բ�ͬ��flash�����Ǵ洢��HTTP session�еģ���˲��������URL�У����������ݣ���ο� [21.6 ʹ����������](http://docs.spring.io/spring-framework/docs/4.2.4.RELEASE/spring-framework-reference/html/mvc.html#mvc-flash-attributes)һ�ڡ�
+
+## �ض���ǰ׺����redirect:
+
+����ʹ��`RedirectView`�����ض����ܹ����úܺã����������������������Ҫ����һ��`RedirectView`�������ɿ����������˽��ض�����ôһ������ķ������⻹���е㲻����������ͬ�������ϻ���̫ǿ����������ʵ��Ӧ��ȥ������Ӧ����α���Ⱦ��In general it should operate only in terms of view names that have been injected into it.
+
+һ���ر����ͼ��ǰ׺�����������`redirect:`��������ص���ͼ���к���`redirect:`ǰ׺����ô`UrlBasedViewResolver`���������������ࣩ�ͻ���ܵ�����źţ���ʶ��������Ҫ�����ض���Ȼ����ͼ��ʣ�µIJ��ֻᱻ�������ض���URL��
+
+���ַ�ʽ��ͨ������������һ���ض�����ͼ`RedirectView`���ﵽ��Ч����һ���ģ���������һ���������Ϳ���ֻרע�ڴ����������߼���ͼ���ˡ�����߼���ͼ������������ʽ��`redirect:/myapp/some/resource`�������ض���·������Servlet��������Ϊ���·�����в��ң����߼���ͼ���������������ʽ��`redirect:http://myhost.com/some/arbitrary/path`����ô�ض���URLʹ�õľ��Ǿ���·����
+
+ע����ǣ��������������ע����`@ResponseStatus`����ôע�����õ�״̬��ֵ�Ḳ��`RedirectView`���õ���Ӧ״̬��ֵ��
+
+## �ض���ǰ׺����forward:
+
+�������ջᱻ`UrlBasedViewResolver`���������������ͼ���������ʹ��һ�������ǰ׺��`forward:`����ᵼ��һ��`InternalResourceView`��ͼ����Ĵ����������ջ����`RequestDispatcher.forward()`�����������߻���Ϊ��ͼ��ʣ�µIJ�����һ��URL����ˣ����ǰ׺��ʹ��`InternalResourceViewResolver`��`InternalResourceView`ʱ��û���ر�����ã��������JSP��˵������������Ҫʹ�õ�����������ͼ������������Ҫǿ�ư�һ����Դת����Servlet/JSP������д���ʱ�����ǰ׺���ܾͺ����ã����ߣ���Ҳ����ͬʱ���������ͼ����������
+
+��`redirect:`ǰ׺һ��������������е���ͼ��ʹ����`forward:`ǰ׺�����������������ᷢ���κ��쳣������ע����Ȼֻ����δ�����Ӧ�����⡣
+
+</section>
+
+
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\350\277\207\346\273\244\345\231\250Filter.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\350\277\207\346\273\244\345\231\250Filter.md"
new file mode 100644
index 0000000..440f4d4
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\344\270\255\347\232\204\350\277\207\346\273\244\345\231\250Filter.md"
@@ -0,0 +1,151 @@
+����Filter
+
+��Spring MVC�У�DispatcherServletֻ��Ҫ�̶����õ�web.xml�У�ʣ�µĹ�����Ҫ��רע�ڱ�дController��
+
+���ǣ���Servlet�淶�У����ǻ�����ʹ��Filter�����Ҫ��Spring MVC��ʹ��Filter��Ӧ����ô����
+
+�е�ͯЬ����һ�ڵ�WebӦ���п��ܷ����ˣ����ע��ʱ�������Ļᵼ�����룬��ΪServletĬ�ϰ���UTF-8�����ȡ������Ϊ���޸���һ���⣬���ǿ��Լ򵥵�ʹ��һ��EncodingFilter����ȫ�ַ�Χ���HttpServletRequest��HttpServletResponseǿ������ΪUTF-8���롣
+
+�����Լ���дһ��EncodingFilter��Ҳ����ֱ��ʹ��Spring MVC�Դ���һ��CharacterEncodingFilter������Filterʱ��ֻ����web.xml���������ɣ�
+````
+<web-app>
+    <filter>
+        <filter-name>encodingFilter</filter-name>
+        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
+        <init-param>
+            <param-name>encoding</param-name>
+            <param-value>UTF-8</param-value>
+        </init-param>
+        <init-param>
+            <param-name>forceEncoding</param-name>
+            <param-value>true</param-value>
+        </init-param>
+    </filter>
+
+    <filter-mapping>
+        <filter-name>encodingFilter</filter-name>
+        <url-pattern>/*</url-pattern>
+    </filter-mapping>
+    ...
+</web-app>
+````
+��Ϊ����Filter������ҵ���ϵ����ע�⵽CharacterEncodingFilter��ʵ��Spring��IoC����û���κι�ϵ�����߾�����֪���Է��Ĵ��ڣ���ˣ���������Filterʮ�ּ򵥡�
+
+�����ٿ�������һ�����⣺��������û�ʹ��Basicģʽ�����û���֤������HTTP����������ͷAuthorization: Basic email:password������������ʵ�֣�
+
+��дһ��AuthFilter����򵥵�ʵ�ַ�ʽ��
+````
+@Component
+public class AuthFilter implements Filter {
+@Autowired
+UserService userService;
+
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+            throws IOException, ServletException {
+        HttpServletRequest req = (HttpServletRequest) request;
+        // ��ȡAuthorizationͷ:
+        String authHeader = req.getHeader("Authorization");
+        if (authHeader != null && authHeader.startsWith("Basic ")) {
+            // ��Header����ȡemail��password:
+            String email = prefixFrom(authHeader);
+            String password = suffixFrom(authHeader);
+            // ��¼:
+            User user = userService.signin(email, password);
+            // ����Session:
+            req.getSession().setAttribute(UserController.KEY_USER, user);
+        }
+        // ������������:
+        chain.doFilter(request, response);
+    }
+}
+````
+�����������ˣ���Spring�д��������AuthFilter��һ����ͨBean��Servlet��������֪�������������������á�
+
+�������ֱ����web.xml���������AuthFilter��ע�⵽AuthFilter��ʵ������Servlet����������Spring������ʼ������ˣ�@Autowire��������Ч�����ڵ�¼��UserService��Ա������Զ��null��
+
+���ԣ���ͨ��һ�ַ�ʽ����Servlet����ʵ������Filter���������Spring����ʵ������AuthFilter��Spring MVC�ṩ��һ��DelegatingFilterProxy��ר������������飺
+````
+<web-app>
+    <filter>
+        <filter-name>authFilter</filter-name>
+        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
+    </filter>
+
+    <filter-mapping>
+        <filter-name>authFilter</filter-name>
+        <url-pattern>/*</url-pattern>
+    </filter-mapping>
+    ...
+</web-app>
+````
+��������ʵ��ԭ����
+
+Servlet������web.xml�ж�ȡ���ã�ʵ����DelegatingFilterProxy��ע��������authFilter��
+Spring����ͨ��ɨ��@Componentʵ����AuthFilter��
+��DelegatingFilterProxy��Ч�������Զ�����ע����ServletContext�ϵ�Spring����������ͼ�������в�����ΪauthFilter��Bean��Ҳ����������@Component������AuthFilter��
+
+DelegatingFilterProxy�����������AuthFilter�����Ĵ������£�
+````
+public class DelegatingFilterProxy implements Filter {
+    private Filter delegate;
+    public void doFilter(...) throws ... {
+        if (delegate == null) {
+            delegate = findBeanFromSpringContainer();
+        }
+        delegate.doFilter(req, resp, chain);
+    }
+}
+````
+�����һ������ģʽ�ļ�Ӧ�á����ǻ���ͼ��ʾ����֮������ù�ϵ���£�
+````
+�� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� �� ��
+����������������������������������������������        ��������������������������   ��
+�� ��DelegatingFilterProxy������������ ��>��AuthFilter ��
+����������������������������������������������        ��������������������������   ��
+�� ���������������������������������������������� �� ��    ��������������������������
+��  DispatcherServlet  ���� �� �� ��>��Controllers��   ��
+�� ���������������������������������������������� �� ��    ��������������������������
+��
+��    Servlet Container    �� ��  Spring Container
+�� �� �� �� �� �� �� �� �� �� �� �� ��   �� �� �� �� �� �� �� �� �� �� ��
+````
+�����web.xml�����õ�Filter���ֺ�Spring������Bean�����ֲ�һ�£���ô��Ҫָ��Bean�����֣�
+````
+<filter>
+    <filter-name>basicAuthFilter</filter-name>
+    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
+    <!-- ָ��Bean������ -->
+    <init-param>
+        <param-name>targetBeanName</param-name>
+        <param-value>authFilter</param-value>
+    </init-param>
+</filter>
+````
+ʵ��Ӧ��ʱ��������������һ�£��Լ��ٲ���Ҫ�����á�
+
+Ҫʹ��Basicģʽ���û���֤�����ǿ���ʹ��curl������ԡ����磬�û���¼����tom@example.com��������tomcat����ô�ȹ���һ��ʹ��URL������û���:������ַ�����
+
+tom%40example.com:tomcat
+�������Base64���룬���չ������Header���£�
+
+Authorization: Basic dG9tJTQwZXhhbXBsZS5jb206dG9tY2F0
+ʹ�����µ�curl��������Ӧ���£�
+````
+$ curl -v -H 'Authorization: Basic dG9tJTQwZXhhbXBsZS5jb206dG9tY2F0' http://localhost:8080/profile
+> GET /profile HTTP/1.1
+> Host: localhost:8080
+> User-Agent: curl/7.64.1
+> Accept: */*
+> Authorization: Basic dG9tJTQwZXhhbXBsZS5jb206dG9tY2F0
+>
+< HTTP/1.1 200
+< Set-Cookie: JSESSIONID=CE0F4BFC394816F717443397D4FEABBE; Path=/; HttpOnly
+< Content-Type: text/html;charset=UTF-8
+< Content-Language: en-CN
+< Transfer-Encoding: chunked
+< Date: Wed, 29 Apr 2020 00:15:50 GMT
+<
+<!doctype html>
+````
+...HTML���...
+������Ӧ˵��AuthFilter����Ч��
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\345\237\272\346\234\254\344\273\213\347\273\215\344\270\216\345\277\253\351\200\237\345\205\245\351\227\250.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\345\237\272\346\234\254\344\273\213\347\273\215\344\270\216\345\277\253\351\200\237\345\205\245\351\227\250.md"
new file mode 100644
index 0000000..21a9ea3
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\345\237\272\346\234\254\344\273\213\347\273\215\344\270\216\345\277\253\351\200\237\345\205\245\351\227\250.md"
@@ -0,0 +1,1153 @@
+
+
+
+
+## MVC ��Ƹ���
+
+������ Java Web �Ŀ����У�ͳһ����ʾ�㡢���Ʋ㡢���ݲ�IJ���ȫ������ JSP ���� JavaBean �����д��������dz�֮Ϊ **Model1��**
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-7b3f9cd59394b017.png)
+
+
+
+
+
+*   **���ֵı׶ˣ�**
+*   JSP �� Java Bean ֮��������ϣ�Java ����� HTML ����Ҳ�������һ��
+*   Ҫ�󿪷��߲���Ҫ���� Java ����Ҫ�и߳���ǰ��ˮƽ
+*   ǰ�˺ͺ���໥������ǰ����Ҫ�ȴ������ɣ����Ҳ����ǰ����ɣ����ܽ�����Ч�IJ���
+*   �������Ը���
+
+����Ϊ��������ֱ׶ˣ����Ժܿ����ַ�ʽ�ͱ� Servlet + JSP + Java Bean ������ˣ����ڵ� MVC ģ��**��Model2��**������ͼ������
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-403a273b08fec826.png)
+
+
+
+
+
+�����û�������ᵽ�� Servlet��Ȼ��������������Ӧ�� Java Bean���������е���ʾ������� JSP ȥ��ɣ�������ģʽ���Ǿͳ�Ϊ MVC ģʽ��
+
+*   **M ���� ģ�ͣ�Model��**
+    ģ����ʲô�أ� ģ�;������ݣ����� dao,bean
+*   **V ���� ��ͼ��View��**
+    ��ͼ��ʲô�أ� ������ҳ, JSP������չʾģ���е�����
+*   **C ���� ��������controller)**
+    ��������ʲô�� �����������þ��ǰѲ�ͬ������(Model)����ʾ�ڲ�ͬ����ͼ(View)�ϣ�Servlet ���ݵľ��������Ľ�ɫ��
+
+> ��չ�Ķ���[Web����ģʽ](https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247483775&idx=1&sn=c9d7ead744c6e0c3ab2fe55c09bbe61f&chksm=ebd7407edca0c9688f3870d895b760836101271b912899821fb35c5704fe215da2fc5daff2f9#rd)
+
+#### Spring MVC �ļܹ�
+
+Ϊ����־ò���һֱδ�����õ����ݿ�����ı�̣���Ϊ��ӭ�� NoSQL ��ǿ������Spring MVC �����˷�����
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-a25782fb05f315de.png)
+
+
+
+
+
+**��ͳ��ģ�Ͳ㱻���Ϊ��ҵ���(Service)�����ݷ��ʲ㣨DAO,Data Access Object����** �� Service �¿���ͨ�� Spring ������ʽ����������ݷ��ʲ㣬����ҵ����ϻ��������Ƿ��� NoSQL ���������ܹ��������ͻ��� NoSQL ��ʹ���ˣ������Դ����߻�����ϵͳ�����ܡ�
+
+*   **�ص㣺**
+    �ṹ��ɢ������������ Spring MVC ��ʹ�ø�����ͼ
+    ����ϣ�����ģ�����
+    �� Spring �޷켯��
+
+* * *
+
+## Hello Spring MVC
+
+��������дһ�����ǵĵ�һ�� Spring MVC ����
+
+#### ��һ������ IDEA ���½� Spring MVC ��Ŀ
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-74ea4c339e8f35f8.png)
+
+
+
+
+
+����ȡ��Ϊ ��HelloSpringMVC���������Finish����
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-cc6cb7d01573ceee.png)
+
+
+
+
+
+IDEA ���Զ����������غñ�Ҫ�� jar ��������Ϊ���Ǵ�����һЩĬ�ϵ�Ŀ¼���ļ����������Ժ���Ŀ�ṹ���£�
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-f6fd3173da6e4939.png)
+
+
+
+
+
+#### �ڶ������޸� web.xml
+
+���Ǵ� web.xml ��������ͼ����޸ģ�
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-2d8a3a7b48dbe59a.png)
+
+
+
+
+
+��`<url-pattern>`Ԫ�ص�ֵ��Ϊ / ����ʾҪ�������е����󣬲�����Spring MVC�ĺ�̨������������������֮��
+
+
+
+```
+<servlet-mapping>
+    <servlet-name>dispatcher</servlet-name>
+    <url-pattern>/</url-pattern>
+</servlet-mapping>
+
+```
+
+
+
+#### ���������༭ dispatcher-servlet.xml
+
+����ļ����Ŀ�ͷ dispatcher ������ web.xml �е� `<servlet-name>` Ԫ�����õ� dispatcher ��Ӧ������ Spring MVC ��ӳ�������ļ���xxx-servlet.xml�������DZ༭���£�
+
+
+
+```
+<?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="simpleUrlHandlerMapping"
+          class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
+        <property name="mappings">
+            <props>
+                <!-- /hello ·�������󽻸� id Ϊ helloController �Ŀ���������-->
+                <prop key="/hello">helloController</prop>
+            </props>
+        </property>
+    </bean>
+    <bean id="helloController" class="controller.HelloController"></bean>
+</beans>
+
+```
+
+
+
+#### ���IJ�����д HelloController
+
+�� Package��controller���´��� ��HelloController���࣬��ʵ�� org.springframework.web.servlet.mvc.Controller �ӿڣ�
+
+
+
+```
+package controller;
+
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.mvc.Controller;
+
+public class HelloController implements Controller{
+    @Override
+    public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {
+        return null;
+    }
+}
+
+```
+
+
+
+*   **���������⣺** javax.servlet ���Ҳ���
+*   **�����** ������ Tomcat ��������Ŀ¼�¡�lib���ļ����µ� servlet-api.jar �����������̡�lib���ļ����£���������
+
+Spring MVC ͨ�� ModelAndView �����ģ�ͺ���ͼ�����һ��
+
+
+
+```
+ModelAndView mav = new ModelAndView("index.jsp");
+mav.addObject("message", "Hello Spring MVC");
+
+```
+
+
+
+�����ʾ��ͼ����index.jsp
+ģ�����ݵ��� message�������� ��Hello Spring MVC��
+
+
+
+```
+package controller;
+
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.mvc.Controller;
+
+public class HelloController implements Controller {
+
+    public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {
+        ModelAndView mav = new ModelAndView("index.jsp");
+        mav.addObject("message", "Hello Spring MVC");
+        return mav;
+    }
+}
+
+```
+
+
+
+#### ���岽��׼�� index.jsp
+
+�� index.jsp �������޸�Ϊ��
+
+
+
+```
+<%@ page language="java" contentType="text/html; charset=UTF-8"
+    pageEncoding="UTF-8" isELIgnored="false"%>
+
+<h1>${message}</h1>
+
+```
+
+
+
+���ݺܼ򵥣���El����ʽ��ʾ message �����ݡ�
+
+#### ������������ Tomcat ����ػ���
+
+�ڡ�Run���˵������ҵ���Edit Configurations��
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-bcca5f5a7c097d6b.png)
+
+
+
+
+
+���� Tomcat ������
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-0600768275c85966.png)
+
+
+
+
+
+ѡ��ñ��ص� Tomcat �����������ĺ����֣�
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-5f033d1463f08d7b.png)
+
+
+
+
+
+�� Deployment ��ǩҳ��������²�����
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-02aa0ac9a6707685.png)
+
+
+
+
+
+��� OK �ͺ��ˣ����ǵ�����Ͻǵ������ν� Tomcat ����������������
+
+*   **���ֵ����⣺** Tomcat �������޷���������
+*   **ԭ��** Tomcat �������Ҳ�����ص� jar ��
+*   **���������** ����lib���ļ���������������WEB-INF���£������½���������
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-b8fcf3da677299cf.png)
+
+
+
+
+
+#### ���߲�������������
+
+�����������������ַ��localhost/hello
+
+
+
+
+
+![](//upload-images.jianshu.io/upload_images/7896890-390fb571e9f6ff03.png)
+
+
+
+
+
+> �ο����ϣ�[Spring MVC �̳�(how2j.cn)](http://how2j.cn/k/springmvc/springmvc-springmvc/615.html#step1891)
+
+* * *
+
+## ���� Spring MVC ������
+
+ÿ���û��� Web ������е�����ӻ����ύ������ʱ������Ϳ�ʼ�����ˣ������ʵ�Աһ�������뿪�������ʼ����ȡ��Ӧ���أ����ᾭ���ܶ�վ�㣬��ÿһ��վ�㶼������һЩ��ϢͬʱҲ�����������Ϣ����ͼΪ Spring MVC ���������̣�
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-65ef874ad7da59a2.png)
+
+
+
+
+
+#### ��һվ��DispatcherServlet
+
+�������뿪������Ժ󣬵�һվ����ľ��� DispatcherServlet������������һ�� Servlet��ͨ�� J2EE ��ѧϰ������֪�� Servlet �������ز����� HTTP ����DispatcherServlet ���������е����󣬲��ҽ���Щ�����͸� Spring MVC ��������
+
+
+
+```
+<servlet>
+    <servlet-name>dispatcher</servlet-name>
+    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
+    <load-on-startup>1</load-on-startup>
+</servlet>
+<servlet-mapping>
+    <servlet-name>dispatcher</servlet-name>
+    <!-- ����������� -->
+    <url-pattern>/</url-pattern>
+</servlet-mapping>
+
+```
+
+
+
+*   **DispatcherServlet ������������������͸� Spring MVC ��������**
+
+#### �ڶ�վ��������ӳ�䣨HandlerMapping��
+
+*   **���⣺** ���͵�Ӧ�ó����п��ܻ��ж������������Щ���󵽵�Ӧ�÷�����һ���������أ�
+
+���� DispatcherServlet ���ѯһ������������ӳ����ȷ���������һվ�����������ӳ���**����������Я���� URL ��Ϣ�����о���**����������������У�����ͨ������ simpleUrlHandlerMapping ���� /hello ��ַ���� helloController ������
+
+
+
+```
+<bean id="simpleUrlHandlerMapping"
+      class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
+    <property name="mappings">
+        <props>
+            <!-- /hello ·�������󽻸� id Ϊ helloController �Ŀ���������-->
+            <prop key="/hello">helloController</prop>
+        </props>
+    </property>
+</bean>
+<bean id="helloController" class="controller.HelloController"></bean>
+
+```
+
+
+
+#### ����վ��������
+
+һ��ѡ���˺��ʵĿ������� DispatcherServlet �Ὣ�����͸�ѡ�еĿ����������˿������������ж���为�أ��û��ύ�����󣩵ȴ���������������Щ��Ϣ��
+
+
+
+```
+public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {
+    // �����߼�
+    ....
+}
+
+```
+
+
+
+#### ����վ������ DispatcherServlet
+
+��������������߼�������ͨ�������һЩ��Ϣ����Щ��Ϣ������Ҫ���ظ��û��������������ʾ����Ϣ�����DZ���Ϊ**ģ�ͣ�Model��**����������ԭʼ����Ϣʱ�����ġ�����Щ��Ϣ��Ҫ���û��Ѻõķ�ʽ���и�ʽ����һ����� HTML�����ԣ���Ϣ��Ҫ���͸�һ��**��ͼ��view��**��ͨ������ JSP��
+
+���������������һ���¾��ǽ�ģ�����ݴ�������ұ�ʾ��������Ⱦ�������ͼ��**���߼���ͼ���������������Ὣ������ͬģ�ͺ���ͼ�����ͻ� DispatcherServlet��**
+
+
+
+```
+public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {
+    // �����߼�
+    ....
+    // ���ظ� DispatcherServlet
+    return mav;
+}
+
+```
+
+
+
+#### ����վ����ͼ������
+
+�����������������Ͳ�����ض�����ͼ����ϣ����ݸ� DispatcherServlet ����ͼ������ֱ�ӱ�ʾij���ض��� JSP����ʵ���ϣ�����������ȷ����ͼ���� JSP���෴��**�����ݵĽ�����һ���߼����ƣ�������ƽ����������Ҳ��������������ͼ��**
+
+DispatcherServlet ����ʹ����ͼ��������view resolver�������߼���ͼ��ƥ��Ϊһ���ض�����ͼʵ�֣���������Ҳ���ܲ��� JSP
+
+> �����������ֱ�Ӱ󶨵��� index.jsp ��ͼ
+
+#### ����վ����ͼ
+
+��Ȼ DispatcherServlet �Ѿ�֪�����ĸ���ͼ��Ⱦ����ˣ�����������������Ҳ������ˡ�
+
+�������һվ����ͼ��ʵ�֣�������������ģ�����ݣ����������Ҳ������ˡ���ͼʹ��ģ��������Ⱦ������������������ͨ����Ӧ���󴫵ݸ��ͻ��ˡ�
+
+
+
+```
+<%@ page language="java" contentType="text/html; charset=UTF-8"
+         pageEncoding="UTF-8" isELIgnored="false"%>
+
+<h1>${message}</h1>
+
+```
+
+
+
+* * *
+
+## ʹ��ע������ Spring MVC
+
+���������Ѿ��� Spring MVC ����һ�����˽⣬����ͨ�� XML ���õķ�ʽ�����˵�һ�� Spring MVC ������������������ע��Ӧ����ô���������������ã�
+
+#### ��һ����Ϊ HelloController ����ע��
+
+
+
+```
+package controller;
+
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.servlet.ModelAndView;
+
+@Controller
+public class HelloController{
+
+    @RequestMapping("/hello")
+    public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {
+        ModelAndView mav = new ModelAndView("index.jsp");
+        mav.addObject("message", "Hello Spring MVC");
+        return mav;
+    }
+}
+
+```
+
+
+
+��ʵ�ֵĽӿ�Ҳ��ȥ����
+
+*   **�򵥽���һ�£�**
+*   `@Controller` ע�⣺
+    �����ԣ����ע�������������������ģ���ʵ�������ע��� Spring MVC ������Ӱ�첢���󡣣�Spring ʵս˵�������Ǹ���ʵ�����ɨ�裬������ `@Component` ע����棬�����Լ�������һ�²����У���Ϊ��������û������ JSP ��ͼ�������һ��Լ�����һ����û�гɹ�...��
+*   `@RequestMapping` ע�⣺
+    ����Ȼ����ͱ�ʾ·�� `/hello` ��ӳ�䵽�÷�����
+
+#### �ڶ�����ȡ��֮ǰ�� XML ע��
+
+�� dispatcher-servlet.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"
+       xmlns:context="http://www.springframework.org/schema/context"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
+
+    <!--<bean id="simpleUrlHandlerMapping"-->
+                                        <!-->-->
+    <!--<property name="mappings">-->
+            <!--<props>-->
+                <!--&lt;!&ndash; /hello ·�������󽻸� id Ϊ helloController �Ŀ���������&ndash;&gt;-->
+                <!--<prop key="/hello">helloController</prop>-->
+            <!--</props>-->
+        <!--</property>-->
+    <!--</bean>-->
+    <!--<bean id="helloController" ></bean>-->
+
+    <!-- ɨ��controller�µ���� -->
+    <context:component-scan base-package="controller"/>
+</beans>
+
+```
+
+
+
+#### ������������������
+
+��������ɣ��������������������� `localhost/hello` ��ַ��Ȼ�ܿ���Ч����
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-390fb571e9f6ff03.png)
+
+
+
+
+
+#### @RequestMapping ע��ϸ��
+
+��� `@RequestMapping` ���������ϣ���ô���൱���Ǹ������������õ�ӳ���ַǰ������һ����ַ�����磺
+
+
+
+```
+@Controller
+@RequestMapping("/wmyskxz")
+public class HelloController {
+    @RequestMapping("/hello")
+    public ModelAndView handleRequest(....) throws Exception {
+        ....
+    }
+}
+
+```
+
+
+
+*   ����ʵ�ַ�� `localhost/wmyskxz/hello`
+
+* * *
+
+## ������ͼ������
+
+���ǵ����� Spring MVC ��������������ͼ����������λ��ͼ��������һ���� DispaterServlet ���ݹ������߼���ͼ����ƥ��һ���ض�����ͼ��
+
+*   **����** ��һЩҳ�����Dz�ϣ���û��û�ֱ�ӷ��ʵ�����������Ҫ���ݵ�ҳ�棬������ģ������֧�ŵ�ҳ�档
+*   **��ɵ����⣺**
+    ���ǿ����ڡ�web����Ŀ¼�·���һ����test.jsp��ģ��һ����Ҫ���ݵ�ҳ�棬����ʲô����������������������������ҳ������ `localhost/test.jsp` ���ܹ�ֱ�ӷ��ʵ��ˣ�������**����й¶**...
+    �������ǿ���ֱ������ `localhost/index.jsp` ���ԣ�������������ij��������һ���հ׵�ҳ�棬��Ϊ��û�л�ȡ�� `${message}` ������ֱ�ӷ����ˣ����**Ӱ���û�����**
+
+#### �������
+
+���ǽ����ǵ� JSP �ļ������ڡ�WEB-INF���ļ����еġ�page���ļ����£���WEB-INF���� Java Web ��Ĭ�ϵİ�ȫĿ¼���Dz������û�ֱ�ӷ��ʵ�_��Ҳ������˵��ͨ�� `localhost/WEB-INF/` �����ķ�ʽ����Զ���ʲ����ģ�_
+
+����������Ҫ������߸���ͼ�������������� dispatcher-servlet.xml �ļ������������ã�
+
+
+
+```
+<bean id="viewResolver"
+      class="org.springframework.web.servlet.view.InternalResourceViewResolver">
+    <property name="prefix" value="/WEB-INF/page/" />
+    <property name="suffix" value=".jsp" />
+</bean>
+
+```
+
+
+
+����������һ�� Spring MVC ���õ�һ����ͼ���������ý���������ѭ��һ��Լ������**����ͼ��������ǰ׺�ͺ�׺������ȷ��һ�� Web Ӧ������ͼ��Դ������·���ġ�**������ʵ��������Ч����
+
+#### ��һ�����޸� HelloController
+
+���ǽ������޸�һ�£�
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-2ce49e171bd6d547.png)
+
+
+
+
+
+#### �ڶ�����������ͼ��������
+
+�������������ã���ɣ�
+
+
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:context="http://www.springframework.org/schema/context"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
+
+    <!--<bean id="simpleUrlHandlerMapping"-->
+                                        <!-->-->
+    <!--<property name="mappings">-->
+            <!--<props>-->
+                <!--&lt;!&ndash; /hello ·�������󽻸� id Ϊ helloController �Ŀ���������&ndash;&gt;-->
+                <!--<prop key="/hello">helloController</prop>-->
+            <!--</props>-->
+        <!--</property>-->
+    <!--</bean>-->
+    <!--<bean id="helloController" ></bean>-->
+
+    <!-- ɨ��controller�µ���� -->
+    <context:component-scan base-package="controller"/>
+    <bean id="viewResolver"
+          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
+        <property name="prefix" value="/WEB-INF/page/" />
+        <property name="suffix" value=".jsp" />
+    </bean>
+</beans>
+
+```
+
+
+
+#### ������������ index.jsp �ļ�
+
+�ڡ�WEB-INF���ļ������½�һ����page���ļ��У�������index.jsp���ļ����������棺
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-88995fd05ccd0f80.png)
+
+
+
+
+
+#### ���IJ���������Դ����������
+
+���� `localhost/hello` ·����������ȷЧ����
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-390fb571e9f6ff03.png)
+
+
+
+
+
+*   **ԭ����**
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-a716a3ac8f7e541d.png)
+
+
+
+
+
+���Ǵ�����߼���ͼ��Ϊ index ���ټ��� ��`/WEB-INF/page/`�� ǰ׺�� ��`.jsp`�� ��׺������ȷ��������ͼ��·���ˣ����������Ժ�Ϳ��Խ����е���ͼ���롾page���ļ������ˣ�
+
+*   **ע�⣺**��ʱ�����ý��� dispatcher-servlet.xml �µ�
+
+* * *
+
+## ������������������
+
+ʹ�ÿ��������ղ��������� Spring MVC ����ҵ���߼��ĵ�һ����Ϊ̽�� Spring MVC �Ĵ��η�ʽ��Ϊ��������������һ���򵥵ı��������ύ���ݣ�
+
+
+
+```
+<!DOCTYPE html>
+<%@ page language="java" contentType="text/html; charset=UTF-8"
+         pageEncoding="UTF-8" import="java.util.*" isELIgnored="false"%>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>Spring MVC ���η�ʽ</title>
+</head>
+<body>
+<form action="/param" role="form">
+    �û�����<br/>
+    ���룺<br/>
+    
+</form>
+</body>
+</html>
+
+```
+
+
+
+��ͳ����ɣ����Ǿ���������һ�£�
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-b50a42db8debde97.png)
+
+
+
+
+
+#### ʹ�� Servlet ԭ�� API ʵ�֣�
+
+���Ǻ�����֪�����������ύ�� `/param` ���Ŀ¼����������ʹ�� Servlet ԭ���� API �������ܲ��ܻ�ȡ�����ݣ�
+
+
+
+```
+@RequestMapping("/param")
+public ModelAndView getParam(HttpServletRequest request,
+                         HttpServletResponse response) {
+    String userName = request.getParameter("userName");
+    String password = request.getParameter("password");
+
+    System.out.println(userName);
+    System.out.println(password);
+    return null;
+}
+
+```
+
+
+
+���Գɹ���
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-df21058b7ef71924.png)
+
+
+
+
+
+#### ʹ��ͬ��ƥ�����
+
+���ǿ��԰ѷ���������β��������óɺ�ǰ̨���������һ���ķ���������ȡ�����ݣ�ͬ��ƥ����򣩣�
+
+
+
+```
+@RequestMapping("/param")
+public ModelAndView getParam(String userName,
+                             String password) {
+    System.out.println(userName);
+    System.out.println(password);
+    return null;
+}
+
+```
+
+
+
+���Գɹ���
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-55a1c296c778e506.png)
+
+
+
+
+
+*   **���⣺** �����ֻ��ǰ̨������ǿ����ϣ��������Dz�ϣ����
+*   **�����** ʹ�� `@RequestParam("ǰ̨������")` ��ע�룺
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-a649ad50866a01c5.png)
+
+
+
+
+
+*   **`@RequestParam` ע��ϸ�ڣ�**
+    ��ע��������������`value`��`required`��`defaultvalue`
+*   `value` ��ָ�� `name` ���Ե�������ʲô��`value` ���Զ�����Ĭ�ϲ�д
+*   `required` ���Ƿ����Ҫ�иò�������������Ϊ��true�����ߡ�false��
+*   `defaultvalue` ������Ĭ��ֵ
+
+#### ʹ��ģ�ʹ���
+
+*   **Ҫ�� ǰ̨�������ֱ����ģ���е��ֶ���һ��**
+
+����������Ϊ���ǵı�������һ�� User ģ�ͣ�
+
+
+
+```
+package pojo;
+
+public class User {
+
+    String userName;
+    String password;
+
+    /* getter and setter */
+}
+
+```
+
+
+
+Ȼ�������Ȼ�ɹ���
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-471d26bcb335aee6.png)
+
+
+
+
+
+#### ������������
+
+*   **ע�⣺** �� Servlet �е�һ�����÷���ֻ�� POST ������Ч����Ϊ��ֱ�Ӵ����� request��
+
+���ǿ���ͨ������ Spring MVC �ַ��������������ɣ��� web.xml �����ӣ�
+
+
+
+```
+<filter>
+    <filter-name>CharacterEncodingFilter</filter-name>
+    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
+    <init-param>
+        <param-name>encoding</param-name>
+        <!-- ���ñ����ʽ -->
+        <param-value>utf-8</param-value>
+    </init-param>
+</filter>
+<filter-mapping>
+    <filter-name>CharacterEncodingFilter</filter-name>
+    <url-pattern>/*</url-pattern>
+</filter-mapping>
+
+```
+
+
+
+* * *
+
+## ��������������
+
+ͨ�����棬����֪������ô�����������ݣ����ܽ�� POST ��������⣬��ô������ô���������أ�Ϊ�������ڡ�page���´���һ����test2.jsp����
+
+
+
+```
+<!DOCTYPE html>
+<%@ page language="java" contentType="text/html; charset=UTF-8"
+         pageEncoding="UTF-8" import="java.util.*" isELIgnored="false" %>
+<html>
+<head>
+    <title>Spring MVC ���ݻ���</title>
+</head>
+<body>
+<h1>�������ݣ�${message}</h1>
+</body>
+</html>
+
+```
+
+
+
+#### ʹ�� Servlet ԭ�� API ��ʵ��
+
+������������һ�� Servlet ԭ���� API �Ƿ�������������
+
+
+
+```
+@RequestMapping("/value")
+public ModelAndView handleRequest(HttpServletRequest request,
+                                  HttpServletResponse response) {
+    request.setAttribute("message","�ɹ���");
+    return new ModelAndView("test1");
+}
+
+```
+
+
+
+���������ַ�������룺`localhost/value` ����
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-66d2f24a876306e6.png)
+
+
+
+
+
+#### ʹ�� Spring MVC ���ṩ�� ModelAndView ����
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-360ce67947be817d.png)
+
+
+
+
+
+#### ʹ�� Model ����
+
+�� Spring MVC �У�����ͨ������ʹ�������ķ�ʽ�������ݣ�
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-685dd384904ad28f.png)
+
+
+
+
+
+*   **ʹ�� `@ModelAttribute` ע�⣺**
+
+
+
+```
+@ModelAttribute
+public void model(Model model) {
+    model.addAttribute("message", "ע��ɹ�");
+}
+
+@RequestMapping("/value")
+public String handleRequest() {
+    return "test1";
+}
+
+```
+
+
+
+����д�ͻ��ڷ��ʿ��������� handleRequest() ʱ�������ȵ��� model() ������ `message` ���ӽ�ҳ�������ȥ������ͼ�п���ֱ�ӵ��ã���������д�ᵼ�¸ÿ��������еķ����������ȵ��� model() ��������ͬ����Ҳ�ܷ��㣬��Ϊ���Լ�����ָ��������ݡ�
+
+* * *
+
+## �ͻ�����ת
+
+ǰ�治���ǵ�ַ `/hello` ��ת�� index.jsp ���� `/test` ��ת�� test.jsp����Щ���Ƿ���˵���ת��Ҳ���� `request.getRequestDispatcher("��ַ").forward(request, response);`
+
+��������ν��пͻ�����ת�أ����Ǽ����� HelloController �б�д��
+
+
+
+```
+@RequestMapping("/hello")
+public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {
+    ModelAndView mav = new ModelAndView("index");
+    mav.addObject("message", "Hello Spring MVC");
+    return mav;
+}
+
+@RequestMapping("/jump")
+public ModelAndView jump() {
+    ModelAndView mav = new ModelAndView("redirect:/hello");
+    return mav;
+}
+
+```
+
+
+
+����ʹ�� `redirect:/hello` �ͱ�ʾ����Ҫ��ת�� `/hello` ���·���������������������ڵ�ַ�������룺`localhost/jump` �����Զ���ת�� `/hello` ·���£�
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-390fb571e9f6ff03.png)
+
+
+
+
+
+Ҳ���������ã�
+
+
+
+```
+@RequestMapping("/jump")
+public String jump() {
+    return "redirect: ./hello";
+}
+
+```
+
+
+
+* * *
+
+## �ļ��ϴ�
+
+���������ع�һ�´�ͳ���ļ��ϴ������أ�[����](https://www.jianshu.com/p/e7837435bf4c)
+
+����������һ���� Spring MVC �����ʵ���ļ����ϴ�������
+
+*   **ע�⣺** ��Ҫ�ȵ��� `commons-io-1.3.2.jar` �� `commons-fileupload-1.2.1.jar` ������
+
+#### ��һ���������ϴ�������
+
+�� dispatcher-servlet.xml ������һ�䣺
+
+
+
+```
+<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"/>
+
+```
+
+
+
+�������ϴ����ܵ�֧��
+
+#### �ڶ�������д JSP
+
+�ļ���Ϊ upload.jsp���Դ����ڡ�page���£�
+
+
+
+```
+<%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<html>
+<head>
+    <title>�����ļ��ϴ�</title>
+</head>
+<body>
+<form action="/upload" method="post" enctype="multipart/form-data">
+    
+    
+</form>
+</body>
+</html>
+
+```
+
+
+
+#### ���������������
+
+�� Package��controller�����½���UploadController���ࣺ
+
+
+
+```
+package controller;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.servlet.ModelAndView;
+
+@Controller
+public class UploadController {
+
+    @RequestMapping("/upload")
+    public void upload(@RequestParam("picture") MultipartFile picture) throws Exception {
+        System.out.println(picture.getOriginalFilename());
+    }
+
+    @RequestMapping("/test2")
+    public ModelAndView upload() {
+        return new ModelAndView("upload");
+    }
+
+}
+
+```
+
+
+
+#### ���IJ�������
+
+���������ַ�������룺`localhost/test2` ��ѡ���ļ�����ϴ������Գɹ���
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7896890-531c47b14dbc71e5.png)
+
+
+
+
+
+* * *
+
+#### �ο����ϣ�
+
+*   ��Java EE ������������������Ͽ�����
+*   ��Spring ʵս��
+*   [How2j Spring MVC ϵ�н̳�](http://how2j.cn/k/springmvc/springmvc-springmvc/615.html)
+*   ȫ�ܵİٶȺ����ܵĴ���
+
+* * *
+
+> ��ӭת�أ�ת����ע��������
+> ����ID��[@��û����������](https://www.jianshu.com/u/a40d61a49221)
+> github��[wmyskxz](https://github.com/wmyskxz/)
+> ��ӭ��ע����΢�źţ�wmyskxz
+> �����Լ���ѧϰ & ѧϰ���� & ����
+> ��Ҫ����������Ҳ���Լ�qqȺ��3382693
+
+
+
+���ߣ���û����������
+���ӣ�https://www.jianshu.com/p/91a2d0a1e45a
+��Դ������
+����Ȩ���������С���ҵת������ϵ���߻����Ȩ������ҵת����ע��������
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\345\246\202\344\275\225\345\256\236\347\216\260\346\226\207\344\273\266\344\270\212\344\274\240.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\345\246\202\344\275\225\345\256\236\347\216\260\346\226\207\344\273\266\344\270\212\344\274\240.md"
new file mode 100644
index 0000000..dd0b576
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\345\246\202\344\275\225\345\256\236\347\216\260\346\226\207\344\273\266\344\270\212\344\274\240.md"
@@ -0,0 +1,237 @@
+
+
+
+
+# Spring MVC �ļ��ϴ�����
+
+
+
+
+
+
+
+
+
+
+Spring���öԶ�·�ϴ���֧�֣�ר�����ڴ���webӦ���е��ļ��ϴ��������ͨ��ע��һ���ɲ�ε�`MultipartResolver`���������ö��ļ���·�ϴ���֧�֡��ýӿ��ڶ�����`org.springframework.web.multipart`���¡�SpringΪ[_һ����ļ��ϴ�_](http://jakarta.apache.org/commons/fileupload)�ṩ��`MultipartResolver`�ӿڵ�һ��ʵ�֣�ΪServlet 3.0��·�����ת���ṩ����һ��ʵ�֡�
+
+<section>
+
+Ĭ������£�Spring�Ķ�·�ϴ�֧���Dz������ģ���Ϊ��Щ������ϣ�����Լ���������·�������������Spring�Ķ�·�ϴ�֧�֣�����Ҫ��webӦ�õ�������������һ����·�����������ÿ�����������󣬽������������Dz���һ���ಿ�����������������������ģ��������������̱��������������������һ����·������������������ע���`MultipartResolver`�������ᱻ��������������֮�������еĶ�·�ϴ����Ծ�����������һ���������Դ��ˡ������һ�䷭�IJ��ã�multipart����ɶ�·���Ƕಿ�ֻ��������С����Ķ���ע��˴�����
+
+</section>
+
+
+
+
+
+
+
+# Spring MVC ʹ��MultipartResolver��Commons FileUpload�����ļ�
+
+
+
+2018-07-26 14:28 ����
+
+
+
+
+
+
+
+����Ĵ���չʾ�����ʹ��һ��ͨ�õĶ�·�ϴ�������`CommonsMultipartResolver`��
+
+<section>
+
+```
+<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
+
+    <!-- ֧�ֵ�����һ�����ԣ�֧�ֵ�����ļ���С�����ֽ�Ϊ��λ -->
+    <property name="maxUploadSize" value="100000"/>
+
+</bean>
+
+```
+
+��Ȼ��Ҫ�ö�·��������������������Ҫ��classpath·����׼�������jar�������ʹ�õ���ͨ�õĶ�·�ϴ�������`CommonsMultipartResolver`��������Ҫ��jar����`commons-fileupload.jar`��
+
+��Spring��`DispatcherServlet`��⵽һ���ಿ������ʱ�����ἤ�������������������Ķ�·�������������󽻸�������������ѵ�ǰ��`HttpServletRequest`��������װ��һ��֧�ֶ�·�ļ��ϴ����������`MultipartHttpServletRequest`������`MultipartHttpServletRequest`�����㲻�����Ի�ȡ�ö�·�����е���Ϣ������������Ŀ������л�øö�·��������ݱ�����
+
+</section>
+
+
+
+
+
+
+
+# Spring MVC ����Servlet 3.0�µ�MultipartResolver
+
+
+
+2018-07-26 14:29 ����
+
+
+
+
+
+
+
+Ҫʹ�û���Servlet 3.0�Ķ�·����ת�����ܣ��������`web.xml`��Ϊ`DispatcherServlet`����һ��`multipart-config`Ԫ�أ�����ͨ��Servlet��̵ķ���ʹ��`javax.servlet.MultipartConfigElement`����ע�ᣬ�����Լ��������Լ���Servlet�࣬�������ʹ��`javax.servlet.annotation.MultipartConfig`�������ע�⡣������������ļ���С��洢λ�õ�����ѡ����������Servlet�������ע�ᣬ��ΪServlet 3.0�������ڽ�����MultipartResolver�IJ㼶������Щ��Ϣ��
+
+<section>
+
+����ͨ��������һ�ַ�ʽ������Servlet 3.0��·����ת�����ܣ���Ϳ��԰�һ��`StandardServletMultipartResolver`���������ӵ����Spring������ȥ�ˣ�
+
+```
+<bean id="multipartResolver" class="org.springframework.web.multipart.support.StandardServletMultipartResolver">
+</bean>
+```
+
+</section>
+
+
+
+
+
+
+# Spring MVC ���������е��ļ��ϴ�
+
+
+
+2018-07-26 14:30 ����
+
+
+
+
+
+
+
+��������`MultipartResolver`��ɴ���ʱ������������������һ�����������̴��������ȣ�����һ�������ļ��ϴ��ı�������������ֱ���ϴ������������������ԣ�`enctype="multipart/form-data"`�����������֪����ζԶ�·�ϴ�����ı������б��루encode����
+
+<section>
+
+```
+<html>
+    <head>
+        <title>Upload a file please</title>
+    </head>
+    <body>
+        <h1>Please upload a file</h1>
+        <form method="post" action="/form" enctype="multipart/form-data">
+            
+            
+            
+        </form>
+    </body>
+</html>
+
+```
+
+��һ���Ǵ���һ���ܴ����ļ��ϴ��Ŀ�������������Ҫ�Ŀ�������[һ��ע����`@Controller`�Ŀ�����](http://docs.spring.io/spring-framework/docs/4.2.4.RELEASE/spring-framework-reference/html/mvc.html#mvc-ann-controller)����һ�������������ܵķ�������������`MultipartHttpServletRequest`����`MultipartFile`��
+
+```
+@Controller
+public class FileUploadController {
+
+    @RequestMapping(path = "/form", method = RequestMethod.POST)
+    public String handleFormUpload(@RequestParam("name") String name, @RequestParam("file") MultipartFile file) {
+
+        if (!file.isEmpty()) {
+            byte[] bytes = file.getBytes();
+            // store the bytes somewhere
+            return "redirect:uploadSuccess";
+        }
+
+        return "redirect:uploadFailure";
+    }
+
+}
+
+```
+
+������`@RequestParam`ע������ν�����������Ӧ�������еĶ���������ֶεġ�������������У������õ���`byte[]`�ļ����ݣ�ֻ��û�������κ��¡���ʵ��Ӧ���У�����ܻὫ�����浽���ݿ⡢�洢���ļ�ϵͳ�ϣ����������Ĵ�����
+
+��ʹ��Servlet 3.0�Ķ�·����ת��ʱ����Ҳ����ʹ��`javax.servlet.http.Part`��Ϊ����������
+
+```
+@Controller
+public class FileUploadController {
+
+    @RequestMapping(path = "/form", method = RequestMethod.POST)
+    public String handleFormUpload(@RequestParam("name") String name, @RequestParam("file") Part file) {
+
+        InputStream inputStream = file.getInputStream();
+        // store bytes from uploaded file somewhere
+
+        return "redirect:uploadSuccess";
+    }
+
+}
+```
+
+</section>
+
+
+
+
+
+
+
+# Spring MVC �����ͻ��˷�����ļ��ϴ�����
+
+
+
+2018-07-26 14:30 ����
+
+
+
+
+
+
+
+��ʹ����RESTful����ij����£���������Ŀͻ���Ҳ����ֱ���ύ��·�ļ�������һ�ڽ�������������������������Ҳ��ͬ�����á������������ͬ���ǣ��ύ���ļ��ͼ򵥵ı����ֶΣ��ͻ��˷��͵����ݿ��Ը��Ӹ��ӣ����ݿ���ָ��Ϊij���ض����������ͣ�content type���������磬һ����·�ϴ�������ܵ�һ�����Ǹ��ļ������ڶ������Ǹ�JSON��ʽ�����ݣ�
+
+<section>
+
+```
+    POST /someUrl
+    Content-Type: multipart/mixed
+
+    --edt7Tfrdusa7r3lNQc79vXuhIIMlatb7PQg7Vp
+    Content-Disposition: form-data; name="meta-data"
+    Content-Type: application/json; charset=UTF-8
+    Content-Transfer-Encoding: 8bit
+
+    {
+        "name": "value"
+    }
+    --edt7Tfrdusa7r3lNQc79vXuhIIMlatb7PQg7Vp
+    Content-Disposition: form-data; name="file-data"; filename="file.properties"
+    Content-Type: text/xml
+    Content-Transfer-Encoding: 8bit
+    ... File Data ...
+
+```
+
+��������Ϊ`meta-data`�IJ��֣������ͨ�������������ϵ�`@RequestParam("meta-data") String metadata`��������á��������Dz�����������ΪJSON��ʽ���ݵ���������ܸ���ͨ������һ����Ӧ��ǿ���Ͷ��󣬾���`@RequestBody`ͨ��`HttpMessageConverter`��һ�������������ת����һ������һ����
+
+���ǿ��ܵģ������ʹ��`@RequestPart`ע����ʵ�֣�����`@RequestParam`����ע�⽫ʹ���ض���·����������屻����`HttpMessageConverter`��������ת��ʱ���Ƕ�·�����в�ͬ���������Ͳ���`'Content-Type'`��
+
+```
+@RequestMapping(path = "/someUrl", method = RequestMethod.POST)
+public String onSubmit(@RequestPart("meta-data") MetaData metadata, @RequestPart("file-data") MultipartFile file) {
+
+    // ...
+
+}
+
+```
+
+��ע��`MultipartFile`��������������ܹ���`@RequestParam`��`@RequestPart`ע���»��õģ����ַ��������õ����ݡ���������ķ�������`@RequestPart("meta-data") MetaData`�����Ϊ�����е�������������ͷ`'Content-Type'`�������ΪJSON���ݣ�Ȼ����ͨ��`MappingJackson2HttpMessageConverter`��ת�����ض��Ķ���
+
+</section>
+
+
+
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\345\270\270\350\247\201\346\263\250\350\247\243.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\345\270\270\350\247\201\346\263\250\350\247\243.md"
new file mode 100644
index 0000000..6bd5272
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC/SpringMVC\345\270\270\350\247\201\346\263\250\350\247\243.md"
@@ -0,0 +1,232 @@
+## 1. ����
+   �ڱ��̳��У����ǽ�̽�� org.springframework.web.bind.annotation ���е� Spring Web ע�͡�
+
+## 2. @RequestMapping
+
+�򵥵�˵��@RequestMapping ���@Controller ���ڲ������������򷽷��� ������ʹ�����ã�
+
+·����������������ƺ�ֵ������ӳ�䵽�ĸ� URL
+���������ݵ� HTTP ����
+params������ HTTP �����Ĵ��ڡ������ڻ�ֵ��������
+headers������ HTTP ��ͷ�Ĵ��ڡ������ڻ�ֵ��������
+���ģ��÷��������� HTTP ����������������Щý������
+produces���÷��������� HTTP ��Ӧ������������Щý������
+����һ���򵥵�ʾ����
+
+````
+@Controller
+class VehicleController {
+
+    @RequestMapping(value = "/vehicles/home", method = RequestMethod.GET)
+    String home() {
+        return "home";
+    }
+}
+````
+����������༶��Ӧ�ô�ע�ͣ����ǿ���Ϊ @Controller ���е����д������򷽷��ṩĬ�����á� Ψһ�������� Spring ����ʹ�÷����������ø��ǵ��ḽ������·�����ֵ� URL��
+
+���磬��������ú������Ч����һ���ģ�
+
+````
+@Controller
+@RequestMapping(value = "/vehicles", method = RequestMethod.GET)
+class VehicleController {
+
+    @RequestMapping("/home")
+    String home() {
+        return "home";
+    }
+}
+````
+
+���⣬@GetMapping��@PostMapping��@PutMapping��@DeleteMapping ��@PatchMapping ��@RequestMapping �IJ�ͬ���壬��HTTP �����ѷֱ�����ΪGET��POST��PUT��DELETE ��PATCH��
+
+��Щ�� Spring 4.3 �汾��ʼ���á�
+
+## 3 @RequestBody
+
+�����Ǽ���@RequestBody�������� HTTP ���������ӳ�䵽һ������
+
+````
+@PostMapping("/save")
+void saveVehicle(@RequestBody Vehicle vehicle) {
+// ...
+}
+````
+�����л����Զ��ģ�ȡ����������������͡�
+
+## 4 @PathVariable
+������˵˵@PathVariable��
+
+��ע��ָʾ���������󶨵� URI ģ������� ���ǿ���ʹ�� @RequestMapping ע��ָ�� URI ģ�壬��ʹ�� @PathVariable �����������󶨵�ģ�岿��֮һ��
+
+���ǿ���ʹ�����ƻ����������ֵ������ʵ����һ�㣺
+
+````
+@RequestMapping("/{id}")
+Vehicle getVehicle(@PathVariable("id") long id) {
+// ...
+}
+````
+���ģ���в��ֵ������뷽��������������ƥ�䣬���ǾͲ�����ע����ָ������
+
+````
+@RequestMapping("/{id}")
+Vehicle getVehicle(@PathVariable long id) {
+// ...
+}
+````
+���⣬���ǿ���ͨ��������IJ�������Ϊ false ����·���������Ϊ��ѡ��
+
+````
+@RequestMapping("/{id}")
+Vehicle getVehicle(@PathVariable(required = false) long id) {
+// ...
+}
+````
+## 5. @RequestParam
+   We use @RequestParam for accessing HTTP request parameters:
+````
+@RequestMapping
+Vehicle getVehicleByParam(@RequestParam("id") long id) {
+// ...
+}
+````
+�������� @PathVariable ע����ͬ������ѡ�
+
+������Щ����֮�⣬�� Spring �������з���û��ֵ��Ϊ��ֵʱ�����ǿ���ʹ�� @RequestParam ָ��ע��ֵ�� Ϊ�ˣ����DZ������� defaultValue ������
+
+�ṩĬ��ֵ��ʽ���� required Ϊ false��
+````
+@RequestMapping("/buy")
+Car buyCar(@RequestParam(defaultValue = "5") int seatCount) {
+// ...
+}
+````
+���˲���֮�⣬���ǻ����Է������� HTTP ���󲿷֣�cookie �ͱ�ͷ�� 
+
+���ǿ��Էֱ�ʹ��ע��@CookieValue ��@RequestHeader ���������ǡ�
+
+
+## 6. Response Handling Annotations
+�ڽ������IJ����У����ǽ������� Spring MVC �в��� HTTP ��Ӧ�����ע�͡�
+
+### 6.1 @ResponseBody
+���������@ResponseBody ������������򷽷���Spring �Ὣ�����Ľ����Ϊ��Ӧ������
+
+````
+@ResponseBody
+@RequestMapping("/hello")
+String hello() {
+return "Hello World!";
+}
+````
+������������ע����ע�� @Controller �࣬�������������򷽷�����ʹ������
+
+### 6.2 @ExceptionHandler
+
+ʹ�ô�ע�ͣ����ǿ�������һ���Զ�����������򷽷��� �����������򷽷��׳��κ�ָ�����쳣ʱ��Spring ���ô˷�����
+
+������쳣������Ϊ�������ݸ�������
+````
+@ExceptionHandler(IllegalArgumentException.class)
+void onIllegalArgumentException(IllegalArgumentException exception) {
+// ...
+}
+````
+
+### 6.3 @ResponseStatus
+�������ʹ�ô�ע�Ͷ����������򷽷�����ע�ͣ������ָ����Ӧ������ HTTP ״̬�� ���ǿ���ʹ�� code ����������� value ����������״̬���롣
+
+���⣬���ǿ���ʹ�� reason �����ṩԭ��
+
+����Ҳ���Խ�����@ExceptionHandler һ��ʹ�ã�
+
+@ExceptionHandler(IllegalArgumentException.class)
+@ResponseStatus(HttpStatus.BAD_REQUEST)
+void onIllegalArgumentException(IllegalArgumentException exception) {
+// ...
+}
+
+�й� HTTP ��Ӧ״̬�ĸ�����Ϣ������ʱ��ġ�
+
+## 7 ���� Webע��
+һЩע�Ͳ�ֱ�ӹ��� HTTP �������Ӧ�� �ڽ������IJ����У����ǽ���������ġ�
+
+### 7.1 @Controller
+���ǿ���ʹ��@Controller ����һ��Spring MVC �������� �йظ�����Ϣ����������ǹ��� Spring Bean Annotations �����¡�
+
+### 7.2 @RestController
+@RestController �����@Controller ��@ResponseBody��
+
+��ˣ����������ǵ�Ч�ģ�
+
+````
+@Controller
+@ResponseBody
+class VehicleRestController {
+// ...
+}
+````
+
+````
+@RestController
+class VehicleRestController {
+// ...
+}
+````
+### 7.3 @ModelAttribute
+ͨ�����ע�⣬���ǿ���ͨ���ṩģ�ͼ��������Ѿ������� MVC @Controller ģ���е�Ԫ�أ�
+
+````
+@PostMapping("/assemble")
+void assembleVehicle(@ModelAttribute("vehicle") Vehicle vehicleInModel) {
+// ...
+}
+````
+��@PathVariable ��@RequestParam һ�����������������ͬ�����ƣ����Dz���ָ��ģ�ͼ���
+
+````
+@PostMapping("/assemble")
+void assembleVehicle(@ModelAttribute Vehicle vehicle) {
+// ...
+}
+````
+���⣬@ModelAttribute����һ����;�������������ע��һ��������Spring���Զ��������ķ���ֵ���ӵ�ģ���У�
+
+````
+@ModelAttribute("vehicle")
+Vehicle getVehicle() {
+// ...
+}
+````
+����ǰһ�������Dz���ָ��ģ�ͼ���Spring Ĭ��ʹ�÷��������ƣ�
+````
+@ModelAttribute
+Vehicle vehicle() {
+// ...
+}
+````
+�� Spring �������������򷽷�֮ǰ����������������� @ModelAttribute ע�͵ķ�����
+
+�й� @ModelAttribute �ĸ�����Ϣ������ı��ġ�
+
+### 7.4 @CrossOrigin
+@CrossOrigin Ϊ��ע�͵����������򷽷����ÿ���ͨ�ţ�
+
+````
+@CrossOrigin
+@RequestMapping("/hello")
+String hello() {
+return "Hello World!";
+}
+````
+��������������һ���࣬�����������е��������������򷽷���
+
+���ǿ���ʹ�ô�ע�͵IJ���΢�� CORS ��Ϊ��
+
+�й���ϸ��Ϣ������ʱ��ġ�
+
+
+# �����
+https://www.baeldung.com/spring-annotations
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/DispatcherServlet\345\210\235\345\247\213\345\214\226\346\265\201\347\250\213.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/DispatcherServlet\345\210\235\345\247\213\345\214\226\346\265\201\347\250\213.md"
new file mode 100644
index 0000000..4ffcaa6
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/DispatcherServlet\345\210\235\345\247\213\345\214\226\346\265\201\347\250\213.md"
@@ -0,0 +1,477 @@
+��[��һƪ����](https://my.oschina.net/funcy/blog/4696657 "��һƪ����")�У�����ͨ��һ���򵥵� demo �ɹ������� springmvc Ӧ�ã����ṩ�� demo �У�����֪�� tomcat ������ʱ����� `MyWebApplicationInitializer#onStartup` ������Ȼ������ spring ��������ô tomcat ������������� spring ���أ�
+
+### 1\. servlet ��ʼ����`DispatcherServlet#init`
+
+�����ٻ����� `MyWebApplicationInitializer#onStartup` ������
+
+```
+@Override
+public void onStartup(ServletContext servletContext) {
+   System.out.println("webApplicationInitializer ...");
+   // ���� spring �� applicationContext
+   AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
+   context.register(MvcConfig.class);
+
+   // ʵ���� DispatcherServlet
+   DispatcherServlet servlet = new DispatcherServlet(context);
+
+   // ��DispatcherServletע�ᵽservlet����
+   ServletRegistration.Dynamic registration = servletContext.addServlet("app", servlet);
+   registration.setLoadOnStartup(1);
+   registration.addMapping("/*");
+}
+
+```
+
+��δ�����׼����һ�� `AnnotationConfigWebApplicationContext`��������Ϊ�������� `DispatcherServlet` �У�Ȼ���� servlet ���������� `DispatcherServlet`��������servlet ����������ʱ���ͻ����� spring �����ˡ���������Ҫ�ľ��� `DispatcherServlet`�����������Ǿ���������� servlet.
+
+������������ `DispatcherServlet` �ļ̳нṹ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-1df54493011b3fc9cb9cafbb944f1a88256.png)
+
+����ͼ���Կ�����spring �ṩ�ġ��� servlet ��ص�����������`HttpServletBean`��`FrameworkServlet` �� `DispatcherServlet`����Ϊ servlet������֪�����ʼ������Ϊ `GenericServlet#init()`��Ҳ���� servlet ����ڷ��������ǵķ���Ҳ�������￪ʼ��
+
+���� `DispatcherServlet` ʵ���� `HttpServletBean`��`FrameworkServlet`��`DispatcherServlet#init()` ʵ���ϼ̳��� `HttpServletBean#init`��
+
+```
+@Override
+public final void init() throws ServletException {
+
+    PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
+    if (!pvs.isEmpty()) {
+        try {
+            BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
+            ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
+            bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
+            initBeanWrapper(bw);
+            bw.setPropertyValues(pvs, true);
+        }
+        catch (BeansException ex) {
+            ...
+        }
+    }
+
+    // ��ʼ�� servlet bean��spring��������þ�����������е�
+    initServletBean();
+}
+
+```
+
+���Կ������������������һЩ���ã�Ȼ��͵����� `initServletBean`����û����һЩ spring ʵ���Ե����ݡ����Ǽ����������������в���Ҫ�ķ�����������·���£�
+
+```
+-HttpServletBean#init
+ -FrameworkServlet#initServletBean
+  -FrameworkServlet#initWebApplicationContext
+
+```
+
+һֱ���� `FrameworkServlet#initWebApplicationContext`��
+
+```
+protected WebApplicationContext initWebApplicationContext() {
+    // ��ȡ����ΪWebServerApplicationContext�ĸ�����������õ��Ľ��Ϊnull
+    WebApplicationContext rootContext =
+            WebApplicationContextUtils.getWebApplicationContext(getServletContext());
+    WebApplicationContext wac = null;
+
+    if (this.webApplicationContext != null) {
+        // ���webApplicationContext��������MyWebApplicationInitializer#onStart������
+        // �����AnnotationConfigWebApplicationContext
+        wac = this.webApplicationContext;
+        if (wac instanceof ConfigurableWebApplicationContext) {
+            ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
+            if (!cwac.isActive()) {
+                if (cwac.getParent() == null) {
+                    cwac.setParent(rootContext);
+                }
+                // ��������� AbstractApplicationContext#refresh ����
+                configureAndRefreshWebApplicationContext(cwac);
+            }
+        }
+    }
+    // wac��Ϊnull,���ﲻ������
+    if (wac == null) {
+        wac = findWebApplicationContext();
+    }
+    // wac��Ϊnull,���ﲻ������
+    if (wac == null) {
+        // ����WebApplicationContext����������AbstractApplicationContext#refresh
+        wac = createWebApplicationContext(rootContext);
+    }
+
+    // ʵ���ϣ�refreshEventReceivedΪtrue��if��Ĵ��벢��ִ��
+    if (!this.refreshEventReceived) {
+        synchronized (this.onRefreshMonitor) {
+            // ˢ��Ӧ�������ģ�springmvc��ش�������������
+            onRefresh(wac);
+        }
+    }
+
+    if (this.publishContext) {
+        // �� WebApplicationContext��ΪservletContext һ�����ԣ����뵽 servletContext ��
+        // ֮��Ϳ���ʹ��
+        // WebApplicationContextUtils.getWebApplicationContext(ServletContext, String attrName)
+        // ����ȡ
+        String attrName = getServletContextAttributeName();
+        getServletContext().setAttribute(attrName, wac);
+    }
+
+    return wac;
+}
+
+```
+
+�����������ز�������������ע�ͣ�ʵ������������� ��Ҫ�Ĵ���Ϊ
+
+```
+protected WebApplicationContext initWebApplicationContext() {
+    ...
+    // ��������� AbstractApplicationContext#refresh ����
+    configureAndRefreshWebApplicationContext(cwac);
+    ...
+    return wac;
+}
+
+```
+
+��ط������£�
+
+> FrameworkServlet#configureAndRefreshWebApplicationContext
+
+```
+protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
+    if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
+        if (this.contextId != null) {
+            wac.setId(this.contextId);
+        }
+        else {
+            // Generate default id...
+            wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
+                    ObjectUtils.getDisplayString(getServletContext().getContextPath()) + 
+                    '/' + getServletName());
+        }
+    }
+    wac.setServletContext(getServletContext());
+    wac.setServletConfig(getServletConfig());
+    wac.setNamespace(getNamespace());
+    // �����¼�������������spring��������¼�
+    // ���������ʮ����Ҫ����������
+    wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));
+    ConfigurableEnvironment env = wac.getEnvironment();
+    if (env instanceof ConfigurableWebEnvironment) {
+        ((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
+    }
+    // ��չ�㣬û��ʲô���ܣ����Ժ���չ
+    postProcessWebApplicationContext(wac);
+    applyInitializers(wac);
+    // ���þ��� AbstractApplicationContext.refresh
+    wac.refresh();
+}
+
+```
+
+�������ʵ���ϻ������� `ConfigurableWebApplicationContext` ��һЩ���ԣ������� `AbstractApplicationContext#refresh` ������ spring ���������� `AbstractApplicationContext#refresh` �ķ��������Բο� [spring ��������֮����ǰ��׼������](https://my.oschina.net/funcy/blog/4633169 "spring��������֮����ǰ��׼������")��
+
+�����spring ���������������ˡ�
+
+### 2. `SourceFilteringListener`�������¼�������
+
+�����и����⣺�� springmvc �У�����֪�� spring ��ʶ�� `@Controller`���� `RequestMapping`/`@PostMapping`/`@GetMapping` ��ע���е�·����װΪһ�� uri���ȴ��ⲿ���ʣ���������һ·�������ƺ� spring ��û������Щ��������ô�ⲿ�ֵĹ�������������е��أ�
+
+ʵ���ϣ�spring �ⲿ�ֵĹ���������������������ɵģ�Ҳ����
+
+```
+wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));
+
+```
+
+����������������� spring ������ �¼������� spring ����������ɺ���á�
+
+���� spring ���¼�������ݣ����Բο� [spring ̽��֮ spring �¼�����](https://my.oschina.net/funcy/blog/4713339 "spring̽��֮spring �¼�����")������ֱ��˵���ۣ�spring ���ṩ�� `ApplicationEventPublisher#publishEvent(Object)`���¼�����������`ApplicationEvent`���¼����� `ApplicationListener` ���¼������������� spring ͨ�� `ApplicationEventPublisher#publishEvent(Object)` ���� `ApplicationEvent`���¼���ʱ��`ApplicationListener` ���¼��������������������
+
+���������� `SourceFilteringListener`��
+
+```
+public class SourceFilteringListener implements GenericApplicationListener, SmartApplicationListener {
+
+    private final Object source;
+
+    @Nullable
+    private GenericApplicationListener delegate;
+
+    /**
+     * ���췽�������� event �� listener
+     */
+    public SourceFilteringListener(Object source, ApplicationListener<?> delegate) {
+        this.source = source;
+        this.delegate = (delegate instanceof GenericApplicationListener ?
+                (GenericApplicationListener) delegate : new GenericApplicationListenerAdapter(delegate));
+    }
+
+    /**
+     * �¼���������
+     */
+    @Override
+    public void onApplicationEvent(ApplicationEvent event) {
+        if (event.getSource() == this.source) {
+            // �����������¼�����
+            onApplicationEventInternal(event);
+        }
+    }
+
+    /**
+     *  �����¼�
+     */
+    protected void onApplicationEventInternal(ApplicationEvent event) {
+        if (this.delegate == null) {
+            throw new IllegalStateException(...);
+        }
+        // ���ջ��ǵ��ô�����¼���������onApplicationEvent����
+        this.delegate.onApplicationEvent(event);
+    }
+
+    // ʡ����һЩ����
+    ...
+
+```
+
+���Կ�����`SourceFilteringListener` ͨ�����췽�������� `ContextRefreshListener` ��ʵ����Ȼ���� `SourceFilteringListener#onApplicationEvent` �����У����յ��õ��� `ContextRefreshListener#onApplicationEvent` ������
+
+���������������� `ContextRefreshListener`��
+
+> FrameworkServlet.ContextRefreshListener
+
+```
+private class ContextRefreshListener implements ApplicationListener<ContextRefreshedEvent> {
+
+    @Override
+    public void onApplicationEvent(ContextRefreshedEvent event) {
+        FrameworkServlet.this.onApplicationEvent(event);
+    }
+}
+
+```
+
+������� `FrameworkServlet` ���ڲ��࣬����ܼ򵥣����յ��õ��� `FrameworkServlet#onApplicationEvent`��
+
+```
+public void onApplicationEvent(ContextRefreshedEvent event) {
+    // �޸�״̬������ܹؼ������������к�
+    // FrameworkServlet#initWebApplicationContext���onRefresh(...)�Ͳ�������
+    this.refreshEventReceived = true;
+    synchronized (this.onRefreshMonitor) {
+         // ������߼�����
+         onRefresh(event.getApplicationContext());
+    }
+}
+
+```
+
+���������� `DispatcherServlet#onRefresh` �����ˣ�
+
+```
+@Override
+protected void onRefresh(ApplicationContext context) {
+    initStrategies(context);
+}
+
+/**
+ * springmvc���ռ����ؾ���������
+ * ��������У���ʼ����springmvc�ĸ������
+ */
+protected void initStrategies(ApplicationContext context) {
+    initMultipartResolver(context);
+    initLocaleResolver(context);
+    initThemeResolver(context);
+    initHandlerMappings(context);
+    initHandlerAdapters(context);
+    initHandlerExceptionResolvers(context);
+    initRequestToViewNameTranslator(context);
+    initViewResolvers(context);
+    initFlashMapManager(context);
+}
+
+```
+
+���Կ������������еķ����� `DispatcherServlet#initStrategies`�����������ֻ�������У��ҳ�ʼ���� springmvc �����������
+
+### 3. `DispatcherServlet#initStrategies`����ʼ�� springmvc ���
+
+spring ��������ɺ󣬻ᷢ����������¼���Ȼ���ɼ����� `SourceFilteringListener` ���������¼���ִ�м����߼������յ��õ� `DispatcherServlet#initStrategies`���������ǽ������� `DispatcherServlet#initStrategies` ��ִ�й��̡�
+
+��ʵ��������ܼ򵥣������� 9 �д��룬ÿ�д��붼��ʼ���� springmvc ��һ��������� `initMultipartResolver`��
+
+```
+public static final String MULTIPART_RESOLVER_BEAN_NAME = "multipartResolver";
+
+private void initMultipartResolver(ApplicationContext context) {
+    try {
+        // ��spring�����л�ȡmultipartResolver����
+        this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
+    }
+    catch (NoSuchBeanDefinitionException ex) {
+        // ��ȡʧ�ܣ�Ĭ��Ϊnull
+        this.multipartResolver = null;
+        }
+    }
+}
+
+```
+
+`multipartResolver` �����������ļ��ϴ��� bean���� spring �У����Ǵ����ļ��ϴ�ʱ��һ������������� `multipartResolver` bean��
+
+```
+@Bean(name = "multipartResolver")
+public MultipartResolver multipartResolver() {
+    CommonsMultipartResolver resolver = new CommonsMultipartResolver();
+    resolver.setDefaultEncoding("UTF-8");
+    resolver.setResolveLazily(true);
+    resolver.setMaxInMemorySize(40960);
+    //�����ϴ��ļ����Ϊ1G
+    resolver.setMaxUploadSize(1024 * 1024 * 1024);
+    return resolver;
+}
+
+```
+
+���δ���� `multipartResolver` bean��spring Ĭ��Ϊ null���Ͳ��ܽ����ļ��ϴ��ˡ�
+
+�������� `springmvc` `HandlerMappings` �ij�ʼ�����̣�
+
+> DispatcherServlet
+
+```
+public static final String HANDLER_MAPPING_BEAN_NAME = "handlerMapping";
+
+private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";
+
+private static final Properties defaultStrategies;
+
+static {
+    try {
+        // ��static���м���DispatcherServlet.properties�ļ�
+        ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, 
+                DispatcherServlet.class);
+        defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
+    }
+    catch (IOException ex) {
+        throw new IllegalStateException(...);
+    }
+}
+
+/**
+ * handlerMappings ����
+ */
+@Nullable
+private List<HandlerMapping> handlerMappings;
+
+/**
+ * ��ʼ�� HandlerMappings
+ * 1\. ��spring �����л�ȡ HandlerMapping bean��
+ *     �����ȡ�ɹ�����ѵõ��Ľ����ֵ��handlerMappings
+ * 2\. ���δ��ã����ȡĬ�ϵ� HandlerMapping bean
+ */
+private void initHandlerMappings(ApplicationContext context) {
+    this.handlerMappings = null;
+    if (this.detectAllHandlerMappings) {
+        // ��������ʵ��HandlerMapping�ӿڵ�bean
+        Map<String, HandlerMapping> matchingBeans = BeanFactoryUtils
+                .beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
+        // ���ﲻΪ�գ�������
+        if (!matchingBeans.isEmpty()) {
+            this.handlerMappings = new ArrayList<>(matchingBeans.values());
+            // ����Spring����������Ǹ����������Ľ�����д�����
+            // �����ǰhandlerMapping�����Դ������׸���һ��
+            AnnotationAwareOrderComparator.sort(this.handlerMappings);
+        }
+    }
+    else {
+        try {
+            HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
+            this.handlerMappings = Collections.singletonList(hm);
+        }
+        catch (NoSuchBeanDefinitionException ex) {
+            // Ignore, we'll add a default HandlerMapping later.
+        }
+    }
+    if (this.handlerMappings == null) {
+        // ���δ����handlerMappings�����ȡĬ�ϵ� handlerMappings
+        this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
+    }
+}
+
+/**
+ * ��ȡĬ�ϵIJ���
+ */
+protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
+    String key = strategyInterface.getName();
+    // ��ȡ�����ļ�DispatcherServlet.properties��Ĭ�ϵ� class ����
+    String value = defaultStrategies.getProperty(key);
+    if (value != null) {
+        String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
+        List<T> strategies = new ArrayList<>(classNames.length);
+        for (String className : classNames) {
+            try {
+                // ʹ�÷��䴴��bean
+                Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
+                Object strategy = createDefaultStrategy(context, clazz);
+                strategies.add((T) strategy);
+            }
+            catch (ClassNotFoundException ex) {
+                throw new BeanInitializationException(...);
+            }
+            catch (LinkageError err) {
+                throw new BeanInitializationException(...);
+            }
+        }
+        return strategies;
+    }
+    else {
+        return new LinkedList<>();
+    }
+}
+
+```
+
+��ʼ�� `HandlerMappings` ʱ��
+
+1.  �ȴ� spring �����л�ȡ `HandlerMapping` bean�������ȡ�ɹ���ʵ��������Ҳ�ܻ�ã�����ѵõ��Ľ����ֵ�� `DispatcherServlet` �� `handlerMappings` ���ԣ�
+2.  ���δʧ�ܣ����� spring ������δ���� `HandlerMapping` �����ȡĬ�ϵ� `HandlerMapping` bean.
+3.  ��ȡĬ�ϵ� `HandlerMapping` bean ʱ����ȡ `DispatcherServlet.properties` ���ã�Ȼ��ʹ�÷���ʵ������
+
+���������� `DispatcherServlet.properties` �ļ������ļ�λ��` spring-webmvc/src/main/resources/org/springframework/web/servlet/DispatcherServlet.properties`�������������£�
+
+```
+org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
+
+org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
+
+org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
+    org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
+    org.springframework.web.servlet.function.support.RouterFunctionMapping
+...
+
+```
+
+`DispatcherServlet#initStrategies` ������ `initXxx()` �������ƣ�����Ͳ�һһ�����ˡ�
+
+### 4\. �ܽ�
+
+������Ҫ������ springmvc ���������̣��ܽ����£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-7ab3fae1e39f545c1d7c1811351227fa434.png)
+
+1.  servlet ������������ tomcat������ʱ��ͨ�� spi ����ִ�� `ServletContainerInitializer#onStartup` �������� springmvc ���ṩ�� `SpringServletContainerInitializer` ���������ʵ�֣����� `SpringServletContainerInitializer#onStartup` �����ᱻ���ã�
+2.  `SpringServletContainerInitializer#onStartup` �����У�spring ����� `WebApplicationInitializer#onStartup` �������� `MyWebApplicationInitializer` ���������ʵ�֣����� `MyWebApplicationInitializer#onStartup` �ᱻ���ã�
+3.  �� `MyWebApplicationInitializer#onStartup` ������ �����Ǵ�����һ�� `applicationContext` ���󣬽����� `DispatcherServlet` �󶨣�Ȼ�� `DispatcherServlet` ע�ᵽ servlet �����У������� tomcat����
+4.  `DispatcherServlet` ע�ᵽ servlet �����У������� tomcat���󣬸��� servlet �������ڣ�`DispatcherServlet#init` ���ᱻ���ã�
+5.  `DispatcherServlet#init` �л�ִ�� spring �������������̣�spring ���������󣬻ᷢ����������¼���
+6.  spring ������ɺ�`ContextRefreshListener` ������� spring ��������¼���`FrameworkServlet.ContextRefreshListener#onApplicationEvent` �����ᱻ���ã����õ��õ� `DispatcherServlet#initStrategies`��
+7.  spring ������ `DispatcherServlet#initStrategies` �г�ʼ�� `MultipartResolver`��`LocaleResolver` ���������ν�ij�ʼ������ʵ�ǻ�ȡ�򴴽���Ӧ�� bean��Ȼ��ֵ�� `DispatcherServlet` �����ԡ�
+
+���ˣ�springmvc �����������̾�����ˡ������������Ƕ�û�п��� **spring ���� `@RequestMapping` ���������**����ô spring ����δ������������ ����һƪ���½�������
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4710330](https://my.oschina.net/funcy/blog/4710330) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/RequestMapping\345\210\235\345\247\213\345\214\226\346\265\201\347\250\213.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/RequestMapping\345\210\235\345\247\213\345\214\226\346\265\201\347\250\213.md"
new file mode 100644
index 0000000..777a297
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/RequestMapping\345\210\235\345\247\213\345\214\226\346\265\201\347\250\213.md"
@@ -0,0 +1,762 @@
+ǰ��������У����Ƿ����� `DispatcherServlet` ��ʼ�����̣����Ľ������� `RequestMapping` ��ʼ�����̡�������˵�� `RequestMapping` ��ʼ�����̣�ֱ����˵������ spring ���� `@RequestMaping` ע��Ĺ��̡�
+
+### 1\. ��̸ `@EnableWebMvc`
+
+�� [spring mvc ֮ springmvc demo �� @EnableWebMvc ע�� ](https://my.oschina.net/funcy/blog/4696657)һ�����ᵽ��spring ͨ�� `@EnableWebMvc` ע�������� mvc ���ܣ�����ͨ�� `@Import` ע��Ϊ��Ŀ������ `DelegatingWebMvcConfiguration.class`������ͨ�� `@Bean` ע��ķ����� spring ����������� mvc �����
+
+*   `public RequestMappingHandlerMapping requestMappingHandlerMapping(...)`
+*   `public PathMatcher mvcPathMatcher()`
+*   `public UrlPathHelper mvcUrlPathHelper()`
+*   ...
+
+��ô����У��� `@RequestMaping` ע����ص������ `RequestMappingHandlerMapping`.
+
+### 2. `RequestMappingHandlerMapping#afterPropertiesSet` ����
+
+`RequestMappingHandlerMapping` �Ǵ������� `WebMvcConfigurationSupport` �У�
+
+```
+@Bean
+public RequestMappingHandlerMapping requestMappingHandlerMapping(
+        @Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager,
+        @Qualifier("mvcConversionService") FormattingConversionService conversionService,
+        @Qualifier("mvcResourceUrlProvider") ResourceUrlProvider resourceUrlProvider) {
+
+    // ����bean
+    RequestMappingHandlerMapping mapping = createRequestMappingHandlerMapping();
+    mapping.setOrder(0);
+    mapping.setInterceptors(getInterceptors(conversionService, resourceUrlProvider));
+    mapping.setContentNegotiationManager(contentNegotiationManager);
+    mapping.setCorsConfigurations(getCorsConfigurations());
+
+    // �����������ã����������һƪ�������ᵽ��getXxx()������ȡ����
+    PathMatchConfigurer configurer = getPathMatchConfigurer();
+    Boolean useSuffixPatternMatch = configurer.isUseSuffixPatternMatch();
+    if (useSuffixPatternMatch != null) {
+        mapping.setUseSuffixPatternMatch(useSuffixPatternMatch);
+    }
+    Boolean useRegisteredSuffixPatternMatch = configurer.isUseRegisteredSuffixPatternMatch();
+    if (useRegisteredSuffixPatternMatch != null) {
+        mapping.setUseRegisteredSuffixPatternMatch(useRegisteredSuffixPatternMatch);
+    }
+    Boolean useTrailingSlashMatch = configurer.isUseTrailingSlashMatch();
+    if (useTrailingSlashMatch != null) {
+        mapping.setUseTrailingSlashMatch(useTrailingSlashMatch);
+    }
+    UrlPathHelper pathHelper = configurer.getUrlPathHelper();
+    if (pathHelper != null) {
+        mapping.setUrlPathHelper(pathHelper);
+    }
+    PathMatcher pathMatcher = configurer.getPathMatcher();
+    if (pathMatcher != null) {
+        mapping.setPathMatcher(pathMatcher);
+    }
+    Map<String, Predicate<Class<?>>> pathPrefixes = configurer.getPathPrefixes();
+    if (pathPrefixes != null) {
+        mapping.setPathPrefixes(pathPrefixes);
+    }
+
+    return mapping;
+}
+
+// ��������
+protected RequestMappingHandlerMapping createRequestMappingHandlerMapping() {
+    return new RequestMappingHandlerMapping();
+}
+
+```
+
+����������������������� `RequestMappingHandlerMapping` ����ģ����Ǵ�����һ������Ȼ�������˸������ԡ����󴴽��󣬼������� spring bean ���������ڣ��̶����� `RequestMappingHandlerMapping#afterPropertiesSet` ������
+
+```
+@Override
+public void afterPropertiesSet() {
+    // ������һЩ����
+    this.config = new RequestMappingInfo.BuilderConfiguration();
+    this.config.setUrlPathHelper(getUrlPathHelper());
+    this.config.setPathMatcher(getPathMatcher());
+    this.config.setSuffixPatternMatch(this.useSuffixPatternMatch);
+    this.config.setTrailingSlashMatch(this.useTrailingSlashMatch);
+    this.config.setRegisteredSuffixPatternMatch(this.useRegisteredSuffixPatternMatch);
+    this.config.setContentNegotiationManager(getContentNegotiationManager());
+    // ���ø���ķ���
+    super.afterPropertiesSet();
+}
+
+```
+
+����������� ������һЩ���ԣ�Ȼ���ٵ��ø���� `afterPropertiesSet()`������׷��ȥ��
+
+> AbstractHandlerMethodMapping#afterPropertiesSet
+
+```
+@Override
+public void afterPropertiesSet() {
+    initHandlerMethods();
+}
+
+protected void initHandlerMethods() {
+    // ����getCandidateBeanNames()��ȡ����������bean��beanName��
+    // Ȼ�󰤸��������������� bean
+    for (String beanName : getCandidateBeanNames()) {
+        if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
+            // ��� bean �������������¿�
+            processCandidateBean(beanName);
+        }
+    }
+    // �������������һ����־��ûʲô����
+    handlerMethodsInitialized(getHandlerMethods());
+}
+
+```
+
+spring �ڴ���ʱ����ȡ������������ bean �� beanName��Ȼ��� beanName ���а��������������� `AbstractHandlerMethodMapping#processCandidateBean`��
+
+```
+// ����bean�ľ����߼�
+protected void processCandidateBean(String beanName) {
+    // ��ȡ beanName ��Ӧ�� beanType
+    // 1\. �����cglib������beanType Ϊ Xxx$$EnhancerBySpringCGLIB
+    // 2\. �����jdk��̬������beanType Ϊ com.sum.proxy.$Proxy
+    Class<?> beanType = null;
+    try {
+        beanType = obtainApplicationContext().getType(beanName);
+    }
+    catch (Throwable ex) {
+        ...
+    }
+    // isHandler: beanType���Ƿ��� @Controller �� @RequestMapping ע��
+    if (beanType != null && isHandler(beanType)) {
+        // ���� handlerMethods
+        detectHandlerMethods(beanName);
+    }
+}
+
+```
+
+����������DZȽϼ򵥣���Ҫ�ǻ�ȡ `beanName` ��Ӧ�� `beanType`��Ȼ���ж��Ƿ��� `@Controller/@RequestMapping` ע�⣬֮��͵��� `AbstractHandlerMethodMapping#detectHandlerMethods` ��һ��������
+
+�������� `isHandler(Class)` ��Ҫ����˵���£�
+
+1. ��ʶ�� `@Controller`��ͬ����ʶ�� `@RestController`������������ע `@Controller` ��ע�⣬����ʶ������ע�⣺
+
+   ```
+   // ����� @Controller
+   @Controller
+   // ʡ������ע��
+   public @interface XxxController {
+       ...
+   }
+   
+   ```
+
+2. ��� `beanName` ��Ӧ bean �� cglib ���� bean��beanType Ϊ `Xxx$$EnhancerBySpringCGLIB`����ʶ���丸�� (Ҳ����Ŀ����) �ϵ� `@Controller/@ReestMapping`;
+
+3. ��� `beanName` ��Ӧ�� bean �� jdk ��̬���� bean��beanType Ϊ `com.sum.proxy.$Proxy`����ʶ���丸�ӿ��ϵ� `@Controller/@RequestMapping`;
+
+4. ��� beanType �� `com.sum.proxy.$Proxy`(jdk ��̬������)��** �޷�ʶ����Ŀ�����ϵ� `@Controller/@RequestMapping` ** �ģ�
+
+5. ��ע `@Controller/@RequestMapping` ����Ҫʵ�� jdk ��̬��������Ҫ�� `@Controller/@RequestMapping` ���ڽӿڼ��ӿڵķ����ϡ�
+
+����������� `AbstractHandlerMethodMapping#detectHandlerMethods` �� `beanType` ���DZ�ע�� `@Controller/@RequestMapping` �����ӿ��ˡ�
+
+### 3. `AbstractHandlerMethodMapping#detectHandlerMethods`
+
+�������� `AbstractHandlerMethodMapping#detectHandlerMethods` �����ݣ�
+
+```
+// ���handler����
+protected void detectHandlerMethods(Object handler) {
+    Class<?> handlerType = (handler instanceof String ?
+            obtainApplicationContext().getType((String) handler) : handler.getClass());
+    if (handlerType != null) {
+        // 1\. ���cglib�������󣬵õ��丸�࣬Ҳ����Ŀ��������
+        Class<?> userType = ClassUtils.getUserClass(handlerType);
+        // 2\. ����ᴦ�� userType��userType�IJ�����Object�����и��༰ userType �����нӿڵķ���
+        Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
+                // 3\. ��ÿ������������� @RequestMapping���򴴽� RequestMappingInfo
+                // �� @RequestMapping ��Ϣ��װ���ö�����
+                (MethodIntrospector.MetadataLookup<T>) method -> {
+                    try {
+                        // �����ﴦ�������ϵ� @RequestMapping ע��
+                        return getMappingForMethod(method, userType);
+                    }
+                    catch (Throwable ex) {
+                        ...
+                    }
+                });
+        methods.forEach((method, mapping) -> {
+            Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
+            // 4\. �����ｫhandler��mapping��method��������
+            registerHandlerMethod(handler, invocableMethod, mapping);
+        });
+    }
+}
+
+```
+
+��������������¼����£�
+
+1.  ��� cglib �������󣬵õ��丸�࣬Ҳ����Ŀ�������ࣨ**����Ϊ��ֻ���� cglib �������󣬶������� jdk ��̬���������أ�** ������� `isHandler(Class)` ��˵����֪��spring ������ʶ�� jdk ��̬���������Ӧ���ϵ� `@Controller/@RequestMapping` ע�⣬��˲���ִ�е������
+2.  ���� `userType`��`userType` �IJ����� Object �����и��༰ `userType` �����нӿڵķ�����
+3.  ��ÿ������������� `@RequestMapping`���򴴽� `RequestMappingInfo`���� `@RequestMapping` ��Ϣ��װ���ö����У�
+4.  ע�ᣬ�� `handler`��`mapping` �� `method` ���浽 Map �С�
+
+#### 3.1 ���ҷ���
+
+�� `detectHandlerMethods` �����Ĵ��������У������ `userType`��`userType` �����и��ࣨ������ Object���� `userType` �����нӿڵķ������������£�
+
+> MethodIntrospector#selectMethods(Class, MethodIntrospector.MetadataLookup)
+
+```
+public static <T> Map<Method, T> selectMethods(Class<?> targetType, final 
+            MetadataLookup<T> metadataLookup) {
+    final Map<Method, T> methodMap = new LinkedHashMap<>();
+    Set<Class<?>> handlerTypes = new LinkedHashSet<>();
+    Class<?> specificHandlerType = null;
+    // ��jdk��̬������
+    if (!Proxy.isProxyClass(targetType)) {
+        // �����cglib�����࣬��ȡ�����ĸ��� class
+        specificHandlerType = ClassUtils.getUserClass(targetType);
+        handlerTypes.add(specificHandlerType);
+    }
+    // ��ȡ������нӿڣ������ӿڵĸ��ӿ�.
+    handlerTypes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetType));
+    for (Class<?> currentHandlerType : handlerTypes) {
+        final Class<?> targetClass = (specificHandlerType != null 
+                      ? specificHandlerType : currentHandlerType);
+        // ����currentHandlerType��currentHandlerType�IJ�����Object�����и��ࡢ
+        // currentHandlerType�����нӿڵķ���
+        // ����aopʱ�����õ�Ҳ���������
+        ReflectionUtils.doWithMethods(currentHandlerType, method -> {
+            Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
+            T result = metadataLookup.inspect(specificMethod);
+            if (result != null) {
+                Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
+                if (bridgedMethod == specificMethod || 
+                             metadataLookup.inspect(bridgedMethod) == null) {
+                    methodMap.put(specificMethod, result);
+                }
+            }
+        }, ReflectionUtils.USER_DECLARED_METHODS);
+    }
+    return methodMap;
+}
+
+```
+
+#### 3.2 ���� `RequestMappingInfo`
+
+��ÿ������������� `@RequestMapping`���򴴽� `RequestMappingInfo`���� `@RequestMapping` ��Ϣ��װ���ö����У�
+
+> RequestMappingHandlerMapping#getMappingForMethod
+
+```
+protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
+    // ���������ϵ� @RequestMapping
+    RequestMappingInfo info = createRequestMappingInfo(method);
+    if (info != null) {
+        // �������ϵ� @RequestMapping
+        RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
+        if (typeInfo != null) {
+            // �ϲ����������ϵ� @RequestMapping ���
+            // ����� @RequestMapping("/test")�������ϵ� @RequestMapping("/hello")
+            // �ϲ���Ľ��Ϊ /test/hello
+            info = typeInfo.combine(info);
+        }
+        String prefix = getPathPrefix(handlerType);
+        if (prefix != null) {
+            info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
+        }
+    }
+    return info;
+}
+
+@Nullable
+private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
+    // ��ȡ @RequestMapping ע��
+    RequestMapping requestMapping = AnnotatedElementUtils
+            .findMergedAnnotation(element, RequestMapping.class);
+    // ��������������ʵ�����������Ϊ��
+    RequestCondition<?> condition = (element instanceof Class ?
+            getCustomTypeCondition((Class<?>) element) : getCustomMethodCondition((Method) element));
+    return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
+}
+
+// ���� RequestMappingInfo����� RequestMapping ���� @RequestMapping ע��
+protected RequestMappingInfo createRequestMappingInfo(
+        RequestMapping requestMapping, @Nullable RequestCondition<?> customCondition) {
+    // ��ʵ���ǽ� @RequestMapping ע���װΪRequestMappingInfo����
+    RequestMappingInfo.Builder builder = RequestMappingInfo
+            .paths(resolveEmbeddedValuesInPatterns(requestMapping.path()))
+            // ��������Խ����� @RequestMapping ע��
+            .methods(requestMapping.method())
+            .params(requestMapping.params())
+            .headers(requestMapping.headers())
+            .consumes(requestMapping.consumes())
+            .produces(requestMapping.produces())
+            .mappingName(requestMapping.name());
+    if (customCondition != null) {
+        builder.customCondition(customCondition);
+    }
+    return builder.options(this.config).build();
+}
+
+```
+
+����������Ǿ�������� `@RequestMapping` �� `RequestMappingInfo����`��ת����
+
+�������� `RequestMappingInfo` ��ʲô����
+
+```
+public final class RequestMappingInfo implements RequestCondition<RequestMappingInfo> {
+    // �ṩ�˺ܶ����ԣ���Ӧ�� @RequestMapping������
+    @Nullable
+    private final String name;
+    private final PatternsRequestCondition patternsCondition;
+    private final RequestMethodsRequestCondition methodsCondition;
+    private final ParamsRequestCondition paramsCondition;
+    private final HeadersRequestCondition headersCondition;
+    private final ConsumesRequestCondition consumesCondition;
+    private final ProducesRequestCondition producesCondition;
+    private final RequestConditionHolder customConditionHolder;
+
+    // ���췽����������
+    public RequestMappingInfo(@Nullable String name, @Nullable PatternsRequestCondition patterns,
+            @Nullable RequestMethodsRequestCondition methods, @Nullable ParamsRequestCondition params,
+            @Nullable HeadersRequestCondition headers, @Nullable ConsumesRequestCondition consumes,
+            @Nullable ProducesRequestCondition produces, @Nullable RequestCondition<?> custom) {
+
+        this.name = (StringUtils.hasText(name) ? name : null);
+        this.patternsCondition = (patterns != null ? patterns : new PatternsRequestCondition());
+        this.methodsCondition = (methods != null ? methods : new RequestMethodsRequestCondition());
+        this.paramsCondition = (params != null ? params : new ParamsRequestCondition());
+        this.headersCondition = (headers != null ? headers : new HeadersRequestCondition());
+        this.consumesCondition = (consumes != null ? consumes : new ConsumesRequestCondition());
+        this.producesCondition = (produces != null ? produces : new ProducesRequestCondition());
+        this.customConditionHolder = new RequestConditionHolder(custom);
+    }
+
+    // builder ����ģʽ��ǰ������ʹ��builder������RequestMappingInfo�����
+    private static class DefaultBuilder implements Builder {
+        // ʡ������
+        ...
+
+        //  ʹ��builder()��������������
+        @Override
+        public RequestMappingInfo build() {
+            ContentNegotiationManager manager = this.options.getContentNegotiationManager();
+            PatternsRequestCondition patternsCondition = new PatternsRequestCondition(
+                    this.paths, this.options.getUrlPathHelper(), this.options.getPathMatcher(),
+                    this.options.useSuffixPatternMatch(), this.options.useTrailingSlashMatch(),
+                    this.options.getFileExtensions());
+            // ���� RequestMappingInfo ���췽��
+            return new RequestMappingInfo(this.mappingName, patternsCondition,
+                    new RequestMethodsRequestCondition(this.methods),
+                    new ParamsRequestCondition(this.params),
+                    new HeadersRequestCondition(this.headers),
+                    new ConsumesRequestCondition(this.consumes, this.headers),
+                    new ProducesRequestCondition(this.produces, this.headers, manager),
+                    this.customCondition);
+        }
+    }
+    // ʡ������
+    ...
+}
+
+```
+
+#### 3.3 ע��
+
+��װ�� `@RequestMapping` ��Ϣ�󣬽��������ǽ��ӿ���Ϣע�ᵽ springmvc ���ˣ�
+
+> RequestMappingHandlerMapping#registerHandlerMethod
+
+```
+@Override
+protected void registerHandlerMethod(Object handler, Method method, RequestMappingInfo mapping) {
+    // ���ø���ķ�����ע������߼�������
+    super.registerHandlerMethod(handler, method, mapping);
+    updateConsumesCondition(mapping, method);
+}
+// �������������� @RequestBody ע��
+private void updateConsumesCondition(RequestMappingInfo info, Method method) {
+    ConsumesRequestCondition condition = info.getConsumesCondition();
+    if (!condition.isEmpty()) {
+        for (Parameter parameter : method.getParameters()) {
+            // ���� ���������� @RequestBody ע�⣬���� BodyRequired ��ֵ
+            MergedAnnotation<RequestBody> annot = MergedAnnotations.from(parameter)
+                    .get(RequestBody.class);
+            if (annot.isPresent()) {
+                condition.setBodyRequired(annot.getBoolean("required"));
+                break;
+            }
+        }
+    }
+}
+
+```
+
+���գ����־����ע���߼����� `AbstractHandlerMethodMapping#registerHandlerMethod` ����ɵģ���������������շ����ˡ��ڷ����������ǰ����������������һ���õ��� `Map<Method, T> methods`:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-ec6b4b2d2156e0e041982425173feda38fc.png)
+
+���Կ�������Ӧ�� `T` ���� `RequestMappingInfo` �ˡ�
+
+### 3. `AbstractHandlerMethodMapping#registerHandlerMethod` ����
+
+���������������� `AbstractHandlerMethodMapping#registerHandlerMethod` ���룺
+
+```
+public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping 
+        implements InitializingBean {
+
+    protected void registerHandlerMethod(Object handler, Method method, T mapping) {
+        this.mappingRegistry.register(mapping, handler, method);
+    }
+
+    // ʡ���˺ö����
+    ... 
+
+    class MappingRegistry {
+        // ��Ϣ��ȫ��map������mapping, handlerMethod, directUrls, name����Ϣ
+        private final Map<T, MappingRegistration<T>> registry = new HashMap<>();
+        // ���е� mapping map��/test/hello��/test/{name}
+        private final Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();
+        // ��ȷ��url map���� /test/hello
+        private final MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<>();
+
+        // ʡ���˺ö����
+        ...
+
+        public void register(T mapping, Object handler, Method method) {
+            ...
+            // ��ȡ��д����д��
+            this.readWriteLock.writeLock().lock();
+            try {
+                // 1\. ��ȡ�� handlerMethod����ʵ���ǽ�handler �� method ��װ��һ��
+                HandlerMethod handlerMethod = createHandlerMethod(handler, method);
+                validateMethodMapping(handlerMethod, mapping);
+                // 2\. ���� mappingLookup �У�����Ϊ LinkedHashMap
+                // ����springmvc��һ����Ҫ��map
+                this.mappingLookup.put(mapping, handlerMethod);
+
+                // 3\. ��ȡurl������urlLookup������ΪMultiValueMap�����map ͬһkey�����ж��value
+                // ����springmvc����һ����Ҫ��map
+                List<String> directUrls = getDirectUrls(mapping);
+                for (String url : directUrls) {
+                    this.urlLookup.add(url, mapping);
+                }
+                String name = null;
+                if (getNamingStrategy() != null) {
+                    name = getNamingStrategy().getName(handlerMethod, mapping);
+                    addMappingName(name, handlerMethod);
+                }
+                CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
+                if (corsConfig != null) {
+                    this.corsLookup.put(handlerMethod, corsConfig);
+                }
+
+                // 4\. ��mapping, handlerMethod, directUrls, name�ȷ�װ����registry��
+                // registry ����ΪHashMap������springmvc �нӿ���Ϣ��ȫ��һ��map
+                this.registry.put(mapping, new MappingRegistration<>(mapping, 
+                        handlerMethod, directUrls, name));
+            }
+            finally {
+                this.readWriteLock.writeLock().unlock();
+            }
+        }
+    }
+}
+
+```
+
+���Կ�����ע����߼��������� `AbstractHandlerMethodMapping.MappingRegistry#register` ����ɵġ����������Ǿ�һ��������ע���߼���
+
+#### 3.1 ��ȡ `HandlerMethod`
+
+��ش������£�
+
+```
+protected HandlerMethod createHandlerMethod(Object handler, Method method) {
+    if (handler instanceof String) {
+        return new HandlerMethod((String) handler,
+                obtainApplicationContext().getAutowireCapableBeanFactory(), method);
+    }
+    return new HandlerMethod(handler, method);
+}
+
+```
+
+��η������Ǽ򵥵ص����� `HandlerMethod` �Ĺ��췽����������
+
+```
+public class HandlerMethod {
+
+    // �ṩ�˷dz��������
+    protected final Log logger = LogFactory.getLog(getClass());
+    private final Object bean;
+    @Nullable
+    private final BeanFactory beanFactory;
+    private final Class<?> beanType;
+    private final Method method;
+    private final Method bridgedMethod;
+    private final MethodParameter[] parameters;
+    @Nullable
+    private HttpStatus responseStatus;
+    @Nullable
+    private String responseStatusReason;
+    @Nullable
+    private HandlerMethod resolvedFromHandlerMethod;
+    @Nullable
+    private volatile List<Annotation[][]> interfaceParameterAnnotations;
+    private final String description;
+
+    // ���췽��
+    public HandlerMethod(Object bean, Method method) {
+        Assert.notNull(bean, "Bean is required");
+        Assert.notNull(method, "Method is required");
+        this.bean = bean;
+        this.beanFactory = null;
+        this.beanType = ClassUtils.getUserClass(bean);
+        this.method = method;
+        this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
+        this.parameters = initMethodParameters();
+        evaluateResponseStatus();
+        this.description = initDescription(this.beanType, this.method);
+    }
+
+    // ʡ������
+    ...
+}
+
+```
+
+���Կ�����`HandlerMethod` ���зdz�������ԣ����췽����������Ҳ�����Ǹ�ֵ���ѡ��ɴ˿ɿ�����`HandlerMethod` ���Ƕ� `handler` �� `method` ��һ����װ��
+
+#### 3.2 ��֤ mapping �Ƿ��ظ�
+
+�� springmvc ʹ���У������С�Ķ�����������ͬ�� `requestMapping`������������쳣��
+
+```
+Caused by: java.lang.IllegalStateException: Ambiguous mapping. Cannot map 
+'xxxController' method xxxMethod to /xxx/xxx: There is already 'xxxControllter' 
+bean method xxxMethod mapped.
+
+```
+
+����쳣��������֤ mapping ʱ���������ظ��� mapping �������ģ��������£�
+
+```
+// ���е� mapping map��/test/hello��/test/{name}
+private final Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();
+
+private void validateMethodMapping(HandlerMethod handlerMethod, T mapping) {
+    // �ҵ��Ѵ��ڵ� method
+    HandlerMethod existingHandlerMethod = this.mappingLookup.get(mapping);
+    // �Ѵ��ڵ�handlerMethod��Ϊ�գ��Ҳ����ڵ�ǰ handlerMethod
+    if (existingHandlerMethod != null && !existingHandlerMethod.equals(handlerMethod)) {
+        throw new IllegalStateException(
+                "Ambiguous mapping. Cannot map '" + handlerMethod.getBean() + "' method \n" +
+                handlerMethod + "\nto " + mapping + ": There is already '" +
+                existingHandlerMethod.getBean() + "' bean method\n" +
+                existingHandlerMethod + " mapped.");
+    }
+}
+
+```
+
+�����Ǹ��� `mapping` �� `mappingLookup` �в��� `HandlerMethod`������ҵ������ҵ��� `handlerMethod` ���ǵ�ǰ `handlerMethod`�����ʾ�ظ����ͱ��쳣�ˡ�
+
+���ֱ��������ж� `HandlerMethod` �� `RequestMappingInfo` ������ж���ȵģ�
+
+> HandlerMethod#equals
+
+```
+@Override
+public boolean equals(@Nullable Object other) {
+    if (this == other) {
+        return true;
+    }
+    if (!(other instanceof HandlerMethod)) {
+        return false;
+    }
+    HandlerMethod otherMethod = (HandlerMethod) other;
+    return (this.bean.equals(otherMethod.bean) && this.method.equals(otherMethod.method));
+}
+
+```
+
+> RequestMappingInfo#equals
+
+```
+@Override
+public boolean equals(@Nullable Object other) {
+    if (this == other) {
+        return true;
+    }
+    if (!(other instanceof RequestMappingInfo)) {
+        return false;
+    }
+    RequestMappingInfo otherInfo = (RequestMappingInfo) other;
+    return (this.patternsCondition.equals(otherInfo.patternsCondition) &&
+            this.methodsCondition.equals(otherInfo.methodsCondition) &&
+            this.paramsCondition.equals(otherInfo.paramsCondition) &&
+            this.headersCondition.equals(otherInfo.headersCondition) &&
+            this.consumesCondition.equals(otherInfo.consumesCondition) &&
+            this.producesCondition.equals(otherInfo.producesCondition) &&
+            this.customConditionHolder.equals(otherInfo.customConditionHolder));
+}
+
+```
+
+`RequestMappingInfo` ��Ҫ��������ͬ���ж���ȣ���������������� `@RequestMapping`���õ��� `RequestMappingInfo` ������ȣ�
+
+```
+// �������� @RequestMapping����Ȼ����·�����ǡ�/hello������֧�ֵ����󷽷�������ͬ
+// ��˵õ��� RequestMappingInfo �������
+
+@RequestMapping(path = "/hello")
+public String hello1() {
+    ...
+}
+
+@RequestMapping(path = "/hello", method = RequestMethod.GET)
+public String hello2() {
+    ...
+}
+
+@RequestMapping(path = "/hello", method = RequestMethod.POST)
+public String hello3() {
+    ...
+}
+
+```
+
+#### 3.3 ��ȡ `directUrls`
+
+springmvc �������� url ����:
+
+1. ��ȷ�� url����
+
+   ```
+   @RequestMapping("/hello")
+   public String hello() {
+      ...
+   }
+   
+   ```
+
+2. ����ȷ�� url����
+
+   ```
+   @RequestMapping("/{name}")
+   public String hello(@PathVariable("name") String name) {
+      ...
+   }
+   
+   ```
+
+springmvc �ṩ��ר�ŵ� `urlLookup` ��������ȷ�� url���ṹ���£�
+
+```
+MultiValueMap<String, LinkedList<RequestMappingInfo>>
+
+```
+
+�������� springmvc ����λ�ȡ��ȷ�� url ��:
+
+```
+List<String> directUrls = getDirectUrls(mapping);
+
+/**
+ * AbstractHandlerMethodMapping.MappingRegistry#getDirectUrls
+ * ��ȡ��ȷ��url
+ */
+private List<String> getDirectUrls(T mapping) {
+    List<String> urls = new ArrayList<>(1);
+    // ��RequestMappingInfo��ȡ���е� MappingPathPattern
+    for (String path : getMappingPathPatterns(mapping)) {
+        // �жϵõ��� MappingPathPattern �Ƿ�Ϊ��ȷ��url
+        if (!getPathMatcher().isPattern(path)) {
+            urls.add(path);
+        }
+    }
+    return urls;
+}
+
+/**
+ * RequestMappingInfoHandlerMapping#getMappingPathPatterns
+ * ��ȡ patterns, �� RequestMappingInfo ��ȡ
+ * ʵ���Ͼ��� @RequestMapping �е� path() ֵ
+ */
+@Override
+protected Set<String> getMappingPathPatterns(RequestMappingInfo info) {
+    return info.getPatternsCondition().getPatterns();
+}
+
+/**
+ * AntPathMatcher#isPattern
+ * �ж��Ƿ�Ϊ��ȷ�� url
+ * ֻҪ������ *����֮һ����ͬʱ����{��}���Ͳ�����ȷ��url
+ */
+@Override
+public boolean isPattern(@Nullable String path) {
+    if (path == null) {
+        return false;
+    }
+    boolean uriVar = false;
+    for (int i = 0; i < path.length(); i++) {
+        char c = path.charAt(i);
+        if (c == '*' || c == '?') {
+            return true;
+        }
+        if (c == '{') {
+            uriVar = true;
+            continue;
+        }
+        if (c == '}' && uriVar) {
+            return true;
+        }
+    }
+    return false;
+}
+
+```
+
+�������£�
+
+1.  ��ȡ��ǰ `mapping` ������ `path`��Ҳ���� `@RequestMapping` �� `path()` ֵ��
+2.  �����õ��� `path`����һ�ж��Ƿ�Ϊ��ȷ�� url (ֻҪ������ `*`��`?` ֮һ����ͬʱ���� `{`��`}`���Ͳ�����ȷ�� url).
+
+#### 3.4 ע��ӿ���Ϣ
+
+ע��ӿ���Ϣ�ͱȽϼ��ˣ���ʵ������ map ���������ݣ������������ map��
+
+*   `urlLookup`����ȷ�� `url map`������Ϊ `MultiValueMap<String, LinkedList<RequestMappingInfo>>`��`key` Ϊ��ȷ�� url���� `/test/hello`��`value` Ϊ `LinkedList<RequestMappingInfo>`��
+
+*   `mappingLookup`�����е� `mapping map`�����е� `@RequestMapping` ��Ӧ�� `RequestMappingInfo` �����������ҵ������� `/test/hello`��`/test/{name}` ��Ӧ�� `RequestMappingInfo`������Ϊ `Map<RequestMappingInfo, HandlerMethod>`��
+
+*   `registry`����Ϣ��ȫ�� map������Ϊ `Map<RequestMappingInfo, MappingRegistration<RequestMappingInfo>>`���������е� `RequestMappingInfo`��key Ϊ `RequestMappingInfo`��value Ϊ `MappingRegistration<RequestMappingInfo>`���� `MappingRegistration` Ϊ `mapping`, `handlerMethod`, `directUrls`, `name` �İ�װ�࣬Ҳ����˵ `MappingRegistration` ������ `mapping`, `handlerMethod`, `directUrls`, `name` ����Ϣ��
+
+������Щ map ��ע����൱���ˣ����Ǽ򵥵ص����� `Map#put` �������Ͳ���˵�ˡ�
+
+### 4\. �ܽ�
+
+���ķ����� spring �������� `@RequestMapping` ע������̣��ⲿ�������� `RequestMappingHandlerMapping#afterPropertiesSet` �����У��������£�
+
+1.  ��ȡ���������� bean �� `beanName`����������������������� 2 ����
+2.  �ҵ��� `beanName` ��Ӧ�� `beanType`���ж������Ƿ��� `@Controller/@RequestMapping` ע�⣻
+3.  �԰��� `@Controller/@RequestMapping` �� `beanType`���ҵ��� `@RequestMapping` ע��ķ��������� `@RequestMapping` ע���װΪ `RequestMappingInfo`����һ���õ��Ľ��Ϊһ�� map��`Map<Method, RequestMappingInfo>`��
+4.  �� `beanName`��`beanType` �� `Map<Method, RequestMappingInfo>` ע�ᵽ springmvc �У������������Ƚ���Ҫ�� map��
+   *   `MultiValueMap<String, LinkedList<RequestMappingInfo>>`��
+   *   `Map<RequestMappingInfo, HandlerMethod>`(`HandlerMethod` Ϊ `Method` �İ�װ��)
+   *   `Map<RequestMappingInfo, MappingRegistration<RequestMappingInfo>>`(`MappingRegistration` Ϊ `RequestMappingInfo`, `HandlerMethod`, `directUrls`, `beanName` �İ�װ��)��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-fe807564e60040b262b28977a46a74f60e9.png)
+
+�ܵ���˵��`RequestMapping` �Ĵ����������رȽ������Ҳ�ǵ����˺ö�β��ҵ���
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4715079](https://my.oschina.net/funcy/blog/4715079) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\225\264\344\275\223\346\272\220\347\240\201\347\273\223\346\236\204\346\200\273\347\273\223.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\225\264\344\275\223\346\272\220\347\240\201\347\273\223\346\236\204\346\200\273\347\273\223.md"
new file mode 100644
index 0000000..7fdb68a
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\225\264\344\275\223\346\272\220\347\240\201\347\273\223\346\236\204\346\200\273\347\273\223.md"
@@ -0,0 +1,82 @@
+### 1\. servlet 3.0 �淶
+
+��ϵ��һ��ʼ���Ƚ����� `servlet3.0` �淶��ͨ���ù淶������������ʵ�� web ��Ŀ�� `0xml` ����.
+
+*   `servlet3.0` �淶�У�servlet ͨ�� `SPI` �����ṩ��һ���ӿڣ�`ServletContainerInitializer`��
+*   spring ʵ���˸ýӿڣ�����ʵ���� `SpringServletContainerInitializer` �� `onStartup(...)` �����У���ִ������ʵ���� `WebApplicationInitializer` �ӿڵ���� `onStartup(...)` ��������������ֻ��Ҫʵ�� `WebApplicationInitializer` �ӿڼ��ɣ�
+*   ����������ʵ�� `WebApplicationInitializer` �ӿڵ����У��� `onStartup(...)` �� servlet �������ֶ�ע����һ �� servlet��`DispatcherServlet`������� servlet �л����� spring ������
+
+�����������̾�������
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-0874fa7ef39ca9c405cdf55d99ca891ebf2.png)
+
+### 2\. ���� webMvc �ķ�ʽ
+
+���Ƿ��������� `webMvc` �����ַ�ʽ��
+
+#### 1. `@EnableWebMvc`
+
+���ַ�ʽ�ܼ򵥣�ֻ��Ҫ������
+
+```
+// ʹ��@EnableWebMvcע������mvc����
+@Component
+@EnableWebMvc
+public class MvcConfig {
+    ...
+}
+
+```
+
+�������Ҫ���� webMvc ��һЩ����ʱ����Ҫʵ�� `WebMvcConfigurer`:
+
+```
+// ʵ�� WebMvcConfigurer�������Զ�������
+@Component
+public class MyWebMvcConfigurer implements WebMvcConfigurer {
+
+    // ��дWebMvcConfigurer�����������Զ�������
+}
+
+```
+
+#### 2\. ʵ�� `WebMvcConfigurationSupport`
+
+����һ�ַ�ʽ���� `webMvc` �� ��ʽ��ʵ�� `WebMvcConfigurationSupport`��
+
+```
+@Component
+public class MyWebMvcConfigurationSupport extends WebMvcConfigurationSupport {
+    // ��д���÷����������Զ�������
+    ...
+
+   /**
+    * ���磬���ӿ������ã�ֱ����д addCorsMappings ����
+    */
+    @Override
+    public void addCorsMappings(CorsRegistry registry) {
+        // �����Լ�������
+        ...
+    }
+
+}
+
+```
+
+��Ҫע����ǣ�ʹ�����ַ�ʽ����Ҫ�����Զ�������ʱ���Ͳ�����ȥʵ�� `WebMvcConfigurer` �ӿ��ˣ���Ӧ��ֱ����д `WebMvcConfigurationSupport` �е���Ӧ��������������д `addCorsMappings()`.
+
+### 3\. ������������
+
+��һ��ͼ���ܽ������������̣�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-74d675bbae28247726b8d054e8758c3d8b1.png) ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-aa6bb35d0ab26925c45c62ab4d709d05cdd.png)
+
+### 4\. ��������
+
+Ҳ��һ��ͼ���ܽ������������̣�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-024b75e7f7952dbf1ace7aa5a8cfe3bcb77.png)
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4773418](https://my.oschina.net/funcy/blog/4773418) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232DispatcherServlet\345\246\202\344\275\225\346\211\276\345\210\260\346\255\243\347\241\256\347\232\204Controller.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232DispatcherServlet\345\246\202\344\275\225\346\211\276\345\210\260\346\255\243\347\241\256\347\232\204Controller.md"
new file mode 100644
index 0000000..8819c8d
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232DispatcherServlet\345\246\202\344\275\225\346\211\276\345\210\260\346\255\243\347\241\256\347\232\204Controller.md"
@@ -0,0 +1,291 @@
+# 目录
+* [前言](#前言)
+* [源码分析](#源码分析)
+* [实例](#实例)
+* [资源文件映射](#资源文件映射)
+* [总结](#总结)
+
+
+本文转载自互联网，侵删
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+文章将同步到我的个人博客：
+> www.how2playlife.com
+
+本文是微信公众号【Java技术江湖】的《Spring和SpringMVC源码分析》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+
+该系列博文会告诉你如何从spring基础入手，一步步地学习spring基础和springmvc的框架知识，并上手进行项目实战，spring框架是每一个Java工程师必须要学习和理解的知识点，进一步来说，你还需要掌握spring甚至是springmvc的源码以及实现原理，才能更完整地了解整个spring技术体系，形成自己的知识框架。
+
+后续还会有springboot和springcloud的技术专题，陆续为大家带来，敬请期待。
+
+为了更好地总结和检验你的学习成果，本系列文章也会提供部分知识点对应的面试题以及参考答案。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+<!-- more -->  
+## 前言
+SpringMVC是目前主流的Web MVC框架之一。
+
+我们使用浏览器通过地址 http://ip:port/contextPath/path 进行访问，SpringMVC是如何得知用户到底是访问哪个Controller中的方法，这期间到底发生了什么。
+
+本文将分析SpringMVC是如何处理请求与Controller之间的映射关系的，让读者知道这个过程中到底发生了什么事情。
+
+本文实际上是在上文基础上，深入分析
+
+HandlerMapping里的
+
+HandlerExecutionChain getHandler(HttpServletRequest var1) throws Exception;
+
+该方法的具体实现，包括它如何找到对应的方法，以及如何把结果保存在map里，以便让请求转发到对应的handler上，同时也分析了handleradaptor具体做了什么事情。
+
+## 源码分析
+
+在分析源码之前，我们先了解一下几个东西。
+
+1.这个过程中重要的接口和类。
+
+**HandlerMethod类：**
+
+Spring3.1版本之后引入的。 是一个封装了方法参数、方法注解，方法返回值等众多元素的类。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/232033308878895.jpg)
+
+它的子类InvocableHandlerMethod有两个重要的属性WebDataBinderFactory和HandlerMethodArgumentResolverComposite， 很明显是对请求进行处理的。
+
+InvocableHandlerMethod的子类ServletInvocableHandlerMethod有个重要的属性HandlerMethodReturnValueHandlerComposite，很明显是对响应进行处理的。
+
+ServletInvocableHandlerMethod这个类在HandlerAdapter对每个请求处理过程中，都会实例化一个出来(上面提到的属性由HandlerAdapter进行设置)，分别对请求和返回进行处理。　　(RequestMappingHandlerAdapter源码，实例化ServletInvocableHandlerMethod的时候分别set了上面提到的重要属性)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/240149411377243.png)
+
+**MethodParameter类：**
+
+HandlerMethod类中的parameters属性类型，是一个MethodParameter数组。MethodParameter是一个封装了方法参数具体信息的工具类，包括参数的的索引位置，类型，注解，参数名等信息。
+
+HandlerMethod在实例化的时候，构造函数中会初始化这个数组，这时只初始化了部分数据，在HandlerAdapter对请求处理过程中会完善其他属性，之后交予合适的HandlerMethodArgumentResolver接口处理。
+
+以类DeptController为例：
+
+```  
+@Controller  
+@RequestMapping(value = "/dept")  
+public class DeptController {  
+  
+  @Autowired  private IDeptService deptService;  
+  @RequestMapping("/update")  @ResponseBody  public String update(Dept dept) {    deptService.saveOrUpdate(dept);    return "success";  }  
+}  
+  
+```  
+
+(刚初始化时的数据)　　  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/241246397157212.png)
+
+(HandlerAdapter处理后的数据)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/241246574657656.png)
+
+**RequestCondition接口：**
+
+**Spring3.1版本之后引入的。 是SpringMVC的映射基础中的请求条件，可以进行combine, compareTo，getMatchingCondition操作。这个接口是映射匹配的关键接口，其中getMatchingCondition方法关乎是否能找到合适的映射。**
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/241429158878034.png)
+
+**RequestMappingInfo类：**
+
+Spring3.1版本之后引入的。 是一个封装了各种请求映射条件并实现了RequestCondition接口的类。
+
+有各种RequestCondition实现类属性，patternsCondition，methodsCondition，paramsCondition，headersCondition，consumesCondition以及producesCondition，这个请求条件看属性名也了解，分别代表http请求的路径模式、方法、参数、头部等信息。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/241556162777007.png)
+
+**RequestMappingHandlerMapping类：**
+
+处理请求与HandlerMethod映射关系的一个类。
+
+2.Web服务器启动的时候，SpringMVC到底做了什么。
+
+先看AbstractHandlerMethodMapping的initHandlerMethods方法中。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/241831201065104.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/241922304028276.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/241932113242502.png)
+
+我们进入createRequestMappingInfo方法看下是如何构造RequestMappingInfo对象的。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/251242523404424.png)
+
+PatternsRequestCondition构造函数：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/252348515124305.png)
+
+类对应的RequestMappingInfo存在的话，跟方法对应的RequestMappingInfo进行combine操作。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/250107154024892.png)
+
+然后使用符合条件的method来注册各种HandlerMethod。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/260023477461660.png)
+
+下面我们来看下各种RequestCondition接口的实现类的combine操作。
+
+PatternsRequestCondition：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/251617000436911.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/251917084021029.png)
+
+RequestMethodsRequestCondition：
+
+方法的请求条件，用个set直接add即可。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/251919265597456.png)
+
+其他相关的RequestConditon实现类读者可自行查看源码。
+
+最终，RequestMappingHandlerMapping中两个比较重要的属性
+
+private final Map<T, HandlerMethod> handlerMethods = new LinkedHashMap<T, HandlerMethod>();
+
+private final MultiValueMap<String, T> urlMap = new LinkedMultiValueMap<String, T>();
+
+T为RequestMappingInfo。
+
+构造完成。
+
+我们知道，SpringMVC的分发器DispatcherServlet会根据浏览器的请求地址获得HandlerExecutionChain。
+
+这个过程我们看是如何实现的。
+
+首先看HandlerMethod的获得(直接看关键代码了)：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/252206079491274.png)
+
+这里的比较器是使用RequestMappingInfo的compareTo方法(RequestCondition接口定义的)。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/252219494658063.png)
+
+然后构造HandlerExecutionChain加上拦截器
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/252208290431970.png)
+
+## 实例
+
+写了这么多，来点例子让我们验证一下吧。
+
+```  
+@Controller  
+@RequestMapping(value = "/wildcard")  
+public class TestWildcardController {  
+  
+  @RequestMapping("/test/**")  @ResponseBody  public String test1(ModelAndView view) {    view.setViewName("/test/test");    view.addObject("attr", "TestWildcardController -> /test/**");    return view;  }  
+  @RequestMapping("/test/*")  @ResponseBody  public String test2(ModelAndView view) {    view.setViewName("/test/test");    view.addObject("attr", "TestWildcardController -> /test*");    return view;  }  
+  @RequestMapping("test?")  @ResponseBody  public String test3(ModelAndView view) {    view.setViewName("/test/test");    view.addObject("attr", "TestWildcardController -> test?");    return view;  }  
+  @RequestMapping("test/*")  @ResponseBody  public String test4(ModelAndView view) {    view.setViewName("/test/test");    view.addObject("attr", "TestWildcardController -> test/*");    return view;  }  
+}  
+  
+```  
+
+由于这里的每个pattern都带了*因此，都不会加入到urlMap中，但是handlerMethods还是有的。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/260032509654870.png)
+
+当我们访问：http://localhost:8888/SpringMVCDemo/wildcard/test1的时候。
+
+会先根据 "/wildcard/test1" 找urlMap对应的RequestMappingInfo集合，找不到的话取handlerMethods集合中所有的key集合(也就是RequestMappingInfo集合)。
+
+然后进行匹配，匹配根据RequestCondition的getMatchingCondition方法。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/260046407936253.png)
+
+最终匹配到2个RequestMappingInfo：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/260049401063106.png)
+
+然后会使用比较器进行排序。
+
+之前也分析过，比较器是有优先级的。
+
+我们看到，RequestMappingInfo除了pattern，其他属性都是一样的。
+
+我们看下PatternsRequestCondition比较的逻辑：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/260125371817100.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/260125488223078.png)
+
+因此，/test*的通配符比/test?的多，因此，最终选择了/test?
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/260129091195087.png)
+
+直接比较优先于通配符。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/260129342756267.png)
+
+```  
+@Controller  
+@RequestMapping(value = "/priority")  
+public class TestPriorityController {  
+  
+  @RequestMapping(method = RequestMethod.GET)  @ResponseBody  public String test1(ModelAndView view) {    view.setViewName("/test/test");    view.addObject("attr", "其他condition相同，带有method属性的优先级高");  
+    return view;  }  
+  @RequestMapping()  @ResponseBody  public String test2(ModelAndView view) {    view.setViewName("/test/test");    view.addObject("attr", "其他condition相同，不带method属性的优先级高");  
+    return view;  }  
+}  
+  
+```  
+
+这里例子，其他requestCondition都一样，只有RequestMethodCondition不一样。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/260151358222728.png)
+
+看出，方法多的优先级越多。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/260152065252948.png)
+
+至于其他的RequestCondition，大家自行查看源码吧。
+
+## 资源文件映射
+
+以上分析均是基于Controller方法的映射(RequestMappingHandlerMapping)。
+
+SpringMVC中还有静态文件的映射，SimpleUrlHandlerMapping。
+
+DispatcherServlet找对应的HandlerExecutionChain的时候会遍历属性handlerMappings，这个一个实现了HandlerMapping接口的集合。
+
+由于我们在*-dispatcher.xml中加入了以下配置：
+
+```  
+<mvc:resources location="/static/" mapping="/static/**"/>  
+```  
+
+Spring解析配置文件会使用ResourcesBeanDefinitionParser进行解析的时候，会实例化出SimpleUrlHandlerMapping。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/261025451501584.jpg)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/261026409781228.jpg)
+
+其中注册的HandlerMethod为ResourceHttpRequestHandler。
+
+访问地址：http://localhost:8888/SpringMVCDemo/static/js/jquery-1.11.0.js
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/261013551199069.jpg)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/261028504315946.jpg)
+
+地址匹配到/static/**。
+
+最终SimpleUrlHandlerMapping找到对应的Handler -> ResourceHttpRequestHandler。
+
+ResourceHttpRequestHandler进行handleRequest的时候，直接输出资源文件的文本内容。
+
+## 总结
+
+大致上整理了一下SpringMVC对请求的处理，包括其中比较关键的类和接口，希望对读者有帮助。
+
+让自己对SpringMVC有了更深入的认识，也为之后分析数据绑定，拦截器、HandlerAdapter等打下基础。
\ No newline at end of file
diff --git "a/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2203\357\274\232DispatcherServlet\347\232\204\345\210\235\345\247\213\345\214\226\344\270\216\350\257\267\346\261\202\350\275\254\345\217\221.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232DispatcherServlet\347\232\204\345\210\235\345\247\213\345\214\226\344\270\216\350\257\267\346\261\202\350\275\254\345\217\221.md"
similarity index 95%
rename from "docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2203\357\274\232DispatcherServlet\347\232\204\345\210\235\345\247\213\345\214\226\344\270\216\350\257\267\346\261\202\350\275\254\345\217\221.md"
rename to "docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232DispatcherServlet\347\232\204\345\210\235\345\247\213\345\214\226\344\270\216\350\257\267\346\261\202\350\275\254\345\217\221.md"
index 521604c..1ae0ed4 100644
--- "a/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2203\357\274\232DispatcherServlet\347\232\204\345\210\235\345\247\213\345\214\226\344\270\216\350\257\267\346\261\202\350\275\254\345\217\221.md"
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232DispatcherServlet\347\232\204\345\210\235\345\247\213\345\214\226\344\270\216\350\257\267\346\261\202\350\275\254\345\217\221.md"
@@ -1,12 +1,7 @@
-# Table of Contents
-
+# 目录
   * [前言](#前言)
-  * [<init-param>配置元素读取</init-param>](#init-param配置元素读取init-param)
   * [容器上下文的建立](#容器上下文的建立)
   * [初始化SpringMVC默认实现类](#初始化springmvc默认实现类)
-* [Default implementation classes for DispatcherServlet's strategy interfaces.](#default-implementation-classes-for-dispatcherservlets-strategy-interfaces)
-* [Used as fallback when no matching beans are found in the DispatcherServlet context.](#used-as-fallback-when-no-matching-beans-are-found-in-the-dispatcherservlet-context)
-* [Not meant to be customized by application developers.](#not-meant-to-be-customized-by-application-developers)
   * [总结](#总结)
 
 
@@ -161,12 +156,12 @@ initFrameworkServlet()方法是一个没有任何实现的空方法，除去一
 this.webApplicationContext = initWebApplicationContext();
 ```
 
-这一句简单直白的代码，道破了FrameworkServlet这个类，在SpringMVC类体系中的设计目的，它是 用来抽离出建立 WebApplicationContext 上下文这个过程的。
+这一句简单直白的代码，道破了FrameworkServlet这个类，在SpringMVC类体系中的设计目的，它是用来抽离出建立WebApplicationContext上下文这个过程的。
 
 initWebApplicationContext()方法，封装了建立Spring容器上下文的整个过程，方法内的逻辑如下：
 
 1.  获取由ContextLoaderListener初始化并注册在ServletContext中的根上下文，记为rootContext
-2.  如果webApplicationContext已经不为空，表示这个Servlet类是通过编程式注册到容器中的（Servlet 3.0+中的ServletContext.addServlet() ），上下文也由编程式传入。若这个传入的上下文还没被初始化，将rootContext上下文设置为它的父上下文，然后将其初始化，否则直接使用。
+2.  如果webApplicationContext已经不为空，表示这个Servlet类是通过编程式注册到容器中的（Servlet 3.0+中的ServletContext.addServlet()），上下文也由编程式传入。若这个传入的上下文还没被初始化，将rootContext上下文设置为它的父上下文，然后将其初始化，否则直接使用。
 3.  通过wac变量的引用是否为null，判断第2步中是否已经完成上下文的设置（即上下文是否已经用编程式方式传入），如果wac==null成立，说明该Servlet不是由编程式注册到容器中的。此时以contextAttribute属性的值为键，在ServletContext中查找上下文，查找得到，说明上下文已经以别的方式初始化并注册在contextAttribute下，直接使用。
 4.  检查wac变量的引用是否为null，如果wac==null成立，说明2、3两步中的上下文初始化策略都没成功，此时调用createWebApplicationContext(rootContext)，建立一个全新的以rootContext为父上下文的上下文，作为SpringMVC配置元素的容器上下文。大多数情况下我们所使用的上下文，就是这个新建的上下文。
 5.  以上三种初始化上下文的策略，都会回调onRefresh(ApplicationContext context)方法（回调的方式根据不同策略有不同），onRefresh方法在DispatcherServlet类中被覆写，以上面得到的上下文为依托，完成SpringMVC中默认实现类的初始化。
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232SpringMVC\346\246\202\350\277\260.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232SpringMVC\346\246\202\350\277\260.md"
new file mode 100644
index 0000000..fb7f88e
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232SpringMVC\346\246\202\350\277\260.md"
@@ -0,0 +1,1017 @@
+# 目录
+
+  * [1.1、SpringMVC引言](#11、springmvc引言)
+  * [1.2、SpringMVC的优势](#12、springmvc的优势)
+  * [二、SpringMVC入门](#二、springmvc入门)
+  * [2.1、环境搭建](#21、环境搭建)
+  * [2.1.1、引入依赖](#211、引入依赖)
+  * [2.1.2、编写配置文件](#212、编写配置文件)
+  * [2.1.3、配置web.xml](#213、配置webxml)
+  * [2.1.4、编写控制器](#214、编写控制器)
+  * [2.2、注解详解](#22、注解详解)
+  * [2.2.1、@Controller](#221、controller)
+  * [2.2.2、@RequestMapping](#222、requestmapping)
+  * [2.3、SpringMVC的跳转方式](#23、springmvc的跳转方式)
+  * [2.3.1、Controller ——>前台页面](#231、controller-前台页面)
+  * [2.3.1.1、forward](#2311、forward)
+  * [2.3.1.2、redirect](#2312、redirect)
+  * [2.3.1Controller ——>Controller](#231controller-controller)
+  * [2.3.1.1、forward](#2311、forward-1)
+  * [2.3.1.2、redirect](#2312、redirect-1)
+  * [2.4、SpringMVC的参数接收](#24、springmvc的参数接收)
+  * [2.4.1、Servlet接收参数的方式](#241、servlet接收参数的方式)
+  * [2.4.2、SpringMVC的参数接收](#242、springmvc的参数接收)
+  * [2.4.2.1、基本数据类型](#2421、基本数据类型)
+  * [2.4.2.2、对象类型](#2422、对象类型)
+  * [2.4.2.3、数组类型](#2423、数组类型)
+  * [2.4.2.4、集合类型](#2424、集合类型)
+  * [2.5、SpringMVC接收参数中文乱码问题](#25、springmvc接收参数中文乱码问题)
+  * [2.5.1、GET请求](#251、get请求)
+  * [2.5.2、POST请求](#252、post请求)
+  * [2.5.2.1、自定义过滤器解决POST乱码请求](#2521、自定义过滤器解决post乱码请求)
+  * [2.5.2.2、使用CharacterEncodingFilter解决POST乱码请求](#2522、使用characterencodingfilter解决post乱码请求)
+  * [2.6、SpringMVC中数据传递机制](#26、springmvc中数据传递机制)
+  * [2.6.1、什么事数据传递机制](#261、什么事数据传递机制)
+  * [2.6.2、Servlet的数据传递机制](#262、servlet的数据传递机制)
+  * [三、前端控制器](#三、前端控制器)
+  * [3.1、什么是前端控制器](#31、什么是前端控制器)
+  * [3.2、代码实现](#32、代码实现)
+  * [3.3、注意](#33、注意)
+  * [3.4、映射路径](#34、映射路径)
+  * [3.4.1、访问静态资源和 JSP 被拦截的原因](#341、访问静态资源和-jsp-被拦截的原因)
+  * [3.4.2、如何解决](#342、如何解决)
+  * [3.4.2.1、方式一](#3421、方式一)
+  * [3.4.2.2、方式二](#3422、方式二)
+  * [3.5、@ModelAttribute 注解](#35、modelattribute-注解)
+  * [四、处理响应](#四、处理响应)
+  * [4.1、返回 ModelAndView](#41、返回-modelandview)
+  * [4.2、返回String](#42、返回string)
+  * [4.3、改进](#43、改进)
+  * [五、请求转发和重定向](#五、请求转发和重定向)
+  * [5.1、请求转发和重定向的区别](#51、请求转发和重定向的区别)
+  * [5.2、请求转发](#52、请求转发)
+  * [5.3、重定向](#53、重定向)
+  * [5.4、请求路径](#54、请求路径)
+  * [六、参数处理](#六、参数处理)
+  * [6.1、处理简单类型的请求参数](#61、处理简单类型的请求参数)
+  * [6.1.1、请求参数名和控制器方法参数列表形参同名](#611、请求参数名和控制器方法参数列表形参同名)
+  * [6.1.2、请求参数名和控制器方法参数列表形参不同名](#612、请求参数名和控制器方法参数列表形参不同名)
+  * [6.2、处理复杂类型的请求参数](#62、处理复杂类型的请求参数)
+  * [6.2.1、数组类型](#621、数组类型)
+  * [6.2.2、自定义类型](#622、自定义类型)
+  * [6.3、处理日期类型的请求参数](#63、处理日期类型的请求参数)
+  * [6.3.1、日期在请求参数上](#631、日期在请求参数上)
+  * [6.3.2、在封装的对象上](#632、在封装的对象上)
+  * [七、文件上传与下载](#七、文件上传与下载)
+  * [7.1、文件上传](#71、文件上传)
+  * [7.1.1、编写表单](#711、编写表单)
+  * [7.1.2、修改web.xml](#712、修改webxml)
+  * [7.1.3、配置上传解析器](#713、配置上传解析器)
+  * [7.1.4、配置上传控制器](#714、配置上传控制器)
+  * [7.2、文件下载](#72、文件下载)
+  * [7.2.1、开发控制器](#721、开发控制器)
+
+
+
+## 1.1、SpringMVC引言
+
+为了使Spring有可插入的MVC架构,SpringFrameWork在Spring基础上开发SpringMVC框架,从而在使用Spring进行WEB开发时可以选择使用**Spring的SpringMVC框架作为web开发的控制器框架**。
+
+## 1.2、SpringMVC的优势
+
+SpringMVC是一个**典型的轻量级MVC框架**，在整个MVC架构中充当控制器框架,相对于之前的struts2框架,**SpringMVC运行更快,其注解式开发更高效灵活**。
+
+<figure data-size="normal">
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-3363c79f645a232562a2d6e800a11967_720w.webp)
+</figure>
+
+1.  可以和Spring框架无缝整合。
+2.  运行效率远远高于struts2框架。
+3.  注解式开发更高效。
+
+## 二、SpringMVC入门
+
+## 2.1、环境搭建
+
+## 2.1.1、引入依赖
+
+依赖就忽略了，我放在了评论区！
+
+## 2.1.2、编写配置文件
+
+
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns:context="http://www.springframework.org/schema/context"
+  xmlns:mvc="http://www.springframework.org/schema/mvc"
+  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
+
+<!--  1\. 开启注解扫描-->
+  <context:component-scan base-package="com.lin.controller"/>
+<!--  2\. 配置处理器映射器-->
+<!--  <bean  />-->
+<!--  3\. 开启处理器适配器-->
+<!--  <bean  />-->
+<!--  上面两段配置被下面的一句话所替代（封装）-->
+  <mvc:annotation-driven />
+  <!--  4\. 开启视图解析器-->
+  <bean >
+    <property name="prefix" value="/"/>
+    <property name="suffix" value=".jsp"/>
+  </bean>
+</beans>
+复制代码
+```
+
+
+
+## 2.1.3、配置web.xml
+
+
+
+```
+<!DOCTYPE web-app PUBLIC
+ "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
+ "http://java.sun.com/dtd/web-app_2_3.dtd" >
+
+<web-app>
+  <display-name>Archetype Created Web Application</display-name>
+
+<!--  配置springmvc的核心servlet-->
+  <servlet>
+    <servlet-name>springmvc</servlet-name>
+    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
+    <init-param>
+<!--      告诉springmvc配置文件的位置-->
+      <param-name>contextConfigLocation</param-name>
+      <param-value>classpath:springmvc.xml</param-value>
+    </init-param>
+  </servlet>
+  <servlet-mapping>
+<!--    拦截所有请求-->
+    <servlet-name>springmvc</servlet-name>
+    <url-pattern>/</url-pattern>
+  </servlet-mapping>
+</web-app>
+复制代码
+```
+
+
+
+## 2.1.4、编写控制器
+
+
+
+```
+package com.lin.controller;
+
+import org.apache.ibatis.annotations.Param;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+/**
+ * @author XiaoLin
+ * @date 2021/2/17 17:09
+ */
+@Controller
+public class HellowController {
+
+  /**
+      * @Description:第一个springmvc测试类
+      * @author XiaoLin
+      * @date 2021/2/17
+      * @Param: [username, password]
+      * @return java.lang.String
+      */
+     /*
+      RequestMapping的修饰范围：可以用在类上和方法上，他的作用如下：
+      1\. 用在方法上可以给当前方法加入指定的请求路径
+      2\. 用在类上可以给类中的所有方法都加入一个统一的请求路径，在这个方法访问之前都必须加上
+      */
+  @RequestMapping("/hello")
+  public String hello(String username,String password){
+    System.out.println("hello");
+    return "index";
+  }
+}
+
+复制代码
+```
+
+
+
+## 2.2、注解详解
+
+## 2.2.1、@Controller
+
+该注解用来类上标识这是一个控制器组件类并创建这个类实例，告诉spring我是一个控制器。
+
+## 2.2.2、@RequestMapping
+
+这个注解可以作用在方法上或者是类上，用来指定请求路径。
+
+## 2.3、SpringMVC的跳转方式
+
+传统的Servlet开发跳转方式有两种：
+
+1.  forward：forward跳转，是在服务器内部跳转，所以是一次请求，地址栏不变。跳转时可以携带数据进行传递（使用request作用域进行传递）。
+2.  redirect：redirect跳转是客户端跳转，所以是多次请求,地址栏会改变，跳转时不可以携带数据传递。
+
+## 2.3.1、Controller ——>前台页面
+
+## 2.3.1.1、forward
+
+通过测试我们可以发现，SpringMVC默认的就是使用请求转发的方式来进行跳转到前台页面的;
+
+
+
+```
+@Controller
+@RequestMapping("forwoartAndRedirect")
+public class TestForwoartAndRedirect {
+
+  @RequestMapping("test")
+  public String test(){
+    System.out.println("test");
+    return"index";
+  }
+}
+复制代码
+```
+
+
+
+## 2.3.1.2、redirect
+
+如果我们想使用重定向的方式来进行跳转的话，需要使用SpringMVC提供给我们的关键字——redirect:来完成。
+
+语法：return "redirect:/视图全路径名";
+
+**注意：**在redirect:后接页面的不是逻辑名，而是全路径名。因为redirect跳转不会经过视图解析器。
+
+## 2.3.1Controller ——>Controller
+
+## 2.3.1.1、forward
+
+如果我们想使用请求转发的方式跳转到相同(不同)Controller的不同方法的时候，我们也需要使用SpringMVC提供的关键字：forward:。
+
+语法：return:"forward: /需要跳转的类上的@RequestMapping的值/需要跳转的方法上的@RequestMapping的值;"
+
+## 2.3.1.2、redirect
+
+如果我们想使用重定向的方式跳转到相同(不同)Controller的不同方法的时候，我们也需要使用SpringMVC提供的关键字：redirect:。
+
+语法：return:"redirect: /需要跳转的类上的@RequestMapping的值/需要跳转的方法上的@RequestMapping的值;"
+
+## 2.4、SpringMVC的参数接收
+
+## 2.4.1、Servlet接收参数的方式
+
+在传统的Servlet开发，我们一般都是用这种方式来进行接收请求参数的。
+
+
+
+```
+// 接收名字为name的参数
+request.getParameter(name)
+复制代码
+```
+
+
+
+他有几个需要注意的点：
+
+1.  参数要求是表单域的name属性。
+2.  getParameter方法用于获取单个值, 返回类型是String。
+3.  getParameterValues方法用于获取一组数据, 返回结果是String[]。
+4.  冗余代码较多, 使用麻烦, 类型需要自己转换。
+
+## 2.4.2、SpringMVC的参数接收
+
+SpringMVC使用的是控制器中方法形参列表来接收客户端的请求参数，他可以进行自动类型转换，**要求传递参数的key要与对应方法的形参变量名一致才可以完成自动赋值**。他的优势很明显：
+
+1.  简化参数接收形式(不需要调用任何方法, 需要什么参数, 就在控制器方法中提供什么参数)。
+2.  参数类型不需要自己转换了。日期时间（默认为yyyy/MM/dd）得注意，需要使用@DateTimeFormat注解声明日期转换时遵循的格式, 否则抛出400异常。
+
+## 2.4.2.1、基本数据类型
+
+**要求传递参数的key要与对应方法的形参变量名一致才可以完成自动赋值。**
+
+## 2.4.2.2、对象类型
+
+如果我们需要接收对象类型的话，直接将需要接收的对象作为控制器的方法参数声明即可。SpringMVC会自动封装对象，若传递参数key与对象中属性名一致，就会自动封装成对象。
+
+## 2.4.2.3、数组类型
+
+如果我们需要接收数组类型的时候，只需将要接收的数组类型直接声明为方法的形式参数即可。
+
+## 2.4.2.4、集合类型
+
+SpringMVC不能直接通过形式参数列表的方式接收集合类型的参数，如果需要接收集合类型的参数必须将集合放入一个对象中，并且提供get/set方法，才可以。推荐放入VO对象中进行封装，进而使用对象类型来进行接收。
+
+## 2.5、SpringMVC接收参数中文乱码问题
+
+## 2.5.1、GET请求
+
+GET请求方式出现乱码需要分Tomcat版本进行讨论：
+
+1.  Tomcat8.x版本之前：默认使用server.xml中的URIEncoding="ISO-8859-1"编码，而不是"UTF-8"编码，进而会出现中文乱码。
+2.  Tomcat8.x版本之后：默认使用server.xml中的URIEncoding="UTF-8"，所以不会出现中文乱码问题。
+
+## 2.5.2、POST请求
+
+SpringMVC中默认没有对POST请求进行任何编码处理，所以无论什么版本直接接收POST请求都会出现中文乱码。
+
+## 2.5.2.1、自定义过滤器解决POST乱码请求
+
+在Servlet阶段，我们学过过滤器，我们可以自定义过滤器来进行过滤编码。
+
+
+
+```
+package com.filter;
+
+import javax.servlet.*;
+import java.io.IOException;
+
+//自定义编码filter
+public class CharacterEncodingFilter  implements Filter {
+
+    private String encoding;
+    @Override
+    public void init(FilterConfig filterConfig) throws ServletException {
+        this.encoding = filterConfig.getInitParameter("encoding");
+        System.out.println(encoding);
+    }
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
+        request.setCharacterEncoding(encoding);
+        response.setCharacterEncoding(encoding);
+        chain.doFilter(request,response);
+    }
+
+    @Override
+    public void destroy() {
+
+    }
+}
+复制代码
+<!--配置post请求方式中文乱码的Filter-->
+  <filter>
+    <filter-name>charset</filter-name>
+    <filter-class>com.filter.CharacterEncodingFilter</filter-class>
+    <init-param>
+      <param-name>encoding</param-name>
+      <param-value>UTF-8</param-value>
+    </init-param>
+  </filter>
+
+  <filter-mapping>
+    <filter-name>charset</filter-name>
+    <url-pattern>/*</url-pattern>
+  </filter-mapping>
+复制代码
+```
+
+
+
+## 2.5.2.2、使用CharacterEncodingFilter解决POST乱码请求
+
+
+
+```
+<!--配置post请求方式中文乱码的Filter-->
+  <filter>
+    <filter-name>charset</filter-name>
+    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
+    <init-param>
+      <param-name>encoding</param-name>
+      <param-value>UTF-8</param-value>
+    </init-param>
+  </filter>
+
+  <filter-mapping>
+    <filter-name>charset</filter-name>
+    <url-pattern>/*</url-pattern>
+  </filter-mapping>
+复制代码
+package com.filter;
+
+import javax.servlet.*;
+import java.io.IOException;
+
+//自定义编码filter
+public class CharacterEncodingFilter  implements Filter {
+
+    private String encoding;
+    @Override
+    public void init(FilterConfig filterConfig) throws ServletException {
+        this.encoding = filterConfig.getInitParameter("encoding");
+        System.out.println(encoding);
+    }
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
+        request.setCharacterEncoding(encoding);
+        response.setCharacterEncoding(encoding);
+        chain.doFilter(request,response);
+    }
+
+    @Override
+    public void destroy() {
+
+    }
+}
+复制代码
+```
+
+
+
+## 2.6、SpringMVC中数据传递机制
+
+## 2.6.1、什么事数据传递机制
+
+数据传递机制主要包含三个问题：
+
+1.  数据如何存储？
+2.  如何在页面中获取数据？
+3.  在页面中获取的数据该如何展示？
+
+## 2.6.2、Servlet的数据传递机制
+
+在以前的Servlet开发中，我们一般是将数据放入作用域（request、session、application），如果数据是单个的直接用EL表达式在前端进行展示，如果是集合或者数组，可以用EL表达式➕JSTL标签进行遍历后在前端进行展示。
+
+## 三、前端控制器
+
+## 3.1、什么是前端控制器
+
+在 MVC 框架中都存在一个前端控制器，在 WEB 应用的前端（Front）设置一个入口控制器（Controller），是用来提供一个集中的请求处理机制，所有的请求都被发往该控制器统一处理，然后把请求分发给各自相应的处理程序。一般用来做一个共同的处理，如权限检查，授权，日志记录等。因为前端控制的集中处理请求的能力，因此提高了可重用性和可拓展性。
+
+在没有前端控制器的时候，我们是这样传递和处理请求的。
+
+<figure data-size="normal">
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/52752e7a606d50ae243cf94309de682b_v2-aadb0832d3c878ff17af7dfe66e7f914_720w.webp)
+</figure>
+
+有了前端控制器之后，我们变成了这样。
+
+<figure data-size="normal">
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-cb0dcdd3922ebfba4781800dd492dd69_720w.webp)
+</figure>
+
+## 3.2、代码实现
+
+Spring MVC 已经提供了一个 DispatcherServlet 类作为前端控制器，所以要使用 Spring MVC 必须在web.xml 中配置前端控制器。
+
+
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<web-app xmlns="http://java.sun.com/xml/ns/javaee"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
+                        http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
+  version="3.0">
+  <!-- Spring MVC 前端控制器-->
+  <servlet>
+    <servlet-name>dispatcherServlet</servlet-name>
+    <servlet-
+      class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
+    <!-- 指定 Spring 容器启动加载的配置文件-->
+    <init-param>
+      <param-name>contextConfigLocation</param-name>
+      <param-value>classpath:mvc.xml</param-value>
+    </init-param>
+    <!-- Tomcat 启动初始化 -->
+    <load-on-startup>1</load-on-startup>
+  </servlet>
+  <servlet-mapping>
+    <servlet-name>dispatcherServlet</servlet-name>
+    <url-pattern>/</url-pattern>
+  </servlet-mapping>
+</web-app>
+复制代码
+```
+
+
+
+## 3.3、注意
+
+load-on-startup 元素是可选的：若值为 0 或者大于 0 时，表示容器在应用启动时就构建 Servlet 并调用其 init 方法做初始化操作（非负数的值越小，启动该 Servlet 的优先级越高）；若值为一个负数时或者没有指定时，则在第一次请求该 Servlet 才加载。配置的话，就可以让 SpringMVC 初始化的工作在容器启动的时候完成，而不是丢给用户请求去完成，提高用户访问的体验性。
+
+## 3.4、映射路径
+
+配置前端控制器的映射路径一般有以下的三种形式：
+
+1.  配置如 .do、.htm 是最传统方式，可以访问静态文件（图片、 JS、 CSS 等），但不支持 RESTful风格。
+2.  配置成 /，可以支持流行的 RESTful 风格，但会导致静态文件（图片、 JS、 CSS 等）被拦截后不能访问。
+3.  配置成 /*，是错误的方式，可以请求到 Controller 中，但跳转到调转到 JSP 时被拦截，不能渲染JSP 视图，也会导致静资源访问不了。
+
+## 3.4.1、访问静态资源和 JSP 被拦截的原因
+
+
+
+```
+Tomcat 容器处理静态资源是交由内置 DefaultServlet 来处理的（拦截路径是 /），处理 JSP 资源是交由内置的 JspServlet 处理的（拦截路径是*.jsp | *.jspx）。
+    启动项目时，先加载容器的 web.xml，而后加载项目中的 web.xml。当拦截路径在两者文件中配置的一样，后面会覆盖掉前者。
+    所以前端控制器配置拦截路径是 / 的所有静态资源都会交由前端控制器处理，而拦截路径配置 /*，所有静态资源和 JSP 都会交由前端控制器处理。
+复制代码
+```
+
+
+
+## 3.4.2、如何解决
+
+## 3.4.2.1、方式一
+
+在 web.xml 中修改，修改前端控制器的映射路径修改为*.do，**但注意，访问控制器里的处理方法时，请求路径须携带 .do。**
+
+
+
+```
+<servlet-mapping>
+	<servlet-name>dispatcherServlet</servlet-name>
+	<url-pattern>*.do</url-pattern>
+</servlet-mapping>	
+复制代码
+```
+
+
+
+## 3.4.2.2、方式二
+
+在 mvc.xml中加入一段配置，这个配置会在 Spring MVC 上下文中创建存入一个 DefaultServletHttpRequestHandler 的 bean，它会 对进入DispatcherServlet的请求进行筛查，若不是映射的请求，就将该请求交由容器默认的 Servlet处理。
+
+
+
+```
+<mvc:default-servlet-handler/>
+复制代码
+```
+
+
+
+## 3.5、@ModelAttribute 注解
+
+在形参中的对象（**必须是自定义类型**），SpringMVC会默认将他存入Model中，名称是参数的类名首字母小写，有些时候，这个类会显得格外长，但是我们又有这种需求，比方说：查询条件的回显。我们只需在自定义类的前面加@ModelAttribute，里面写我们需要修改的key的名称即可。
+
+
+
+```
+package cn.wolfcode.web.controller;
+	@Controller
+	public class RequestController {
+		@RequestMapping("/req7")
+			public String resp7(@ModelAttribute("u") User user) {
+			return "m";
+		}
+}
+复制代码
+```
+
+
+
+## 四、处理响应
+
+SpringMVC的作用是请求和处理响应，响应处理是指怎么编写控制器里面的处理方法接受请求做响应，找视图文件和往作用域中存入数据。要处理方法要做响应，一般处理方法返回的类型为 ModelAndView 和 String。
+
+## 4.1、返回 ModelAndView
+
+方法中返回 ModelAndView 对象，此对象中设置模型数据并指定视图。前端依旧是使用JSTL+CgLib来进行取值。他有两个常用方法：
+
+1.  addObject(String key, Object value)：设置共享数据的 key 和 value。
+2.  addObject(Object value)：设置共享数据的 value，key 为该 value 类型首字母小写。
+
+
+
+```
+package cn.linstudy.web.controller;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.servlet.ModelAndView;
+
+@Controller
+public class ResponseController {
+  // 提供方法处理请求，localhost/resp1
+  @RequestMapping("/resp1")
+  public ModelAndView resp1() {
+// 通过创建这个类对象，告诉 Spring MVC 找什么视图文件， 往作用域或者说往模型中存入什么数据
+    ModelAndView mv = new ModelAndView();
+// 往作用域或者模型中存入数据
+    mv.addObject("msg", "方法返回类型是 ModelAndView");
+// 找视图
+    mv.setViewName("/WEB-INF/views/resp.jsp");
+    return mv;
+  }
+复制代码
+```
+
+
+
+## 4.2、返回String
+
+返回 String 类型（使用广泛），此时如果我们需要共享数据，那么就需要用到HttpServlet对象，Spring帮我们封装好了一个对象：Model 。组合使用，用其往作用域或模型中存入数据。
+
+
+
+```
+package cn.instudy.web.controller;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+@Controller
+public class ResponseController {
+  // 提供方法处理请求，localhost/resp2
+  @RequestMapping("/resp2")
+  public String resp2(Model model) {
+// 往作用域或者模型中存入数据
+    model.addAttribute("msg", "方法返回类型是 String");
+// 返回视图名
+    return "/WEB-INF/views/resp.jsp";
+  }
+}
+复制代码
+```
+
+
+
+## 4.3、改进
+
+我们会发现，如果我们需要写返回界面的话需要不断的写前缀和后缀，这个时候需要进行消除消除视图前缀和后缀，我们只需在Spring中进行配置视图解析器即可。
+
+
+
+```
+<!--
+配置视图解析器 配置这个Spring MVC 找视图的路径就是：前缀 + 逻辑视图名（处理方法设置或返回视图名）+ 后缀名
+-->
+<bean >
+	<!-- 视图前缀 -->
+	<property name="prefix" value="/WEB-INF/views/"/>
+	<!-- 视图后缀 -->
+	<property name="suffix" value=".jsp"/>
+</bean>
+复制代码
+```
+
+
+
+## 五、请求转发和重定向
+
+## 5.1、请求转发和重定向的区别
+
+|  | 几次请求 | 地址栏 | WEB-INF中资源 | 共享请求数据 | 有无表单重复提交 |
+| --- | --- | --- | --- | --- | --- |
+| 请求转发 | 1次 | 不改变 | 可以访问 | 可以共享 | 有 |
+| 重定向 | 多次 | 改变 | 不可访问 | 不可共享 | 无 |
+
+## 5.2、请求转发
+
+加上forward 关键字，表示请求转发，相当于request.getRequestDispatcher().forward(request,response)，转发后浏览器地址栏不变，共享之前请求中的数据。**加了关键字后，配置的视图解析器就不起作用了。如果返回视图必须写全路径**
+
+
+
+```
+package cn.linstudy.web.controller;
+@Controller
+public class ResponseController {
+
+	@RequestMapping("/TestForward")
+	public String forward() {
+		return "forward:/WEB-INF/views/welcome.jsp";
+	}
+}
+复制代码
+```
+
+
+
+## 5.3、重定向
+
+加上 redirect 关键字，表示重定向，相当于 response.sendRedirect()，重定向后浏览器地址栏变为重定向后的地址，不共享之前请求的数据。
+
+
+
+```
+package cn.linstudy.web.controller;
+@Controller
+public class ResponseController {
+	// localhost/r
+	@RequestMapping("/TestRedirect")
+	public String redirect() {
+		return "redirect:/static/demo.html";
+	}
+}
+复制代码
+```
+
+
+
+## 5.4、请求路径
+
+在请求转发和重定向的时候，我们一般有两种方式来写请求路径：
+
+1.  加/：使用是绝对路径（推荐使用），从项目根路径找。(/response/test6 ---> "redirect:/hello.html" ---> localhost:/hello.html)
+2.  不加/：使用是相对路径，相对于上一次访问上下文路径的上一级找。(/response/test6 ---> "redirect:hello.html" ---> localhost:/response/hello.html)
+
+## 六、参数处理
+
+## 6.1、处理简单类型的请求参数
+
+我们在控制器的如何获取请求中的简单数据类型的参数参数？简单数据类型包含基本数据类型及其包装类、String 和BigDecimal 等形参接收。
+
+## 6.1.1、请求参数名和控制器方法参数列表形参同名
+
+如果前台传递过来的参数名和控制器方法中参数列表的形参参数名相同就无需做任何操作，SpringMVC会自动帮我们进赋值。
+
+
+
+```
+// 请求路径为：/req1?username=zs&age=18
+package cn.linstudy.web.controller;
+	@Controller
+	public class RequestController {
+		@RequestMapping("/req1")
+		public ModelAndView resp1(String username, int age) {
+			System.out.println(username);
+			System.out.println(age);
+			return null;
+		}
+}
+复制代码
+```
+
+
+
+## 6.1.2、请求参数名和控制器方法参数列表形参不同名
+
+如果前台传递过来的参数名和控制器方法中参数列表的形参参数名不相同的话，我们需要使用一个注解@RequestParam("前台携带的参数名")来告诉SpringMVC我们任何对数据来进行赋值。
+
+
+
+```
+// 请求路径为：/req1?username=zs&age=18
+package cn.linstudy.web.controller;
+	@Controller
+	public class RequestController {
+		@RequestMapping("/req1")
+		public ModelAndView resp1(@RequestParam("username") String username1, @RequestParam("age") int age1) {
+			System.out.println(username);
+			System.out.println(age);
+			return null;
+		}
+}
+复制代码
+```
+
+
+
+## 6.2、处理复杂类型的请求参数
+
+## 6.2.1、数组类型
+
+对于数组类型参数，我们只需在方法参数的形参列表中定义一个同名的数组类型进行接收即可。
+
+
+
+```
+// 请求路径 /req3?ids=1&ids=2&ids=3
+package cn.linstudy.web.controller;
+	@Controller
+	public class RequestController {
+		@RequestMapping("/req3")
+		public ModelAndView resp3(Long[] ids) {
+			System.out.println(Arrays.toString(ids));
+			return null;
+		}
+}
+复制代码
+```
+
+
+
+## 6.2.2、自定义类型
+
+我们在很多的时候，需要接收的是一个自定义类型的对象。比如说我们进行保存用户，需要将前台传递的数据进行封装成一个自定义的用户类型，那么这个时候，只需要保证自定义的类型里面的字段和前端传过来的字段相同（**注意传递参数名与封装对象的属性名一致**），SpringMVC即可自动进行封装。
+
+
+
+```
+// /req4?username=hehe&password=666
+package cn.linstudy.web.controller;	
+	@Controller
+	public class RequestController {
+		@RequestMapping("/req4")
+		public ModelAndView resp4(User user) {
+			System.out.println(user);
+			return null
+		}
+}
+复制代码
+```
+
+
+
+底层 Spring MVC 根据请求地址对应调用处理方法，调用方法时发现要传递 User 类型的实参，SpringMVC 会反射创建 User 对象，之后通过请求参数名找对应的属性，给对象的属性设置对应的参数值。
+
+## 6.3、处理日期类型的请求参数
+
+## 6.3.1、日期在请求参数上
+
+如果日期在请求参数上，那么我们需要在处理方法的 Date 类型的形参贴上 @DateTimeFormat注解。
+
+
+
+```
+package cn.linstudy.controller;
+	@Controller
+	public class RequestController {
+		@RequestMapping("/req5")
+		// 注意形参的类型为 java.util.Date
+		public ModelAndView resp5(@DateTimeFormat(pattern="yyyy-MM-dd")Date date) {
+			System.out.println(date.toLocaleString());
+			return null;
+		}
+}
+复制代码
+```
+
+
+
+## 6.3.2、在封装的对象上
+
+如果日期在封装对象的字段，那么我们需要在字段的上贴@DateTimeFormat注解。
+
+
+
+```
+package cn.linstudy.domain;
+	public class User {
+	private Long id;
+	private String Username;
+	private String password;
+	// 增加下面这个字段，并贴注解
+	@DateTimeFormat(pattern="yyyy-MM-dd")
+	private Date date;
+	// 省略 setter getter toString
+}
+复制代码
+package cn.linstudy.controller;
+	@Controller
+	public class RequestController {
+		@RequestMapping("/req6")
+		public ModelAndView resp6(User user) {
+			System.out.println(user);
+			return null;
+		}
+}
+复制代码
+```
+
+
+
+## 七、文件上传与下载
+
+## 7.1、文件上传
+
+回顾之前使用 Servlet3.0 来解决文件上传的问题，编写上传表单（POST、multipart/form-data），还在处理方法 doPost 中编写解析上传文件的代码。但是在SpringMVC是可以帮我们简化文件上传的步骤和代码。
+
+## 7.1.1、编写表单
+
+注意请求数据类型必须是：multipart/form-data，且请求方式是POST。
+
+
+
+```
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<title>文件上传</title>
+</head>
+<body>
+	<form action="/upload" method="POST" enctype="multipart/form-data">
+		文件:<br>
+		
+	</form>
+</body>
+</html>
+复制代码
+```
+
+
+
+## 7.1.2、修改web.xml
+
+我们可以在web.xml中指定上传文件的大小。
+
+
+
+```
+<servlet>
+	<servlet-name>dispatcherServlet</servlet-name>
+	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
+	<init-param>
+		<param-name>contextConfigLocation</param-name>
+		<param-value>classpath:mvc.xml</param-value>
+	</init-param>
+	<load-on-startup>1</load-on-startup>
+	<multipart-config>
+		<max-file-size>52428800</max-file-size>
+		<max-request-size>52428800</max-request-size>
+	</multipart-config>
+</servlet>
+<servlet-mapping>
+	<servlet-name>dispatcherServlet</servlet-name>
+	<url-pattern>/</url-pattern>
+</servlet-mapping>
+复制代码
+```
+
+
+
+## 7.1.3、配置上传解析器
+
+在mvc.xml中配置上传解析器，**使用springmvc中multipartfile接收客户端上传的文件必须配置文件上传解析器且解析的id必须为multipartResolver**
+
+
+
+```
+<bean id="multipartResolver" >
+  <!--控制文件上传大小单位字节 默认没有大小限制 这里是2-->
+  <property name="maxUploadSize" value="2097152"/>
+</bean>
+复制代码
+```
+
+
+
+## 7.1.4、配置上传控制器
+
+
+
+```
+package cn.linstudy.controller;
+	@Controller
+	public class UploadController {
+	// Spring 容器存在 ServletContext 类型的对象，所以定义好 ServletContext 类型字段贴@Autowired 注解即可获取到
+	@Autowired
+	private ServletContext servletContext;
+	@RequestMapping("/upload")
+	public ModelAndView upload(Part pic) throws Exception {
+		System.out.println(pic.getContentType()); // 文件类型
+		System.out.println(pic.getName()); // 文件参数名
+		System.out.println(pic.getSize()); // 文件大小
+		System.out.println(pic.getInputStream()); // 文件输入流
+		// FileCopyUtils.copy(in, out)，一个 Spring 提供的拷贝方法
+		// 获取项目 webapp 目录下 uploadDir 目录的绝对路径
+		System.out.println(servletContext.getRealPath("/uploadDir"));
+		return null;
+	}
+}
+复制代码
+```
+
+
+
+## 7.2、文件下载
+
+文件下载:将服务器上的文件下载到当前用户访问的计算机的过程称之为文件下载
+
+## 7.2.1、开发控制器
+
+下载时必须设置响应的头信息,指定文件以何种方式保存,另外下载文件的控制器不能存在返回值,代表响应只用来下载文件信息`
+
+
+
+```
+/**
+     * 测试文件下载
+     * @param fileName 要下载文件名
+     * @return
+     */
+    @RequestMapping("download")
+    public String download(String fileName, HttpServletRequest request, HttpServletResponse response) throws IOException {
+        //获取下载服务器上文件的绝对路径
+        String realPath = request.getSession().getServletContext().getRealPath("/down");
+        //根据文件名获取服务上指定文件
+        FileInputStream is = new FileInputStream(new File(realPath, fileName));
+        //获取响应对象设置响应头信息
+        response.setHeader("content-disposition","attachment;fileName="+ URLEncoder.encode(fileName,"UTF-8"));
+        ServletOutputStream os = response.getOutputStream();
+        IOUtils.copy(is,os);
+        IOUtils.closeQuietly(is);
+        IOUtils.closeQuietly(os);
+        return null;
+    }
+```
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232SpringMVC\347\232\204\350\247\206\345\233\276\350\247\243\346\236\220\345\216\237\347\220\206.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232SpringMVC\347\232\204\350\247\206\345\233\276\350\247\243\346\236\220\345\216\237\347\220\206.md"
new file mode 100644
index 0000000..cb28598
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232SpringMVC\347\232\204\350\247\206\345\233\276\350\247\243\346\236\220\345\216\237\347\220\206.md"
@@ -0,0 +1,301 @@
+# 目录
+* [目录](#目录)
+* [前言](#前言)
+* [重要接口和类介绍](#重要接口和类介绍)
+* [源码分析](#源码分析)
+* [编码自定义的ViewResolver](#编码自定义的viewresolver)
+* [总结](#总结)
+
+
+转自[SpringMVC视图机制详解[附带源码分析]](https://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html)
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+文章将同步到我的个人博客：
+> www.how2playlife.com
+
+本文是微信公众号【Java技术江湖】的《Spring和SpringMVC源码分析》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+
+该系列博文会告诉你如何从spring基础入手，一步步地学习spring基础和springmvc的框架知识，并上手进行项目实战，spring框架是每一个Java工程师必须要学习和理解的知识点，进一步来说，你还需要掌握spring甚至是springmvc的源码以及实现原理，才能更完整地了解整个spring技术体系，形成自己的知识框架。
+
+后续还会有springboot和springcloud的技术专题，陆续为大家带来，敬请期待。
+
+为了更好地总结和检验你的学习成果，本系列文章也会提供部分知识点对应的面试题以及参考答案。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+<!-- more -->  
+
+
+## 目录
+
+*   [前言](http://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html#preface)
+*   [重要接口和类介绍](http://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html#introduction)
+*   [源码分析](http://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html#analysis)
+*   [编码自定义的ViewResolver](http://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html#demo)
+*   [总结](http://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html#summary)
+*   [参考资料](http://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html#reference)
+
+## 前言
+
+SpringMVC是目前主流的Web MVC框架之一。
+
+如果有同学对它不熟悉，那么请参考它的入门blog：[http://www.cnblogs.com/fangjian0423/p/springMVC-introduction.html](http://www.cnblogs.com/fangjian0423/p/springMVC-introduction.html)
+
+本文将分析SpringMVC的视图这部分内容，让读者了解SpringMVC视图的设计原理。
+
+## 重要接口和类介绍
+
+**1.View接口**
+
+视图基础接口，它的各种实现类是无状态的，因此是线程安全的。 该接口定义了两个方法：　  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/092359485145662.png)
+
+**2.AbstractView抽象类**
+
+View接口的基础实现类。我们稍微介绍一下这个抽象类。
+
+首先看下这个类的属性：  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/100014083899865.png)
+
+再看下抽象类中接口方法的实现：  
+　　getContentType方法直接返回contentType属性即可。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/100110310773735.png)
+
+render方法：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/102247323892787.png)
+
+**3.AbstractUrlBasedView抽象类**
+
+继承自AbstractView抽象类，增加了1个类型为String的url参数。
+
+**4.InternalResourceView类**
+
+继承自AbstractUrlBasedView抽象类的类，表示JSP视图。
+
+我们看下这个类的renderMergedOutputModel方法(AbstractView抽象类定义的抽象方法，为View接口提供的render方法服务)。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/102252020309641.png)
+
+**5.JstlView类**
+
+JSTL视图，继承自InternalResourceView，该类大致上与InternalResourceView类一致。
+
+**6.AbstractTemplateView抽象类**
+
+继承自AbstractUrlBasedView抽象类，重写了renderMergedOutputModel方法，在该方法中会调用renderMergedTemplateModel方法，renderMergedTemplateModel方法为新定义的抽象方法。
+
+该抽象类有几个boolean属性exposeSessionAttributes，exposeRequestAttributes。 设置为true的话会将request和session中的键值和值丢入到renderMergedTemplateModel方法中的model这个Map参数中。
+
+这个类是某些模板引擎视图类的父类。 比如FreemarkerView，VelocityView。
+
+**7.FreeMarkerView类**
+
+继承自AbstractTemplateView抽象类。
+
+直接看renderMergedTemplateModel方法，renderMergedTemplateModel内部会调用doRender方法：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/102258387178319.png)
+
+**8\. RedirectView类**
+
+继承自AbstractUrlBasedView，并实现SmartView接口。SmartView接口定义了1个boolean isRedirectView();方法。
+
+该视图的renderMergedOutputModel方法主要就是通过response.sendRedirect进行重定向。
+
+有关RedirectView方面的知识楼主另外写了1篇博客。[http://www.cnblogs.com/fangjian0423/p/springMVC-redirectView-analysis.html](http://www.cnblogs.com/fangjian0423/p/springMVC-redirectView-analysis.html)
+
+**9.ViewResolver接口**
+
+视图解释器，用来解析视图View，与View接口配合使用。
+
+该接口只有1个方法，通过视图名称viewName和Locale对象得到View接口实现类：
+
+ 
+  View resolveViewName(String viewName, Locale locale) throws Exception;```  
+  
+**10.AbstractCachingViewResolver抽象类**  
+  
+　　带有缓存功能的ViewResolver接口基础实现抽象类，该类有个属性名为viewAccessCache的以 "viewName_locale" 为key， View接口为value的Map。  
+  
+　　该抽象类实现的resolveViewName方法内部会调用createView方法，方法内部会调用loadView抽象方法。  
+  
+**11.UrlBasedViewResolver类**  
+  
+　　继承自AbstractCachingViewResolver抽象类、并实现Ordered接口的类，是ViewResolver接口简单的实现类。  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/102341126705605.png)  
+  
+　　该类复写了createView方法：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/102349273585708.png)  
+  
+　　父类(AbstractCachingViewResolver)的createView方法内部会调用loadView抽象方法，UrlBasedViewResolver实现了这个抽象方法：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/110037187498815.png)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/110043510779523.png)  
+  
+　　下面对UrlBasedViewResolver做1个test，配置如下：  
+  
+```  
+<bean class="org.springframework.web.servlet.view.UrlBasedViewResolver">  
+  <property name="prefix" value="/WEB-INF/view/"/>  <property name="suffix" value=".jsp"/>  <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceView"/>  <property name="viewNames">  
+      <value type="java.lang.String">*</value>    
+  </property>  <property name="contentType" value="text/html;charset=utf-8"/>  
+  <property name="attributesMap">    <map>      <entry key="mytest" value="mytestvalue"/>    </map>  </property>  <property name="attributes">    <props>      <prop key="test">testvalue</prop>    </props>  </property></bean>  
+
+```  
+  
+　　我们看到：以InternalResourceView这个JSP视图作为视图；viewNames我们设置了_，这里的_代表全部视图名(这个viewNames属性不设置也可以，代表全部视图名都处理)；http响应头部contentType信息：text/html;charset=utf-8；attributesMap和attributes传入的Map和Properties参数都会被丢入到staticAttributes属性中，这个staticAttributes会被设置成AbstractView的staticAttributes属性，也就是request域中的参数。  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/122254034056621.png)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/122255053584961.png)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/122253337649444.png)  
+  
+　　我们看到request域中没有设置mytest和testvalue值。但是页面中会显示，因为我们配置了attributesMap和attributes参数。  
+  
+　　如果我们把viewNames中的"*"改成"index1"。那么就报错了，因为处理视图名的时候index匹配不上index1。  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/122258119528822.png)  
+  
+**12.InternalResourceViewResolver类**  
+  
+　　继承自UrlBasedViewResolver，以InternalResourceView作为视图，若项目中存在“javax.servlet.jsp.jstl.core.Config”该类，那么会以JstlView作为视图。重写了buildView方法，主要就是为了给InternalResourceView视图设置属性。  
+  
+**13.AbstractTemplateViewResolver类**  
+  
+　　继承自UrlBasedViewResolver，重写了buildView方法，主要就是构造AbstractTemplateView以及为它设置相应的属性。  
+  
+**14.FreeMarkerViewResolver类**  
+  
+　　继承自AbstractTemplateViewResolver，将视图设置为FreeMarkerView。  
+  
+**15\. ModelAndView对象**  
+  
+　　顾名思义，带有视图和Model属性的一个模型和视图类。  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/122342141709643.png)  
+  
+　　值得注意的是，这个视图属性是一个Object类型的数据，可以直接是View接口的实现类或者视图名(字符串)。  
+  
+## 源码分析  
+  
+下面我们来分析SpringMVC处理视图的源码。  
+  
+SpringMVC在处理请求的时候，通过RequestMappingHandlerMapping得到HandlerExecutionChain，然后通过RequestMappingHandlerAdapter得到1个ModelAndView对象，之后通过processDispatchResult方法处理。  
+  
+processDispatchResult方法如下：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/122331490924509.png)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/122339489831665.png)  
+  
+如果配置的ViewResolver如下：  
+  
+````  
+<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
+  <property name="prefix" value="/WEB-INF/view/"/>  <property name="suffix" value=".jsp"/></bean>  
+
+````  
+  
+那么就是使用InternalResourceViewResolver来解析视图。  
+  
+之前分析过，InternalResourceViewResolver重写了UrlBasedViewResolver的buildView方法。但是还是会调用UrlBasedViewResolver的buildView方法。  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/130106345772394.png)  
+  
+最终得到InternalResourceView或JstlView视图。这两个视图的render方法本文介绍重要接口及类的时候已分析。  
+  
+PS：DispathcerServlet中的viewResolvers属性是个集合，如果存在多个ViewResolver对象，必定会有优先级的问题，这部分的内容请参考楼主的另一篇博客：  
+  
+[http://www.cnblogs.com/fangjian0423/p/spring-Ordered-interface.html](http://www.cnblogs.com/fangjian0423/p/spring-Ordered-interface.html)  
+  
+## 编码自定义的ViewResolver  
+  
+下面，我们就来编写自定义的ViewResolver。  
+  
+自定义的ViewResolver处理视图名的时候，遇到 "jsp:" 开头的会找jsp页面，遇到 "freemarker:" 开头的找freemarker页面。  
+  
+````
+public class CustomViewResolver extends UrlBasedViewResolver {
+
+public static final String JSP_URL_PREFIX = "jsp:";  public static final String FTL_URL_PREFIX = "freemarker:";  
+private static final boolean jstlPresent = ClassUtils.isPresent(            "javax.servlet.jsp.jstl.core.Config", CustomViewResolver.class.getClassLoader());  
+private Boolean exposePathVariables = false;  
+private boolean exposeRequestAttributes = false;  
+private boolean allowRequestOverride = false;  
+private boolean exposeSessionAttributes = false;  
+private boolean allowSessionOverride = false;  
+private boolean exposeSpringMacroHelpers = true;  
+public CustomViewResolver() {      this.setViewClass(FreeMarkerView.class);  }    
+@Override  protected AbstractUrlBasedView buildView(String viewName) throws Exception {    if(viewName.startsWith(FTL_URL_PREFIX)) {  
+return buildFreemarkerView(viewName.substring(FTL_URL_PREFIX.length()));    } else if(viewName.startsWith(JSP_URL_PREFIX)) {        Class viewCls = jstlPresent ? JstlView.class : InternalResourceView.class;        return buildView(viewCls, viewName.substring(JSP_URL_PREFIX.length()), getPrefix(), ".jsp");    } else {        //默认以freemarker处理  
+return buildFreemarkerView(viewName);    }  }  
+private AbstractUrlBasedView build(Class viewClass, String viewName, String prefix, String suffix) {    AbstractUrlBasedView view = (AbstractUrlBasedView) BeanUtils.instantiateClass(viewClass);  
+view.setUrl(prefix + viewName + suffix);    String contentType = getContentType();    if (contentType != null) {        view.setContentType(contentType);    }    view.setRequestContextAttribute(getRequestContextAttribute());    view.setAttributesMap(getAttributesMap());    if (this.exposePathVariables != null) {        view.setExposePathVariables(exposePathVariables);    }    return view;  }
+
+private AbstractUrlBasedView buildFreemarkerView(String viewName) throws Exception {    AbstractTemplateView view = (AbstractTemplateView) build(FreeMarkerView.class, viewName, "", getSuffix());  
+view.setExposeRequestAttributes(this.exposeRequestAttributes);    view.setAllowRequestOverride(this.allowRequestOverride);    view.setExposeSessionAttributes(this.exposeSessionAttributes);    view.setAllowSessionOverride(this.allowSessionOverride);    view.setExposeSpringMacroHelpers(this.exposeSpringMacroHelpers);    return view;  }
+
+//get set方法省略
+
+}
+````
+
+  
+  
+xml配置：  
+  
+```  
+<bean class="org.format.demo.support.viewResolver.CustomViewResolver">  
+  <property name="prefix" value="/WEB-INF/view/"/>  <property name="suffix" value=".ftl"/>  <property name="contentType" value="text/html;charset=utf-8"/>  <property name="exposeRequestAttributes" value="true"/>  <property name="exposeSessionAttributes" value="true"/>  <property name="exposeSpringMacroHelpers" value="true"/>  <property name="requestContextAttribute" value="request"/></bean>  
+
+
+<bean id="freemarkerConfig" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">  
+  <property name="templateLoaderPath" value="/WEB-INF/view/"/>  <property name="defaultEncoding" value="utf-8"/>  <property name="freemarkerSettings">    <props>      <prop key="template_update_delay">10</prop>      <prop key="locale">zh_CN</prop>      <prop key="datetime_format">yyyy-MM-dd</prop>      <prop key="date_format">yyyy-MM-dd</prop>      <prop key="number_format">#.##</prop>    </props>  </property></bean>  
+
+```  
+  
+简单解释一下：CustomViewResolver解析视图名的时候，判断 "jsp:" 和 "freemarker:" 开头的名字，如果是 "jsp:" 开头的，如果有JSTL依赖，构造JSTLView视图，否则构造InternalResourceView视图。如果是"freemarker:" 构造FreemarkerView。在构造视图之前分别会设置一些属性。  
+  
+xml配置：配置prefix是为了给jsp视图用的，freemarker视图不需要prefix，因为FreemarkerView内部会使用配置的FreeMarkerConfigurer，并用FreeMarkerConfigurer内部的templateLoaderPath属性作为前缀，配置的suffix是为了让FreemarkerView使用，当后缀。  
+  
+最后附上Controller代码：  
+  
+```  
+@Controller  
+@RequestMapping(value = "/tvrc")  
+public class TestViewResolverController {
+
+    @RequestMapping("jsp")    public ModelAndView jsp(ModelAndView view) {        view.setViewName("jsp:trvc/index");        return view;    }  
+    @RequestMapping("/ftl")    public ModelAndView freemarker(ModelAndView view) {        view.setViewName("freemarker:trvc/index");        return view;    }  
+}
+```  
+  
+视图 /WEB-INF/view/trvc/index.jsp 中的的内容是输出  
+  
+### This is jsp page  
+  
+视图 /WEB-INF/view/trvc/index.ftl 中的的内容是输出  
+  
+### This is freemarker page  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/140202040149946.png)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/140202212495247.png)  
+  
+## 总结  
+  
+本文分析了SpringMVC中的视图机制，View和ViewResolver这两个接口是视图机制的核心，并分析了几个重要的View和ViewResolver接口实现类，最终写了一个区别jsp和freemarker视图的ViewResolver实现类，让读者更加理解视图机制。  
+  
+希望这篇文章能帮助读者了解SpringMVC视图机制。  
+  
+文中难免有错误，希望读者能够指明出来。
\ No newline at end of file
diff --git "a/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2202\357\274\232SpringMVC\350\256\276\350\256\241\347\220\206\345\277\265\344\270\216DispatcherServlet.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232SpringMVC\350\256\276\350\256\241\347\220\206\345\277\265\344\270\216DispatcherServlet.md"
similarity index 98%
rename from "docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2202\357\274\232SpringMVC\350\256\276\350\256\241\347\220\206\345\277\265\344\270\216DispatcherServlet.md"
rename to "docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232SpringMVC\350\256\276\350\256\241\347\220\206\345\277\265\344\270\216DispatcherServlet.md"
index fb56599..a33c502 100644
--- "a/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2202\357\274\232SpringMVC\350\256\276\350\256\241\347\220\206\345\277\265\344\270\216DispatcherServlet.md"
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232SpringMVC\350\256\276\350\256\241\347\220\206\345\277\265\344\270\216DispatcherServlet.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [SpringMVC简介](#springmvc简介)
   * [HandlerMapping接口](#handlermapping接口)
   * [DispatcherServlet接受请求并找到对应Handler](#dispatcherservlet接受请求并找到对应handler)
@@ -107,7 +106,7 @@ HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;
     }
 ```
 
-是的，第一步处理就这么简单的完成了。一个web请求经过处理后，会得到一个HandlerExecutionChain对象，这就是SpringMVC对URl映射给出的回答。需要留意的是，HandlerMapping接口的getHandler方法参数是HttpServletRequest，这意味着，HandlerMapping的实现类可以利用HttpServletRequest中的 所有信息来做出这个HandlerExecutionChain对象的生成”决策“。这包括，请求头、url路径、cookie、session、参数等等一切你从一个web请求中可以得到的任何东西（最常用的是url路径）。
+是的，第一步处理就这么简单的完成了。一个web请求经过处理后，会得到一个HandlerExecutionChain对象，这就是SpringMVC对URl映射给出的回答。需要留意的是，HandlerMapping接口的getHandler方法参数是HttpServletRequest，这意味着，HandlerMapping的实现类可以利用HttpServletRequest中的所有信息来做出这个HandlerExecutionChain对象的生成”决策“。这包括，请求头、url路径、cookie、session、参数等等一切你从一个web请求中可以得到的任何东西（最常用的是url路径）。
 
 SpirngMVC的第一个扩展点，就出现在这里。我们可以编写任意的HandlerMapping实现类，依据任何策略来决定一个web请求到HandlerExecutionChain对象的生成。可以说，从第一个核心接口的声明开始，SpringMVC就把自己的灵活性和野心暴露无疑：哥玩的就是”Open-Closed“。
 
diff --git "a/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\211\226\346\236\2205\357\274\232\346\266\210\346\201\257\350\275\254\346\215\242\345\231\250HttpMessageConverter\344\270\216@ResponseBody\346\263\250\350\247\243.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\346\266\210\346\201\257\350\275\254\346\215\242\345\231\250HttpMessageConverter\344\270\216@ResponseBody\346\263\250\350\247\243.md"
similarity index 65%
rename from "docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\211\226\346\236\2205\357\274\232\346\266\210\346\201\257\350\275\254\346\215\242\345\231\250HttpMessageConverter\344\270\216@ResponseBody\346\263\250\350\247\243.md"
rename to "docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\346\266\210\346\201\257\350\275\254\346\215\242\345\231\250HttpMessageConverter\344\270\216@ResponseBody\346\263\250\350\247\243.md"
index 7a3c1d0..d4cb3bc 100644
--- "a/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\211\226\346\236\2205\357\274\232\346\266\210\346\201\257\350\275\254\346\215\242\345\231\250HttpMessageConverter\344\270\216@ResponseBody\346\263\250\350\247\243.md"
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220\357\274\232\346\266\210\346\201\257\350\275\254\346\215\242\345\231\250HttpMessageConverter\344\270\216@ResponseBody\346\263\250\350\247\243.md"
@@ -1,17 +1,14 @@
-# Table of Contents
-
-  * [目录](#目录)
-  * [前言](#前言)
-  * [现象](#现象)
-  * [源码分析](#源码分析)
-  * [实例讲解](#实例讲解)
-  * [关于配置](#关于配置)
-  * [总结](#总结)
-  * [详解RequestBody和@ResponseBody注解](#详解requestbody和responsebody注解)
-  * [参考资料](#参考资料)
-
-
-转自 [SpringMVC关于json、xml自动转换的原理研究[附带源码分析]](https://www.cnblogs.com/fangjian0423/p/springMVC-xml-json-convert.html)
+# 目录
+* [前言](#前言)
+* [现象](#现象)
+* [源码分析](#源码分析)
+* [实例讲解](#实例讲解)
+* [关于配置](#关于配置)
+* [总结](#总结)
+* [详解RequestBody和@ResponseBody注解](#详解requestbody和responsebody注解)
+* [参考资料](#参考资料)
+
+转自[SpringMVC关于json、xml自动转换的原理研究[附带源码分析]](https://www.cnblogs.com/fangjian0423/p/springMVC-xml-json-convert.html)
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -33,19 +30,9 @@
 
 <!-- more -->
 
-## 目录
-
-*   [前言](http://www.cnblogs.com/fangjian0423/p/springMVC-xml-json-convert.html#preface)
-*   [现象](http://www.cnblogs.com/fangjian0423/p/springMVC-xml-json-convert.html#phenomenon)
-*   [源码分析](http://www.cnblogs.com/fangjian0423/p/springMVC-xml-json-convert.html#analysis)
-*   [实例讲解](http://www.cnblogs.com/fangjian0423/p/springMVC-xml-json-convert.html#demo)
-*   [关于配置](http://www.cnblogs.com/fangjian0423/p/springMVC-xml-json-convert.html#config)
-*   [总结](http://www.cnblogs.com/fangjian0423/p/springMVC-xml-json-convert.html#summary)
-*   [参考资料](http://www.cnblogs.com/fangjian0423/p/springMVC-xml-json-convert.html#reference)
-
 ## 前言
 
-SpringMVC是目前主流的Web MVC框架之一。 
+SpringMVC是目前主流的Web MVC框架之一。
 
 如果有同学对它不熟悉，那么请参考它的入门blog：[http://www.cnblogs.com/fangjian0423/p/springMVC-introduction.html](http://www.cnblogs.com/fangjian0423/p/springMVC-introduction.html)
 
@@ -57,43 +44,37 @@ SpringMVC是目前主流的Web MVC框架之一。 
 
 (视图配置省略)
 
-```
-<mvc:resources location="/static/" mapping="/static/**"/>
-<mvc:annotation-driven/>
-<context:component-scan base-package="org.format.demo.controller"/>
-```
+```  
+<mvc:resources location="/static/" mapping="/static/**"/>  
+<mvc:annotation-driven/>  
+<context:component-scan base-package="org.format.demo.controller"/>  
+```  
 
 pom中需要有以下依赖(Spring依赖及其他依赖不显示)：
 
-```
-<dependency>
-  <groupId>org.codehaus.jackson</groupId>
-  jackson-core-asl
-  <version>1.9.13</version>
-</dependency>
-<dependency>
-  <groupId>org.codehaus.jackson</groupId>
-  jackson-mapper-asl
-  <version>1.9.13</version>
-</dependency>
-
-```
+```  
+<dependency>  
+  <groupId>org.codehaus.jackson</groupId>  jackson-core-asl  <version>1.9.13</version></dependency>  
+<dependency>  
+  <groupId>org.codehaus.jackson</groupId>  jackson-mapper-asl  <version>1.9.13</version></dependency>  
+  
+```  
 
 这个依赖是json序列化的依赖。
 
 ok。我们在Controller中添加一个method：
 
-
-<pre>@RequestMapping("/xmlOrJson")
-@ResponseBody public Map <string, object="">xmlOrJson() {
-    Map <string, object="">map = new HashMap<string, object="">();
-    map.put("list", employeeService.list()); return map;
-}</string,></string,></string,></pre>
-
+````
+@RequestMapping("/xmlOrJson")  
+@ResponseBody public Map <string, object="">xmlOrJson() {  
+    Map <string, object="">map = new HashMap<string, object="">();  
+    map.put("list", employeeService.list()); return map;  
+}</string,></string,></string,> 
+````
 
 直接访问地址：
 
-![](https://images0.cnblogs.com/i/411512/201405/101449596675807.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101449596675807.png)
 
 我们看到，短短几行配置。使用@ResponseBody注解之后，Controller返回的对象 自动被转换成对应的json数据，在这里不得不感叹SpringMVC的强大。
 
@@ -109,13 +90,13 @@ ok。我们在Controller中添加一个method：
 
 HttpMessageConverter接口就是Spring提供的http消息转换接口。有关这方面的知识大家可以参考"参考资料"中的[第二条链接](http://my.oschina.net/lichhao/blog/172562)，里面讲的很清楚。
 
-![](https://images0.cnblogs.com/i/411512/201405/101510002604230.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101510002604230.png)
 
 下面开始分析<mvc:annotation-driven>这句配置:</mvc:annotation-driven>
 
 这句代码在spring中的解析类是：
 
-![](https://images0.cnblogs.com/i/411512/201405/101606162131470.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101606162131470.png)
 
 在AnnotationDrivenBeanDefinitionParser源码的152行parse方法中：
 
@@ -127,11 +108,11 @@ RequestMappingHandlerMapping处理请求映射的，处理@RequestMapping跟请
 
 RequestMappingHandlerAdapter是请求处理的适配器，也就是请求之后处理具体逻辑的执行，关系到哪个类的哪个方法以及转换器等工作，这个类是我们讲的重点，其中它的属性messageConverters是本文要讲的重点。
 
-![](https://images0.cnblogs.com/i/411512/201405/101611179016436.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101611179016436.png)
 
 私有方法:getMessageConverters
 
-![](https://images0.cnblogs.com/i/411512/201405/101630232136603.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101630232136603.png)
 
 从代码中我们可以，RequestMappingHandlerAdapter设置messageConverters的逻辑：
 
@@ -139,28 +120,24 @@ RequestMappingHandlerAdapter是请求处理的适配器，也就是请求之后
 
 message-converters的子节点配置如下：
 
-```
-<mvc:annotation-driven>
-  <mvc:message-converters>
-    <bean class="org.example.MyHttpMessageConverter"/>
-    <bean class="org.example.MyOtherHttpMessageConverter"/>
-  </mvc:message-converters>
-</mvc:annotation-driven>
-```
+```  
+<mvc:annotation-driven>  
+  <mvc:message-converters>    <bean class="org.example.MyHttpMessageConverter"/>    <bean class="org.example.MyOtherHttpMessageConverter"/>  </mvc:message-converters></mvc:annotation-driven>  
+```  
 
 2.message-converters子节点不存在或它的属性register-defaults为true的话，加入其他的转换器：ByteArrayHttpMessageConverter、StringHttpMessageConverter、ResourceHttpMessageConverter等。
 
 我们看到这么一段：
 
-![](https://images0.cnblogs.com/i/411512/201405/101640298384297.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101640298384297.png)
 
 这些boolean属性是哪里来的呢，它们是AnnotationDrivenBeanDefinitionParser的静态变量。
 
-![](https://images0.cnblogs.com/i/411512/201405/101641297132356.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101641297132356.png)
 
- 其中ClassUtils中的isPresent方法如下：
+其中ClassUtils中的isPresent方法如下：
 
-![](https://images0.cnblogs.com/i/411512/201405/101643277139672.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101643277139672.png)
 
 看到这里，读者应该明白了为什么本文一开始在pom文件中需要加入对应的jackson依赖，为了让json转换器jackson成为默认转换器之一。
 
@@ -176,23 +153,22 @@ HandlerMethodReturnValueHandlerComposite维护了一个HandlerMethodReturnValueH
 
 RequestResponseBodyMethodProcessor的supportsReturnType方法：
 
-![](https://images0.cnblogs.com/i/411512/201405/101803027605809.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101803027605809.png)
 
 然后使用handleReturnValue方法进行处理：
 
-![](https://images0.cnblogs.com/i/411512/201405/101803105889900.png)
-
-我们看到，这里使用了转换器。　　
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101803105889900.png)
 
+我们看到，这里使用了转换器。　　  
 具体的转换方法：
 
-![](https://images0.cnblogs.com/i/411512/201405/101809037135949.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101809037135949.png)
 
-![](https://images0.cnblogs.com/i/411512/201405/102031439173571.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/102031439173571.png)
 
 至于为何是请求头部的**Accept**数据，读者可以进去debug这个**getAcceptableMediaTypes**方法看看。 我就不罗嗦了～～～
 
- ok。至此，我们走遍了所有的流程。
+ok。至此，我们走遍了所有的流程。
 
 现在，回过头来看。为什么一开始的demo输出了json数据？
 
@@ -200,19 +176,19 @@ RequestResponseBodyMethodProcessor的supportsReturnType方法：
 
 由于我们只配置了<mvc:annotation-driven>，因此使用spring默认的那些转换器。</mvc:annotation-driven>
 
-![](https://images0.cnblogs.com/i/411512/201405/101816581047144.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101816581047144.png)
 
-很明显，我们看到了2个xml和1个json转换器。 **要看能不能转换，得看HttpMessageConverter接口的public boolean canWrite(Class<?> clazz, MediaType mediaType)方法是否返回true来决定的。**
+很明显，我们看到了2个xml和1个json转换器。**要看能不能转换，得看HttpMessageConverter接口的public boolean canWrite(Class<?> clazz, MediaType mediaType)方法是否返回true来决定的。**
 
 我们先分析SourceHttpMessageConverter：
 
 它的canWrite方法被父类AbstractHttpMessageConverter重写了。
 
-![](https://images0.cnblogs.com/i/411512/201405/101830573234896.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101830573234896.png)
 
-![](https://images0.cnblogs.com/i/411512/201405/101832284176592.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101832284176592.png)
 
-![](https://images0.cnblogs.com/i/411512/201405/101832352929525.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101832352929525.png)
 
 发现SUPPORTED_CLASSES中没有Map类(本文demo返回的是Map类)，因此不支持。
 
@@ -220,7 +196,7 @@ RequestResponseBodyMethodProcessor的supportsReturnType方法：
 
 这个类直接重写了canWrite方法。
 
-![](https://images0.cnblogs.com/i/411512/201405/101838053851073.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101838053851073.png)
 
 需要有XmlRootElement注解。 很明显，Map类当然没有。
 
@@ -228,7 +204,7 @@ RequestResponseBodyMethodProcessor的supportsReturnType方法：
 
 ## 实例讲解
 
- 我们分析了转换器的转换过程之后，下面就通过实例来验证我们的结论吧。
+我们分析了转换器的转换过程之后，下面就通过实例来验证我们的结论吧。
 
 首先，我们先把xml转换器实现。
 
@@ -237,18 +213,18 @@ RequestResponseBodyMethodProcessor的supportsReturnType方法：
 由于Map是jdk源码中的部分，因此我们用Employee来做demo。
 
 因此，Controller加上一个方法：
-
-<pre>@RequestMapping("/xmlOrJsonSimple")
-@ResponseBody public Employee xmlOrJsonSimple() { return employeeService.getById(1);
-}</pre>
-
+````
+@RequestMapping("/xmlOrJsonSimple")  
+@ResponseBody public Employee xmlOrJsonSimple() { return employeeService.getById(1);  
+} 
+````
 实体中加上@XmlRootElement注解
 
-![](https://images0.cnblogs.com/i/411512/201405/101903141989122.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101903141989122.png)
 
 
 
-![](https://images0.cnblogs.com/i/411512/201405/101904598389030.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/101904598389030.png)
 
 我们发现，解析成了xml。
 
@@ -258,29 +234,29 @@ RequestResponseBodyMethodProcessor的supportsReturnType方法：
 
 我们使用firebug看到：
 
-![](https://images0.cnblogs.com/i/411512/201405/102222464019898.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/102222464019898.png)
 
 我们发现Accept有xml，没有json。因此解析成xml了。
 
 我们再来验证，同一地址，HTTP头部不同Accept。看是否正确。
 
-
-<pre>$.ajax({
-    url: "${request.contextPath}/employee/xmlOrJsonSimple",
-    success: function(res) {
-        console.log(res);
-    },
-    headers: { "Accept": "application/xml" }
-});</pre>
-
-<pre>$.ajax({
-    url: "${request.contextPath}/employee/xmlOrJsonSimple",
-    success: function(res) {
-        console.log(res);
-    },
-    headers: { "Accept": "application/json" }
-});</pre>
-
+````
+$.ajax({  
+    url: "${request.contextPath}/employee/xmlOrJsonSimple",  
+    success: function(res) {  
+        console.log(res);  
+    },  
+    headers: { "Accept": "application/xml" }  
+}); 
+
+$.ajax({  
+    url: "${request.contextPath}/employee/xmlOrJsonSimple",  
+    success: function(res) {  
+        console.log(res);  
+    },  
+    headers: { "Accept": "application/json" }  
+}); 
+````
 
 验证成功。
 
@@ -290,23 +266,19 @@ RequestResponseBodyMethodProcessor的supportsReturnType方法：
 
 为何会覆盖，请参考楼主的另外一篇博客：[http://www.cnblogs.com/fangjian0423/p/spring-Ordered-interface.html](http://www.cnblogs.com/fangjian0423/p/spring-Ordered-interface.html)
 
-<pre>    ` <bean><property name="messageConverters"><list><bean><bean><bean></bean></bean></bean></list></property></bean> ` </pre>
+    ` <bean><property name="messageConverters"><list><bean><bean><bean></bean></bean></bean></list></property></bean> `  
 
 或者如果只想换messageConverters的话。
 
-```
-<mvc:annotation-driven>
-  <mvc:message-converters>
-    <bean class="org.example.MyHttpMessageConverter"/>
-    <bean class="org.example.MyOtherHttpMessageConverter"/>
-  </mvc:message-converters>
-</mvc:annotation-driven>
-
-```
+```  
+<mvc:annotation-driven>  
+  <mvc:message-converters>    <bean class="org.example.MyHttpMessageConverter"/>    <bean class="org.example.MyOtherHttpMessageConverter"/>  </mvc:message-converters></mvc:annotation-driven>  
+  
+```  
 
 如果还想用其他converters的话。
 
-![](https://images0.cnblogs.com/i/411512/201405/102311480731629.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/102311480731629.png)
 
 以上是spring-mvc jar包中的converters。
 
@@ -314,13 +286,12 @@ RequestResponseBodyMethodProcessor的supportsReturnType方法：
 
 这个converter里面使用了marshaller进行转换
 
-![](https://images0.cnblogs.com/i/411512/201405/102313161827280.png)
-
-我们这里使用XStreamMarshaller。　　
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/102313161827280.png)
 
-![](https://images0.cnblogs.com/i/411512/201405/102319292603758.png)
+我们这里使用XStreamMarshaller。　　  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/102319292603758.png)
 
-![](https://images0.cnblogs.com/i/411512/201405/102319412294581.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/102319412294581.png)
 
 json没有转换器，返回406.
 
@@ -328,17 +299,14 @@ json没有转换器，返回406.
 
 使用这种方式，pom别忘记了加入xstream的依赖：
 
-```
-<dependency>
-  <groupId>com.thoughtworks.xstream</groupId>
-  xstream
-  <version>1.4.7</version>
-</dependency>
-```
+```  
+<dependency>  
+  <groupId>com.thoughtworks.xstream</groupId>  xstream  <version>1.4.7</version></dependency>  
+```  
 
 ## 总结
 
- 写了这么多，可能读者觉得有点罗嗦。 毕竟这也是自己的一些心得，希望都能说出来与读者共享。
+写了这么多，可能读者觉得有点罗嗦。 毕竟这也是自己的一些心得，希望都能说出来与读者共享。
 
 刚接触SpringMVC的时候，发现这种自动转换机制很牛逼，但是一直没有研究它的原理，目前，算是了了一个小小心愿吧，SpringMVC还有很多内容，以后自己研究其他内容的时候还会与大家一起共享的。
 
@@ -350,17 +318,16 @@ json没有转换器，返回406.
 
 Http请求的抽象 还是回到请求-响应，也就是解析请求体，然后返回响应报文这个最基本的Http请求过程中来。我们知道，在servlet标准中，可以用javax.servlet.ServletRequest接口中的以下方法：
 
-```
-public ServletInputStream getInputStream() throws IOException; 
-
-```
+```  
+public ServletInputStream getInputStream() throws IOException;   
+```  
 
 来得到一个ServletInputStream。这个ServletInputStream中，可以读取到一个原始请求报文的所有内容。同样的，在javax.servlet.ServletResponse接口中，可以用以下方法：
 
-```
-public ServletOutputStream getOutputStream() throws IOException;
-
-```
+```  
+public ServletOutputStream getOutputStream() throws IOException;  
+  
+```  
 
 来得到一个ServletOutputStream，这个ServletOutputSteam，继承自java中的OutputStream，可以让你输出Http的响应报文内容。
 
@@ -370,75 +337,65 @@ public ServletOutputStream getOutputStream() throws IOException;
 
 HttpInputMessage 这个类是SpringMVC内部对一次Http请求报文的抽象，在HttpMessageConverter的read()方法中，有一个HttpInputMessage的形参，它正是SpringMVC的消息转换器所作用的受体“请求消息”的内部抽象，消息转换器从“请求消息”中按照规则提取消息，转换为方法形参中声明的对象。
 
-```
-package org.springframework.http;
-
-import java.io.IOException;
-import java.io.InputStream;
-
-public interface HttpInputMessage extends HttpMessage {
-
-    InputStream getBody() throws IOException;
-
-}
-
-```
+```  
+package org.springframework.http;  
+  
+import java.io.IOException;  
+import java.io.InputStream;  
+  
+public interface HttpInputMessage extends HttpMessage {  
+  
+    InputStream getBody() throws IOException;  
+}  
+  
+```  
 
 HttpOutputMessage 这个类是SpringMVC内部对一次Http响应报文的抽象，在HttpMessageConverter的write()方法中，有一个HttpOutputMessage的形参，它正是SpringMVC的消息转换器所作用的受体“响应消息”的内部抽象，消息转换器将“响应消息”按照一定的规则写到响应报文中。
 
-```
-package org.springframework.http;
-
-import java.io.IOException;
-import java.io.OutputStream;
-
-public interface HttpOutputMessage extends HttpMessage {
-
-    OutputStream getBody() throws IOException;
-
-}
-
-```
+```  
+package org.springframework.http;  
+  
+import java.io.IOException;  
+import java.io.OutputStream;  
+  
+public interface HttpOutputMessage extends HttpMessage {  
+  
+    OutputStream getBody() throws IOException;  
+}  
+  
+```  
 
 HttpMessageConverter 对消息转换器最高层次的接口抽象，描述了一个消息转换器的一般特征，我们可以从这个接口中定义的方法，来领悟Spring3.x的设计者对这一机制的思考过程。
 
-```
-package org.springframework.http.converter;
-
-import java.io.IOException;
-import java.util.List;
-
-import org.springframework.http.HttpInputMessage;
-import org.springframework.http.HttpOutputMessage;
-import org.springframework.http.MediaType;
-
-public interface HttpMessageConverter<T> {
-
-    boolean canRead(Class<?> clazz, MediaType mediaType);
-
-    boolean canWrite(Class<?> clazz, MediaType mediaType);
-
-    List<MediaType> getSupportedMediaTypes();
-
-    T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
-            throws IOException, HttpMessageNotReadableException;
-
-    void write(T t, MediaType contentType, HttpOutputMessage outputMessage)
-            throws IOException, HttpMessageNotWritableException;
-
-}
-
-```
+```  
+package org.springframework.http.converter;  
+  
+import java.io.IOException;  
+import java.util.List;  
+  
+import org.springframework.http.HttpInputMessage;  
+import org.springframework.http.HttpOutputMessage;  
+import org.springframework.http.MediaType;  
+  
+public interface HttpMessageConverter<T> {  
+  
+    boolean canRead(Class<?> clazz, MediaType mediaType);  
+    boolean canWrite(Class<?> clazz, MediaType mediaType);  
+    List<MediaType> getSupportedMediaTypes();  
+    T read(Class<? extends T> clazz, HttpInputMessage inputMessage)            throws IOException, HttpMessageNotReadableException;  
+    void write(T t, MediaType contentType, HttpOutputMessage outputMessage)            throws IOException, HttpMessageNotWritableException;  
+}  
+  
+```  
 
 HttpMessageConverter接口的定义出现了成对的canRead()，read()和canWrite()，write()方法，MediaType是对请求的Media Type属性的封装。举个例子，当我们声明了下面这个处理方法。
 
-```
-@RequestMapping(value="/string", method=RequestMethod.POST)
-public @ResponseBody String readString(@RequestBody String string) {
-    return "Read string '" + string + "'";
-}
-
-```
+```  
+@RequestMapping(value="/string", method=RequestMethod.POST)  
+public @ResponseBody String readString(@RequestBody String string) {  
+    return "Read string '" + string + "'";}  
+  
+```  
 
 在SpringMVC进入readString方法前，会根据@RequestBody注解选择适当的HttpMessageConverter实现类来将请求参数解析到string变量中，具体来说是使用了StringHttpMessageConverter类，它的canRead()方法返回true，然后它的read()方法会从请求中读出请求参数，绑定到readString()方法的string变量中。
 
@@ -446,93 +403,65 @@ public @ResponseBody String readString(@RequestBody String string) {
 
 我们可以用下面的图，简单描述一下这个过程。
 
-![消息转换图](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825151641382-1716038917.png)
+![消息转换图](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825151641382-1716038917.png)
 
 RequestResponseBodyMethodProcessor 将上述过程集中描述的一个类是org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor，这个类同时实现了HandlerMethodArgumentResolver和HandlerMethodReturnValueHandler两个接口。前者是将请求报文绑定到处理方法形参的策略接口，后者则是对处理方法返回值进行处理的策略接口。两个接口的源码如下：
 
-```
-package org.springframework.web.method.support;
-
-import org.springframework.core.MethodParameter;
-import org.springframework.web.bind.WebDataBinder;
-import org.springframework.web.bind.support.WebDataBinderFactory;
-import org.springframework.web.context.request.NativeWebRequest;
-
-public interface HandlerMethodArgumentResolver {
-
-    boolean supportsParameter(MethodParameter parameter);
-
-    Object resolveArgument(MethodParameter parameter,
-                           ModelAndViewContainer mavContainer,
-                           NativeWebRequest webRequest,
-                           WebDataBinderFactory binderFactory) throws Exception;
-
-}
-
-package org.springframework.web.method.support;
-
-import org.springframework.core.MethodParameter;
-import org.springframework.web.context.request.NativeWebRequest;
-
-public interface HandlerMethodReturnValueHandler {
-
-    boolean supportsReturnType(MethodParameter returnType);
-
-    void handleReturnValue(Object returnValue,
-                           MethodParameter returnType,
-                           ModelAndViewContainer mavContainer,
-                           NativeWebRequest webRequest) throws Exception;
-
-}
-
-```
+```  
+package org.springframework.web.method.support;  
+  
+import org.springframework.core.MethodParameter;  
+import org.springframework.web.bind.WebDataBinder;  
+import org.springframework.web.bind.support.WebDataBinderFactory;  
+import org.springframework.web.context.request.NativeWebRequest;  
+  
+public interface HandlerMethodArgumentResolver {  
+  
+    boolean supportsParameter(MethodParameter parameter);  
+    Object resolveArgument(MethodParameter parameter,                           ModelAndViewContainer mavContainer,                           NativeWebRequest webRequest,                           WebDataBinderFactory binderFactory) throws Exception;  
+}  
+  
+package org.springframework.web.method.support;  
+  
+import org.springframework.core.MethodParameter;  
+import org.springframework.web.context.request.NativeWebRequest;  
+  
+public interface HandlerMethodReturnValueHandler {  
+  
+    boolean supportsReturnType(MethodParameter returnType);  
+    void handleReturnValue(Object returnValue,                           MethodParameter returnType,                           ModelAndViewContainer mavContainer,                           NativeWebRequest webRequest) throws Exception;  
+}  
+  
+```  
 
 RequestResponseBodyMethodProcessor这个类，同时充当了方法参数解析和返回值处理两种角色。我们从它的源码中，可以找到上面两个接口的方法实现。
 
 对HandlerMethodArgumentResolver接口的实现：
 
-```
-public boolean supportsParameter(MethodParameter parameter) {
-    return parameter.hasParameterAnnotation(RequestBody.class);
-}
-
-public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
-        NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
-
-    Object argument = readWithMessageConverters(webRequest, parameter, parameter.getGenericParameterType());
-
-    String name = Conventions.getVariableNameForParameter(parameter);
-    WebDataBinder binder = binderFactory.createBinder(webRequest, argument, name);
-
-    if (argument != null) {
-        validate(binder, parameter);
-    }
-
-    mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
-
-    return argument;
-}
-
-```
+```  
+public boolean supportsParameter(MethodParameter parameter) {  
+    return parameter.hasParameterAnnotation(RequestBody.class);}  
+  
+public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,  
+        NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {  
+    Object argument = readWithMessageConverters(webRequest, parameter, parameter.getGenericParameterType());  
+    String name = Conventions.getVariableNameForParameter(parameter);    WebDataBinder binder = binderFactory.createBinder(webRequest, argument, name);  
+    if (argument != null) {        validate(binder, parameter);    }  
+    mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());  
+    return argument;}  
+  
+```  
 
 对HandlerMethodReturnValueHandler接口的实现
 
-```
-public boolean supportsReturnType(MethodParameter returnType) {
-    return returnType.getMethodAnnotation(ResponseBody.class) != null;
-}
-
-    public void handleReturnValue(Object returnValue, MethodParameter returnType,
-        ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
-        throws IOException, HttpMediaTypeNotAcceptableException {
-
-    mavContainer.setRequestHandled(true);
-    if (returnValue != null) {
-        writeWithMessageConverters(returnValue, returnType, webRequest);
-    }
-}
-
-```
+```  
+public boolean supportsReturnType(MethodParameter returnType) {  
+    return returnType.getMethodAnnotation(ResponseBody.class) != null;}  
+  
+    public void handleReturnValue(Object returnValue, MethodParameter returnType,        ModelAndViewContainer mavContainer, NativeWebRequest webRequest)        throws IOException, HttpMediaTypeNotAcceptableException {  
+    mavContainer.setRequestHandled(true);    if (returnValue != null) {        writeWithMessageConverters(returnValue, returnType, webRequest);    }}  
+  
+```  
 
 看完上面的代码，整个HttpMessageConverter消息转换的脉络已经非常清晰。因为两个接口的实现，分别是以是否有@RequestBody和@ResponseBody为条件，然后分别调用HttpMessageConverter来进行消息的读写。
 
@@ -551,4 +480,4 @@ public boolean supportsReturnType(MethodParameter returnType) {
 
 [http://my.oschina.net/lichhao/blog/172562](http://my.oschina.net/lichhao/blog/172562)
 
-[http://docs.spring.io/spring/docs/current/spring-framework-reference/html/mvc.html](http://docs.spring.io/spring/docs/current/spring-framework-reference/html/mvc.html)
+[http://docs.spring.io/spring/docs/current/spring-framework-reference/html/mvc.html](http://docs.spring.io/spring/docs/current/spring-framework-reference/html/mvc.html)
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\347\232\204Demo\344\270\216@EnableWebMvc\346\263\250\350\247\243.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\347\232\204Demo\344\270\216@EnableWebMvc\346\263\250\350\247\243.md"
new file mode 100644
index 0000000..2682d3d
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/SpringMVC\347\232\204Demo\344\270\216@EnableWebMvc\346\263\250\350\247\243.md"
@@ -0,0 +1,583 @@
+### 1\. demo ׼��
+
+Ϊ�˸��õط��� springmvc ���Դ�룬������Ҫ��׼��һ�� springmvc �� demo������� demo ���Ƿ��� `spring-learn` ģ�顣
+
+#### 1\. ���� tomcat ��
+
+�� tomcat 8 ֮��tomcat �ṩ�˶��������а�����Ҫʱֱ��������������Ϳ����ˣ���Ӧ�� gradle ��������:
+
+```
+optional("org.apache.tomcat.embed:tomcat-embed-core")
+
+```
+
+�� spring ��Ŀ�� `build.gradle` �У��Ѿ������� `tomcat-embed-core-9.0.29.jar`������� `spring-learn` ģ��������ʱ������ָ���汾��
+
+#### 2\. ׼��������
+
+```
+package org.springframework.learn.mvc.demo01;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.config.annotation.EnableWebMvc;
+
+@Component
+@ComponentScan("org.springframework.learn.mvc.demo01")
+@EnableWebMvc
+public class MvcConfig {
+
+}
+
+```
+
+������Ϊ `MvcConfig`������ָ������Ŀ�İ�ɨ��·�����Լ�ͨ�� `@EnableWebMvc` ���� mvc ���ܡ�
+
+#### 3\. ʵ�� `WebApplicationInitializer`
+
+```
+package org.springframework.learn.mvc.demo01;
+
+import org.springframework.web.WebApplicationInitializer;
+import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
+import org.springframework.web.servlet.DispatcherServlet;
+
+import javax.servlet.ServletContext;
+import javax.servlet.ServletRegistration;
+
+public class MyWebApplicationInitializer implements WebApplicationInitializer {
+
+    @Override
+    public void onStartup(ServletContext servletContext) {
+        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
+        context.register(MvcConfig.class);
+
+        DispatcherServlet servlet = new DispatcherServlet(context);
+        ServletRegistration.Dynamic registration = servletContext.addServlet("app", servlet);
+        registration.setLoadOnStartup(1);
+        registration.addMapping("/*");
+    }
+}
+
+```
+
+spring �ṩ��һ���ӿ� ����`WebApplicationInitializer`��ʵ�ָýӿ�ʱ�������� `onStartup(...)` �����д��� spring �� `applicationContext`��Ȼ���� servelet ��ע�� `DispatcherServlet`��
+
+#### 4\. ׼�� controller
+
+```
+package org.springframework.learn.mvc.demo01;
+
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/test")
+public class TestController {
+
+    @RequestMapping("/hello")
+    public String hello() {
+         System.out.println("hello!!!");
+         return "hello world!";
+    }
+}
+
+```
+
+����׼����һ���򵥵� controller������һ���ַ��� "hello world".
+
+#### 5\. ����
+
+���������������ˣ�
+
+```
+package org.springframework.learn.mvc.demo01;
+
+import org.apache.catalina.Context;
+import org.apache.catalina.LifecycleListener;
+import org.apache.catalina.connector.Connector;
+import org.apache.catalina.startup.Tomcat;
+
+public class MvcDemo01Main {
+
+    public static void main(String[] args) throws Exception {
+        Tomcat tomcat = new Tomcat();
+
+        Connector connector = new Connector();
+        connector.setPort(8080);
+        connector.setURIEncoding("UTF-8");
+        tomcat.getService().addConnector(connector);
+
+        Context context = tomcat.addContext("", System.getProperty("java.io.tmpdir"));
+        LifecycleListener lifecycleListener = (LifecycleListener) 
+                Class.forName(tomcat.getHost().getConfigClass())
+                .getDeclaredConstructor().newInstance();
+        context.addLifecycleListener(lifecycleListener);
+        tomcat.start();
+        tomcat.getServer().await();
+    }
+}
+
+```
+
+�� `main` �����У���Ҫ���� tomcat �����߼���
+
+���У�������£�
+
+����̨��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-8d13bb650364488f8ce5e593eff00448ee1.png)
+
+ҳ�淵�أ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-6a8407a1945dccd6e4ef217a383d4309ec5.png)
+
+���Կ�����һ���򵥵� springmvc ��Ŀ�ʹ����ˡ�
+
+### 2. `servlet 3.0` �淶����
+
+�����¹��ϵ� springmvc ��Ŀ��һ�����⼸�� xml �����ļ���
+
+*   `web.xml`��servlet �����ļ������� web ����ʱ�IJ������Լ� `servlet`/`listener`/`filter`;
+*   `spring.xml`��spring �����������ļ�����Ҫ�������� spring bean.
+*   `spring-mvc.xml`��springmvc �����ļ����������� mvc ��ص� bean�����ļ��ϴ���ص� bean����ͼ���� bean��controller ��·���ȡ�
+
+��Ŀ������ʱ�����ȼ��� `web.xml`���� `web.xml` �м��� spring ������ã����� spring ������
+
+������� demo �У����Ƿ��ֲ� û����Щ���ã������� `web.xml` �ļ���û�У���ô������� web ��Ŀ����ô�������أ�
+
+�� `servlet` �� `3.0` ֮���ṩ��һ�� spi �淶��spring ����ʵ�����£�
+
+1.  �� `spring-web` ģ��� `/src/main/resources/META-INF/services/` �ļ����£������ļ� `javax.servlet.ServletContainerInitializer`����������
+
+```
+org.springframework.web.SpringServletContainerInitializer
+
+```
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-92853ebc9c4388d325244b81557ecf80ddd.png)
+
+1.  `org.springframework.web.SpringServletContainerInitializer` ʵ���� servlet �淶��
+
+```
+// @HandlesTypes ע��������servlet�淶����ʾ webAppInitializerClass Ϊ WebApplicationInitializer.class
+@HandlesTypes(WebApplicationInitializer.class)
+public class SpringServletContainerInitializer implements ServletContainerInitializer {
+
+    /*
+     * ��д ServletContainerInitializer �� onStartup ����
+     * ������������Ҫ��ʵ���� spring �ṩ�� WebApplicationInitializer.class��Ȼ��ִ���� onStartup ����
+     *
+     * Set<Class<?>> webAppInitializerClasses �е�����Ϊ WebApplicationInitializer.class��
+     * ��������� @HandlesTypes ע��ָ��
+     */
+    @Override
+    public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
+            throws ServletException {
+
+        List<WebApplicationInitializer> initializers = new LinkedList<>();
+
+        if (webAppInitializerClasses != null) {
+            for (Class<?> waiClass : webAppInitializerClasses) {
+                if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
+                        WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
+                    try {
+                       // ʹ�÷���ʵ���� WebApplicationInitializer ��ʵ���࣬���ӵ� initializers ��
+                        initializers.add((WebApplicationInitializer)
+                                ReflectionUtils.accessibleConstructor(waiClass).newInstance());
+                    }
+                    catch (Throwable ex) {
+                        ...
+                    }
+                }
+            }
+        }
+
+        servletContext.log(initializers.size() + " ...");
+        // ����ʵ����Orderd�ӿڣ���ע @Order ע�⣬��ʵ���� PriorityOrderd �ӿ�
+        AnnotationAwareOrderComparator.sort(initializers);
+        for (WebApplicationInitializer initializer : initializers) {
+           // ���� WebApplicationInitializer ʵ�����onStartup����
+           initializer.onStartup(servletContext);
+        }
+    }
+
+}
+
+```
+
+1.  `WebApplicationInitializer` ��ʵ�� ���������� demo �ж� `WebApplicationInitializer` ��ʵ�֣�
+
+```
+package org.springframework.learn.mvc.demo01;
+
+import org.springframework.web.WebApplicationInitializer;
+import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
+import org.springframework.web.servlet.DispatcherServlet;
+
+import javax.servlet.ServletContext;
+import javax.servlet.ServletRegistration;
+
+public class MyWebApplicationInitializer implements WebApplicationInitializer {
+
+    /*
+     * ���������� spring ��Ŀ
+     */
+    @Override
+    public void onStartup(ServletContext servletContext) {
+        // ���� spring �� ApplicationContext
+        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
+        context.register(MvcConfig.class);
+
+        // ���� DispatcherServlet �� servlet ��
+        DispatcherServlet servlet = new DispatcherServlet(context);
+        ServletRegistration.Dynamic registration = servletContext.addServlet("app", servlet);
+        registration.setLoadOnStartup(1);
+        registration.addMapping("/*");
+    }
+}
+
+```
+
+����ִ�й������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-0874fa7ef39ca9c405cdf55d99ca891ebf2.png)
+
+�ɴˣ�spring �����������ˡ�
+
+### 3\. @EnableWebMvc ����
+
+�� demo �У�����ͨ�� `@EnableWebMvc` ������ mvc ���ܣ���ô���ע������ʲô�أ����ǽ��� `EnableWebMvc` �ࣺ
+
+```
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Documented
+@Import(DelegatingWebMvcConfiguration.class)
+public @interface EnableWebMvc {
+}
+
+```
+
+���Կ��������ע��ͨ�� `@Import` ע�������� `DelegatingWebMvcConfiguration.class`�������������� `DelegatingWebMvcConfiguration`:
+
+```
+@Configuration(proxyBeanMethods = false)
+public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
+    ...
+
+}
+
+```
+
+�������� `@Configuration` ע�⣬�������Ǹ������࣬�����̳е��� `WebMvcConfigurationSupport`��������������`WebMvcConfigurationSupport` Ϊ "mvc ����֧��"�������������������ô��� mvc ��ص����õġ�
+
+Ϊ�˸��õط����������Ƚ��ܼ����ࣺ
+
+1. `DelegatingWebMvcConfiguration`���� `@EnableWebMvc` ������࣬�� `WebMvcConfigurationSupport` �����࣬��д�� `WebMvcConfigurationSupport` �ṩ�����÷�����
+
+   ```
+   /*
+    * @Configuration���������Ǹ�������
+    * extends WebMvcConfigurationSupport���̳���WebMvcConfigurationSupport��
+    */
+   @Configuration(proxyBeanMethods = false)
+   public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
+   
+       // WebMvcConfigurerComposite �� WebMvcConfigurer ����ϣ�������ᵽ
+       private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
+   
+       /**
+        * ����configurers
+        * ������@Autowiredע�⣬��ʾ��spring�����е�����WebMvcConfigurer bean ��Ϊ
+        * ����configurers��ֵ ��Ȼ����ø÷���
+        */
+       @Autowired(required = false)
+       public void setConfigurers(List<WebMvcConfigurer> configurers) {
+           if (!CollectionUtils.isEmpty(configurers)) {
+               this.configurers.addWebMvcConfigurers(configurers);
+           }
+       }
+   
+       /**
+        * ����PathMatch
+        */
+       @Override
+       protected void configurePathMatch(PathMatchConfigurer configurer) {
+           // ���� WebMvcConfigurerComposite �ķ�����������
+           this.configurers.configurePathMatch(configurer);
+       }
+   
+       // �������÷���Ҳ�ǵ��� WebMvcConfigurerComposite ��Ӧ�ķ����������õ�
+       ...
+   
+   }
+   
+   ```
+
+2. `WebMvcConfigurerComposite`��`WebMvcConfigurer` ����ϣ�
+
+   ```
+   /**
+    * ʵ���� WebMvcConfigurer
+    */
+   class WebMvcConfigurerComposite implements WebMvcConfigurer {
+   
+       // delegates����Ϊ WebMvcConfigurer �ļ���
+       private final List<WebMvcConfigurer> delegates = new ArrayList<>();
+   
+       /*
+        * ��DelegatingWebMvcConfiguration#setConfigurers����
+        * �����ǰѴ����configurers���ӵ�delegates(Ҳ����WebMvcConfigurer����)��
+        */
+       public void addWebMvcConfigurers(List<WebMvcConfigurer> configurers) {
+           if (!CollectionUtils.isEmpty(configurers)) {
+               this.delegates.addAll(configurers);
+           }
+       }
+   
+       /**
+        * ����ʱ�������delegates(Ҳ����WebMvcConfigurer����)����������������õ�
+        * �����е�ÿһ��WebMvcConfigurer
+        */
+       @Override
+       public void configurePathMatch(PathMatchConfigurer configurer) {
+           for (WebMvcConfigurer delegate : this.delegates) {
+               delegate.configurePathMatch(configurer);
+           }
+       }
+   
+       // �����������ƣ�ʡ��
+       ...
+   }
+   
+   ```
+
+3. `WebMvcConfigurer`��springmvc �����ýӿڣ��ṩ�˷dz��������
+
+   ```
+   public interface WebMvcConfigurer {
+   
+       default void configurePathMatch(PathMatchConfigurer configurer) {
+       }
+   
+       default void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
+       }
+   
+       default void configureAsyncSupport(AsyncSupportConfigurer configurer) {
+       }
+   
+       ...
+   }
+   
+   ```
+
+4. `WebMvcConfigurationSupport`��springmvc ������֧����
+
+   ```
+   /**
+    * ʵ��������aware�ӿ�
+    */
+   public class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {
+   
+       //================= ���� XxxAware �ӿڵķ��� =================
+       @Override
+       public void setApplicationContext(@Nullable ApplicationContext applicationContext) {
+           this.applicationContext = applicationContext;
+       }
+   
+       @Override
+       public void setServletContext(@Nullable ServletContext servletContext) {
+           this.servletContext = servletContext;
+       }
+   
+       //================= @Bean ��������spring������ bean =================
+       @Bean
+       public RequestMappingHandlerMapping requestMappingHandlerMapping(...) {
+           RequestMappingHandlerMapping mapping = createRequestMappingHandlerMapping();
+           mapping.setOrder(0);
+           // getInterceptors(...) ��ȡ interceptors�����¿�
+           mapping.setInterceptors(getInterceptors(conversionService, resourceUrlProvider));
+           mapping.setContentNegotiationManager(contentNegotiationManager);
+           // getCorsConfigurations(...) ��ȡCors���ã����¿�
+           mapping.setCorsConfigurations(getCorsConfigurations());
+           // getPathMatchConfigurer(...) ��ȡPathMatch���ã����¿�
+           PathMatchConfigurer configurer = getPathMatchConfigurer();
+   
+           ...
+   
+           return mapping;
+       }
+       ...
+       //================= get xxx ���÷���������spring�ṩ��Ĭ�����ã������Զ������� =======
+       // ��ȡ interceptors
+       protected final Object[] getInterceptors(
+               FormattingConversionService mvcConversionService,
+               ResourceUrlProvider mvcResourceUrlProvider) {
+           if (this.interceptors == null) {
+               InterceptorRegistry registry = new InterceptorRegistry();
+               // �������÷��������� interceptor�����¿�
+               addInterceptors(registry);
+               registry.addInterceptor(new ConversionServiceExposingInterceptor(mvcConversionService));
+               registry.addInterceptor(new ResourceUrlProviderExposingInterceptor(mvcResourceUrlProvider));
+               this.interceptors = registry.getInterceptors();
+           }
+           return this.interceptors.toArray();
+       }
+   
+       // ��ȡCors����
+       protected final Map<String, CorsConfiguration> getCorsConfigurations() {
+           if (this.corsConfigurations == null) {
+               CorsRegistry registry = new CorsRegistry();
+               // �������÷��������� CorsMapping�����¿�
+               addCorsMappings(registry);
+               this.corsConfigurations = registry.getCorsConfigurations();
+           }
+           return this.corsConfigurations;
+       }
+   
+       // ��ȡPathMatch����
+       protected PathMatchConfigurer getPathMatchConfigurer() {
+           if (this.pathMatchConfigurer == null) {
+               this.pathMatchConfigurer = new PathMatchConfigurer();
+               configurePathMatch(this.pathMatchConfigurer);
+           }
+           return this.pathMatchConfigurer;
+       }
+   
+       ...
+   
+       //================= ���÷�������������ʵ�� =================
+       // �����Զ��� Interceptor��������ʵ��
+       protected void addInterceptors(InterceptorRegistry registry) {
+       }
+   
+       // �����Զ��� CorsMapping��������ʵ��
+       protected void addCorsMappings(CorsRegistry registry) {
+       }
+   
+       // �����Զ��� PathMatch
+       protected void configurePathMatch(PathMatchConfigurer configurer) {
+       }
+       ...
+   
+   }
+   
+   ```
+
+   ���Կ����������ķ�����Ϊ���ࣺ
+
+    *   ���� `XxxAware` �ķ�����`XxxAware` �ӿ��� spring �ṩ��bean ��ʼ�����ʱ�����ص���
+    *   �� `@Bean` ע��ķ������� spring ������ bean������ bean ʱ����� `getXxx` ������
+    *   `getXxx` ��������ȡ���÷������ڸ÷����У������� spring �ṩ��Ĭ�����ã��Լ����� `addXxx/configureXxx` ���������Զ������ã�
+    *   `addXxx/configureXxx` ������������ʵ�֣������� springmvc �������Զ������á�
+
+�����ܽ����� 4 ����Ĺ�ϵ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-5e25e6e7303044e7282b3472492c04cf656.png)
+
+���������ĸ���Ĺ�ϵ��`@EnableWebMvc` ��ִ�����̾�һĿ��Ȼ�ˣ������ܽ����£�
+
+1.  `@EnableWebMvc` �� spring ������������` DelegatingWebMvcConfiguration`��
+
+2.  `DelegatingWebMvcConfiguration` ���а��� `@Autowired` ע��ķ��� `setConfigurers(List<WebMvcConfigurer>)`���� spring bean �������л����ִ�У�����Ϊ��ȡ���������� `WebMvcConfigurer` �� bean �������õ�` DelegatingWebMvcConfiguration` �������У�
+
+3.  `DelegatingWebMvcConfiguration` �̳��� `WebMvcConfigurationSupport`���� spring bean �������лᴦ�� `WebMvcConfigurationSupport` ���� `@Bean` ע��ķ��������ַ����Ƚ϶࣬�� `requestMappingHandlerMapping()`��`mvcPathMatcher` �ȣ���Щ���� smvc �Ĺ��������
+
+4.  �ڴ��� `WebMvcConfigurationSupport` ���� `@Bean` ע��ķ���ʱ������� `getXxx()` ��ȡ������ã������ð��� spring �ṩ��Ĭ�����ü��Զ������ã�`getXxx()` �� `WebMvcConfigurationSupport` �ṩ��
+
+5.  �ڵ��� `WebMvcConfigurationSupport#getXxx()` ��ȡ�Զ�������ʱ������� `addXxx()/configureXxx()`���÷����� `WebMvcConfigurationSupport` ���ǿշ������������߼������� (Ҳ����` DelegatingWebMvcConfiguration`) �ṩ�����յ��÷�ʽ��**����ִ�е� 2 ����ȡ�� `WebMvcConfigurer` �� `addXxx()/configureXxx()`**��
+
+������������ͼ��ʾ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-4057f913076f01ba0b507b4654e5031391c.png)
+
+������ springmvc ���ܣ��������Զ�������ʱ�����ǿ�����ô��:
+
+1. ��ʽ 1��ʹ�� @EnableWebMvc ע������ mvc ���ܣ�ʵ�� WebMvcConfigurer�������Զ�������
+
+   ```
+   // ʹ��@EnableWebMvcע������mvc����
+   @Component
+   @EnableWebMvc
+   public class MvcConfig {
+       ...
+   }
+   
+   // ʵ�� WebMvcConfigurer�������Զ�������
+   @Component
+   public class MyWebMvcConfigurer implements WebMvcConfigurer {
+   
+       // ��дWebMvcConfigurer�����������Զ�������
+   }
+   
+   ```
+
+2. ��ʽ 2��ʵ�� `WebMvcConfigurationSupport` �࣬��д���е����÷���
+
+   ```
+   @Component
+   public class MyWebMvcConfigurationSupport extends WebMvcConfigurationSupport {
+       // ��д���÷����������Զ�������
+   
+   }
+   
+   ```
+
+   �����������ַ�ʽ����ʵ�� `WebMvcConfigurer` �����Զ������þͲ���Ч�ˣ��Զ�������ֻ���� `WebMvcConfigurationSupport` �������á�
+
+springmvc �ṩ����Щ�������أ����������� `WebMvcConfigurer` �ṩ�ķ�����
+
+*   `configurePathMatch`������·���������
+*   `configureContentNegotiation`������������
+*   `configureAsyncSupport`��
+*   `configureDefaultServletHandling`��Ĭ�Ͼ�̬��Դ������
+*   `addFormatters`��ע���Զ���ת����
+*   `addInterceptors`������������
+*   `addResourceHandlers`����Դ����
+*   `addCorsMappings`��CORS ����
+*   `addViewControllers`����ͼ��ת������
+*   `configureViewResolvers`��������ͼ����
+*   `addArgumentResolvers`�������Զ��巽������������
+*   `addReturnValueHandlers`�������Զ��巵�ؽ��������
+*   `configureMessageConverters`��������Ϣת���������ػḲ��Ĭ��ע��� `HttpMessageConverter`
+*   `extendMessageConverters`��������Ϣת������������һ���Զ���� `HttpMessageConverter`.
+*   `configureHandlerExceptionResolvers`�������쳣ת����
+*   `extendHandlerExceptionResolvers`�������쳣ת����
+*   `getValidator`:
+*   `getMessageCodesResolver`��
+
+�����Ҫ��������ֻ��Ҫ��д��ط��� ���ɡ�
+
+��������������� `WebMvcConfigurationSupport` ����������Щ Bean���� `@Bean` ע��ķ������£�
+
+*   `public RequestMappingHandlerMapping requestMappingHandlerMapping(...)`
+*   `public PathMatcher mvcPathMatcher()`
+*   `public UrlPathHelper mvcUrlPathHelper()`
+*   `public ContentNegotiationManager mvcContentNegotiationManager()`
+*   `public HandlerMapping viewControllerHandlerMapping(...)`
+*   `public BeanNameUrlHandlerMapping beanNameHandlerMapping(...)`
+*   `public RouterFunctionMapping routerFunctionMapping(...)`
+*   `public HandlerMapping resourceHandlerMapping(...)`
+*   `ResourceUrlProvider mvcResourceUrlProvider()`
+*   `public HandlerMapping defaultServletHandlerMapping()`
+*   `public RequestMappingHandlerAdapter requestMappingHandlerAdapter(...)`
+*   `public HandlerFunctionAdapter handlerFunctionAdapter()`
+*   `public FormattingConversionService mvcConversionService()`
+*   `public Validator mvcValidator()`
+*   `public CompositeUriComponentsContributor mvcUriComponentsContributor(...)`
+*   `public HttpRequestHandlerAdapter httpRequestHandlerAdapter()`
+*   `public SimpleControllerHandlerAdapter simpleControllerHandlerAdapter()`
+*   `public HandlerExceptionResolver handlerExceptionResolver(...)`
+*   `public ViewResolver mvcViewResolver(...)`
+*   `HandlerMappingIntrospector mvcHandlerMappingIntrospector()`
+
+��Щ���� springmvc ���õ���һЩ���������ľ������ݾͲ�չ���ˡ�
+
+### 4\. �ܽ�
+
+�������ݱȽ��ӣ����ṩ��һ�� springmvc �� demo��Ȼ������� demo �� `0 xml` ����ԭ�� (Ҳ���� `servlet 3.0` �淶�������Ž����� `@EnableWebMvc` �Ĺ��ܣ����ؽ����� `WebMvcConfigurationSupport` �����á�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4696657](https://my.oschina.net/funcy/blog/4696657) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\256\271\345\231\250\345\220\257\345\212\250Tomcat.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\256\271\345\231\250\345\220\257\345\212\250Tomcat.md"
new file mode 100644
index 0000000..4623d0f
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\256\271\345\231\250\345\220\257\345\212\250Tomcat.md"
@@ -0,0 +1,299 @@
+''�� [spring mvc ֮ springmvc demo �� @EnableWebMvc ע��](https://my.oschina.net/funcy/blog/4696657)һ���У������ṩ��һ��ʾ�� demo���� demo �������� servlet ������Ȼ��ͨ�� `servlet3.0` �淶�� `DispatcherServlet` ע�ᵽ `servlet` �����У�Ȼ���� `DispatcherServlet#init` ���������� spring �������������̾���������
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-0874fa7ef39ca9c405cdf55d99ca891ebf2.png)
+
+��ûʲô���⣬����������Ҳ�������ã�ֻ���������� spring �������޷���ȡ `DispatcherServlet`����������
+
+```
+@Component
+public class Test {
+    // ��ǰ���ṩ��ʾ����tomcat������spring��������ע�벻�˵�
+    @Autowired
+    public DispatcherServlet dispatcherServlet;
+
+    ...
+
+}
+
+```
+
+����ʱ��spring �϶��ᱨ������Ϊ�Ҳ��� `DispatcherServlet` ��Ӧ�� bean��
+
+����ڿ� springboot Դ��ʱ������ spring ������������ tomcat ���������ģ��෴��springboot �������� spring ������Ȼ���� spring �������� tomcat ��������������������أ����ﱾ���ṩһ�� demo ģ���¡�
+
+### 1\. ׼�� `DispatcherServlet`
+
+```
+@Component
+@EnableWebMvc
+public class MvcConfig implements WebMvcConfigurer {
+
+    @Override
+    public void configureViewResolvers(ViewResolverRegistry registry) {
+        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
+        viewResolver.setPrefix("/WEB-INF/views/");
+        viewResolver.setSuffix(".html");
+        registry.viewResolver(viewResolver);
+    }
+
+    /**
+     * dispatcherServlet
+     * @param webApplicationContext
+     * @return
+     */
+    @Bean
+    public DispatcherServlet dispatcherServlet(WebApplicationContext webApplicationContext) {
+        return new DispatcherServlet(webApplicationContext);
+    }
+
+}
+
+```
+
+�Ը���˵�����£�
+
+*   `MvcConfig` �౻ `@EnableWebMvc` ע���ǣ���ʾ��Ҫ������ `web mvc` ����
+*   `MvcConfig` ʵ���� `WebMvcConfigurer`������ͨ����д `WebMvcConfigurer` �ķ�����ʵ���Զ��� `web mvc` ������
+*   `MvcConfig` �л����� `DispatcherServlet` bean���� bean �ᱣ�浽 spring ������
+
+### 2\. ׼��һ�� `WebApplicationInitializer` ʵ����
+
+```
+@Component
+public class MyWebApplicationInitializer implements WebApplicationInitializer {
+
+    private static BeanFactory beanFactory;
+
+    private static AbstractRefreshableWebApplicationContext applicationContext;
+
+    @Override
+    public void onStartup(ServletContext servletContext) {
+        // �� beanFactory �л�ȡ DispatcherServlet ��ע�ᵽservlet����
+        DispatcherServlet servlet = beanFactory.getBean(DispatcherServlet.class);
+        ServletRegistration.Dynamic registration = servletContext.addServlet("app", servlet);
+        // loadOnStartup ���ó� -1 ʱ��ֻ���ڵ�һ������ʱ���Ż���� init ����
+        registration.setLoadOnStartup(-1);
+        registration.addMapping("/*");
+
+        // Ϊ applicationContext ���� servletContext
+        applicationContext.setServletContext(servletContext);
+    }
+
+    /**
+     * ���� beanFactory
+     * ΪʲôҪ���� beanFactory��ֵ����Ϊ DispatcherServlet Ҫ�� beanFactory �л�ȡ
+     * @param beanFactory
+     * @throws BeansException
+     */
+    public static void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+        MyWebApplicationInitializer.beanFactory = beanFactory;
+    }
+
+    /**
+     * ���� applicationContext
+     * ΪʲôҪ���� applicationContext ��ֵ����Ϊ servletContext Ҫ���õ� applicationContext
+     * @param applicationContext
+     */
+    public static void setApplicationContext(
+                AbstractRefreshableWebApplicationContext applicationContext) {
+        MyWebApplicationInitializer.applicationContext = applicationContext;
+    }
+}
+
+```
+
+`WebApplicationInitializer` �� spring �� servlet 3.0 �淶��ʵ�֣��� [spring mvc ֮ springmvc demo �� @EnableWebMvc ע��](https://my.oschina.net/funcy/blog/4696657)һ��Ҳ��ϸ��������tomcat ������ʱ����ִ�� `WebApplicationInitializer#onStartup` ������
+
+�� `MyWebApplicationInitializer` ˵�����£�
+
+*   `MyWebApplicationInitializer` ����������̬��Ա������`beanFactory` �� `applicationContext`����Ӧ���ṩ��������̬ `set` ��������Ҫע����ǣ���������̬ `set` ����Ҫ�� `onStartup()` ����ǰ���ã�Ҳ���� tomcat ����ǰ���õ��ã�
+*   �� `MyWebApplicationInitializer#onStartup` �����У��������Ǵ� `beanFactory` �л�ȡ�� `DispatcherServlet`��Ȼ����ע�ᵽ `servlet` �����У�Ȼ�� `onStartup(...)` �����IJ��� `servletContext` ���õ� `applicationContext` ��
+
+### 3\. ׼��һ�� `ServletContextAwareProcessor` ������
+
+```
+public class MyServletContextAwareProcessor extends ServletContextAwareProcessor {
+
+	AbstractRefreshableWebApplicationContext webApplicationContext;
+
+	/**
+	 * ���� webApplicationContext
+	 * @param webApplicationContext
+	 */
+	public MyServletContextAwareProcessor(
+                AbstractRefreshableWebApplicationContext webApplicationContext) {
+		this.webApplicationContext = webApplicationContext;
+	}
+
+	/**
+	 * ���� ServletContext
+	 * �ȴ� webApplicationContext �л�ȡ�������ȡ�������ٴӸ��෽���л�ȡ
+	 * @return
+	 */
+	@Override
+	protected ServletContext getServletContext() {
+		ServletContext servletContext = this.webApplicationContext.getServletContext();
+		return (servletContext != null) ? servletContext : super.getServletContext();
+	}
+
+	@Override
+	protected ServletConfig getServletConfig() {
+		ServletConfig servletConfig = this.webApplicationContext.getServletConfig();
+		return (servletConfig != null) ? servletConfig : super.getServletConfig();
+	}
+}
+
+```
+
+�� `MyWebApplicationInitializer#onStartup` �����ж� `applicationContext` ���õ� `servletContext` ����������ʹ�õģ�`MyServletContextAwareProcessor` �Ĺ��췽�������� `webApplicationContext`��Ȼ����д�� `getServletContext()` ��������ȡ `servletContext` ʱ���ȴ� `webApplicationContext` �л�ȡ�������ȡ�������ٴӸ��෽���л�ȡ��
+
+### 4\. ׼��һ�� `ApplicationContext` ��ʵ����
+
+`ApplicationContext` ������Ҫ����������ѡ��ֱ����չ `AnnotationConfigWebApplicationContext`��
+
+```
+public class MyWebApplicationContext extends AnnotationConfigWebApplicationContext {
+
+    private Tomcat tomcat;
+
+    /**
+     * ��д postProcessBeanFactory ����
+     * ��������������������Զ���� MyServletContextAwareProcessor
+     * @param beanFactory
+     */
+    @Override
+    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
+        beanFactory.addBeanPostProcessor(new MyServletContextAwareProcessor(this));
+        beanFactory.ignoreDependencyInterface(ServletContextAware.class);
+        WebApplicationContextUtils.registerWebApplicationScopes(getBeanFactory());
+    }
+
+    /**
+     * ��������������� tomcat
+     */
+    @Override
+    protected void onRefresh() {
+        // �ȵ��ø���ķ���
+        super.onRefresh();
+        // ���� MyWebApplicationInitializer �� beanFactory �� applicationContext
+        MyWebApplicationInitializer.setBeanFactory(getBeanFactory());
+        MyWebApplicationInitializer.setApplicationContext(this);
+
+        // tomcat�Ĵ���������
+        tomcat = new Tomcat();
+        Connector connector = new Connector();
+        connector.setPort(8080);
+        connector.setURIEncoding("UTF-8");
+        tomcat.getService().addConnector(connector);
+
+        Context context = tomcat.addContext("", System.getProperty("java.io.tmpdir"));
+        LifecycleListener lifecycleListener = null;
+        try {
+            lifecycleListener = (LifecycleListener) 
+                    Class.forName(tomcat.getHost().getConfigClass())
+                    .getDeclaredConstructor().newInstance();
+            context.addLifecycleListener(lifecycleListener);
+            // ����tomcat
+            tomcat.start();
+        } catch (Exception e) {
+            System.out.println("�����쳣��");
+            e.printStackTrace();
+        }
+    }
+
+}
+
+```
+
+�������չ�� spring ���������̣�����һ����д����������������һһ������:
+
+*   `postProcessBeanFactory()`�����������Ҫ��Ϊ��ע�� `MyServletContextAwareProcessor`��ǰ������׼���� `MyServletContextAwareProcessor` ����������ע��ģ�֮������д������Ϊ��ʹ�� `tomcat` �ṩ�� `ServletContext`��
+*   `onRefresh()`�������������������� `MyWebApplicationInitializer` �� `beanFactory` �� `applicationContext` ����ֵ��Ȼ������ `tomcat`��
+
+### 5\. ׼��һ���򵥵� `Controller`
+
+׼��һ�� `Controller`����Ҫ�ǰ���������֤��Ŀ�Ƿ�����������
+
+```
+@RestController
+@RequestMapping("/test")
+public class TestController {
+
+    @RequestMapping("/hello")
+    public String hello() {
+        System.out.println("hello!!!");
+        return "hello world!";
+    }
+
+}
+
+```
+
+### 6\. ����
+
+�����������ˣ���Ҫ�Ǵ��� spring ������������Ҳ���൱�򵥣�
+
+```
+@ComponentScan
+public class MvcDemo03Main {
+
+    public static void main(String[] args) throws Exception {
+        MyWebApplicationContext webApplicationContext = new MyWebApplicationContext();
+        webApplicationContext.register(MvcDemo03Main.class);
+        webApplicationContext.refresh();
+    }
+}
+
+```
+
+���У����� `http://localhost:8080/test/hello`��������£�
+
+ҳ�棺
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-d87b4a09e7a87e0535eb52a09759fcc6534.png)
+
+����̨��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-c608886c751dcf595d74efb8506e5d67306.png)
+
+### 7\. ���⣺������`DispatcherServlet#init` �������ٴ����� spring ������
+
+ǰ�����Ƿ�������ʹ�� tomcat ���� spring �����ķ�ʽʱ��spring �������� `DispatcherServlet#init` �����������ģ�������ʹ�� **spring �������� tomcat** ��������ʽʱ��tomcat ִ�� `DispatcherServlet#init` ����ʱ�����ٴ����� spring ������
+
+��������ֱ�ӽ��� `FrameworkServlet#initWebApplicationContext` ���������϶ϵ㣺
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-64ee29f90ef5683f7968f782b9175d42e0f.png)
+
+����� `wac` �� `this.webApplicationContext` ���� `MyWebApplicationContext` ��ʵ�����ڴ��� `DispatcherServlet` ʱ�����:
+
+```
+@Bean
+public DispatcherServlet dispatcherServlet(WebApplicationContext webApplicationContext) {
+    // �ڹ��췽���IJ����д����� webApplicationContext
+    return new DispatcherServlet(webApplicationContext);
+}
+
+```
+
+����Ϊʲô�����������������Ϊ `DispatcherServlet#init` ���������ú�����������������ﴦ�� spring �����������ģ����ϵ����е� `if (!cwac.isActive()) {...` ʱ��`!cwac.isActive()` ���ؽ��Ϊ `false`����� `if` ��������� spring �����Ͳ���ִ�е��ˡ�
+
+����������ͨ�� spring �������� tomcat ���� `DispatcherServlet#init` �ﲻ���ٴ����� spring ����������������`DispatcherServlet` ����һ�� spring bean�����ǾͿ����ڴ�����ʹ�� `@Autowired` ע�⽫��ע�뵽���������ˣ�
+
+```
+@Component
+public class Test {
+    // ���ĵ�ʾ������ spring ���������� tomcat���ǿ���ע��ɹ���
+    @Autowired
+    public DispatcherServlet dispatcherServlet;
+
+    ...
+
+}
+
+```
+
+���� `spring` ���� `tomcat` �ķ����͵�������е��ѵ�����**��ν� `tomcat` �ṩ�� `ServletContext` ���õ� `ServletContextAwareProcessor` ��**�����еĽ����ʽע����ᡣ
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4928222](https://my.oschina.net/funcy/blog/4928222) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/\350\257\267\346\261\202\346\211\247\350\241\214\346\265\201\347\250\213\357\274\210\344\270\200\357\274\211\344\271\213\350\216\267\345\217\226Handler.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/\350\257\267\346\261\202\346\211\247\350\241\214\346\265\201\347\250\213\357\274\210\344\270\200\357\274\211\344\271\213\350\216\267\345\217\226Handler.md"
new file mode 100644
index 0000000..2f1e035
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/\350\257\267\346\261\202\346\211\247\350\241\214\346\265\201\347\250\213\357\274\210\344\270\200\357\274\211\344\271\213\350\216\267\345\217\226Handler.md"
@@ -0,0 +1,772 @@
+��һƪ�������Ƿ��� `RequestMapping` ��ʼ�����̣����Ľ����� spring mvc ������ִ�����̡�
+
+### 1\. �����ִ�����
+
+�� [spring mvc ֮ DispatcherServlet ��ʼ������](https://my.oschina.net/funcy/blog/4710330 "spring mvc֮DispatcherServlet ��ʼ������")һ���У���������������� `servlet` ���������� `DispatcherServlet` ��������һϵ�г�ʼ�����̣����Ľ�����Χ����� `servlet` ���� `springmvc` ���������̡�
+
+#### 1.1 �ع� servlet ��ִ����ڣ�
+
+�ڷ��� `DispatcherServlet` ǰ����Ҫ�ع��� servlet ��ִ����ڡ�
+
+������ʵ���Զ���� servlet ʱ��һ����ʵ�� `HttpServlet`��Ȼ����д `doGet(xxx)`��`doPost()` ��������ʵ���� servlet Ϊ `HttpServlet#service(ServletRequest, ServletResponse)`��
+
+```
+public abstract class HttpServlet extends GenericServlet {
+    ...
+
+    // ������������˲�������ת��
+    @Override
+    public void service(ServletRequest req, ServletResponse res)
+        throws ServletException, IOException {
+
+        HttpServletRequest  request;
+        HttpServletResponse response;
+
+        // �����ﴦ������������ת��
+        try {
+            request = (HttpServletRequest) req;
+            response = (HttpServletResponse) res;
+        } catch (ClassCastException e) {
+            throw new ServletException(lStrings.getString("http.non_http"));
+        }
+        service(request, response);
+    }
+
+    /**
+     * �����ﴦ������
+     * �Ӵ�����Կ������������ʵ����һ��ת�����ж����󷽷���Ȼ����þ���ķ���ִ��
+     */
+    protected void service(HttpServletRequest req, HttpServletResponse resp)
+        throws ServletException, IOException {
+
+        String method = req.getMethod();
+
+        // �жϵ����󷽷���Ȼ���ҵ���Ӧ�ķ���ȥִ��
+        if (method.equals(METHOD_GET)) {
+            long lastModified = getLastModified(req);
+            if (lastModified == -1) {
+                doGet(req, resp);
+            } else {
+                ...
+                doGet(req, resp);
+            }
+        } else if (method.equals(METHOD_HEAD)) {
+            long lastModified = getLastModified(req);
+            maybeSetLastModified(resp, lastModified);
+            doHead(req, resp);
+        } else if (method.equals(METHOD_POST)) {
+            doPost(req, resp);
+        } else if (method.equals(METHOD_PUT)) {
+            doPut(req, resp);
+        } else if (method.equals(METHOD_DELETE)) {
+            doDelete(req, resp);
+        } else if (method.equals(METHOD_OPTIONS)) {
+            doOptions(req,resp);
+        } else if (method.equals(METHOD_TRACE)) {
+            doTrace(req,resp);
+        } else {
+            // û�ж�Ӧ�ķ���������
+            ...
+        }
+    }
+
+}
+
+```
+
+������ servlet Դ�룬�����Ƚϼ򵥣��ص㲿�ֶ�����ע�ͣ�������������Ҫ�ٴ�ǿ���£�
+
+1.  servlet ��ִ�����Ϊ `HttpServlet#service(ServletRequest, ServletResponse)`��
+2.  `HttpServlet#service(HttpServletRequest, HttpServletResponse)` ������������󷽷��ҵ���Ӧ�Ĵ�������ִ�У�һ����˵�������Զ��� servlet��ֻҪ��д `doGet(xxx)`��`doPost(xxx)` �ȷ������ɡ�
+
+�������̴�����£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-60d0e2afcbdb75a175c6f28471fc467f0e5.png)
+
+#### 1.2 `DispatcherServlet` �ĸ��ࣺ`FrameworkServlet`
+
+�˽��� servlet ��������ں󣬽������͵÷���һ�����ò�������ˣ�`FrameworkServlet`��`FrameworkServlet` �� `HttpServlet` �����࣬ʵ���� `HttpServlet` �ĸ��� `doXxx()`��ͬʱҲʵ���� `service(HttpServletRequest, HttpServletResponse)`��
+
+```
+/**
+ *  FrameworkServlet�̳���HttpServletBean����HttpServletBean�̳���HttpServlet
+ *  ���FrameworkServletҲ��HttpServlet������
+ */
+public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
+    @Override
+    protected final void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        processRequest(request, response);
+    }
+
+    @Override
+    protected final void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        processRequest(request, response);
+    }
+
+    @Override
+    protected final void doPut(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        processRequest(request, response);
+    }
+
+    @Override
+    protected final void doDelete(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        processRequest(request, response);
+    }
+
+    @Override
+    protected void service(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
+        if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
+            processRequest(request, response);
+        }
+        else {
+            // GET/POST/PUT/DELETE �����󷽷������ǻ���ø���ķ���
+            super.service(request, response);
+        }
+    }
+}
+
+```
+
+���Կ��������ϴ����У���һ�������ij������൱�ߣ�`FrameworkServlet#processRequest`�������� `doXxx(xxx)`������ `service(xxx)`��������� `processRequest(xxx)`�����������Ǿ������������������ʲô��
+
+> FrameworkServlet#processRequest
+
+```
+protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
+        throws ServletException, IOException {
+    // ��¼��ʼʱ��
+    long startTime = System.currentTimeMillis();
+    Throwable failureCause = null;
+    // ��¼��ǰ�̵߳���Ϣ
+    LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
+    LocaleContext localeContext = buildLocaleContext(request);
+    RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
+    ServletRequestAttributes requestAttributes = buildRequestAttributes(
+            request, response, previousAttributes);
+    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
+    asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), 
+             new RequestBindingInterceptor());
+    initContextHolders(request, localeContext, requestAttributes);
+    try {
+        // ���Ĵ���
+        doService(request, response);
+    }
+    catch (ServletException | IOException ex) {
+        failureCause = ex;
+        throw ex;
+    }
+    catch (Throwable ex) {
+        failureCause = ex;
+        throw new NestedServletException("Request processing failed", ex);
+    }
+    finally {
+        // ����̰߳���Ϣ
+        resetContextHolders(request, previousLocaleContext, previousAttributes);
+        if (requestAttributes != null) {
+            requestAttributes.requestCompleted();
+        }
+        logResult(request, response, failureCause, asyncManager);
+        // �����¼�֪ͨ
+        publishRequestHandledEvent(request, response, startTime, failureCause);
+    }
+}
+
+```
+
+���������Ȼ�е㳤�����󲿷������������̹�ϵ������������������ص�ֻ�м��У�
+
+```
+    ...
+    try {
+        // ���Ĵ���
+        doService(request, response);
+    }
+    catch (ServletException | IOException ex) {
+        failureCause = ex;
+        throw ex;
+    }
+    ...
+
+```
+
+�ɴ˿��Կ�����ʵ�ʴ�������ķ������� `FrameworkServlet#doService` �С�������`FrameworkServlet#doService` �Ǹ����󷽷���
+
+```
+protected abstract void doService(HttpServletRequest request, 
+        HttpServletResponse response) throws Exception;
+
+```
+
+������ʵ���������࣬Ҳ���� `DispatcherServlet#doService` �С�
+
+#### 1.3 `DispatcherServlet#doService`
+
+������ `DispatcherServlet#doService` ����ɶ�£�
+
+```
+public class DispatcherServlet extends FrameworkServlet {
+    @Override
+    protected void doService(HttpServletRequest request, 
+            HttpServletResponse response) throws Exception {
+        logRequest(request);
+        // ʡ����һ�����������
+        ...
+        try {
+            // ����Ĵ���
+            doDispatch(request, response);
+        }
+        finally {
+            ...
+        }
+    }
+}
+
+```
+
+���˷���Ҳû��ʲô��ʵ��ֻ�ǵ�����һ�� `doDispatch` ������Ȼ���û�ˡ���ʵ�ϣ�`DispatcherServlet#doDispatch` �������մ���������߼��������������ص����������� ��
+
+��һ���������ܽ��� `DispatcherServlet` ���������̣�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-f854710c25924666cd5ab755c2983a9baf7.png)
+
+### 2\. springmvc ����ַ���`DispatcherServlet#doDispatch`
+
+��һ�ڵ�������Ƿ��� springmvc ��������ķ����� `DispatcherServlet#doDispatch`�����ھʹ�����������֣���������������߼���
+
+```
+protected void doDispatch(HttpServletRequest request, HttpServletResponse response) 
+            throws Exception {
+    HttpServletRequest processedRequest = request;
+    HandlerExecutionChain mappedHandler = null;
+    boolean multipartRequestParsed = false;
+    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
+    try {
+        ModelAndView mv = null;
+        Exception dispatchException = null;
+        try {
+            //������ļ��ϴ�������������⴦��
+            processedRequest = checkMultipart(request);
+            multipartRequestParsed = (processedRequest != request);
+            // 1\. ��ȡ��Ӧ��handler, 
+            // Handler�а��������ش�������Controller�еķ�������һ��HandlerInterceptor������
+            mappedHandler = getHandler(processedRequest);
+            if (mappedHandler == null) {
+                // ���û�ҵ�������404
+                noHandlerFound(processedRequest, response);
+                return;
+            }
+            // 2\. ��ȡ��Ӧ��handlerAdapter���������� handler(xxx)
+            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
+            // ����last-modified���
+            String method = request.getMethod();
+            boolean isGet = "GET".equals(method);
+            if (isGet || "HEAD".equals(method)) {
+                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
+                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
+                    return;
+                }
+            }
+            // 3\. ����spring��������, ���� HandlerInterceptor#preHandle ����
+            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
+                return;
+            }
+            // 4\. ͨ�������ȡ����handlerAdapter������handle
+            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
+            if (asyncManager.isConcurrentHandlingStarted()) {
+                return;
+            }
+            // �����������û�з�����ͼ��ʹ��Ĭ�ϵ�
+            applyDefaultViewName(processedRequest, mv);
+            // 5\. ִ�������������� HandlerInterceptor#postHandle ����
+            mappedHandler.applyPostHandle(processedRequest, response, mv);
+        }
+        catch (Exception ex) {
+            dispatchException = ex;
+        }
+        catch (Throwable err) {
+            dispatchException = new NestedServletException("Handler dispatch failed", err);
+        }
+        // 6\. �������ؽ������������������Ⱦ��ͼ���Լ�ִ�� HandlerInterceptor#afterCompletion
+        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
+    }
+    catch (...) {
+        // �����ִ�� HandlerInterceptor#afterCompletion
+        triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
+    }
+    finally {
+        if (asyncManager.isConcurrentHandlingStarted()) {
+            if (mappedHandler != null) {
+                // �ص���������ִ�з��� AsyncHandlerInterceptor#afterConcurrentHandlingStarted
+                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
+            }
+        }
+        else {
+            if (multipartRequestParsed) {
+                cleanupMultipart(processedRequest);
+            }
+        }
+    }
+}
+
+```
+
+��������ڵ㳤���������̺�������springmvc �������������̶��������ˣ�����ѹؼ�����չʾ���£�
+
+1.  ��ȡ��Ӧ�� `HandlerExecutionChain`, ��ȡ�� `HandlerExecutionChain` �а��������ش�������`Controller` �еķ�������һ�� `HandlerInterceptor` ��������
+2.  ��ȡ��Ӧ�� `handlerAdapter`���ö����������� `handler(xxx)` ������
+3.  ִ�� spring �������������� `HandlerInterceptor#preHandle` ������
+4.  ��������Ҳ����ͨ�������ȡ���� `handlerAdapter` ������ `handle(xxx)` ������
+5.  ִ�� spring �������������� `HandlerInterceptor#postHandle` ������
+6.  �������ؽ�����������Ⱦ��ͼ���Լ�ִ�� spring �������� `HandlerInterceptor#afterCompletion`��
+
+�ܵ�������������ˣ�����������������̷����ˡ�
+
+### 3\. ��ȡ `HandlerExecutionChain`
+
+��ȡ `HandlerExecutionChain` �ķ����� `DispatcherServlet#getHandler` �У�
+
+```
+protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
+    if (this.handlerMappings != null) {
+        // �������е�handlerMapping��
+        // ����� handlerMapping ����WebMvcConfigurationSupport�������
+        for (HandlerMapping mapping : this.handlerMappings) {
+            // ������þ����handler���ĸ�handler�ܹ�������ֱ�ӷ���
+            HandlerExecutionChain handler = mapping.getHandler(request);
+            if (handler != null) {
+                return handler;
+            }
+        }
+    }
+    return null;
+}
+
+```
+
+����� `handlerMappings` ���� `WebMvcConfigurationSupport` ������ģ�������һ��ķ��������ܲο� [springmvc demo �� @EnableWebMvc ע��](https://my.oschina.net/funcy/blog/4678093 "springmvc demo �� @EnableWebMvc ע��")һ�ģ�������������� `handlerMappings` ��Щɶ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-4465a638ca6c52f24f8c9343986be0bbee9.png)
+
+���� `RequestMappingHandlerMapping` ���Ŵ���Ѿ�����Ϥ������ `@Controller`/`@RequestMapping` ��ʽʵ�ֵ� `controller`����Ӧ�� `HandlerMapping` ���� `RequestMappingHandlerMapping`��������������� `HandlerMapping`����ֱ��Ӧ��ͬ��ʽʵ�ֵ� `controller`��������һ�㣬����Ȥ��С���������аٶȣ�����Ͳ�չ���ˡ�
+
+���Ǽ����� `AbstractHandlerMapping#getHandler` ������
+
+```
+public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
+    // 1\. ���þ����ʵ��ȥ��ȡhandler
+    Object handler = getHandlerInternal(request);
+    // ���Ϊ��ʹ��Ĭ�ϵ�
+    if (handler == null) {
+        handler = getDefaultHandler();
+    }
+    // û��Ĭ�ϵķ��ؿ�
+    if (handler == null) {
+        return null;
+    }
+    // ����ͨ��BeanNameȥ��ȡhandler
+    if (handler instanceof String) {
+        String handlerName = (String) handler;
+        handler = obtainApplicationContext().getBean(handlerName);
+    }
+    // 2\. ��ȡ executionChain����ʵ�����ҵ� uri ��Ӧ�� Interceptors,
+    // Ȼ���������ҵ���handlerһ���װ��HandlerExecutionChain������
+    // �����Interceptors��Ҳ����WebMvcConfigurationSupport�����õ�
+    HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
+    // 3\. ����·����ص����ã�CorsHandlerExecutionChain
+    // ������Կ�������ν��cors�������ã�Ҳ����������ʵ�ֵ�
+    if (hasCorsConfigurationSource(handler)) {
+        CorsConfiguration config = (this.corsConfigurationSource != null 
+                ? this.corsConfigurationSource.getCorsConfiguration(request) : null);
+        CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
+        config = (config != null ? config.combine(handlerConfig) : handlerConfig);
+        // ��������ص��������ӵ� Interceptors���ӵ�������List�ĵ�һ����
+        executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
+    }
+    return executionChain;
+}
+
+```
+
+���������Ҫ���������£�
+
+1.  ���þ����ʵ��ȥ��ȡ handler������������ص㣬������������
+2.  ��ȡ `executionChain`����� `executionChain` ���˰�������һ���� `handler` �⣬������ `uri` ��Ӧ�� `Interceptors`����ȡ����Ϊ��ȡ���е� `Interceptors` ���ã��� `WebMvcConfigurationSupport` �����õģ�������һ�ж� uri �Ƿ���� `Interceptor` �� uri ���ã�
+3.  ��ȡ cors �������ã�Ȼ�����ӵ� `executionChain` �е� `Interceptors` �б��ĵ�һλ���ţ�û����cors ��������Ҳ���� `WebMvcConfigurationSupport` �����õġ�
+
+#### 3.1 ���� `HandlerMethod`
+
+���ǽ��� `getHandlerInternal(xxx)` ������
+
+> AbstractHandlerMethodMapping#getHandlerInternal
+
+```
+@Override
+protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
+    // ��ȡ�����url
+    String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
+    request.setAttribute(LOOKUP_PATH, lookupPath);
+    this.mappingRegistry.acquireReadLock();
+    try {
+        // ���������uri��Ӧ��handlerMethod
+        HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
+        // ���handlerMethod��Ϊ�գ������´���һ��HandlerMethod����
+        return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
+    }
+    finally {
+        this.mappingRegistry.releaseReadLock();
+    }
+}
+
+```
+
+���ﻹ�ǵ��� `lookupHandlerMethod(xxx)` ������ `handlerMethod`������
+
+> AbstractHandlerMethodMapping#lookupHandlerMethod
+
+```
+protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) 
+        throws Exception {
+    List<Match> matches = new ArrayList<>();
+    // �ȴ�urlLookup���ң�urlLookup��һ��map��key��url��value��LinkedList<RequestMappingInfo>
+    List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
+    if (directPathMatches != null) {
+        // ���ڷ��ص���һ�� list�����������е�ƥ��Ľ������һ��matches��
+        addMatchingMappings(directPathMatches, matches, request);
+    }
+    if (matches.isEmpty()) {
+        // ���ͨ��urlû�ҵ�����������е� mappings ƥ�䣬ƥ�������� /test/{name} ��url
+        // mappingsҲ��һ��map��key��RequestMappingInfo�� value��HandlerMethod
+        addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
+    }
+    // �ҵ����ƥ���mapping,�������Ӧ��HandlerMethod
+    // �ȽϹ��������� RequestMappingInfo#compareTo����
+    if (!matches.isEmpty()) {
+        Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
+        matches.sort(comparator);
+        Match bestMatch = matches.get(0);
+        if (matches.size() > 1) {
+            if (CorsUtils.isPreFlightRequest(request)) {
+                return PREFLIGHT_AMBIGUOUS_MATCH;
+            }
+            Match secondBestMatch = matches.get(1);
+            // �ҵ����������ƥ�䣬�׳��쳣
+            if (comparator.compare(bestMatch, secondBestMatch) == 0) {
+                Method m1 = bestMatch.handlerMethod.getMethod();
+                Method m2 = secondBestMatch.     .,m.bvc .getMethod();
+                String uri = request.getRequestURI();
+                throw new IllegalStateException(...);
+            }
+        }W
+        request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);
+        handleMatch(bestMatch.mapping, lookupPath, request);
+        return bestMatch.handlerMethod;
+    }
+    else {
+        return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
+    }
+}
+
+```
+
+����������Ǵ��� handler �Ļ�ȡ�ˡ�����Ļ�ȡ��Ϊ�������裺
+
+1.  �ȴ� `urlLookup` ���ң�`urlLookup` ��һ�� `map`��`key` �� `url`��`value` �� `LinkedList<RequestMappingInfo>`������������� `map.get(xxx)` ������
+2.  ���ͨ�� `url` û�ҵ�����������е� `mappings` ƥ�䣬ƥ�������� `/test/{name}` �� `url`��`mappings` Ҳ��һ�� `map`��`key` �� `RequestMappingInfo`�� `value` �� `HandlerMethod`��
+3.  ����ҵ��˶�� `HandlerMethod`������� `RequestMappingInfo#compareTo` �����ṩ�ķ������ҵ���ѵ� `RequestMappingInfo` ��Ӧ�� `HandlerMethod`��
+
+������������ `mappings` ��������ҵ�ƥ��� `RequestMappingInfo` �ģ�
+
+> AbstractHandlerMethodMapping#addMatchingMappings
+
+```
+private void addMatchingMappings(Collection<T> mappings, List<Match> matches, 
+            HttpServletRequest request) {
+    for (T mapping : mappings) {
+        // ƥ�������������ҵ��������з��������� mappings
+        T match = getMatchingMapping(mapping, request);
+        if (match != null) {
+            matches.add(new Match(match, this.mappingRegistry.getMappings().get(mapping)));
+        }
+    }
+}
+
+```
+
+���շ���ƥ��Ĵ������� `RequestMappingInfo#getMatchingCondition` �����У�`RequestMappingInfo` ����һ�� `compareTo` ����������Ҳһ���鿴�£�
+
+> RequestMappingInfo
+
+```
+/**
+ * ƥ�����
+ * ��ֱ�ƥ�� ���󷽷�(get,post��)���������������ͷ��
+ */
+public RequestMappingInfo getMatchingCondition(HttpServletRequest request) {
+    RequestMethodsRequestCondition methods = this.methodsCondition.getMatchingCondition(request);
+    if (methods == null) {
+        return null;
+    }
+    ParamsRequestCondition params = this.paramsCondition.getMatchingCondition(request);
+    if (params == null) {
+        return null;
+    }
+    HeadersRequestCondition headers = this.headersCondition.getMatchingCondition(request);
+    if (headers == null) {
+        return null;
+    }
+    ConsumesRequestCondition consumes = this.consumesCondition.getMatchingCondition(request);
+    if (consumes == null) {
+        return null;
+    }
+    ProducesRequestCondition produces = this.producesCondition.getMatchingCondition(request);
+    if (produces == null) {
+        return null;
+    }
+    PatternsRequestCondition patterns = this.patternsCondition.getMatchingCondition(request);
+    if (patterns == null) {
+        return null;
+    }
+    RequestConditionHolder custom = this.customConditionHolder.getMatchingCondition(request);
+    if (custom == null) {
+        return null;
+    }
+    return new RequestMappingInfo(this.name, patterns,
+            methods, params, headers, consumes, produces, custom.getCondition());
+}
+
+/**
+ * �ȽϹ����ҵ����ƥ��
+ * ��ֱ�Ƚ� ���󷽷�(get,post��)���������������ͷ��
+ */
+public int compareTo(RequestMappingInfo other, HttpServletRequest request) {
+    int result;
+    if (HttpMethod.HEAD.matches(request.getMethod())) {
+        result = this.methodsCondition.compareTo(other.getMethodsCondition(), request);
+        if (result != 0) {
+            return result;
+        }
+    }
+    result = this.patternsCondition.compareTo(other.getPatternsCondition(), request);
+    if (result != 0) {
+        return result;
+    }
+    result = this.paramsCondition.compareTo(other.getParamsCondition(), request);
+    if (result != 0) {
+        return result;
+    }
+    result = this.headersCondition.compareTo(other.getHeadersCondition(), request);
+    if (result != 0) {
+        return result;
+    }
+    result = this.consumesCondition.compareTo(other.getConsumesCondition(), request);
+    if (result != 0) {
+        return result;
+    }
+    result = this.producesCondition.compareTo(other.getProducesCondition(), request);
+    if (result != 0) {
+        return result;
+    }
+    result = this.methodsCondition.compareTo(other.getMethodsCondition(), request);
+    if (result != 0) {
+        return result;
+    }
+    result = this.customConditionHolder.compareTo(other.customConditionHolder, request);
+    if (result != 0) {
+        return result;
+    }
+    return 0;
+}
+
+```
+
+����ƥ�䣬���DZȽϣ���������󷽷� (get,post ��)���������������ͷ��һһ���д�����
+
+��������Ǿ������� springmvc ������ҵ� `HandlerMethod` ���ˡ�
+
+#### 3.2 ���� `Interceptors`
+
+���ǻص� `AbstractHandlerMapping#getHandler`����������λ�ȡ `Interceptor` �ģ�
+
+```
+public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
+    ...
+    // 2\. ��ȡ executionChain����ʵ�����ҵ� uri ��Ӧ�� Interceptors,
+    // Ȼ���������ҵ���handlerһ���װ��HandlerExecutionChain������
+    // �����Interceptors��Ҳ����WebMvcConfigurationSupport�����õ�
+    HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
+    ...
+    return executionChain;
+}
+
+```
+
+���� `getHandlerExecutionChain` ������
+
+> AbstractHandlerMapping#getHandlerExecutionChain
+
+```
+protected HandlerExecutionChain getHandlerExecutionChain(Object handler, 
+            HttpServletRequest request) {
+    HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
+            (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
+    // ��ȡ��ǰ������·��
+    String lookupPath = this.urlPathHelper.getLookupPathForRequest(request, LOOKUP_PATH);
+    for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
+        if (interceptor instanceof MappedInterceptor) {
+            MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
+            // �жϵ�ǰ����·���Ƿ�����interceptor�����õ�·��
+            if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
+                chain.addInterceptor(mappedInterceptor.getInterceptor());
+            }
+        }
+        else {
+            chain.addInterceptor(interceptor);
+        }
+    }
+    return chain;
+}
+
+```
+
+��������Ƚϼ򵥣���������Ѿ��ڴ���������ע�ͣ��Ͳ���˵�� ��
+
+#### 3.3 ���� cors ��������
+
+�������������������õĴ�����
+
+```
+public final HandlerExecutionChain getHandler(HttpServletRequest request) 
+        throws Exception {
+    ...
+    // 3\. ����·����ص����ã�CorsHandlerExecutionChain
+    // ������Կ�������ν��cors�������ã�Ҳ����������ʵ�ֵ�
+    if (hasCorsConfigurationSource(handler)) {
+        // ��ȡ��������
+        CorsConfiguration config = (this.corsConfigurationSource != null 
+                ? this.corsConfigurationSource.getCorsConfiguration(request) : null);
+        CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
+        config = (config != null ? config.combine(handlerConfig) : handlerConfig);
+        // ��������ص��������ӵ� Interceptors���ӵ�������List�ĵ�һ����
+        executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
+    }
+    return executionChain;
+}
+
+```
+
+�����������Ҳ���� `WebMvcConfigurationSupport` �����ã�
+
+```
+protected void addCorsMappings(CorsRegistry registry) {
+    ...
+}
+
+```
+
+springmvc ��ȡ���������ú󣬻������������ӵ� `HandlerExecutionChain` �У�
+
+```
+# AbstractHandlerMapping#getCorsHandlerExecutionChain
+protected HandlerExecutionChain getCorsHandlerExecutionChain(HttpServletRequest request,
+        HandlerExecutionChain chain, @Nullable CorsConfiguration config) {
+    if (CorsUtils.isPreFlightRequest(request)) {
+        HandlerInterceptor[] interceptors = chain.getInterceptors();
+        chain = new HandlerExecutionChain(new PreFlightHandler(config), interceptors);
+    }
+    else {
+        // ���ӵ�Interceptors����λ
+        chain.addInterceptor(0, new CorsInterceptor(config));
+    }
+    return chain;
+}
+
+# HandlerExecutionChain#addInterceptor(int, HandlerInterceptor)
+public void addInterceptor(int index, HandlerInterceptor interceptor) {
+    // ��ʵ���Dz���һ��list
+    initInterceptorList().add(index, interceptor);
+}
+
+```
+
+�� `HandlerExecutionChain` �У���һ�� `List` �������� `Interceptor`����ȡ���Ŀ������ã������ӵ���� `List` �� `index=0` ��λ�á�
+
+�����`handler` �ͻ�ȡ����ˣ���� `handler` ���������֣�
+
+*   `HandlerMethod`: ��������ķ��������ڱ���ֻ���� `@Controller` ��ʽ�� controller�����Լ�����Ϊ�� `@RequestMapping` ע��ķ�����
+*   `List<Interceptor>`: ��������������п������ã���ô�������û������� List �ĵ�һλ��
+
+### 4\. ��ȡ `HandlerAdapter`
+
+�ٻص� `DispatcherServlet#doDispatch` ������������������ȡ `HandlerAdapter` �ķ�����
+
+```
+protected void doDispatch(HttpServletRequest request, HttpServletResponse response) 
+        throws Exception {
+            ...
+    // 2\. ��ȡ��Ӧ��handlerAdapter���������� handler(xxx)
+    HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
+    ...
+
+```
+
+���� `getHandlerAdapter(xxx)` ������
+
+> DispatcherServlet#getHandlerAdapter
+
+```
+protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
+    // handlerAdapters ���bean��Ҳ����WebMvcConfigurationSupport�����
+    if (this.handlerAdapters != null) {
+        for (HandlerAdapter adapter : this.handlerAdapters) {
+            // ��ͬ��handlerAdapter���жϷ�����ͬ
+            if (adapter.supports(handler)) {
+                return adapter;
+            }
+        }
+    }
+    throw new ServletException(...);
+}
+
+```
+
+���Կ�����������ҵ���ǰ���е� `adapter`��Ȼ�����������ж��Ƿ��ܴ�����ǰ�� `handler`�����е� `adapter` ���£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-dedb2d58b9e99091aeb559f6c5a4aab4ccc.png)
+
+������������ж��Ƿ��ܴ�����ǰ�� `handler` �ģ����ǿ�����һ�� `handler`������ `AbstractHandlerMethodAdapter#supports` ������
+
+> AbstractHandlerMethodAdapter#supports
+
+```
+@Override
+public final boolean supports(Object handler) {
+    // �ж�handler�Ƿ�ΪHandlerMethod��ʵ��
+    return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler));
+}
+
+```
+
+���������һ���򵥵��жϣ�Ȼ���ٵ��� `supportsInternal` ������������
+
+> RequestMappingHandlerAdapter#supportsInternal
+
+```
+protected boolean supportsInternal(HandlerMethod handlerMethod) {
+    return true;
+}
+
+```
+
+�������ֱ�ӷ��� true, ���ڿɼ������ `handler` ��ʵ���� `HandlerMethod`����ô�ͻ᷵�� `RequestMappingHandlerAdapter`.
+
+��һ���ҵ��� `adapter` Ϊ `RequestMappingHandlerAdapter`����� `adapter` ��ʲô���أ�����ƪ�������ľ��ȵ������ˣ�ʣ�µ�������ƪ���¼���������
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4717420](https://my.oschina.net/funcy/blog/4717420) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/\350\257\267\346\261\202\346\211\247\350\241\214\346\265\201\347\250\213\357\274\210\344\272\214\357\274\211\344\271\213\346\211\247\350\241\214Handler\346\226\271\346\263\225.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/\350\257\267\346\261\202\346\211\247\350\241\214\346\265\201\347\250\213\357\274\210\344\272\214\357\274\211\344\271\213\346\211\247\350\241\214Handler\346\226\271\346\263\225.md"
new file mode 100644
index 0000000..daed837
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\220/\350\257\267\346\261\202\346\211\247\350\241\214\346\265\201\347\250\213\357\274\210\344\272\214\357\274\211\344\271\213\346\211\247\350\241\214Handler\346\226\271\346\263\225.md"
@@ -0,0 +1,668 @@
+������ **springmvc ����ִ������**�ĵڶ�ƪ���£�����һƪ�����У����Ƿ����� `DispatcherServlet#doDispatch` �������ܽ������ִ�з�Ϊ���²��裺
+
+1.  ��ȡ��Ӧ�� `HandlerExecutionChain`, ��ȡ�� `HandlerExecutionChain` �а��������ش�������`Controller` �еķ�������һ�� `HandlerInterceptor` ��������
+2.  ��ȡ��Ӧ�� `handlerAdapter`���ö����������� `handler(xxx)` ������
+3.  ִ�� spring �������������� `HandlerInterceptor#preHandle` ������
+4.  ��������Ҳ����ͨ�������ȡ���� `handlerAdapter` ������ `handle(xxx)` ������
+5.  ִ�� spring �������������� `HandlerInterceptor#postHandle` ������
+6.  �������ؽ�����������Ⱦ��ͼ���Լ�ִ�� spring �������� `HandlerInterceptor#afterCompletion`��
+
+���ţ����Ǽ������� `HandlerExecutionChain` �Ļ�ȡ�Լ� `handlerAdapter` �Ļ�ȡ������ϻأ����Ľ����������������IJ��衣
+
+### 5\. ִ�� spring ����������`HandlerInterceptor#preHandle`
+
+```
+protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
+    ...
+    // 3\. ����spring��������, ���� HandlerInterceptor#preHandle ����
+    // ���mappedHandler�����ǵ�1����ȡ��HandlerExecutionChain
+    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
+        return;
+    }
+    ...
+}
+
+```
+
+����� `mappedHandler`�����ǵ� 1 ����ȡ�� `HandlerExecutionChain`������ `HandlerExecutionChain#applyPreHandle`��
+
+> HandlerExecutionChain#applyPreHandle
+
+```
+/**
+ * ִ�� HandlerInterceptor#preHandle ����
+ */
+boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) 
+        throws Exception {
+    // ��ȡ���е�������
+    HandlerInterceptor[] interceptors = getInterceptors();
+    if (!ObjectUtils.isEmpty(interceptors)) {
+        // ����ִ�� preHandle ����
+        for (int i = 0; i < interceptors.length; i++) {
+            HandlerInterceptor interceptor = interceptors[i];
+            if (!interceptor.preHandle(request, response, this.handler)) {
+                // ʧ���ˣ��������ִ�� HandlerInterceptor#afterCompletion ����
+                triggerAfterCompletion(request, response, null);
+                return false;
+            }
+            this.interceptorIndex = i;
+        }
+    }
+    return true;
+}
+
+/**
+ * ִ�� HandlerInterceptor#afterCompletion ����
+ * Ϊ�˱�֤HandlerInterceptor#afterCompletion��ִ�У�
+ * �������ķ����ῴ��������������ڶ���������õ�
+ */
+void triggerAfterCompletion(HttpServletRequest request, 
+        HttpServletResponse response, @Nullable Exception ex) throws Exception {
+    HandlerInterceptor[] interceptors = getInterceptors();
+    if (!ObjectUtils.isEmpty(interceptors)) {
+        // ����ִ�� HandlerInterceptor#afterCompletion ����
+        for (int i = this.interceptorIndex; i >= 0; i--) {
+            HandlerInterceptor interceptor = interceptors[i];
+            try {
+                interceptor.afterCompletion(request, response, this.handler, ex);
+            }
+            catch (Throwable ex2) {
+                logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
+            }
+        }
+    }
+}
+
+```
+
+��������һ�� `HandlerExecutionChain`��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-40ba62630b5d83a16ed9aba35aba48af8be.png)
+
+������������ `HandlerInterceptor` �� `handler` ��ɶ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-6c50a936804c1db4a7b817dbb5ff417034d.png)
+
+��� `handler` ���� `HandlerMethod`�������������Ϣ����ͦ�ḻ�ģ��� `bean`/`beanFactory`/`method`�������⼸�����ԣ����ǿ��Զ�����и��ֲ�����
+
+### 6\. ������ִ�У�`AbstractHandlerMethodAdapter#handle`
+
+�����ٻص� `DispatcherServlet#doDispatch`��ִ���� `HandlerInterceptor#preHandle` �����󣬾��������������е���ͷϷ��`handler` ��ִ�У�Ҳ���� `controller` �У�`url` ��Ӧ�ķ���ִ�У�
+
+```
+protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
+    ...
+    // 4\. ͨ�������ȡ����handlerAdapter������handle
+    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
+    ...
+}
+
+```
+
+һ·����ȥ������������ `RequestMappingHandlerAdapter#invokeHandlerMethod` ������
+
+```
+protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
+        HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
+    // ��װreques��request����
+    ServletWebRequest webRequest = new ServletWebRequest(request, response);
+    try {
+        // ��ȡ @InitBinder ע��ķ�����
+        // ������ǰcontroller�� @ControllerAdvice ��ע������� @InitBinder ע��ķ���
+        WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
+        // ��ȡ @ModelAttribute ע��ķ�����
+        // ������ǰcontroller�� @ControllerAdvice ��ע������� @ModelAttribute ע��ķ���
+        ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
+        // ��������ִ�ж���
+        ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
+        if (this.argumentResolvers != null) {
+            invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
+        }
+        if (this.returnValueHandlers != null) {
+            invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
+        }
+        invocableMethod.setDataBinderFactory(binderFactory);
+        invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
+        // ����ModelAndView������
+        ModelAndViewContainer mavContainer = new ModelAndViewContainer();
+        mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
+        modelFactory.initModel(webRequest, mavContainer, invocableMethod);
+        mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
+        // �����첽����
+        AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
+        asyncWebRequest.setTimeout(this.asyncRequestTimeout);
+        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
+        asyncManager.setTaskExecutor(this.taskExecutor);
+        asyncManager.setAsyncWebRequest(asyncWebRequest);
+        asyncManager.registerCallableInterceptors(this.callableInterceptors);
+        asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);
+        if (asyncManager.hasConcurrentResult()) {
+            Object result = asyncManager.getConcurrentResult();
+            mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
+            asyncManager.clearConcurrentResult();
+            LogFormatUtils.traceDebug(logger, traceOn -> {
+                String formatted = LogFormatUtils.formatValue(result, !traceOn);
+                return "Resume with async result [" + formatted + "]";
+            });
+            invocableMethod = invocableMethod.wrapConcurrentResult(result);
+        }
+        // ִ��Controller�ķ������ص㣩
+        invocableMethod.invokeAndHandle(webRequest, mavContainer);
+        if (asyncManager.isConcurrentHandlingStarted()) {
+            return null;
+        }
+        // �������ؽ��
+        return getModelAndView(mavContainer, modelFactory, webRequest);
+    }
+    finally {
+        webRequest.requestCompleted();
+    }
+}
+
+```
+
+��������е㳤�����ص㷽��ֻ��һ�У�`invocableMethod.invokeAndHandle(webRequest, mavContainer);`�����������ǰ�IJ��ֶ�����������ִ��ǰ��׼�����������ȡ `@InitBinder` ע��ķ�������ȡ `@ModelAttribute` ע��ķ�����׼���������� `webRequest`(��װ `request` �� `response` ����) �� `mavContainer`(`ModelAndView` ��װ����) �ȡ���������ֱ�ӽ��� `invocableMethod.invokeAndHandle`���������������ִ�еģ�
+
+> ServletInvocableHandlerMethod#invokeAndHandle
+
+```
+public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
+        Object... providedArgs) throws Exception {
+    // ִ��handler����
+    Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
+    // ���� RequestHandled ����ֵ��springmvc����ݸ�ֵ�ж�Ҫ��Ҫ��ת
+    if (returnValue == null) {
+        if (isRequestNotModified(webRequest) || getResponseStatus() != null 
+                || mavContainer.isRequestHandled()) {
+            disableContentCachingIfNecessary(webRequest);
+            mavContainer.setRequestHandled(true);
+            return;
+        }
+    }
+    else if (StringUtils.hasText(getResponseStatusReason())) {
+        mavContainer.setRequestHandled(true);
+        return;
+    }
+    mavContainer.setRequestHandled(false);
+    Assert.state(this.returnValueHandlers != null, "No return value handlers");
+    try {
+        // �������ؽ��
+        this.returnValueHandlers.handleReturnValue(
+                returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
+    }
+    catch (Exception ex) {
+        throw ex;
+    }
+}
+
+```
+
+���﷽�����ǵ����� `invokeForRequest` ִ�з�����Ȼ���ٸ��ݷ����ķ���ֵ������ `mavContainer` �� `RequestHandled` ֵ����������ؽ������������ `invokeForRequest` ������
+
+> InvocableHandlerMethod#invokeForRequest
+
+```
+@Nullable
+public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainermavContainer,
+        Object... providedArgs) throws Exception {
+    // ����������
+    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
+    // ������÷���
+    return doInvoke(args);
+}
+
+```
+
+������������Ǵ����˲���������Ȼ��ʹ�÷�����з������á���ʵ�ϣ�����ִ�������У�����ĵľ��Dz��������ˣ��� controller ��� handler �����У����ǿ�������ָ��������
+
+```
+// ֱ�Ӵ���
+@RequestMapping("xxx")
+public Object test(String name) {
+    ...
+}
+
+// �ڲ����ϱ���@RequestParam��@RequestHeader��ע��
+@RequestMapping("xxx")
+public Object test(@RequestParam("name") String name, 
+                   @RequestHeader("uid") String uid) {
+    ...
+}
+
+// ������IJ�����װΪ����
+@RequestMapping("xxx")
+public Object test(User user) {
+    ...
+}
+
+// ����ķ�������ʹ��form��������(Ҳ����k1=v1&2=v2&...�ķ���)
+// �������ʹ�� RequestBody ��ʽ���Σ����������ݷ�����Ϣ����
+@RequestMapping("xxx")
+public Object test(@RequestBody User user) {
+    ...
+}
+
+...
+
+```
+
+�����ǰ��淶�������ʱ��springmvc ������������������������ springmvc �����������һ��ġ�
+
+#### ��������
+
+���������� `InvocableHandlerMethod#getMethodArgumentValues` ������
+
+> InvocableHandlerMethod#getMethodArgumentValues
+
+```
+protected Object[] getMethodArgumentValues(NativeWebRequest request, 
+        @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
+    // ��ȡ���������в��������Լ�����Ϊ���÷����ȡhandler����������Ȼ���װΪ MethodParameter
+    MethodParameter[] parameters = getMethodParameters();
+    if (ObjectUtils.isEmpty(parameters)) {
+        return EMPTY_ARGS;
+    }
+    Object[] args = new Object[parameters.length];
+    // ���δ���ÿ������
+    for (int i = 0; i < parameters.length; i++) {
+        MethodParameter parameter = parameters[i];
+        parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
+        args[i] = findProvidedArgument(parameter, providedArgs);
+        if (args[i] != null) {
+            continue;
+        }
+        // �ж��Ƿ��в���������֧�ֵ�ǰ�����Ľ���
+        if (!this.resolvers.supportsParameter(parameter)) {
+            throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
+        }
+        try {
+            // ������������
+            args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, 
+                    this.dataBinderFactory);
+        }
+        catch (Exception ex) {
+            throw ex;
+        }
+    }
+    return args;
+}
+
+```
+
+��������Ȼ�ȡ�� handler �����IJ��� (���Լ�����Ϊ���÷����ȡ handler ����������Ȼ���װΪ `MethodParameter`)��Ȼ�����Щ�����������������ʱ�����õ�������Ҫ�ķ�����`resolvers.supportsParameter(...)` �� `resolvers.resolveArgument(...)`���������������յ��õķ����� `HandlerMethodArgumentResolverComposite` �У�
+
+> HandlerMethodArgumentResolverComposite
+
+```
+@Nullable
+public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainermavContainer,
+        NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
+    // ��ȡһ��������
+    HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
+    if (resolver == null) {
+        throw new IllegalArgumentException(...);
+    }
+    // �������������� HandlerMethodArgumentResolver#resolveArgument ����
+    return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
+}
+
+private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
+    HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
+    if (result == null) {
+        // �������еĽ�����
+        for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
+            // �ҵ�����һ��������������
+            // ���� HandlerMethodArgumentResolver#supportsParameter ����
+            if (resolver.supportsParameter(parameter)) {
+                result = resolver;
+                this.argumentResolverCache.put(parameter, result);
+                break;
+            }
+        }
+    }
+    return result;
+}
+
+```
+
+������������Ҫ�DZ�����������Ȼ����� `HandlerMethodArgumentResolver#supportsParameter` �� `HandlerMethodArgumentResolver#resolveArgument` ��������IJ�����`HandlerMethodArgumentResolver` �Ǹ��ӿڣ������������������
+
+```
+public interface HandlerMethodArgumentResolver {
+    /**
+     * ��ǰ�Ƿ�֧�ִ�����ǰ����
+     */
+    boolean supportsParameter(MethodParameter parameter);
+
+    /**
+     * ����Ľ�������
+     */
+    @Nullable
+    Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
+            NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;
+}
+
+```
+
+������������IJ����������ˡ��� springmvc �У��ṩ�˶����ֲ����������أ��������˵ĵ��ԣ����ֶ�� 26 ����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-fd30bc847fc2cf7082de3731e68df6ae5f9.png) ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-894b391bbe4567734ee7237d900bc55ee31.png)
+
+��������Щ�����������İ����£�springmvc ��֧�ֶ��ֲ������շ�ʽ�����ڲ�����������������ƱȽϸ��ӣ��漰���ִ��η�ʽ�����IJ�����չ�����ۣ�����Ȥ��С�������в�������ĵ���
+
+#### ִ�� handler ����
+
+��������������󣬾Ϳ�ʼִ�� handler �����ˡ������ǻص� `InvocableHandlerMethod#invokeForRequest` ������
+
+> InvocableHandlerMethod#invokeForRequest
+
+```
+@Nullable
+public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainermavContainer,
+        Object... providedArgs) throws Exception {
+    // ����������
+    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
+    // ������÷���
+    return doInvoke(args);
+}
+
+```
+
+���� `doInvoke` ������
+
+```
+@Nullable
+protected Object doInvoke(Object... args) throws Exception {
+    // ʹ�÷���ִ�з���
+    ReflectionUtils.makeAccessible(getBridgedMethod());
+    try {
+        // ������Ƿ������
+        return getBridgedMethod().invoke(getBean(), args);
+    }
+    catch (...) {
+        ...
+    }
+}
+
+```
+
+��������ܼ򵥣��������÷��������з���ִ�еģ��Ͳ���������ˡ�
+
+#### �������ز���
+
+�����ǻص� `ServletInvocableHandlerMethod#invokeAndHandle` ������
+
+> ServletInvocableHandlerMethod#invokeAndHandle
+
+```
+public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
+        Object... providedArgs) throws Exception {
+    // ִ��handle����
+    Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
+    ...
+    try {
+        // �������ؽ��
+        this.returnValueHandlers.handleReturnValue(
+                returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
+    }
+    catch (Exception ex) {
+        throw ex;
+    }
+}
+
+```
+
+�����귽��ִ�к󣬽��žʹ������ؽ����
+
+> HandlerMethodReturnValueHandlerComposite#handleReturnValue
+
+```
+@Override
+public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
+        ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
+    // ���ݷ���������һ�����ʵ�handler��������������
+    HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
+    if (handler == null) {
+        throw new IllegalArgumentException(...);
+    }
+    handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
+}
+
+@Nullable
+private HandlerMethodReturnValueHandler selectHandler(@Nullable Object value, MethodParameterreturnType) {
+    boolean isAsyncValue = isAsyncReturnValue(value, returnType);
+    // ����������ж��Ƿ��ܴ�����ǰ��������
+    for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) {
+        if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) {
+            continue;
+        }
+        if (handler.supportsReturnType(returnType)) {
+            return handler;
+        }
+    }
+    return null;
+}
+
+```
+
+��ȡ `ReturnValueHandler` ����·��ǰ���ȡ `ArgumentResolver` ����·����޼���`ReturnValueHandler` �� `HandlerMethodReturnValueHandler` �����࣬`HandlerMethodReturnValueHandler` �������£�
+
+```
+public interface HandlerMethodReturnValueHandler {
+
+    /**
+     * �жϵ�ǰReturnValueHandler�ܷ��������returnType
+     */
+    boolean supportsReturnType(MethodParameter returnType);
+
+    /**
+     * ����Ĵ����߼�
+     */
+    void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
+            ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception;
+
+}
+
+```
+
+ͬǰ�����������һ��������ӿ���Ҳ������������
+
+*   `boolean supportsReturnType(xxx)`���жϵ�ǰ `ReturnValueHandler` �ܷ�������� `returnType`
+*   `void handleReturnValue(xxx)`������Ĵ����߼�
+
+ͬ���أ�springmvc Ҳ�ṩ�˷dz����ʵ�����������ز�����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-8e3c1fd4dca7c13efbceac5800e26145963.png)
+
+���ڲ����ķ��أ���������һ���򵥵�ʾ����
+
+�����������������ֵʱ��
+
+```
+@Controller
+@RequestMapping("/xxx")
+public class XxxController {
+
+    @RequestMapping("/index")
+    public String index() {
+        return "index";
+    }
+}
+
+```
+
+���ص�ҳ��Ľ���һ����ͼ����Ӧ�� `HandlerMethodReturnValueHandler` Ϊ `ViewNameMethodReturnValueHandler`��
+
+```
+public class ViewNameMethodReturnValueHandler implements HandlerMethodReturnValueHandler {
+
+    @Nullable
+    private String[] redirectPatterns;
+
+    // ʡ�� redirectPatterns ��setter��getter����
+    ...
+
+    @Override
+    public boolean supportsReturnType(MethodParameter returnType) {
+        Class<?> paramType = returnType.getParameterType();
+        // ֧�ִ����ķ���ֵ���ͣ�����ֵ����Ϊvoid������Ϊ�ַ�������
+        return (void.class == paramType || CharSequence.class.isAssignableFrom(paramType));
+    }
+
+    /**
+     * ����Ĵ����߼�
+     */
+    @Override
+    public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
+            ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
+
+        if (returnValue instanceof CharSequence) {
+            // viewName ���Ƿ���ֵ
+            String viewName = returnValue.toString();
+            mavContainer.setViewName(viewName);
+            if (isRedirectViewName(viewName)) {
+                // �Ƿ���Ҫ��ת
+                mavContainer.setRedirectModelScenario(true);
+            }
+        }
+        else if (returnValue != null) {
+            throw new UnsupportedOperationException(...);
+        }
+    }
+
+    /**
+     * �ж��Ƿ���Ҫ��ת
+     */
+    protected boolean isRedirectViewName(String viewName) {
+        // this.redirectPatterns Ĭ��Ϊnull���������е��� setter ��������
+        return (PatternMatchUtils.simpleMatch(this.redirectPatterns, viewName) 
+            // ƥ�� redirect: ��ͷ��Ҳ����˵��������Ƿ��� "redirect:index"���ͱ����ý����Ҫ��ת
+            || viewName.startsWith("redirect:"));
+    }
+
+}
+
+```
+
+�����Ƚϼ򵥣��ؼ��������ڴ���������ע�ͣ�����Ͳ���˵�ˡ�ֵ��һ����ǣ��� `handleReturnValue(xxx)` �����У�springmvc �����ص��ַ�������Ϊ `viewName` ��Ҫע���£������ڴ�����ͼʱ����������� `viewName` �õ���Ӧ�� `View`��
+
+#### ��ȡ ModelAndView
+
+�����ǻص� `RequestMappingHandlerAdapter#invokeHandlerMethod` ������
+
+```
+@Nullable
+protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
+        HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
+    ServletWebRequest webRequest = new ServletWebRequest(request, response);
+    try {
+        ...
+        // ִ��Controller�ķ���
+        invocableMethod.invokeAndHandle(webRequest, mavContainer);
+        if (asyncManager.isConcurrentHandlingStarted()) {
+            return null;
+        }
+        // ����ִ�н���������õ� ModelAndView
+        return getModelAndView(mavContainer, modelFactory, webRequest);
+    }
+    finally {
+        webRequest.requestCompleted();
+    }
+}
+
+```
+
+ִ���� `invocableMethod.invokeAndHandle(webRequest, mavContainer)` ��������ž��Ǵ�ִ�н�����õ� `ModelAndView` �ˣ����� `RequestMappingHandlerAdapter#getModelAndView` ������
+
+```
+private ModelAndView getModelAndView(ModelAndViewContainer mavContainer,
+        ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {
+    // ��� ModelFactory������ǰ���ȡ�� ����@ModelAttribute ע��ķ���
+    modelFactory.updateModel(webRequest, mavContainer);
+    if (mavContainer.isRequestHandled()) {
+        return null;
+    }
+    ModelMap model = mavContainer.getModel();
+    // ������ͼ���󣬰�mavContainer.getViewName()���뵽ModelAndView�Ĺ��췽����
+    ModelAndView mav = new ModelAndView(mavContainer.getViewName(), 
+            model, mavContainer.getStatus());
+    if (!mavContainer.isViewReference()) {
+        mav.setView((View) mavContainer.getView());
+    }
+    // �����ض������
+    if (model instanceof RedirectAttributes) {
+        Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
+        HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
+        if (request != null) {
+            RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
+        }
+    }
+    return mav;
+}
+
+```
+
+���Կ�����`ModelAndView` ���Ǵ�ǰ��ִ�н���� `viewName` �õ��ġ�
+
+���ˣ�`AbstractHandlerMethodAdapter#handle` ִ����ϡ�
+
+### 7\. ִ����������`HandlerInterceptor#postHandle`
+
+�������ٻص� `DispatcherServlet#doDispatch` ������
+
+> DispatcherServlet#doDispatch
+
+```
+protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
+    ...
+
+    try {
+        ...
+        try {
+            ...
+            // 4.ͨ�������ȡ����handlerAdapter������handle
+            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
+            // 5.�����������û�з�����ͼ��ʹ��Ĭ�ϵ�
+            applyDefaultViewName(processedRequest, mv);
+            // 6\. ִ�������������� HandlerInterceptor#postHandle ����
+            mappedHandler.applyPostHandle(processedRequest, response, mv);
+        }
+        catch (...) {
+            ...
+        }
+        // 7\. �������ؽ����������������ִ�� HandlerInterceptor.afterCompletion
+        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
+    }
+    catch (...) {
+        ...
+    }
+}
+
+```
+
+ִ���� `handler` �����󣬾Ϳ�ʼִ���������� `HandlerInterceptor#postHandle` �����ˣ�
+
+> HandlerExecutionChain#applyPostHandle
+
+```
+void applyPostHandle(HttpServletRequest request, HttpServletResponse response, 
+        @NullableModelAndView mv) throws Exception {
+    HandlerInterceptor[] interceptors = getInterceptors();
+    if (!ObjectUtils.isEmpty(interceptors)) {
+        // ����ִ�� postHandle(...) ����
+        for (int i = interceptors.length - 1; i >= 0; i--) {
+            HandlerInterceptor interceptor = interceptors[i];
+            interceptor.postHandle(request, response, this.handler, mv);
+        }
+    }
+}
+
+```
+
+���ͬǰ��ִ���������������ƣ�����Ͳ���������ˡ���Ҫǿ�����ǣ�`HandlerInterceptor#postHandle` ��ִ��ʱ����**��ִ���� `handler` ������֮������ͼ����֮ǰ**����ˣ����ǿ���������������������ﴦ��һЩ�������Ⱦ������
+
+����ƪ�������ľ��ȵ������ˣ�request ִ�еĺ������̣�������ƪ�����ٷ�����
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4741104](https://my.oschina.net/funcy/blog/4741104) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/AOP\347\244\272\344\276\213demo\345\217\212@EnableAspectJAutoProxy.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/AOP\347\244\272\344\276\213demo\345\217\212@EnableAspectJAutoProxy.md"
new file mode 100644
index 0000000..841ee00
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/AOP\347\244\272\344\276\213demo\345\217\212@EnableAspectJAutoProxy.md"
@@ -0,0 +1,230 @@
+在前面的文章中，我们成功的编译了 spring 源码，也构建了第一个 spring 测试 demo，接下来我们就基于[第一个 spring 源码调试 demo](https://my.oschina.net/funcy/blog/4533250 "第一个spring源码调试demo") 中的代码，来对 spring 源码进行源码分析。
+
+### 1\. spring 启动流程概览
+
+在前面 demo 的 `main()` 方法中，有这么一行：
+
+```
+ApplicationContext context =
+        new AnnotationConfigApplicationContext("org.springframework.learn.demo01");
+
+```
+
+这短短的一行就是 spring 的整个启动流程了。上面的代码中，声明了一个 `ApplicationContext` 类型的对象 `context`，右边使用其子类 `AnnotationConfigApplicationContext` 实例化，并在构造方法中传入了包名 `org.springframework.learn.demo01`，这个包名就表明了接下来要扫描哪些包。
+
+> 这里我们接触到了 spring 的第一个组件：`ApplicationContext`，关于 `ApplicationContext` 的分析，可以参考我的文章 [spring 组件（一）：ApplicationContext](https://my.oschina.net/funcy/blog/4597456 "spring组件（一）：ApplicationContext")。
+
+进入到 `AnnotationConfigApplicationContext`，代码如下：
+
+> AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
+
+```
+public AnnotationConfigApplicationContext(String... basePackages) {
+     // 1\. 调用无参构造函数，会先调用父类GenericApplicationContext的构造函数
+     // 2\. 父类的构造函数里面就是初始化DefaultListableBeanFactory，并且赋值给beanFactory
+     // 3\. 本类的构造函数里面，初始化了一个读取器：AnnotatedBeanDefinitionReader read，
+     //    一个扫描器ClassPathBeanDefinitionScanner scanner
+     // 4\. 这个scanner，就是下面 scan(basePackages) 调用的对象
+     this();
+
+     //对传入的包进行扫描，扫描完成后，会得到一个 BeanDefinition 的集合
+     scan(basePackages);
+
+     //启动spring，在这里完成spring容器的初始化操作，
+     //包括bean的实例化、属性注入，将bean保存到spring容器中等
+     refresh();
+}
+
+```
+
+这个类就三行，相关操作都已在代码中注释了，这里稍微再总结下，这段代码主要做了三件事：
+
+1.  调用无参构造，进行属性初始化
+2.  进行包扫描，得到 BeanDefinition
+3.  启用 spring 容器。
+
+接着，我们再来看看 spring 启动流程中，做了哪些事：
+
+> AbstractApplicationContext#refresh
+
+```
+public void refresh() throws BeansException, IllegalStateException {
+    // 使用synchronized是为了避免refresh() 还没结束，再次发起启动或者销毁容器引起的冲突
+    synchronized (this.startupShutdownMonitor) {
+        // 做一些准备工作，记录容器的启动时间、标记“已启动”状态、检查环境变量等
+        prepareRefresh();
+
+        // 初始化BeanFactory容器、注册BeanDefinition, 最终获得了DefaultListableBeanFactory
+        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
+
+        // 还是一些准备工作:
+        // 1\. 设置了一个类加载器
+        // 2\. 设置了bean表达式解析器
+        // 3\. 添加了属性编辑器的支持
+        // 4\. 添加了一个后置处理器：ApplicationContextAwareProcessor
+        // 5\. 设置了一些忽略自动装配的接口
+        // 6\. 设置了一些允许自动装配的接口，并且进行了赋值操作
+        // 7\. 在容器中还没有XX的bean的时候，帮我们注册beanName为XX的singleton bean
+        prepareBeanFactory(beanFactory);
+
+        try {
+            // Spring的一个扩展点. 如果有Bean实现了BeanFactoryPostProcessor接口，
+            // 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。
+            // 具体的子类可以在这步的时候添加特殊的 BeanFactoryPostProcessor 的实现类，来做些事
+            postProcessBeanFactory(beanFactory);
+
+            // 调用BeanFactoryPostProcessor各个实现类的postProcessBeanFactory(factory) 方法
+            invokeBeanFactoryPostProcessors(beanFactory);
+
+            // 扩展点,注册 BeanPostProcessor 的实现类，注意不是BeanFactoryPostProcessor
+            registerBeanPostProcessors(beanFactory);
+
+            // 初始化当前 ApplicationContext 的 MessageSource，用在国际化操作中
+            initMessageSource();
+
+            // 这个方法主要为初始化当前 ApplicationContext 的事件广播器
+            initApplicationEventMulticaster();
+
+            // 这也是spring的一个扩展点
+            onRefresh();
+
+            // Check for listener beans and register them.
+            // 注册事件监听器
+            registerListeners();
+
+            // 初始化所有的 singleton beans
+            finishBeanFactoryInitialization(beanFactory);
+
+            // 完成启动，
+            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.
+            // 销毁已经初始化的的Bean
+            destroyBeans();
+
+            // Reset 'active' flag.
+            // 重置 'active' 状态
+            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();
+        }
+    }
+}
+
+```
+
+这个方法虽然代码不多，但包含了 spring bean 的整个创建过程，每个方法做了些什么，在代码中都有注释，这里就不赘述了。
+
+实际上，`refresh()` 涵盖了 spring 整个创建 bean 的流程，在后面的文章中，我们也将重点展开这里面的方法来分析，在现阶段只需要大致了解这些方法做了什么事即可。
+
+整个流程总结如下：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-9307fefa65470e5c36ae6044631b5416aef.png)
+
+### 2\. spring 启动中 `beanFactory` 的变化
+
+本文中的源码解读就到这里了，接下来我们来看看，spring 启动中 `beanFactory` 有些什么变化。
+
+> `beanFactory` 是 spring 的重要组件之一，直译为 spring bean 工厂，是 spring 生产 bean 与保存 bean 的地方，关于 `beanFactory` 的详细分析，可以查看 [spring BeanFactory 分析](https://my.oschina.net/funcy/blog/4597529 "spring BeanFactory分析")。
+
+我们将断点打在 `AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)` 的 `this()` 方法上，然后运行 demo01 的 `main()` 方法：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-c3c672a675d9b06f03ea29cb31f6ed5d012.png)
+
+此时的变量中，并没有 `beanFactory`，我们自己添加 `beanFactory` 到调度窗口的变量列表中：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-e9d8ae8fdd3b02b2279376303e3eae4cf2f.png)
+
+这样就能看到对应的值了：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-44d1ade26f0cb667425b0dd99d82666877f.png)
+
+可以看到，此时的 `beanFactory` 为 null，表明 `beanFactory` 并未实例化，我们继续运行：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-664780be9dfef73c12a3f163b349e7e54d8.png)
+
+当运行完 `this()` 后，发现 `beanFactory` 已经有值了，类型为 `DefaultListableBeanFactory`。但是，在查看 `beanFactory` 对象时，发现 `beanFactory` 的属性太多了，我们应该重点关注啥呢？
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-1b617cf7edda29c652a7661d4be3779ec85.png)
+
+我们这部分主要关注 spring bean 的创建，因此只需要关注 `beanFactory` 的两个属性就可以了：
+
+*   beanDefinitionMap：存放 beanDefinition 的 map.
+*   singletonObjects：存放 spring bean 的 map，spring bean 创建后都存放在这里，也即直观上理解的 `spring 容器`.
+
+> `BeanDefinition` 是 spring 重要组件之一，为‘spring bean 的描述’，简单来说，就是说明了一个 spring bean 应该如何创建。关于 `BeanDefinition` 的详细分析，可以查看 [spring BeanDefinition 分析](https://my.oschina.net/funcy/blog/4597536)。
+
+我们手动添加变量，如下：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-0c6368478258f8b9f76b47fc1c85b02f13f.png)
+
+可以看到，此时的 `beanDefinitionMap` 中已经有 4 个对象了，显然是在 `this()` 方法中添加的，关于这块我们后面会分析。
+
+接着运行，发现 `beanDefinitionMap` 又多了两个：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-a493061fbd4b4066f9a4d91e91ff61e8c4e.png)
+
+这里的 `beanObj1` 与 `beanObj2` 就是我们自己的类了，由此可以判断出 **spring 就是在 `AnnotationConfigApplicationContext#scan` 方法中对包进行扫描的**。
+
+接下来，代码执行进入 `AbstractApplicationContext#refresh` 方法，我们一行行运行下去，发现运行到 `prepareBeanFactory(beanFactory);` 时，`singletonObjects` 中第一次出现了对象：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-8cebcb82f5a8754fd1bb4bb3eb3c57dda2d.png)
+
+可以看到，这里出现了 3 个类，基本都跟系统、环境相关，如 `environment` 是 spring 当前使用的环境 (`profile`)，`systemProperties` 当前系统的属性（操作系统、操作系统版本等）。
+
+继续往下运行，发现代码运行到 `invokeBeanFactoryPostProcessors(beanFactory)` 时，又多了 4 个类：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-baa09e51272baa384418cb2c82b9dfb079b.png)
+
+关于这几个类的作用，我们后面的文章中会分析，这里先不必管。继续往下运行，发现在 `registerBeanPostProcessors(beanFactory);` 中，又多了一个对象：
+
+```
+org.springframework.context.annotation.internalAutowiredAnnotationProcessor
+
+```
+
+这里我们依旧不用管这个对象，接着运行下去，可以看到在运行 `initMessageSource()` 时，又多了一个对象：
+
+```
+messageSource -> {DelegatingMessageSource@1847} "Empty MessageSource"
+
+```
+
+显然，这个对象是用来处理国际化问题的，不过由于 demo01 中并没有用到国际化，所以这里显示 `Empty MessageSource`。继续运行，发现运行到 `initApplicationEventMulticaster();` 时，又多了一个对象：
+
+```
+applicationEventMulticaster -> {SimpleApplicationEventMulticaster@1869} 
+
+```
+
+显然，这个对象是用来处理 `ApplicationContext` 的广播事件的，我们的 demo 中并没有用到，暂时不必理会。继续下去，发现在运行完 `finishBeanFactoryInitialization(beanFactory);`，`singletonObjects` 中终于出现了我们期待的对象：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-68b1ee71e468ef8cf839230c07b64c45563.png)
+
+由此可见，对象就是在该方法中创建的。
+
+### 总结
+
+1.  spring 包的描述：`AnnotationConfigApplicationContext#scan`
+2.  spring bean 的创建：`AbstractApplicationContext#finishBeanFactoryInitialization`
+
+本文主要是了解 spring 启动流程，从整体上把握 spring 启动过程中的 beanFactory 的变化。本文意在了解 spring 的整体启动流程，后续的分析中，我们将对这些流程进行展开分析。
+
+* * *
+
+_本文原文链接：[https://my.oschina.net/funcy/blog/4597493](https://my.oschina.net/funcy/blog/4597493) ，限于作者个人水平，文中难免有错误之处，欢迎指正！原创不易，商业转载请联系作者获得授权，非商业转载请注明出处。_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/AnnotationAwareAspectJAutoProxyCreator\345\210\206\346\236\220\357\274\210\344\270\212\357\274\211.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/AnnotationAwareAspectJAutoProxyCreator\345\210\206\346\236\220\357\274\210\344\270\212\357\274\211.md"
new file mode 100644
index 0000000..afcdd55
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/AnnotationAwareAspectJAutoProxyCreator\345\210\206\346\236\220\357\274\210\344\270\212\357\274\211.md"
@@ -0,0 +1,669 @@
+在[上一篇文章](https://my.oschina.net/funcy/blog/4678093 "上一篇文章")的分析中，我们介绍了使用 `@EnableAspectJAutoProxy` 开启用 spring aop 功能，而 `@EnableAspectJAutoProxy` 最终向 spring 中引入了一个类：`AnnotationAwareAspectJAutoProxyCreator`，本文就从该类入手，进 一步分析 spring aop 功能。
+
+首先我们来看看这个类的继承关系：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-53b639dcaacb2480e9098a046407a80a574.png)
+
+从继承关系上来看，`AnnotationAwareAspectJAutoProxyCreator` 是一个 `BeanPostProcessor`，结合前面的分析，spring `BeanPostProcessor` 的执行是在 spring bean 初始化前后，这里我们通过断点调试的方式验证下。
+
+### 1\. 调试查看代理对象的产生
+
+我们将断点打在 `AbstractAutowireCapableBeanFactory#initializeBean(String, Object, RootBeanDefinition)` 方法上，然后在 debug 模式下运行：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-449fe5a3456350ae0d9854c1c13f4a59a80.png)
+
+此时的 `wrappedBean` 的类型还是 `AopBean1`，继续往下，当运行完 `applyBeanPostProcessorsAfterInitialization` 后，`wrappedBean` 的类型就变了样：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-8b791334bf1873c652a265db9ab1d0e1441.png)
+
+表现上看还是 `AopBean1`，但前面出现了 `$Poxy19` 字样，且多了一个属性：`JdkDynamicAopProxy`，这表明该动态是 jdk 动态代理生成的对象。
+
+再看看 `AopBean2` 运行到此处的变化：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-4fc5d03af4298f55d69e5c619cd72df1ff0.png)
+
+可以看到，类名中出现了 `SpringCGLIB` 字样，这表示该对象是由 spring cglib 代理生成的。
+
+从以上调试结果来看，spring 是在 `AnnotationAwareAspectJAutoProxyCreator#postProcessAfterInitialization` 中完成对象代理的。
+
+实际上，`AnnotationAwareAspectJAutoProxyCreator` 中并未实现 `postProcessAfterInitialization` 方法，`AnnotationAwareAspectJAutoProxyCreator` 的 `postProcessAfterInitialization` 方法继承自 `AbstractAutoProxyCreator#postProcessAfterInitialization`，因此 spring 对象代理的实际完成是在 `AbstractAutoProxyCreator#postProcessAfterInitialization` 中。
+
+`AnnotationAwareAspectJAutoProxyCreator` 是 `BeanPostProcessor` 的子类，spring 在 bean 的初始化前后会调用 `BeanPostProcessor#postProcessBeforeInitialization` 与 `BeanPostProcessor#postProcessAfterInitialization` 方法，我们将从源码上看看 `AnnotationAwareAspectJAutoProxyCreator` 在 bean 的初始前后是如何完成 aop 操作。
+
+### 2. `AbstractAutoProxyCreator#postProcessBeforeInitialization` 方法
+
+代理对象的生成虽然是在 `BeanPostProcessor#postProcessAfterInitialization` 方法，但正所谓 “做戏做全套”，本文我们先分析 `AbstractAutoProxyCreator#postProcessBeforeInitialization` 方法，看看这个方法做了些什么，至于 `AbstractAutoProxyCreator#postProcessAfterInitialization` 方法，将留到下一篇文章分析。
+
+`AnnotationAwareAspectJAutoProxyCreator` 的 `postProcessBeforeInitialization` 方法继承自 `AbstractAutoProxyCreator`，`AbstractAutoProxyCreator#postProcessBeforeInitialization` 方法如下：
+
+```
+public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
+    Object cacheKey = getCacheKey(beanClass, beanName);
+
+    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
+        if (this.advisedBeans.containsKey(cacheKey)) {
+            return null;
+        }
+        //1\. 加载所有增强
+        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
+            this.advisedBeans.put(cacheKey, Boolean.FALSE);
+            return null;
+        }
+    }
+
+    // 2\. 如果有自定义的TargetSource，则运行下面的方法来创建代理
+    TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
+    if (targetSource != null) {
+        if (StringUtils.hasLength(beanName)) {
+            this.targetSourcedBeans.add(beanName);
+        }
+        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
+        Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
+        this.proxyTypes.put(cacheKey, proxy.getClass());
+        return proxy;
+    }
+
+    return null;
+}
+
+```
+
+这个方法主要功能就是加载项目中的增强方法，处理代码如下：
+
+```
+if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
+     ...
+}
+
+```
+
+这段代码包含两个方法：`isInfrastructureClass(beanClass)` 与 `shouldSkip(beanClass, beanName)`，先来看 `isInfrastructureClass(beanClass)`
+
+#### 2.1 `isInfrastructureClass(beanClass)` 方法
+
+> AnnotationAwareAspectJAutoProxyCreator#isInfrastructureClass
+
+```
+@Override
+protected boolean isInfrastructureClass(Class<?> beanClass) {
+     // 判断当前类是否为 Advice/Pointcut/Advisor/AopInfrastructureBean 的子类
+     return (super.isInfrastructureClass(beanClass) ||
+          // 判断当前beanClass是否为切面：包含有@Aspect注解， 且不由ajc编译
+         (this.aspectJAdvisorFactory != null && this.aspectJAdvisorFactory.isAspect(beanClass)));
+}
+
+```
+
+以上代码就两行，功能注释得很清楚了，简单来说就是判断是否为 aop 自身相关的类，如果是 aop 自身相关的类，就不进行切面操作了。
+
+#### 2.2 `shouldSkip(beanClass, beanName)` 方法
+
+接着，我们来看 `shouldSkip(beanClass, beanName)` 方法：
+
+> AspectJAwareAdvisorAutoProxyCreator#shouldSkip
+
+```
+@Override
+protected boolean shouldSkip(Class<?> beanClass, String beanName) {
+    //查找所有标识了@Aspect注解的类，这个方法很重要 ，下面会继续分析
+    List<Advisor> candidateAdvisors = findCandidateAdvisors();
+    for (Advisor advisor : candidateAdvisors) {
+        // 如果当前 advisor 为 AspectJPointcutAdvisor 的实例且 AspectName 为 beanName，返回true
+        if (advisor instanceof AspectJPointcutAdvisor &&
+                ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
+            return true;
+        }
+    }
+    // 调用父类的方法，判断当前 bean 是否为 OriginalInstance
+    return super.shouldSkip(beanClass, beanName);
+}
+
+```
+
+这个方法会先查找所有标识了 `@Aspect` 注解的类，然后做一些判断，其中 `findCandidateAdvisors` 很关键，我们来看看这个方法：
+
+> AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors
+
+```
+@Override
+protected List<Advisor> findCandidateAdvisors() {
+    // 调用父类的方法，查找当前beanFactory中的Advisor bean
+    List<Advisor> advisors = super.findCandidateAdvisors();
+    if (this.aspectJAdvisorsBuilder != null) {
+        // 将包含 @Aspect 注解的类构建为 Advisor，这句是关键
+        advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
+    }
+    return advisors;
+}
+
+```
+
+首先来看下 `super.findCandidateAdvisors()` 方法，也就是 `AbstractAdvisorAutoProxyCreator#findCandidateAdvisors`:
+
+```
+protected List<Advisor> findCandidateAdvisors() {
+    Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
+    return this.advisorRetrievalHelper.findAdvisorBeans();
+}
+
+```
+
+这个调用了 `BeanFactoryAdvisorRetrievalHelper#findAdvisorBeans`，继续下去：
+
+```
+public List<Advisor> findAdvisorBeans() {
+    String[] advisorNames = this.cachedAdvisorBeanNames;
+    if (advisorNames == null) {
+        // 1\. 查找当前beanFactory中所有 Advisor 的 bean class
+        advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
+                this.beanFactory, Advisor.class, true, false);
+        this.cachedAdvisorBeanNames = advisorNames;
+    }
+    ...
+
+    List<Advisor> advisors = new ArrayList<>();
+    for (String name : advisorNames) {
+            ...
+            // 2\. 从spring中获取 bean class 对应的 bean，将其放入advisors中
+            advisors.add(this.beanFactory.getBean(name, Advisor.class));
+            ...
+
+    }
+    return advisors;
+}
+
+```
+
+以上代码做了两件事：
+
+1.  查找当前 beanFactory 中所有 Advisor 的 bean class，Advisor 可以是用户实现 Advisor 相关接口，也可以是 xml 指定的
+2.  从 spring 中获取 bean class 对应的 bean，将其放入 advisors 中
+
+#### 2.3 `aspectJAdvisorsBuilder.buildAspectJAdvisors()` 方法
+
+接着我们再回过头来看看 `aspectJAdvisorsBuilder.buildAspectJAdvisors())` 方法 ：
+
+> BeanFactoryAspectJAdvisorsBuilder#buildAspectJAdvisors
+
+```
+public List<Advisor> buildAspectJAdvisors() {
+    List<String> aspectNames = this.aspectBeanNames;
+
+    // 只有在第一次运行时，才会成立
+    if (aspectNames == null) {
+        synchronized (this) {
+            aspectNames = this.aspectBeanNames;
+            if (aspectNames == null) {
+                List<Advisor> advisors = new ArrayList<>();
+                aspectNames = new ArrayList<>();
+                //1\. 获取所有Bean名称
+                String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
+                        this.beanFactory, Object.class, true, false);
+                for (String beanName : beanNames) {
+                    ...
+                    //2\. 判断Bean的Class上是否标识@Aspect注解
+                    if (this.advisorFactory.isAspect(beanType)) {
+                        aspectNames.add(beanName);
+                        AspectMetadata amd = new AspectMetadata(beanType, beanName);
+                        if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
+                            // 创建factory对象，这个对象里包含了beanFactory与@Aspect的beanName
+                            MetadataAwareAspectInstanceFactory factory =
+                                new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
+                            // 3\. 解析所有的增强方法, 这个方法是重点的重点
+                            List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
+                            if (this.beanFactory.isSingleton(beanName)) {
+                                //将解析的Bean名称及类上的增强缓存起来,每个Bean只解析一次
+                                this.advisorsCache.put(beanName, classAdvisors);
+                            }
+                            ...
+                        }
+                        else {
+                            ...
+                        }
+                    }
+                }
+                // 对属性赋值，之后就不会再运行了
+                this.aspectBeanNames = aspectNames;
+                return advisors;
+            }
+        }
+    }
+
+    if (aspectNames.isEmpty()) {
+        return Collections.emptyList();
+    }
+    List<Advisor> advisors = new ArrayList<>();
+    for (String aspectName : aspectNames) {
+        //从缓存中获取当前Bean的切面实例，如果不为空，则指明当前Bean的Class标识了@Aspect，且有切面方法
+        List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
+        if (cachedAdvisors != null) {
+            advisors.addAll(cachedAdvisors);
+        }
+        else {
+            MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
+            advisors.addAll(this.advisorFactory.getAdvisors(factory));
+        }
+    }
+    return advisors;
+}
+
+```
+
+方法虽然有点长，不过只做了 3 件事：
+
+1.  获取所有 beanName：`BeanFactoryUtils.beanNamesForTypeIncludingAncestors`
+2.  找出所有标记 Aspect 注解的类：`advisorFactory.isAspect(beanType)`
+3.  对标记 Aspect 的类提取增强器：`this.advisorFactory.getAdvisors(factory)`
+
+这里我们重点分析第 3 点，看看 `Advisors` 是如何构建的。
+
+> ReflectiveAspectJAdvisorFactory#getAdvisors
+
+```
+public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
+    //获取Aspect类、类名称、并校验
+    // aspectInstanceFactory 里包含beanFactory与 @Aspect 的 beanName
+    Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
+    String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
+    //校验类的合法性相关
+    validate(aspectClass);
+
+    MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
+                  new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
+    List<Advisor> advisors = new ArrayList<>();
+    // 获取这个类除去 @Pointcut 外的所有方法，看下面的分析
+    for (Method method : getAdvisorMethods(aspectClass)) {
+          // 生成增强实例，这个 方法是重点，看后面的分析
+          // 注意 advisors.size()，这个指定了advisor的顺序，由于获取之后会个添加
+          // 操作，因此这个值是递增且是不重复的
+          Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 
+                    advisors.size(), aspectName);
+          if (advisor != null) {
+              // 添加 advisors 列表
+              advisors.add(advisor);
+          }
+    }
+    // 如果需要增强且配置了延迟增强,则在第一个位置添加同步实例化增强方法
+    if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory
+                    .getAspectMetadata().isLazilyInstantiated()) {
+        Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(
+                    lazySingletonAspectInstanceFactory);
+        advisors.add(0, instantiationAdvisor);
+    }
+    // 获取属性中配置DeclareParents注解的增强
+    for (Field field : aspectClass.getDeclaredFields()) {
+        Advisor advisor = getDeclareParentsAdvisor(field);
+        if (advisor != null) {
+              advisors.add(advisor);
+        }
+    }
+    return advisors;
+}
+
+/**
+ * 获取指定类除@Pointcut外的所有方法
+ */
+private List<Method> getAdvisorMethods(Class<?> aspectClass) {
+    final List<Method> methods = new ArrayList<>();
+    // 递归操作 ：排除@Pointcut标识的方法，获取当前类的的方法、来自接口的默认方法，再对父类进行同样的操作
+    // 最终结果：除@Pointcut标识之外的所有方法，得到的方法集合包括：
+    // 1\. 继承自父类的方法，
+    // 2\. 来自自接口的默认的方法
+    // 3\. 不包含继承自Object的方法
+    ReflectionUtils.doWithMethods(aspectClass, method -> {
+        if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
+            methods.add(method);
+        }
+    }, ReflectionUtils.USER_DECLARED_METHODS);
+    //对得到的所有方法排序，
+    //如果方法标识了切面注解，则按@Around, @Before, @After, @AfterReturning, @AfterThrowing的顺序排序
+    //如果没有标识这些注解，则按方法名称的字符串排序,
+    //有注解的方法排在无注解的方法之前
+    //最后的排序应该是这样的Around, Before, After, AfterReturning, AfterThrowing
+    methods.sort(METHOD_COMPARATOR);
+    return methods;
+}
+
+```
+
+以上方法主要做了两件事：
+
+1.  获取当前类除 `@Pointcut` 外的所有增强方法，包括继承自父类的方法，继承自 Object 的方法，以及来自接口的默认方法
+2.  遍历得到的方法，从符合条件的方法得到 Advisor 实例，保存到集合中
+
+关于第一步，上面的代码已经分析了，主要是根据反射来进行的，就不再深入了，这里我们来看第二步，该操作是在 `ReflectiveAspectJAdvisorFactory#getAdvisor` 方法中：
+
+```
+@Override
+@Nullable
+/**
+ * declarationOrderInAspect：指定了Advisor的顺序，来源于 AdvisorMethods 的排序，上面已分析
+ */
+public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory 
+        aspectInstanceFactory, int declarationOrderInAspect, String aspectName) {
+    //再次校验类的合法性
+    validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
+    //切点表达式的包装类里面包含这些东西：@Around("testAop()") 里的 testAop()
+    AspectJExpressionPointcut expressionPointcut = getPointcut(
+            candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
+    if (expressionPointcut == null) {
+        return null;
+    }
+    //根据方法、切点、AOP实例工厂、类名、序号生成切面实例，下面我们先来看看是如何实例化的
+    return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
+               this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
+}
+
+/**
+ * 处理切点表达式
+ */
+@Nullable
+private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, 
+               Class<?> candidateAspectClass) {
+    // 查询方法上的切面注解，根据注解生成相应类型的AspectJAnnotation,
+    // 在调用AspectJAnnotation的构造函数的同时，根据注解value或pointcut属性得到切点表达式，
+    // 有argNames则设置参数名称
+    AspectJAnnotation<?> aspectJAnnotation =
+               AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
+    // 过滤那些不含@Before, @Around, @After, @AfterReturning, @AfterThrowing注解的方法
+    if (aspectJAnnotation == null) {
+        return null;
+    }
+
+    //生成带表达式的切面切入点，设置其切入点表达式
+    AspectJExpressionPointcut ajexp =
+               new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
+    ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
+    if (this.beanFactory != null) {
+        ajexp.setBeanFactory(this.beanFactory);
+    }
+    return ajexp;
+}
+
+```
+
+`Advisor` 实例化过程如下：
+
+```
+public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
+        Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
+        MetadataAwareAspectInstanceFactory aspectInstanceFactory,
+        int declarationOrder, String aspectName) {
+    // 处理属性设置
+    this.declaredPointcut = declaredPointcut;
+    this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
+    this.methodName = aspectJAdviceMethod.getName();
+    this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
+    this.aspectJAdviceMethod = aspectJAdviceMethod;
+    this.aspectJAdvisorFactory = aspectJAdvisorFactory;
+    this.aspectInstanceFactory = aspectInstanceFactory;
+    this.declarationOrder = declarationOrder;
+    this.aspectName = aspectName;
+
+    if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
+        ...
+    }
+    else {
+        this.pointcut = this.declaredPointcut;
+        this.lazy = false;
+        //初始化对应的增强器，这里是重点
+        this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
+    }
+}
+
+/**
+ * 实例化过程
+ */
+private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) {
+    // getAdvice: 处理 Advice 实例化操作
+    Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut,
+            this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
+    return (advice != null ? advice : EMPTY_ADVICE);
+}
+
+```
+
+这段代码清晰明了，主要是实例化 `Advisor`，所谓的实例化，就是往 `Advisor` 对象里设置了一些属性。这里 `instantiatedAdvice` 属性需要特别说明一下，这个属性封装了切面方法，也就是增强的内容。
+
+*   切面方法 (切面具体的执行代码) 封装为 `Advice`；
+*   `Advice` 是 `Advisor` 的一个属性。
+
+#### 2.4 实例化 `Advice`
+
+接下来看看 `Advice` 的流程：
+
+> ReflectiveAspectJAdvisorFactory#getAdvice
+
+```
+@Override
+@Nullable
+public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
+        MetadataAwareAspectInstanceFactory aspectInstanceFactory,
+        int declarationOrder, String aspectName) {
+
+    Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
+    //又是一次校验
+    validate(candidateAspectClass);
+
+    AspectJAnnotation<?> aspectJAnnotation =
+            AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
+    if (aspectJAnnotation == null) {
+        return null;
+    }
+
+    if (!isAspect(candidateAspectClass)) {
+        throw new AopConfigException(...);
+    }
+
+    AbstractAspectJAdvice springAdvice;
+    // 根据注解类型生成不同的通知实例，
+    // 对应的注解就是 @Before, @Around, @After, @AfterReturning, @AfterThrowing
+    switch (aspectJAnnotation.getAnnotationType()) {
+        case AtPointcut:
+            return null;
+        case AtAround:
+            springAdvice = new AspectJAroundAdvice(
+                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
+            break;
+        case AtBefore:
+            springAdvice = new AspectJMethodBeforeAdvice(
+                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
+            break;
+        case AtAfter:
+            springAdvice = new AspectJAfterAdvice(
+                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
+            break;
+        case AtAfterReturning:
+            springAdvice = new AspectJAfterReturningAdvice(
+                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
+            AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
+            if (StringUtils.hasText(afterReturningAnnotation.returning())) {
+                springAdvice.setReturningName(afterReturningAnnotation.returning());
+            }
+            break;
+        case AtAfterThrowing:
+            springAdvice = new AspectJAfterThrowingAdvice(
+                   candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
+            AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
+            if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
+                springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
+            }
+            break;
+        default:
+            throw new UnsupportedOperationException(...);
+    }
+
+    //设置通知方法所属的类
+    springAdvice.setAspectName(aspectName);
+    //设置通知的序号,同一个类中有多个切面注解标识的方法时,按上方说的排序规则来排序，
+    //其序号就是此方法在列表中的序号，第一个就是0
+    springAdvice.setDeclarationOrder(declarationOrder);
+    //获取通知方法的所有参数
+    String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
+    //将通知方法上的参数设置到通知中
+    if (argNames != null) {
+        springAdvice.setArgumentNamesFromStringArray(argNames);
+    }
+    //计算参数绑定工作，此方法详解请接着往下看
+    springAdvice.calculateArgumentBindings();
+    return springAdvice;
+}
+
+```
+
+我们知道，切面注解标识的方法第一个参数要求是 `JoinPoint`，如果是 `@Around` 注解，则第一个参数可以是 `ProceedingJoinPoint`，计算参数绑定就是来验证参数类型的。
+
+对于不同的通知，spring 会封装成不同的 `advice`，这里先来看看 `advice` 的继承结构：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-671bd92a16642a059ff722ec42c8ea7ef28.png)
+
+关于 `advice`，后面在分析切面的执行时会详细分析，这里只需知道 “不同的切面类型，最终会封装为不同的 advice” 即可。
+
+再来看看 spring 计算参数绑定的流程：
+
+> AbstractAspectJAdvice
+
+```
+/**
+ * 处理参数绑定
+ */
+public final synchronized void calculateArgumentBindings() {
+    if (this.argumentsIntrospected || this.parameterTypes.length == 0) {
+        return;
+    }
+
+    int numUnboundArgs = this.parameterTypes.length;
+    Class<?>[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
+    //切面注解标识的方法第一个参数要求是JoinPoint,或StaticPart，若是@Around注解则也可以是ProceedingJoinPoint
+    if (maybeBindJoinPoint(parameterTypes[0]) || maybeBindProceedingJoinPoint(parameterTypes[0]) ||
+            maybeBindJoinPointStaticPart(parameterTypes[0])) {
+        numUnboundArgs--;
+    }
+
+    if (numUnboundArgs > 0) {
+        //绑定属性其他属性
+        bindArgumentsByName(numUnboundArgs);
+    }
+
+    this.argumentsIntrospected = true;
+}
+
+```
+
+以上代码验证了切面注解标识的方法第一个参数的类型，此外，如果在方法中定义了多个方法，spring 还会进一步进行参数绑定：
+
+> AbstractAspectJAdvice
+
+```
+/**
+  * 绑定属性其他属性
+  */
+private void bindArgumentsByName(int numArgumentsExpectingToBind) {
+    if (this.argumentNames == null) {
+        //获取方法参数的名称
+        this.argumentNames = createParameterNameDiscoverer()
+                .getParameterNames(this.aspectJAdviceMethod);
+    }
+    if (this.argumentNames != null) {
+        // 继续绑定
+        bindExplicitArguments(numArgumentsExpectingToBind);
+    }
+    else {
+        throw new IllegalStateException(...);
+    }
+}
+
+/**
+ * 针对 @AfterReturning 与 @AfterThrowing 注解，进一步处理其参数
+ */
+private void bindExplicitArguments(int numArgumentsLeftToBind) {
+    Assert.state(this.argumentNames != null, "No argument names available");
+    //此属性用来存储方法未绑定的参数名称，及参数的序号
+    this.argumentBindings = new HashMap<>();
+
+    int numExpectedArgumentNames = this.aspectJAdviceMethod.getParameterCount();
+    if (this.argumentNames.length != numExpectedArgumentNames) {
+        throw new IllegalStateException(...);
+    }
+
+    // argumentIndexOffset代表第一个未绑定参数的顺序
+    int argumentIndexOffset = this.parameterTypes.length - numArgumentsLeftToBind;
+    for (int i = argumentIndexOffset; i < this.argumentNames.length; i++) {
+        //存储未绑定的参数名称及其顺序的映射关系
+        this.argumentBindings.put(this.argumentNames[i], i);
+    }
+
+    // 如果是@AfterReturning注解的returningName 有值，验证，解析，同时得到定义返回值的类型
+    if (this.returningName != null) {
+        if (!this.argumentBindings.containsKey(this.returningName)) {
+            throw new IllegalStateException(...);
+        }
+        else {
+            Integer index = this.argumentBindings.get(this.returningName);
+            this.discoveredReturningType = this.aspectJAdviceMethod.getParameterTypes()[index];
+            this.discoveredReturningGenericType = this.aspectJAdviceMethod
+                        .getGenericParameterTypes()[index];
+        }
+    }
+    // 如果是@AfterThrowing注解的throwingName 有值，验证，解析，同时得到抛出异常的类型
+    if (this.throwingName != null) {
+        if (!this.argumentBindings.containsKey(this.throwingName)) {
+            throw new IllegalStateException(...);
+        }
+        else {
+            Integer index = this.argumentBindings.get(this.throwingName);
+            this.discoveredThrowingType = this.aspectJAdviceMethod.getParameterTypes()[index];
+        }
+    }
+
+    configurePointcutParameters(this.argumentNames, argumentIndexOffset);
+}
+
+/**
+ *  这一步仅是将前面未处理过的参数做一个保存，记录到 pontcut 中，待后续再做处理
+ */
+private void configurePointcutParameters(String[] argumentNames, int argumentIndexOffset) {
+    int numParametersToRemove = argumentIndexOffset;
+    if (this.returningName != null) {
+        numParametersToRemove++;
+    }
+    if (this.throwingName != null) {
+        numParametersToRemove++;
+    }
+    String[] pointcutParameterNames = new String[argumentNames.length - numParametersToRemove];
+    Class<?>[] pointcutParameterTypes = new Class<?>[pointcutParameterNames.length];
+    Class<?>[] methodParameterTypes = this.aspectJAdviceMethod.getParameterTypes();
+
+    int index = 0;
+    for (int i = 0; i < argumentNames.length; i++) {
+        if (i < argumentIndexOffset) {
+            continue;
+        }
+        if (argumentNames[i].equals(this.returningName) ||
+            argumentNames[i].equals(this.throwingName)) {
+            continue;
+        }
+        pointcutParameterNames[index] = argumentNames[i];
+        pointcutParameterTypes[index] = methodParameterTypes[i];
+        index++;
+    }
+    //剩余的未绑定的参数会赋值给AspectJExpressionPointcut(表达式形式的切入点)的属性，以备后续使用
+    this.pointcut.setParameterNames(pointcutParameterNames);
+    this.pointcut.setParameterTypes(pointcutParameterTypes);
+}
+
+```
+
+### 3\. 总结
+
+本文主要是分析了 `AnnotationAwareAspectJAutoProxyCreator#postProcessBeforeInitialization` 方法，也就是 `AbstractAutoProxyCreator#postProcessBeforeInitialization` 方法，在该方法的运行过程中，主要是将 `@Aspect` 类封装成一个个 `Advisor`，封装步骤如下：
+
+1.  找到项目中标注了 `@Aspect` 的类；
+2.  遍历上一步得到的类，通过反射得到该类的方法，包括父接口的默认方法、父类的方法但不包括 Object 类的方法；
+3.  从上述方法中，找到标注了 `@Around`, `@Before`, `@After`, `@AfterReturning`, `@AfterThrowing` 等的方法，将其封装为 `Advisor` 对象。
+
+关于 `Advisor`，其中有个重要属性为 `Advice`，这个属性就是切面方法的具体内容。关于 `Advice`，在后面分析切面的执行时会详细分析。
+
+* * *
+
+_本文原文链接：[https://my.oschina.net/funcy/blog/4678817](https://my.oschina.net/funcy/blog/4678817) ，限于作者个人水平，文中难免有错误之处，欢迎指正！原创不易，商业转载请联系作者获得授权，非商业转载请注明出处。_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/AnnotationAwareAspectJAutoProxyCreator\345\210\206\346\236\220\357\274\210\344\270\213\357\274\211.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/AnnotationAwareAspectJAutoProxyCreator\345\210\206\346\236\220\357\274\210\344\270\213\357\274\211.md"
new file mode 100644
index 0000000..c21a988
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/AnnotationAwareAspectJAutoProxyCreator\345\210\206\346\236\220\357\274\210\344\270\213\357\274\211.md"
@@ -0,0 +1,628 @@
+[��һƪ����](https://my.oschina.net/funcy/blog/4678817 "��һƪ����")��Ҫ������ `AbstractAutoProxyCreator#postProcessAfterInitialization` �������������������� `AbstractAutoProxyCreator#postProcessAfterInitialization` ������
+
+��������������������ĵ�������
+
+```
+|-AnnotationConfigApplicationContext
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#finishBeanFactoryInitialization
+   |-ConfigurableListableBeanFactory#preInstantiateSingletons
+    |-AbstractBeanFactory#getBean(String)
+     |-AbstractBeanFactory#doGetBean
+      |-DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)
+       |-ObjectFactory#getObject
+        |-AbstractBeanFactory#createBean
+         |-AbstractAutowireCapableBeanFactory#doCreateBean
+          |-AbstractAutowireCapableBeanFactory#initializeBean(String, Object, RootBeanDefinition)
+           |-AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization
+            |-AbstractAutoProxyCreator#postProcessAfterInitialization
+
+```
+
+ʵ������������ĵ��������� spring bean �Ĵ������̣����ǽ��� `AbstractAutoProxyCreator#postProcessAfterInitialization`��
+
+```
+@Override
+public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
+    if (bean != null) {
+        Object cacheKey = getCacheKey(bean.getClass(), beanName);
+        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
+           // ����wrapIfNecessary()����
+           return wrapIfNecessary(bean, beanName, cacheKey);
+        }
+    }
+    return bean;
+}
+
+```
+
+�������� `AbstractAutoProxyCreator#wrapIfNecessary`��
+
+```
+protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
+    //����Ѿ�������
+    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
+        return bean;
+    }
+    //�����ǰ������ǿ�࣬����
+    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
+        return bean;
+    }
+
+    // ��Ҫ����һ���жϵ�ǰ���Ƿ�Ϊ�����࣬�ô�������һƪ�����Ѿ������ˣ��Ͳ���˵��
+    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
+        this.advisedBeans.put(cacheKey, Boolean.FALSE);
+        return bean;
+    }
+
+    // ��Ҫ�������У������Ƿ�Ӧ�ñ���������ȡ��������ǿ
+    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
+    //�����ȡ������ǿ����Ҫ�����ǿ��������
+    if (specificInterceptors != DO_NOT_PROXY) {
+        this.advisedBeans.put(cacheKey, Boolean.TRUE);
+        // ��Ҫ����������������
+        Object proxy = createProxy(
+            bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
+        this.proxyTypes.put(cacheKey, proxy.getClass());
+        return proxy;
+    }
+
+    this.advisedBeans.put(cacheKey, Boolean.FALSE);
+    return bean;
+}
+
+```
+
+������� �����е㳤���������붼�������жϣ��� aop ���ܹ�ϵ���������й�ϵ�Ĵ���ֻ�����У�
+
+```
+// ��Ҫ����һ��
+// 1\. isInfrastructureClass���жϵ�ǰ�Ƿ�Ϊaop����࣬
+//    ��Advice/Pointcut/Advisor�ȵ����࣬�Ƿ���� @AspectJ��ע��
+// 2\. shouldSkip���������������࣬�ж��Ƿ��ų�
+if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
+    ...
+}
+
+// ��Ҫ�������У������Ƿ�Ӧ�ñ���������ȡ��������ǿ
+Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
+
+// ��Ҫ����������������
+Object proxy = createProxy(
+    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
+
+```
+
+����`��Ҫ����һ`����һƪ�����Ѿ�������������������Ҫ����`��Ҫ�����`��`��Ҫ������`��
+
+### 1\. ��ȡ�����ǿ
+
+> AbstractAdvisorAutoProxyCreator
+
+```
+@Override
+@Nullable
+protected Object[] getAdvicesAndAdvisorsForBean(
+        Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
+    // ���ҷ�����������ǿ���������¿�
+    List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
+    if (advisors.isEmpty()) {
+        return DO_NOT_PROXY;
+    }
+    return advisors.toArray();
+}
+
+/**
+ * ���ҷ�����������ǿ
+ */
+protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
+    //��ȡ�����е�������ǿ������һƪ�������Ѿ���������
+    List<Advisor> candidateAdvisors = findCandidateAdvisors();
+    //��֤beanClass�Ƿ�ñ����������Ӧ�ã��򷵻����������bean����ǿ
+    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
+    extendAdvisors(eligibleAdvisors);
+    if (!eligibleAdvisors.isEmpty()) {
+        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
+    }
+    return eligibleAdvisors;
+}
+
+/**
+ * ��֤beanClass�Ƿ�ñ�����
+ */
+protected List<Advisor> findAdvisorsThatCanApply(
+        List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
+    ProxyCreationContext.setCurrentProxiedBeanName(beanName);
+    try {
+        // ��֤beanClass�Ƿ�ñ�����
+        return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
+    }
+    finally {
+        ProxyCreationContext.setCurrentProxiedBeanName(null);
+    }
+}
+
+```
+
+spring �ķ������ñȽ��һ·׷�٣����յ��� `AopUtils.findAdvisorsThatCanApply` �������������¿���
+
+> AopUtils
+
+```
+public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
+    if (candidateAdvisors.isEmpty()) {
+        return candidateAdvisors;
+    }
+    List<Advisor> eligibleAdvisors = new ArrayList<>();
+    // ���� candidateAdvisors���ж��Ƿ������������
+    for (Advisor candidate : candidateAdvisors) {
+        //������ǿ���ص㣬�����¿�
+        if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
+            eligibleAdvisors.add(candidate);
+        }
+    }
+    boolean hasIntroductions = !eligibleAdvisors.isEmpty();
+    for (Advisor candidate : candidateAdvisors) {
+        if (candidate instanceof IntroductionAdvisor) {
+            // already processed
+            continue;
+        }
+        //����ͨbean�Ĵ���
+        if (canApply(candidate, clazz, hasIntroductions)) {
+            eligibleAdvisors.add(candidate);
+        }
+    }
+    return eligibleAdvisors;
+}
+
+/**
+ * �ж��Ƿ���Ҫ��ǿ
+ */
+public static boolean canApply(Advisor advisor, Class<?> targetClass) {
+    // ������һ������
+    return canApply(advisor, targetClass, false);
+}
+
+/**
+ * �ж��Ƿ���Ҫ��ǿ
+ */
+public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
+    //��������ų�������
+    if (advisor instanceof IntroductionAdvisor) {
+        return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
+    }
+    else if (advisor instanceof PointcutAdvisor) {
+        PointcutAdvisor pca = (PointcutAdvisor) advisor;
+        //����÷�������
+        return canApply(pca.getPointcut(), targetClass, hasIntroductions);
+    }
+    else {
+        // It doesn't have a pointcut so we assume it applies.
+        return true;
+    }
+}
+
+/**
+ * �ж��Ƿ���Ҫ��ǿ
+ */
+public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
+    Assert.notNull(pc, "Pointcut must not be null");
+    //�е����Ƿ�����ų��������
+    if (!pc.getClassFilter().matches(targetClass)) {
+        return false;
+    }
+    //��֤ע����������Ƿ���������ڷ�����
+    MethodMatcher methodMatcher = pc.getMethodMatcher();
+    if (methodMatcher == MethodMatcher.TRUE) {
+        // No need to iterate the methods if we're matching any method anyway...
+        return true;
+    }
+
+    IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
+    if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
+        introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
+    }
+
+    // classes����targetClass����Object�����и��ࡢ���нӿ�
+    Set<Class<?>> classes = new LinkedHashSet<>();
+    if (!Proxy.isProxyClass(targetClass)) {
+        classes.add(ClassUtils.getUserClass(targetClass));
+    }
+    classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
+
+    // ѭ���жϷ����Ƿ���Ҫ������
+    // ������Կ�����
+    // 1\. ֻҪһ�������������Ҫ����ô������ͻᱻ����
+    // 2\. ��������з�����Ҫ����������ô����Ҳ�ᱻ����
+    for (Class<?> clazz : classes) {
+         // ��ȡ clazz ����ķ���
+         // ������ǰ��ķ�������Object������и��෽�����ӿڵ�Ĭ�Ϸ���
+        Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
+        for (Method method : methods) {
+            //��ȡ����ʵ�ֵ����нӿں�������㼶�ķ�����ѭ����֤
+            if (introductionAwareMethodMatcher != null ?
+                introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
+                methodMatcher.matches(method, targetClass)) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+```
+
+������������Ͼ��˽��� spring ��������ж�һ�������Ƿ���Ҫ�������ģ������ܽ��������£�
+
+1.  ��ȡ����Ŀ�����е�������󣬽����е����淽����װΪһ�� `List<Advisor>`�������������һƪ����������ϸ������
+2.  ���� `Advisor`����ÿһ�� `Advisor`�����÷����ȡ��ǰ��ij� `Object` ������и��༰�ӿڣ����Ϊ `Set<Class>`��
+3.  ���� `Set<Class>`��������ÿһ�� `Class`�����÷����ȡ�� `Class` �������� Object ������и���ķ������ӿڵ�Ĭ�Ϸ��������Ϊ `Method[]`;
+4.  ���� `Method[]`�������һ�� `method` ���� `Advisor` ���������������ʾ��ǰ `Advisor` ����Ӧ�õ���ǰ bean���� bean ����Ҫ����������һ�����յõ��Ľ��Ҳ��һ�� `List<Advisor>`����ʾ���ж�� `Advisor` ��ҪӦ�õ��ö���
+
+α���������ڣ�
+
+```
+// 1\. ��ȡ���е�Advisor
+List<Advisor> advisorList = getAdvisorList();
+// 2\. ����Advisor
+for(Advisor advisor : advisorList) {
+    // ��ȡ��ǰ��ij�`Object`������и��༰�ӿڣ�classSetҲ����targetClass
+    Set<Class> classSet = getSuperClassAndInterfaces(targetClass);
+    for(Class cls : classSet) {
+        // ����cls�ж���ķ�����������ǰ��ķ�������Object������и��෽�����ӿڵ�Ĭ�Ϸ���
+        Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
+        //  ����������
+        for (Method method : methods) {
+             // �ж�method�Ƿ�������������
+        }
+    }
+}
+
+```
+
+�õ� `List<Advisor>` �󣬽��������Ǹ��� `List<Advisor>` ���������������ˡ�
+
+### 2\. ������������
+
+���������� spring ����������������̡�
+
+> `AbstractAutoProxyCreator#wrapIfNecessary`��
+
+```
+protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
+    ...
+    if (specificInterceptors != DO_NOT_PROXY) {
+        this.advisedBeans.put(cacheKey, Boolean.TRUE);
+        // ����������������ﴴ����
+        // - specificInterceptors������Ӧ�õ��ö����  Advisor��
+        //    specificInterceptors�Ļ�ȡ���̣���һ�����Ѿ���ϸ�������ˣ�����׸����
+        // - SingletonTargetSource����ԭʼ�����һ����װ
+        Object proxy = createProxy(
+            bean.getClass(), beanName, specificInterceptors, 
+                        new SingletonTargetSource(bean));
+        this.proxyTypes.put(cacheKey, proxy.getClass());
+        return proxy;
+    }
+    this.advisedBeans.put(cacheKey, Boolean.FALSE);
+    return bean;
+}
+
+```
+
+������������ `SingletonTargetSource`��
+
+```
+public class SingletonTargetSource implements TargetSource, Serializable {
+
+    private static final long serialVersionUID = 9031246629662423738L;
+
+    private final Object target;
+
+    public SingletonTargetSource(Object target) {
+        Assert.notNull(target, "Target object must not be null");
+        this.target = target;
+    }
+
+    @Override
+    public Class<?> getTargetClass() {
+        return this.target.getClass();
+    }
+
+    @Override
+    public Object getTarget() {
+        return this.target;
+    }
+
+    ...
+}
+
+```
+
+��������ܼ򵥣����Ƕ�ԭʼ��������һ���װ���������¿���
+
+> AbstractAutoProxyCreator#createProxy
+
+```
+protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
+        @Nullable Object[] specificInterceptors, TargetSource targetSource) {
+
+    if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
+        AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) 
+            this.beanFactory, beanName, beanClass);
+    }
+
+    ProxyFactory proxyFactory = new ProxyFactory();
+    //ʹ��proxyFactory����copy��ǰ���е��������
+    proxyFactory.copyFrom(this);
+
+    // �ж��Ƿ�ʹ��Cglib��̬������������ע����ָ����
+    // @EnableAspectJAutoProxy(proxyTargetClass = true)
+    if (!proxyFactory.isProxyTargetClass()) {
+        // ��� beanFactory �� ConfigurableListableBeanFactory��
+        // ����� BeanDefinition �������ԣ���������ijһ����ʹ�� cglib ����
+        if (shouldProxyTargetClass(beanClass, beanName)) {
+            proxyFactory.setProxyTargetClass(true);
+        }
+        else {
+            // ���û�����ÿ���, ���ж�bean�Ƿ��к��ʵĽӿ�ʹ��JDK�Ķ�̬����
+            // ע�⣺JDK��̬���������Ǵ��нӿڵ���
+            // �����û��ʵ���κνӿ���ֻ��ʹ��Cglib��̬������
+            evaluateProxyInterfaces(beanClass, proxyFactory);
+        }
+    }
+
+    // ����Advisor�������������������
+    // 1\. ���ӹ����� Interceptor
+    // 2\. ���ڸ�����advisor���ж������ͣ�Ȼ��ת��Ϊ���������
+    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
+    //����������ǿ
+    proxyFactory.addAdvisors(advisors);
+    //����Ҫ��������
+    proxyFactory.setTargetSource(targetSource);
+    //Spring��һ����չ�㣬Ĭ��ʵ��Ϊ�ա�������������Ҫ�Դ����������������ʱ��ʵ��
+    customizeProxyFactory(proxyFactory);
+
+    proxyFactory.setFrozen(this.freezeProxy);
+    if (advisorsPreFiltered()) {
+        proxyFactory.setPreFiltered(true);
+    }
+    //ʹ�ô���������ȡ��������
+    return proxyFactory.getProxy(getProxyClassLoader());
+}
+
+```
+
+�� `@EnableAspectJAutoProxy` ע���У�����ʹ�� `proxyTargetClass = true` ��������Ŀʹ�� `cglib` ���������ڴ�����Ҳ�����֣�
+
+```
+// ֻ����proxyFactory.isProxyTargetClass()Ϊfalseʱ���Ż����������ж�
+// ����֮���� @EnableAspectJAutoProxy(proxyTargetClass = true) ʱ
+// ����Ĵ����Dz������еģ�Ĭ��ʹ�þ���cglib����
+if (!proxyFactory.isProxyTargetClass()) {
+    // �ж���û�� BeanDefinition ������ʹ�� cglib����
+    if (shouldProxyTargetClass(beanClass, beanName)) {
+        proxyFactory.setProxyTargetClass(true);
+    }
+    else {
+        // �Ƿ���������ӿڵ����������Ƿ�����jdk��̬����������
+        evaluateProxyInterfaces(beanClass, proxyFactory);
+    }
+}
+
+```
+
+spring ������ж�һ�����Ƿ����� jdk ��̬�������������أ�����������֪����˵��ʵ���˽ӿڣ��Ϳ���ʹ�ö�̬�����������ֻ��ʹ�� cglib ���������������� spring ������жϵģ�
+
+> ProxyProcessorSupport#evaluateProxyInterfaces
+
+```
+/**
+ * �ж��Ƿ���ʹ��jdk��̬����
+ */
+protected void evaluateProxyInterfaces(Class<?> beanClass, ProxyFactory proxyFactory) {
+    // ��ȡ������нӿ�
+    Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
+    boolean hasReasonableProxyInterface = false;
+    for (Class<?> ifc : targetInterfaces) {
+        // 1.isConfigurationCallbackInterface: �ж�ifc�Ƿ�ΪInitializingBean��DisposableBean��
+        //   Closeable��AutoCloseable���Լ����� Aware
+        // 2.isInternalLanguageInterface: �Ƿ�Ϊ�ڲ����Խӿڣ���groovy��mock��
+        // 3.ifc.getMethods().length > 0���ӿڵķ������������1
+        if (!isConfigurationCallbackInterface(ifc) && !isInternalLanguageInterface(ifc) &&
+                ifc.getMethods().length > 0) {
+            hasReasonableProxyInterface = true;
+            break;
+        }
+    }
+    if (hasReasonableProxyInterface) {
+         // ��Ҫ�����еĽӿڶ����õ�proxyFactory
+         // ����һ�£����һ����A ʵ���˽ӿ� I1 �� I2��
+         // �����A�Ķ���a  �йܵ���spring��������ô������ʹ�� beanFactory.get(I1.class)��
+         // ���� beanFactory.get(I1.class)����Ӧ���ܻ�ȡ��a.
+         for (Class<?> ifc : targetInterfaces) {
+             proxyFactory.addInterface(ifc);
+         }
+    }
+    else {
+        proxyFactory.setProxyTargetClass(true);
+    }
+}
+
+```
+
+��Դ����������spring �ж��Ƿ���ʹ�� jdk ��̬�����Ĺ�����������֪�ϵIJ�࣬����������ʵ��������ӿھ���ʹ�� jdk ��̬������spring ���ų� `InitializingBean`��`DisposableBean`��`Closeable`��`AutoCloseable` �Ƚӿڣ�ͬʱҲ���ų����κη����Ľӿڡ�
+
+������ spring ����ж��Ƿ�ʹ�� jdk ��̬�����󣬽ӿ����������� spring ����δ�����������ġ�Ϊ��˵�����⣬���ȼ��� `AbstractAutoProxyCreator#createProxy`��
+
+```
+protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
+        @Nullable Object[] specificInterceptors, TargetSource targetSource) {
+    // ʡ��һЩ����
+    ...
+    ProxyFactory proxyFactory = new ProxyFactory();
+    //ʹ��proxyFactory����copy��ǰ���е��������
+    proxyFactory.copyFrom(this);
+    // ����ʡ���˺ö���ж�
+    proxyFactory.setProxyTargetClass(true);
+    //����������ǿ
+    proxyFactory.addAdvisors(advisors);
+    //����Ҫ��������
+    proxyFactory.setTargetSource(targetSource);
+    ...
+    //ʹ�ô���������ȡ��������
+    return proxyFactory.getProxy(getProxyClassLoader());
+}
+
+```
+
+��������Կ������������������һ�� `ProxyFactory` ����Ȼ�����ö����������������һЩֵ���������¿���
+
+> ProxyFactory#getProxy(java.lang.ClassLoader)
+
+```
+public Object getProxy(@Nullable ClassLoader classLoader) {
+    return createAopProxy().getProxy(classLoader);
+}
+
+```
+
+����������������`createAopProxy()` �� `getProxy(classLoader)`������������ `createAopProxy()`��
+
+> ProxyCreatorSupport#createAopProxy
+
+```
+protected final synchronized AopProxy createAopProxy() {
+    if (!this.active) {
+         activate();
+    }
+    return getAopProxyFactory().createAopProxy(this);
+}
+
+```
+
+������
+
+> DefaultAopProxyFactory#createAopProxy
+
+```
+/**
+ * �жϴ�������
+ * �����ʹ��jdk��̬�������ͷ��� JdkDynamicAopProxy
+ * ����ͷ��� ObjenesisCglibAopProxy
+ */
+public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
+    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
+        Class<?> targetClass = config.getTargetClass();
+        if (targetClass == null) {
+            throw new AopConfigException(...);
+        }
+        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
+            return new JdkDynamicAopProxy(config);
+        }
+        return new ObjenesisCglibAopProxy(config);
+    }
+    else {
+        return new JdkDynamicAopProxy(config);
+    }
+}
+
+```
+
+��������Ǿ������ף�`JdkDynamicAopProxy` ���������� jdk ��̬�����ģ�`ObjenesisCglibAopProxy` ���������� cglib �����ġ������������������� `getProxy(classLoader)` ������
+
+> JdkDynamicAopProxy#getProxy(java.lang.ClassLoader)
+
+```
+@Override
+public Object getProxy(@Nullable ClassLoader classLoader) {
+    Class<?>[] proxiedInterfaces = AopProxyUtils
+            .completeProxiedInterfaces(this.advised, true);
+    // �Ƿ���equals()��hashCode()����
+    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
+    // ���� jdk ���� ��������
+    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
+}
+
+```
+
+��������������õ��Ĵ���������ʲô���ģ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-ee46c03d86755b936862c9e8cde266fca1e.png)
+
+���Կ�������������� `h` ���Ա���ľ��� `JdkDynamicAopProxy` ����`JdkDynamicAopProxy` ����� `advised` ���Ա����˴����Ĵ����������Ϣ��
+
+> CglibAopProxy#getProxy(java.lang.ClassLoader)
+
+```
+public Object getProxy(@Nullable ClassLoader classLoader) {
+    try {
+        Class<?> rootClass = this.advised.getTargetClass();
+        Assert.state(rootClass != null, "xxx");
+
+        Class<?> proxySuperClass = rootClass;
+        if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
+            proxySuperClass = rootClass.getSuperclass();
+            Class<?>[] additionalInterfaces = rootClass.getInterfaces();
+            for (Class<?> additionalInterface : additionalInterfaces) {
+                this.advised.addInterface(additionalInterface);
+            }
+        }
+
+        validateClassIfNecessary(proxySuperClass, classLoader);
+
+        // ���� Enhancer ���󣬲�setһЩ����
+        Enhancer enhancer = createEnhancer();
+        if (classLoader != null) {
+            enhancer.setClassLoader(classLoader);
+            if (classLoader instanceof SmartClassLoader &&
+                    ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
+                enhancer.setUseCache(false);
+            }
+        }
+        // Superclass����Ҫ��������
+        enhancer.setSuperclass(proxySuperClass);
+        // ���ýӿڣ��� SpringProxy��Advised
+        enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
+        enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
+        enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
+
+        Callback[] callbacks = getCallbacks(rootClass);
+        Class<?>[] types = new Class<?>[callbacks.length];
+        for (int x = 0; x < types.length; x++) {
+            types[x] = callbacks[x].getClass();
+        }
+        enhancer.setCallbackFilter(new ProxyCallbackFilter(
+                this.advised.getConfigurationOnlyCopy(), 
+                this.fixedInterceptorMap, this.fixedInterceptorOffset));
+        enhancer.setCallbackTypes(types);
+
+        return createProxyClassAndInstance(enhancer, callbacks);
+    }
+    catch (CodeGenerationException | IllegalArgumentException ex) {
+        throw new AopConfigException(...);
+    }
+    catch (Throwable ex) {
+        throw new AopConfigException("Unexpected AOP exception", ex);
+    }
+}
+
+```
+
+spring ʹ�� cglib ����������Ҫ�õ��� `Enhancer` �࣬������һ�������ٷ�����
+
+�������Ҳ������������õ��Ķ���
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-97d647a818f62fa0979dabd58f3aa19e473.png)
+
+### 3\. �ܽ�
+
+������Ҫ������ `AbstractAutoProxyCreator#postProcessAfterInitialization`���÷�����Ҫ���������£�
+
+1.  ��ȡ��Ŀ�����������࣬���е㷽����װΪ `List`��ʵ���ϣ���һ���IJ���Ҳ���� `AbstractAutoProxyCreator#postProcessBeforeInitialization` ��ִ�У�Ȼ�󽫽����������������һ����ʵ��ֱ���ڻ������ý����
+2.  ��ȡ��ǰ�����������ǿ����һ�������ж���Щ��ǿ�������ڵ�ǰ�����ж�ʱ�Ȼ�ȡ��ǰ������нӿ��벻���� Object �ĸ��࣬Ȼ����һ�ж���Щ�ӿ������еķ����Ƿ�������ǿ������ֻҪ��һ���������㣬�ͱ�ʾ��ǰ������Ҫ��������
+3.  �����������󣺴�����������ʱ��Ĭ������£�������Ƿ�ʵ���˽ӿ���ѡ��ʹ�� jdk ��̬�������� cglib����Ӧ���ڵ�ǰ bean �� `List` Ҳ���װ�����������С�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4687961](https://my.oschina.net/funcy/blog/4687961) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/SpringAop\357\274\210\344\272\224\357\274\211\357\274\232cglib\344\273\243\347\220\206.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/SpringAop\357\274\210\344\272\224\357\274\211\357\274\232cglib\344\273\243\347\220\206.md"
new file mode 100644
index 0000000..412483a
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/SpringAop\357\274\210\344\272\224\357\274\211\357\274\232cglib\344\273\243\347\220\206.md"
@@ -0,0 +1,449 @@
+
+
+[��һƪ����](https://my.oschina.net/funcy/blog/4696654 "��һƪ����")������ spring �� jdK ��̬���������������� spring �� cglib ������
+
+### 1\. cglib �������
+
+jdk ��Ȼ�ṩ�˶�̬���������Ƕ�̬������һ�����㣺**�����û��ʵ�ֽӿڣ����޷� jdk ��̬����**��Ϊ�˽��������㣬spring �������� cglib ������
+
+cglib �ײ��ǻ��� asm �ģ�Ҳ����ֱ�Ӳ����ֽ��룬�൱�ڶ� asm ������һ���װ��ֱ�Ӳ������룬��Ҫ�� java ָ��ֽ����ļ�������������ܽ��У����ֽ����ɬ�Ѷ���һ�㲻����ֱ�Ӳ������� cglib ��װ���ֽ���IJ����ͱ�ü򵥶��ˣ����**�����������¶�����ʹ�� cglib ��װ�õķ����������ֽ������**��
+
+spring cglib ����λ�� `spring-core` ģ�飺
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-6b64440344221ca08ed8c822b5b22c1d341.png)
+
+�������� asm �� cglib ��˵����
+
+```
+/**
+ * Spring's repackaging of
+ * ASM 7.0
+ * (with Spring-specific patches; for internal use only).
+ *
+ * <p>This repackaging technique avoids any potential conflicts with
+ * dependencies on ASM at the application level or from third-party
+ * libraries and frameworks.
+ *
+ * <p>As this repackaging happens at the class file level, sources
+ * and javadocs are not available here.
+ */
+ package org.springframework.asm;
+
+```
+
+ע���һ�䣺`Spring's repackaging of ASM 7.0`���������� spring �� `asm7.0` ���´��.
+
+```
+/**
+ * Spring's repackaging of
+ * CGLIB 3.3
+ * (with Spring-specific patches; for internal use only).
+ *
+ * <p>This repackaging technique avoids any potential conflicts with
+ * dependencies on CGLIB at the application level or from third-party
+ * libraries and frameworks.
+ *
+ * <p>As this repackaging happens at the class file level, sources
+ * and javadocs are not available here.
+ */
+package org.springframework.cglib;
+
+```
+
+ע���һ�䣺`Spring's repackaging of CGLIB 3.3`���������� spring �� `CGLIB 3.3` ���´��.
+
+��ν���´���أ��������⣬���ǽ� `asm7.0` �� `CGLIB 3.3` ��Դ��ĸ����������Ƶ� spring ��Ŀ�¡���� spring ��û���� `gradle` �ļ������� `asm` �� `cglib` ���൱ jar ������������Ŀ��ֱ����������������Ŀ��Դ�룡
+
+### 2\. cglib ����ʾ��
+
+����ʽ��ʼ֮ǰ������������ �� cglib ��������ν��еġ�
+
+����׼��һ���ࣺ
+
+```
+package org.springframework.learn.demo04;
+
+public class CglibProxyService {
+    public void hello01() {
+        System.out.println("hello01");
+    }
+}
+
+```
+
+��׼��һ�� `MethodInterceptor`����� jdk ��̬�����е� `InvocationHandler`����
+
+```
+package org.springframework.learn.demo04;
+
+import org.springframework.cglib.proxy.MethodInterceptor;
+import org.springframework.cglib.proxy.MethodProxy;
+
+import java.lang.reflect.Method;
+
+public class MyMethodInterceptor implements MethodInterceptor {
+
+    /** Ŀ����� */
+    private Object target;
+
+    public MyMethodInterceptor(Object target){
+        this.target = target;
+    }
+
+    @Override
+    public Object intercept(Object proxyObj, Method method, Object[] objects, 
+                MethodProxy proxy) throws Throwable {
+        System.out.println("ִ�з���Ϊ:" + method.getName());
+        return proxy.invoke(target, objects);
+    }
+}
+
+```
+
+��������ࣺ
+
+```
+package org.springframework.learn.demo04;
+
+import org.springframework.cglib.proxy.Enhancer;
+
+/**
+ * ����������������
+ *
+ * @author fangchengyan
+ * @date 2020-11-01 9:23 ����
+ */
+public class Demo04Main {
+
+    public static void main(String[] args) {
+        CglibProxyService target = new CglibProxyService();
+        MyMethodInterceptor interceptor = new MyMethodInterceptor(target);
+
+        Enhancer enhancer = new Enhancer();
+        // ���ø���
+        enhancer.setSuperclass(CglibProxyService.class);
+        // ����callback�����callback���������ṩ�� MyMethodInterceptor
+        enhancer.setCallback(interceptor);
+        // ʹ�� enhancer ������������
+        CglibProxyService proxy = (CglibProxyService)enhancer.create();
+        proxy.hello01();
+    }
+}
+
+```
+
+���У�������£�
+
+```
+ִ�з���Ϊ:hello01
+hello01
+
+```
+
+���Կ������������� `MyMethodInterceptor#intercept` ִ��Ŀ�����ķ�����
+
+ͬ jdk ��̬�����ȽϺ󣬷������ߴ���߶����ƣ�
+
+*   `InvocationHandler` �� `InvocationHandler`�����ߴ�����ʽ����һ�� ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-6f3e8213e743554a7a8ffc587b98b1d7d3a.png)
+
+*   ��������Ĵ�����һ����ʹ�� `Enhangcer` ���д������󴴽���һ����ʹ�÷�װ�õķ������ж��󴴽��� ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-8ee847f9cbb7ec7fa6c35b2ad5a5537ef3a.png)
+
+�Ӵ������󴴽����������Կ��� `cglib` ���ɶ���ʱ�����õIJ����϶࣬���ܽϷḻ��
+
+���� `Enhangcer` ����δ������������Լ� `org.springframework.asm` �� `org.springframework.cglib` ���������µĴ��룬��Щ���� cglib �����ݣ��Ͳ���������ˡ�
+
+### 3\. spring �� `cglib` ������������
+
+������������ spring ����δ�����������ģ�
+
+> CglibAopProxy#getProxy(java.lang.ClassLoader)
+
+```
+public Object getProxy(@Nullable ClassLoader classLoader) {
+    try {
+        Class<?> rootClass = this.advised.getTargetClass();
+        Assert.state(rootClass != null, "...");
+
+        Class<?> proxySuperClass = rootClass;
+        if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
+            proxySuperClass = rootClass.getSuperclass();
+            Class<?>[] additionalInterfaces = rootClass.getInterfaces();
+            for (Class<?> additionalInterface : additionalInterfaces) {
+                this.advised.addInterface(additionalInterface);
+            }
+        }
+
+        // ��Ŀ������м�飬��Ҫ������������
+        // 1\. Ŀ�귽������ʹ��final���Σ�
+        // 2\. Ŀ�귽��������private���͵ģ�
+        // 3\. Ŀ�귽�������ǰ�����Ȩ�޵ģ�
+        // �������������κ�һ������ǰ�����Ͳ��ܱ���������ʱ�÷����ͻᱻ�Թ�
+        validateClassIfNecessary(proxySuperClass, classLoader);
+
+        Enhancer enhancer = createEnhancer();
+        if (classLoader != null) {
+            enhancer.setClassLoader(classLoader);
+            if (classLoader instanceof SmartClassLoader &&
+                    ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
+                enhancer.setUseCache(false);
+            }
+        }
+        // Superclass����Ҫ��������
+        enhancer.setSuperclass(proxySuperClass);
+        // ����AopProxyUtils.completeProxiedInterfaces()��������ҪĿ����ΪҪ���ɵĴ�����
+        // ����SpringProxy��Advised��DecoratingProxy������Ҫʵ�ֵĽӿڡ����������ӿڵ��������£�
+        // 1\. SpringProxy����һ���սӿڣ����ڱ�ǵ�ǰ���ɵĴ�������Spring���ɵĴ����ࣻ
+        // 2\. Advised��Spring���ɴ�������ʹ�õ����Զ������ڸýӿ��У�
+        //    ����Advisor��Advice������������ԣ�
+        // 3\. DecoratingProxy���ýӿ����ڻ�ȡ��ǰ����������������Ŀ������Class���͡�
+        enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
+        enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
+        enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
+
+        // ����callback
+        Callback[] callbacks = getCallbacks(rootClass);
+        Class<?>[] types = new Class<?>[callbacks.length];
+        for (int x = 0; x < types.length; x++) {
+            types[x] = callbacks[x].getClass();
+        }
+        // ���ô������и���������Ҫʹ�õ������߼�������ProxyCallbackFilter.accept()��������
+        // ������ֵ����һһ��Ӧ����Callback�����и��������߼����±꣬Ҳ����˵�����CallbackFilter
+        // ����������ָ���˴������и���������Ҫʹ��Callback�����е��ĸ����ļ��������߼�
+        enhancer.setCallbackFilter(new ProxyCallbackFilter( this.advised.getConfigurationOnlyCopy(),
+                this.fixedInterceptorMap, this.fixedInterceptorOffset));
+        enhancer.setCallbackTypes(types);
+
+        // ���ɴ�������
+        return createProxyClassAndInstance(enhancer, callbacks);
+    }
+    catch (...) {
+        ...
+    }
+}
+
+```
+
+���ϴ������������ `Enhancer` �����ԣ��� `classLoader`��`superclass`��`callbackFilter` �ȣ������� `createProxyClassAndInstance(xxx)` ������������
+
+> ObjenesisCglibAopProxy#createProxyClassAndInstance
+
+```
+protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
+    // ����������
+    Class<?> proxyClass = enhancer.createClass();
+    Object proxyInstance = null;
+
+    // ���ݴ����࣬ʹ�÷������ɶ���
+    if (objenesis.isWorthTrying()) {
+        try {
+            proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache());
+        }
+        catch (Throwable ex) {
+            ...
+        }
+    }
+
+    if (proxyInstance == null) {
+        try {
+            Constructor<?> ctor = (this.constructorArgs != null ?
+                    proxyClass.getDeclaredConstructor(this.constructorArgTypes) :
+                    proxyClass.getDeclaredConstructor());
+            ReflectionUtils.makeAccessible(ctor);
+            proxyInstance = (this.constructorArgs != null ?
+                    ctor.newInstance(this.constructorArgs) : ctor.newInstance());
+        }
+        catch (Throwable ex) {
+            throw new AopConfigException(...);
+        }
+    }
+    // ����callback����
+    // �������˶�� callback ʱ����ͨ�� CallbackFilter ��ȷ������ʹ���ĸ� callback
+    ((Factory) proxyInstance).setCallbacks(callbacks);
+    return proxyInstance;
+}
+
+```
+
+ͨ���ڵڶ����ֵ� `demo04` ����֪����cglib ������ִ�У��ᾭ�� `MethodInterceptor#intercept` �������õģ�Ҳ���� `Enhancer` �� `callback` ���ԣ���˽��������������� `callback` �Ļ�ȡ����ش���λ�� `CglibAopProxy#getCallbacks`��
+
+> CglibAopProxy#getCallbacks
+
+```
+private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
+    boolean exposeProxy = this.advised.isExposeProxy();
+    boolean isFrozen = this.advised.isFrozen();
+    boolean isStatic = this.advised.getTargetSource().isStatic();
+
+    // �û��Զ���Ĵ����߼���callback���������У������ @Before��@Around��@After�����淽����
+    // ����DynamicAdvisedInterceptor�����
+    Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);
+
+    Callback targetInterceptor;
+    // �ж����Ҫ��¶������������ǣ���ʹ��AopContext���ý������������õ�ThreadLocal��
+    // �û������ͨ��AopContext��ȡĿ�����
+    if (exposeProxy) {
+        // �жϱ������Ķ����Ƿ��Ǿ�̬�ģ�����Ǿ�̬�ģ���Ŀ����󻺴�������ÿ�ζ�ʹ�øö��󼴿ɣ�
+        // ���Ŀ������Ƕ�̬�ģ�����DynamicUnadvisedExposedInterceptor��ÿ�ζ�����һ���µ�
+        // Ŀ�������֯�����Ĵ����߼�
+        targetInterceptor = (isStatic ?
+                new StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) :
+                new DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource()));
+    }
+    else {
+        // �����������������������Ψһ����������Ƿ�ʹ��AopContext��¶���ɵĴ�������
+        targetInterceptor = (isStatic ?
+                new StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) :
+                new DynamicUnadvisedInterceptor(this.advised.getTargetSource()));
+    }
+
+    // ��ǰCallback���ڲ��ñ������ķ���
+    Callback targetDispatcher = (isStatic ?
+            new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp());
+
+    // ����ȡ����callback��װΪһ������
+    Callback[] mainCallbacks = new Callback[] {
+            // �û��Լ������������
+            aopInterceptor,  // for normal advice
+            // ���������Ƿ�¶���������������
+            targetInterceptor,  // invoke target without considering advice, if optimized
+            // �����κβ�����������
+            new SerializableNoOp(),  // no override for methods mapped to this
+            // ���ڴ洢Advised����ķַ���
+            targetDispatcher, this.advisedDispatcher,
+            // ���equals�������õ�������
+            new EqualsInterceptor(this.advised),
+            // ���hashcode�������õ�������
+            new HashCodeInterceptor(this.advised)
+    };
+
+    Callback[] callbacks;
+
+    // ���Ŀ������Ǿ�̬�ģ����������߼��ĵ������ǹ̶��ģ����Ŀ�������������������л���
+    if (isStatic && isFrozen) {
+        Method[] methods = rootClass.getMethods();
+        Callback[] fixedCallbacks = new Callback[methods.length];
+        this.fixedInterceptorMap = new HashMap<>(methods.length);
+
+        for (int x = 0; x < methods.length; x++) {
+            Method method = methods[x];
+            // ��ȡĿ�����������߼�
+            List<Object> chain = this.advised
+                    .getInterceptorsAndDynamicInterceptionAdvice(method, rootClass);
+            fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
+                    chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
+            // �Ե��������л���
+            this.fixedInterceptorMap.put(method, x);
+        }
+
+        // �����ɵľ�̬����������Callback������
+        callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
+        System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
+        System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
+        // ����fixedInterceptorOffset��¼�˵�ǰ��̬�ĵ������������߼�����ʼλ�ã�
+        // �����¼���ô����ں���ʹ��CallbackFilter��ʱ����������Ǿ�̬�ĵ�������
+        // ��ֱ��ͨ���ò�����ȡ��Ӧ�ĵ���������ֱ���Թ���ǰ��Ķ�̬������
+        this.fixedInterceptorOffset = mainCallbacks.length;
+    }
+    else {
+        callbacks = mainCallbacks;
+    }
+    return callbacks;
+}
+
+```
+
+���ϴ���Ƚϳ�����Ҫ���þ��ǻ�ȡ `callback`����Ȼ spring �ṩ���ڶ� `callback`�����������Զ���֪ͨ��ص� callback ֻ��һ���� `DynamicAdvisedInterceptor`������� `callback` �� `CglibAopProxy.DynamicAdvisedInterceptor#intercept` �����У������ڴ����е��Զ�֪ͨ����������ִ�еġ�
+
+��һ�����ǵõ� cglib �Ĵ�������󣬽����������������淽�������ִ�еġ�
+
+### 4\. cglib ���淽����ִ��
+
+cglib ���淽����ִ�� `CglibAopProxy.DynamicAdvisedInterceptor#intercept` ������
+
+> `CglibAopProxy.DynamicAdvisedInterceptor#intercept`
+
+```
+public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) 
+        throws Throwable {
+    Object oldProxy = null;
+    boolean setProxyContext = false;
+    Object target = null;
+    // ͨ��TargetSource��ȡĿ�����
+    TargetSource targetSource = this.advised.getTargetSource();
+    try {
+        // �ж������Ҫ��¶���������򽫵�ǰ�����������õ�ThreadLocal��
+        if (this.advised.exposeProxy) {
+            oldProxy = AopContext.setCurrentProxy(proxy);
+            setProxyContext = true;
+        }
+        target = targetSource.getTarget();
+        Class<?> targetClass = (target != null ? target.getClass() : null);
+        // ��ȡĿ����������߼��ĵ�����
+        List<Object> chain = this.advised
+                .getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
+        Object retVal;
+        if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
+            Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
+            // û����������ֱ�ӵ���Ŀ�����ķ���
+            retVal = methodProxy.invoke(target, argsToUse);
+        }
+        else {
+            // �������������裺
+            // 1\. ����ִ������new CglibMethodInvocation()
+            // 2\. ִ������������CglibMethodInvocation#proceed
+            retVal = new CglibMethodInvocation(proxy, target, method, args, 
+                    targetClass, chain, methodProxy).proceed();
+        }
+        // �Է���ֵ���д������������ֵ���ǵ�ǰĿ�������ô���������ɵĴ������󷵻أ�
+        // �������ֵΪ�գ����ҷ���ֵ�����Ƿ�void�Ļ����������ͣ����׳��쳣��
+        // ����������������������ϣ���ֱ�ӽ����ɵķ���ֵ����
+        retVal = processReturnType(proxy, target, method, retVal);
+        return retVal;
+    }
+    finally {
+        if (target != null && !targetSource.isStatic()) {
+            targetSource.releaseTarget(target);
+        }
+        if (setProxyContext) {
+            AopContext.setCurrentProxy(oldProxy);
+        }
+    }
+}
+
+```
+
+����ִ������ `new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed()`����������ȥ��
+
+> CglibAopProxy.CglibMethodInvocation#proceed
+
+```
+public Object proceed() throws Throwable {
+    try {
+        return super.proceed();
+    }
+    catch (...) {
+        ....
+    }
+}
+
+```
+
+ֱ�ӵ��õ��Ǹ���ķ�����`CglibAopProxy.CglibMethodInvocation` �ĸ�����˭�أ�һ����ȥ�����־�Ȼ�� `ReflectiveMethodInvocation`��`super.proceed()` ���õ��� `ReflectiveMethodInvocation#proceed`��
+
+��[��һ ƪ����](https://my.oschina.net/funcy/blog/4696654 "��һ ƪ����")�У����Ǿ���ϸ������ `ReflectiveMethodInvocation#proceed` �ĵ��ù��̣������ڣ��� cglib ���������ִ�е�Ҳ��ͬ���Ĵ��룬��һ���ִ�й��̾Ͳ��ظ������ˡ�
+
+�����һ��ͼ��˵������֪ͨ��ִ�й��̣�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-1c31c8e6279af4c150df18ebbd345c7f110.png)
+
+���յ�ִ��˳��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-a1f3ccebe3b7335eaef88b8a39ca36b9e05.png)
+
+### 5\. �ܽ�
+
+���ķ����� cglib ������ִ�й��̣������ִ������λ�� `CglibAopProxy.DynamicAdvisedInterceptor#intercept`�����յ��õ��� `ReflectiveMethodInvocation#proceed`������ jdk ��̬������ִ��������ͬ��
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4696655](https://my.oschina.net/funcy/blog/4696655) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/SpringAop\357\274\210\345\205\255\357\274\211\357\274\232aop\346\200\273\347\273\223.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/SpringAop\357\274\210\345\205\255\357\274\211\357\274\232aop\346\200\273\347\273\223.md"
new file mode 100644
index 0000000..041e629
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/SpringAop\357\274\210\345\205\255\357\274\211\357\274\232aop\346\200\273\347\273\223.md"
@@ -0,0 +1,22 @@
+ǰ�漸ƪ�������Ƿ����� spring aop ����ش��룬�����������ܽᡣ
+
+### 1\. spring ���� aop ����
+
+�� [spring aop��һ����ʾ�� demo �� @EnableAspectJAutoProxy](https://my.oschina.net/funcy/blog/4678093 "spring aop��һ����ʾ�� demo �� @EnableAspectJAutoProxy") һ���У����Ƿ����� spring ͨ�� `@EnableAspectJAutoProxy` ע������ aop ���ܣ������ע��ʵ�������� spring �е����� `AnnotationAwareAspectJAutoProxyCreator`�����������һ�� `BeanPostProcessor`�������� bean ��ʼ��ǰ����ɴ�����������ɡ�
+
+### 2\. �������������
+
+spring aop ����ע�ⷽʽ��ʵ����ͨ�� `AnnotationAwareAspectJAutoProxyCreator` ���������ģ��������һ�� `BeanPostProcessor`���� bean �ij�ʼ��ǰ��ִ�еIJ������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-c634a0bda86d94cce68aaa46ac74f57d41d.png)
+
+### 3\. ���淽����ִ��
+
+�����ô�������ķ�����jdk ����ݴ��������Ͷ�ѡ��ִ�� `InvocationHandler#invoke`(jdk ��̬����) ���� `MethodInterceptor#intercept`(cglib ����)����һ���ڴ�����������ʱ���Ѿ�������������ˣ��������޷���������ĸ���������������������������ݿ����߿������ɷ��ӡ��������������У�spring ���ȡ�����õ�ǰ���������� Advisors��Ȼ��ִ�� Advisors ������淽���������������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-96bb9ba4b77e60a85a1da1c2cec3858edf7.png) ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-013fb0c06e03fbe5044c211497df8ce306a.png)
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4701587](https://my.oschina.net/funcy/blog/4701587) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/SpringAop\357\274\210\345\233\233\357\274\211\357\274\232jdk\345\212\250\346\200\201\344\273\243\347\220\206.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/SpringAop\357\274\210\345\233\233\357\274\211\357\274\232jdk\345\212\250\346\200\201\344\273\243\347\220\206.md"
new file mode 100644
index 0000000..c2965a5
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/SpringAOP/SpringAop\357\274\210\345\233\233\357\274\211\357\274\232jdk\345\212\250\346\200\201\344\273\243\347\220\206.md"
@@ -0,0 +1,742 @@
+
+
+��һƪ���µ�������Ƿ����� spring ���ڴ����˴����������д�������ķ�ʽΪ `jdk��̬����`�� `cglib����`���������ǽ����� spring �Ķ�̬������
+
+### 1. jdk ��̬��������
+
+������ spring �Ķ�̬����ǰ�����������˽��� jdk �Ķ�̬������jdk ��̬������Ҫ�ӿڣ�Ϊ��������׼�������ӿڣ�
+
+> IJdkDynamicProxy01
+
+```java
+package org.springframework.learn.demo03;
+
+public interface IJdkDynamicProxy01 {
+    void hello01();
+}
+```
+
+> IJdkDynamicProxy02
+
+```java
+package org.springframework.learn.demo03;
+
+public interface IJdkDynamicProxy02 {
+    void hello02();
+}
+```
+
+����׼������ʵ���ࣺ
+
+> JdkDynamicProxyImpl01
+
+```java
+package org.springframework.learn.demo03;
+
+public class JdkDynamicProxyImpl01 implements IJdkDynamicProxy01, IJdkDynamicProxy02{
+    @Override
+    public void hello01() {
+        System.out.println("hello01");
+    }
+
+    @Override
+    public void hello02() {
+        System.out.println("hello02");
+    }
+}
+```
+
+> JdkDynamicProxyImpl02
+
+```java
+package org.springframework.learn.demo03;
+
+public class JdkDynamicProxyImpl02 implements IJdkDynamicProxy01 {
+
+    @Override
+    public void hello01() {
+        System.out.println("hello01");
+    }
+
+}
+```
+
+������Ҫע����ǣ�`JdkDynamicProxyImpl01` ʵ���� `IJdkDynamicProxy01` �� `IJdkDynamicProxy02` �����ӿڣ�`JdkDynamicProxyImpl02` ֻʵ���� `IJdkDynamicProxy01` һ�� �ӿڡ�
+
+����׼��һ�� `InvocationHandler`:
+
+> MyInvocationHandler
+
+```java
+package org.springframework.learn.demo03;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+
+public class MyInvocationHandler implements InvocationHandler {
+
+     /** Ŀ����� */
+     private Object target;
+
+    public MyInvocationHandler(Object target){
+        this.target = target;
+    }
+
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+        System.out.println("ִ�з���Ϊ:" + method.getName());
+        // ����������ִ��������
+        Object rs = method.invoke(target,args);
+        return rs;
+    }
+
+}
+```
+
+���������:
+
+```java
+package org.springframework.learn.demo03;
+
+import java.lang.reflect.Proxy;
+
+public class Demo03Main {
+
+    public static void main(String[] args) {
+        System.out.println("------------bean01------------");
+        JdkDynamicProxyImpl01 bean01 = new JdkDynamicProxyImpl01();
+        Object obj1 = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
+                // JdkDynamicProxyImpl01ʵ���� IJdkDynamicProxy01, IJdkDynamicProxy02
+                // �����classΪ IJdkDynamicProxy01, IJdkDynamicProxy02
+                new Class<?>[]{ IJdkDynamicProxy01.class, IJdkDynamicProxy02.class },
+                new MyInvocationHandler(bean01));
+        // ���Խ�������ǿ��ת��
+        ((IJdkDynamicProxy01) obj1).hello01();
+        ((IJdkDynamicProxy02) obj1).hello02();
+
+        System.out.println("------------bean01------------");
+        Object obj2 = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
+                 // JdkDynamicProxyImpl01ʵ���� IJdkDynamicProxy01, IJdkDynamicProxy02
+                 // �����classΪ IJdkDynamicProxy01
+                 new Class<?>[]{ IJdkDynamicProxy01.class },
+                 new MyInvocationHandler(bean01));
+        ((IJdkDynamicProxy01) obj2).hello01();
+        // ���쳣��java.lang.ClassCastException: class com.sun.proxy.$Proxy1 cannot be cast to class xxx
+        //((IJdkDynamicProxy02) obj2).hello02();
+
+        System.out.println("-----------bean02-------------");
+        JdkDynamicProxyImpl02 bean02 = new JdkDynamicProxyImpl02();
+        Object obj3 = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
+                 // JdkDynamicProxyImpl01ʵ���� IJdkDynamicProxy01
+                 // �����classΪ IJdkDynamicProxy01, IJdkDynamicProxy02
+                 new Class<?>[]{ IJdkDynamicProxy01.class, IJdkDynamicProxy02.class },
+                 new MyInvocationHandler(bean02));
+        ((IJdkDynamicProxy01) obj3).hello01();
+        IJdkDynamicProxy02 proxy02 = (IJdkDynamicProxy02) obj3;
+        // ���쳣��java.lang.IllegalArgumentException: object is not an instance of declaring class
+        //proxy02.hello02();
+
+    }
+}
+```
+
+������
+
+```
+ִ�з���Ϊ:hello01
+hello01
+ִ�з���Ϊ:hello02
+hello02
+------------bean01------------
+ִ�з���Ϊ:hello01
+hello01
+-----------bean02-------------
+ִ�з���Ϊ:hello01
+hello01
+```
+
+�Խ���������£�
+
+1. `Proxy#newProxyInstance(ClassLoader, Class<?>[], InvocationHandler)` �ĵڶ�����������Ľӿڣ��������Ǵ������������Ľӿ����ͣ�������������ִ����������������ִ��Ϊ�� `invoke()` ������
+2. `JdkDynamicProxyImpl01` ͬʱʵ���� `IJdkDynamicProxy01` �� `IJdkDynamicProxy02` �ӿڣ�������ӿ�����ʱ��ֻ������ `IJdkDynamicProxy01`������������ obj2 ǿתΪ `IJdkDynamicProxy02` ʱ���ͻᱨ `ClassCastException`��ǿתʧ�ܣ������ `Proxy#newProxyInstance(ClassLoader, Class<?>[], InvocationHandler)` �������Ǵ������������Ľӿ����ͣ�
+3. `JdkDynamicProxyImpl02` ֻʵ���� `IJdkDynamicProxy01` �ӿڣ�������ӿ�����ʱ�������� `IJdkDynamicProxy01` �� `IJdkDynamicProxy02`������������ `obj3` ǿתΪ `IJdkDynamicProxy02` ʱ����δ���쳣��������ִ�� `proxy02.hello02()` ʱ��ȴ���� `java.lang.IllegalArgumentException: object is not an instance of declaring class`��ͬ�������� `Proxy#newProxyInstance(ClassLoader, Class<?>[], InvocationHandler)` �������Ǵ������������Ľӿ����ͣ���Ŀ�����������޹ء�
+
+### 2. �ٴη��� spring jdk ��̬��������Ĵ���
+
+��������ķ����������������� spring ����δ�����������ģ�
+
+```java
+@Override
+public Object getProxy(@Nullable ClassLoader classLoader) {
+    // ��ȡĿ�����ʵ�ֵĽӿ�
+    Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
+    // �Ƿ���equals()��hashCode()����
+    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
+    // ���� jdk ���� ��������
+    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
+}
+```
+
+1. ����Ľӿ�Ϊ `proxiedInterfaces`�����ֵ������Ŀ����ʵ�ֵ����нӿڣ�ͬʱ spring Ҳ�����������Ľӿڣ��� `SpringProxy`��`Advised`����Щ����һƪ�����Ѿ���ϸ�������ˣ�
+2. ָ�� `InvocationHandler` Ϊ `this`��Ҳ���� `JdkDynamicAopProxy` �Ķ���ʵ���� `JdkDynamicAopProxy` ʵ���� `InvocationHandler`.
+
+�ɵ�һ���ֵķ�����֪��jdk ��̬��������ķ����������� `java.lang.reflect.InvocationHandler#invoke` ��ִ�еģ�Ҳ���� `JdkDynamicAopProxy#invoke`�����������Ǿ������� `JdkDynamicAopProxy#invoke` ������������ spring �����ִ�д��������ġ�
+
+### 3. jdk ��̬����������ִ��
+
+spring jdk ��̬����������ִ���� `JdkDynamicAopProxy#invoke`��
+
+> JdkDynamicAopProxy#invoke
+
+```java
+public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+    Object oldProxy = null;
+    boolean setProxyContext = false;
+
+    TargetSource targetSource = this.advised.targetSource;
+    Object target = null;
+
+    try {
+        // ��ִ�е� equals ����������Ҫ����ִ��
+        if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
+            return equals(args[0]);
+        }
+        // ��ִ�е� hashCode ����������Ҫ����ִ��
+        else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
+            return hashCode();
+        }
+        // ���ִ�е�class������DecoratingProxy��Ҳ����Ҫ����ִ��
+        else if (method.getDeclaringClass() == DecoratingProxy.class) {
+            return AopProxyUtils.ultimateTargetClass(this.advised);
+        }
+        else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
+                method.getDeclaringClass().isAssignableFrom(Advised.class)) {
+            return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
+        }
+
+        Object retVal;
+
+        // �ж� advised��exposeProxy ֵ�Ƿ�Ϊ true
+        // advised��exposeProxy��Դ�� @EnableAspectJAutoProxy �� exposeProxy
+        // �� ������ָ��ʱ��@EnableAspectJAutoProxy(exposeProxy = true)�����´���ִ��
+        if (this.advised.exposeProxy) {
+            // ����ǰ�� proxy ����ŵ� threadLocal ��
+            // �������� (UserService (AopContext.currentProxy)).getUser() ��ʽ����
+            oldProxy = AopContext.setCurrentProxy(proxy);
+            setProxyContext = true;
+        }
+
+        // ��ȡĿ�����Ŀ������class
+        target = targetSource.getTarget();
+        Class<?> targetClass = (target != null ? target.getClass() : null);
+
+        // �� aop �� advisor ת��Ϊ���������������жϸ÷�������ʹ����Щ���淽��
+        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(
+                method, targetClass);
+        if (chain.isEmpty()) {
+            // ����������������Ϊ�գ������÷���û�б����أ�ͨ������ֱ��ִ��
+            Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
+            retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
+        }
+        else {
+            // ����һ���������ö���
+            MethodInvocation invocation =
+                   new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
+            // ����ִ�У��ص�
+            retVal = invocation.proceed();
+        }
+
+        Class<?> returnType = method.getReturnType();
+        if (retVal != null && retVal == target &&
+                returnType != Object.class && returnType.isInstance(proxy) &&
+                !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
+            retVal = proxy;
+        }
+        else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
+            throw new AopInvocationException(...);
+        }
+        return retVal;
+    }
+    finally {
+        if (target != null && !targetSource.isStatic()) {
+            targetSource.releaseTarget(target);
+        }
+        if (setProxyContext) {
+            AopContext.setCurrentProxy(oldProxy);
+        }
+    }
+}
+```
+
+���Ϸ����������£�
+
+1. �ж�Ҫִ�еķ����Ƿ�Ϊ `equals`��`hashcode` �ȣ���Щ��������Ҫ������
+2. ��ȡ������Ҫִ�еķ������������淽�����õ�һ�����������ϣ�
+3. �������淽�������뼰Ŀ�귽����
+
+���������ص��ע���淽����Ŀ�귽����ִ�У��ؼ��������£�
+
+```java
+// �� aop �� advisor ת��Ϊ���������������жϸ÷�������ʹ����Щ���淽��
+List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(
+        method, targetClass);
+// ����һ���������ö���
+MethodInvocation invocation =
+       new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
+// ����ִ�У��ص�
+retVal = invocation.proceed();
+```
+
+#### ��ȡ `MethodInterceptor`
+
+�ڷ���������ִ��ǰ�������������� `getInterceptorsAndDynamicInterceptionAdvice(...)`�����������������ȡִ�е����淽���ģ�Ҳ���� `MethodInterceptor`��
+
+> AdvisedSupport#getInterceptorsAndDynamicInterceptionAdvice
+
+```java
+public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, 
+        @Nullable Class<?>targetClass) {
+    MethodCacheKey cacheKey = new MethodCacheKey(method);
+    List<Object> cached = this.methodCache.get(cacheKey);
+    if (cached == null) {
+        // ����������������ȡ��������ٷ���
+        cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
+                this, method, targetClass);
+        this.methodCache.put(cacheKey, cached);
+    }
+    return cached;
+}
+```
+
+������
+
+```java
+/**
+ * ��ȡ Interceptor���������£�
+ */
+@Override
+public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
+        Advised config, Method method, @Nullable Class<?> targetClass) {
+    AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
+    // ��ȡ advisors��aop��advisors���£�
+    Advisor[] advisors = config.getAdvisors();
+    List<Object> interceptorList = new ArrayList<>(advisors.length);
+    Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
+    Boolean hasIntroductions = null;
+    for (Advisor advisor : advisors) {
+        // ���advisor��PointcutAdvisor����ʹ��PointcutAdvisor���Pointcut����ƥ��
+        if (advisor instanceof PointcutAdvisor) {
+            PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
+            // �����ж������߼��ĵ������Ƿ���ǰ���й����ˣ�������й������ٽ���Ŀ�귽����ƥ�䣬
+            // ���û�У����ٽ���һ��ƥ�䡣
+            if (config.isPreFiltered() 
+                    || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
+                MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
+                boolean match;
+                if (mm instanceof IntroductionAwareMethodMatcher) {
+                    if (hasIntroductions == null) {
+                        hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
+                    }
+                    match = ((IntroductionAwareMethodMatcher) mm)
+                            .matches(method, actualClass, hasIntroductions);
+                }
+                else {
+                    match = mm.matches(method, actualClass);
+                }
+                if (match) {
+                    // ��Advisor����ת��ΪMethodInterceptor����
+                    MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
+                    if (mm.isRuntime()) {
+                        for (MethodInterceptor interceptor : interceptors) {
+                            // �� interceptor��methodMatcher��װ��InterceptorAndDynamicMethodMatcher
+                            interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
+                        }
+                    }
+                    else {
+                        interceptorList.addAll(Arrays.asList(interceptors));
+                    }
+                }
+            }
+        }
+        else if (advisor instanceof IntroductionAdvisor) {
+            // �ж����ΪIntroductionAdvisor���͵�Advisor���򽫵�������װΪInterceptor����
+            IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
+            if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
+                Interceptor[] interceptors = registry.getInterceptors(advisor);
+                interceptorList.addAll(Arrays.asList(interceptors));
+            }
+        }
+        else {
+            // �������ṩ��ʹ���Զ����ת������Advisor����ת�����߼�����ΪgetInterceptors()������
+            // ��ʹ����Ӧ��Adapter��Ŀ��Advisor����ƥ�䣬�����ƥ���ϣ�ͨ����getInterceptor()����
+            // ���Զ����Adviceת��ΪMethodInterceptor����
+            Interceptor[] interceptors = registry.getInterceptors(advisor);
+            interceptorList.addAll(Arrays.asList(interceptors));
+        }
+    }
+    return interceptorList;
+}
+```
+
+���Ǹ������Ϸ������ܽ��»�ȡ `MethodInterceptor` �Ĺ��̹������£�
+
+1. ��ȡ��Ŀ�����е� `advisors`
+
+2. ��������ÿ��
+
+
+
+   ```
+   advisor
+   ```
+
+
+
+�������������̴�����
+
+1. ��� `advisor` �� `PointcutAdvisor`����ʹ�����е� `Pointcut` ����ƥ�䣬ƥ��ɹ��󣬻�ȡ `MethodInterceptor` ���أ�
+2. ��� `advisor` �� `IntroductionAdvisor`����ʹ�����е� `ClassFilter` ����ƥ�䣬ƥ��ɹ��󣬻�ȡ `MethodInterceptor` ���أ�
+3. ����������������㣬ֱ�ӻ�ȡ `MethodInterceptor` ���أ�
+
+��ô `MethodInterceptor` ����λ�ȡ���أ����Ǽ������¿���
+
+```java
+// ��� AdvisorAdapter �ĵط�
+private final List<AdvisorAdapter> adapters = new ArrayList<>(3);
+
+// ���� adapter
+public DefaultAdvisorAdapterRegistry() {
+    // @Before
+    registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
+    // @AfterReturning
+    registerAdvisorAdapter(new AfterReturningAdviceAdapter());
+    // @AfterThrowing
+    registerAdvisorAdapter(new ThrowsAdviceAdapter());
+}
+
+/**
+ * ��ȡadvisor��Ӧ��MethodInterceptor
+ */
+@Override
+public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
+    List<MethodInterceptor> interceptors = new ArrayList<>(3);
+    // ��ȡ��ǰadvisor���MethodInterceptor
+    Advice advice = advisor.getAdvice();
+    // ��� advice �� MethodInterceptor��ʵ��������
+    if (advice instanceof MethodInterceptor) {
+        interceptors.add((MethodInterceptor) advice);
+    }
+    // 
+    // ʹ�� AdvisorAdapter �� advice ת��Ϊ MethodInterceptor
+    // ���advice����adapter������ adapter.getInterceptor ��ȡ MethodInterceptor
+    for (AdvisorAdapter adapter : this.adapters) {
+        if (adapter.supportsAdvice(advice)) {
+            interceptors.add(adapter.getInterceptor(advisor));
+        }
+    }
+    if (interceptors.isEmpty()) {
+        throw new UnknownAdviceTypeException(advisor.getAdvice());
+    }
+    return interceptors.toArray(new MethodInterceptor[0]);
+}
+```
+
+����������������ܽ����£�
+
+1. ��� `advice` �� `MethodInterceptor`��ֱ�ӽ���ת���� `MethodInterceptor`��
+2. ������ϲ����㣬��ʹ�� `AdvisorAdapter` �� advice ת���� `MethodInterceptor`.
+
+���� `adapters`��spring Ϊ�ṩ������ `Adapter`��
+
+- MethodBeforeAdviceAdapter������ `@Before`
+- AfterReturningAdviceAdapter������ `@AfterReturning`
+- ThrowsAdviceAdapter������ `@AfterThrowing`
+
+������ `Adapter` ��ֻ��һ�����ܣ����� `advice` ��Ӧ�� `MethodInterceptor`������������ `MethodBeforeAdviceAdapter` �Ĵ���������ˣ�
+
+```java
+class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
+    /**
+     * �Ƿ��ܴ�����ǰadvice
+     */
+    @Override
+    public boolean supportsAdvice(Advice advice) {
+        return (advice instanceof MethodBeforeAdvice);
+    }
+
+    /**
+     * ���ض�Ӧ��MethodInterceptor
+     */
+    @Override
+    public MethodInterceptor getInterceptor(Advisor advisor) {
+        MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
+        return new MethodBeforeAdviceInterceptor(advice);
+    }
+}
+```
+
+�������� `Adapter` �Ĺ��ܼ������ƣ��Ͳ������ˣ������ܽ��¸�ע���Ӧ�� `advice`��`methodInterceptor`��
+
+| ע��            | advice                      | methodInterceptor               |
+| --------------- | --------------------------- | ------------------------------- |
+| @Before         | AspectJMethodBeforeAdvice   | MethodBeforeAdviceInterceptor   |
+| @After          | AspectJAfterAdvice          | AspectJAfterAdvice              |
+| @Around         | AspectJAroundAdvice         | AspectJAroundAdvice             |
+| @AfterReturning | AspectJAfterReturningAdvice | AfterReturningAdviceInterceptor |
+| @AfterThrowing  | AspectJAfterThrowingAdvice  | ThrowsAdviceInterceptor         |
+
+#### ReflectiveMethodInvocation#proceed
+
+��ȡ�� `MethodInterceptor` �󣬾Ϳ�ʼ���з�����ִ���ˣ�����ֱ�ӽ��� `ReflectiveMethodInvocation#proceed` ������
+
+```java
+public Object proceed() throws Throwable {
+    // ִ�������е���ǿ��ִ��Ŀ�귽��
+    // ����ʹ����������ģʽ������������������е��ã�����������ʾ��ǰ�������Ѿ�ִ�е������
+    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
+        return invokeJoinpoint();
+    }
+
+    // ��ȡ��һ��Ҫִ�е�������
+    Object interceptorOrInterceptionAdvice =
+           this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
+    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
+        InterceptorAndDynamicMethodMatcher dm =
+                (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
+        Class<?> targetClass = (this.targetClass != null 
+                ? this.targetClass : this.method.getDeclaringClass());
+        if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
+            // ƥ�䣬�͵����������ķ�����Ҳ�������淽��
+            // �� MethodInterceptor#invoke����ٴ� ReflectiveMethodInvocation#proceed���ֵ����˵�ǰ����
+            return dm.interceptor.invoke(this);
+        }
+        else {
+            // ��ƥ�䣬��ݹ���õ�ǰ����
+            return proceed();
+        }
+    }
+    else {
+        // ע�⣬�����������IJ����� this����ʾ��ǰ����
+        // �� MethodInterceptor#invoke����ٴ� ReflectiveMethodInvocation#proceed���ֵ����˵�ǰ����
+        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
+    }
+}
+
+/**
+ * ����Ŀ�귽��
+ */
+protected Object invokeJoinpoint() throws Throwable {
+    // ʹ�÷������Ŀ����󷽷���ע�����ﴫ���Ӧ����Ŀ����󣬶����Ǵ�������
+    return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
+}
+```
+
+���ϴ���ĵ���ʹ����������ģʽ��ִ���߼����£�
+
+1. �ж��Ƿ�ִ�������е����淽�������ǣ���ִ��Ŀ�귽��������ִ����һ����
+2. ��ȡ��һ�����������ж��ܷ�ִ�У����ܣ����������������������ִ�е� һ��������
+
+�����߼�����ͦ�򵥣�����������ôִ�е��أ��� spring �У�����֪ͨ���������ͣ�`@Before`��`@After`��`@AfterReturning`��`@AfterThrowing` �� `@Around`����������һһ������������֪ͨ����ε��õġ�
+
+#### 1. `@Before`
+
+> MethodBeforeAdviceInterceptor#invoke
+
+```java
+@Override
+public Object invoke(MethodInvocation mi) throws Throwable {
+    // ִ��ǰ��֪ͨ��������
+    this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
+    // ����ִ����һ��������
+    return mi.proceed();
+}
+```
+
+���� `advice.before(xxx)` ������
+
+> AspectJMethodBeforeAdvice#before
+
+```java
+@Override
+public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
+    invokeAdviceMethod(getJoinPointMatch(), null, null);
+}
+```
+
+��������ȥ��
+
+> AbstractAspectJAdvice#invokeAdviceMethod(JoinPointMatch, Object, Throwable)
+
+```java
+protected Object invokeAdviceMethod(
+         @Nullable JoinPointMatch jpMatch, @Nullable Object returnValue, @Nullable Throwable ex)
+         throws Throwable {
+
+     return invokeAdviceMethodWithGivenArgs(argBinding(getJoinPoint(), jpMatch, returnValue, ex));
+}
+
+/**
+  *  ���÷���ִ��
+  */
+protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
+    Object[] actualArgs = args;
+    if (this.aspectJAdviceMethod.getParameterCount() == 0) {
+        actualArgs = null;
+    }
+    try {
+        // ��Ϥ��jdk�������
+        ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);
+        return this.aspectJAdviceMethod.invoke(
+                this.aspectInstanceFactory.getAspectInstance(), actualArgs);
+    }
+    catch (...) {
+        ...
+}
+```
+
+���Կ����������ǵ��� jdk ���������õġ�
+
+#### 2. `@After`
+
+> AspectJAfterAdvice#invoke
+
+```java
+@Override
+public Object invoke(MethodInvocation mi) throws Throwable {
+    try {
+        // ����ִ����һ��������
+        return mi.proceed();
+    }
+    finally {
+        // �������淽�������� finally �飬��ʾһ����ִ�У�����Ҳ��ʹ�÷������
+        invokeAdviceMethod(getJoinPointMatch(), null, null);
+    }
+}
+```
+
+#### 3. `@AfterReturning`
+
+> AfterReturningAdviceInterceptor#invoke
+
+```java
+@Override
+public Object invoke(MethodInvocation mi) throws Throwable {
+    // ����ִ����һ��������
+    Object retVal = mi.proceed();
+    // �������淽�����������¿�
+    this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
+    return retVal;
+}
+```
+
+> AspectJAfterReturningAdvice#afterReturning
+
+```java
+public void afterReturning(@Nullable Object returnValue, Method method, 
+            Object[] args, @Nullable Object target) throws Throwable {
+    if (shouldInvokeOnReturnValueOf(method, returnValue)) {
+        // �������淽������Ȼ�ǵ��÷���ִ��
+        invokeAdviceMethod(getJoinPointMatch(), returnValue, null);
+    }
+}
+```
+
+#### 4. `@AfterThrowing`
+
+> AspectJAfterThrowingAdvice#invoke
+
+```java
+@Override
+public Object invoke(MethodInvocation mi) throws Throwable {
+    try {
+        // ���� ReflectiveMethodInvocation#proceed
+        return mi.proceed();
+    }
+    catch (Throwable ex) {
+        if (shouldInvokeOnThrowing(ex)) {
+            // �������淽����ֻ�����׳��쳣ʱ�Żᱻ����
+            invokeAdviceMethod(getJoinPointMatch(), null, ex);
+        }
+        throw ex;
+    }
+}
+```
+
+#### 5. `@Around`
+
+> AspectJAroundAdvice#invoke
+
+```java
+@Override
+public Object invoke(MethodInvocation mi) throws Throwable {
+    if (!(mi instanceof ProxyMethodInvocation)) {
+        throw new IllegalStateException(...);
+    }
+    ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
+    ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi);
+    JoinPointMatch jpm = getJoinPointMatch(pmi);
+    // �������淽��
+    return invokeAdviceMethod(pjp, jpm, null, null);
+}
+```
+
+������ʵ�ֻ���֪ͨʱ��һ��������ʵ�֣�
+
+```java
+@Around(xxx)
+public Object around(ProceedingJoinPoint p){
+    // ִ��Ŀ�귽��ǰ�IJ���
+    ...
+
+    // ִ��Ŀ�귽������һ���ǹؼ�
+    // ʵ�����ﲢ��������ִ��Ŀ�귽�������յ��õ��� ReflectiveMethodInvocation#proceed
+    // ��������������������ִ����һ��������������ִ��Ŀ�귽��
+    Object o = p.proceed();
+
+    // ִ��Ŀ�귽����IJ���
+    ...
+    return o;
+}
+```
+
+spring ����������֪ͨ��ִ�У���Ҫ��Ϊ�������֣�
+
+1. ʹ�÷��䷽ʽִ�����淽����Ҳ������ν�� ����ǿ����
+2. ���� `ReflectiveMethodInvocation#proceed` ����ִ����һ������������ִ��Ŀ�귽����
+
+�����������ֵIJ�������ִ�д���ִ�е�λ�ã���
+
+- `@Before` ֪ͨ��`1` ��ǰ��`2` �ں�
+- `@AfterReturning` ֪ͨ��`2` ��ǰ��`1` �ں����ִ�� `2` ʱ�������쳣��`1` �Ͳ���ִ���ˣ�
+- `@AfterThrowing` ֪ͨ��`2` ��ǰ��`1` �ں��� `1` �Ƿ��� `catch` ����ִ�У���ֻ�з������쳣��`1` �Ż�ִ�У�
+- `@After` ֪ͨ��`2` ��ǰ��`1` �ں�`1` �Ƿ��� `finally` ����ִ�У����� `finally` �������ԣ���ʹ�������쳣��`1` ͬ����ִ�У�
+- `@Around` ֪ͨ�������淽��������ָ���� `2` ��ִ��ʱ����
+
+ע������ `@AfterReturning`��`@AfterThrowing` �� `@After` ֪ͨ��ִ��ʱ����
+
+����������������⼸��֪ͨ�����ִ�еġ�
+
+ͨ�����Եķ�ʽ������ spring ִ��֪ͨ��˳�����£�
+
+1. ����ִ�� `@AfterThrowing` ֪ͨ���ȵ��� `mi.proceed()` ִ����һ����������Ȼ���� `catch` ����ִ�����淽��������ֻ�г����쳣ʱ�������淽���Ż�ִ�У�
+2. ��һ�������У����� `mi.proceed()` ʱ��ִ�� `@AfterReturning` ֪ͨ��ִ��ʱ�ȵ��� `mi.proceed()` ִ����һ����������Ȼ����ִ�����淽����
+3. ��һ�������У����� `mi.proceed()` ʱ��ִ�� `@After` ֪ͨ��ִ��ʱ�ȵ��� `mi.proceed()` ִ����һ����������Ȼ���� `finally` ����ִ�����淽����������ʹ�����쳣�����淽�����ǻ�ִ�У�
+4. ��һ�������У����� `mi.proceed()` ʱ��ִ�� `@Around` ֪ͨ��ִ��ʱֱ��ִ�����淽�������� `@Around` ֪ͨ�����淽�������� `ProceedingJoinPoint#proceed()`�����ջ��ǻ�ִ����һ����������
+5. ��һ�������У����� `mi.proceed()` ʱ��ִ�� `@Before` ֪ͨ��ִ��ʱ����ִ�����淽�����ٵ��� `mi.proceed()` ִ����һ����������
+6. ��������ִ�е���󣬷���û�п�ִ�е��������ˣ���ʱ�Ϳ�ʼִ��Ŀ�귽����
+
+��ͼʾ��֪ͨ��ִ�й������£�
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-e88e0cec49c47648005e5d3160663425739.png)
+
+���յ�ִ��˳��
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-97026239d0b2dc02abbe87a9b76325c3cc0.png)
+
+### 4. �ܽ�
+
+������Ҫ������ jdk ��̬������ִ�й��̣������˸�������֪ͨ��ִ��˳�򡣱��ľ��ȵ������ˣ���һƪ���½����� cglib ��ִ�й��̡�
+
+------
+
+*����ԭ�����ӣ�https://my.oschina.net/funcy/blog/4696654 ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������*
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\344\270\200\357\274\211\357\274\232\350\256\244\350\257\206\344\272\213\345\212\241\347\273\204\344\273\266.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\344\270\200\357\274\211\357\274\232\350\256\244\350\257\206\344\272\213\345\212\241\347\273\204\344\273\266.md"
new file mode 100644
index 0000000..d46a99e
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\344\270\200\357\274\211\357\274\232\350\256\244\350\257\206\344\272\213\345\212\241\347\273\204\344\273\266.md"
@@ -0,0 +1,825 @@
+ǰ��������� spring aop ��ع��ܺ󣬱��Ľ������� spring aop ��һ��Ӧ�� ���� ���������
+
+### 1\. ������ demo ����
+
+����ʽ����ǰ����������˼���£�����������Լ������� spring aop �����һ�����������ƣ������ʵ���أ����û�� spring�����ǵ�����������һ�㳤������
+
+```
+public void fun() {
+    // ��������
+    start();
+    try {
+        // ҵ����
+        xxx();
+        // �ύ����
+        commit();
+    } catch(Exception e) {
+        // �ع�����
+        rollback();
+        throw e;
+    }
+}
+
+```
+
+������Ĵ������������������ύ���񡢻ع����񣬶���ҵ������޹أ���Щ����ʹ�� spring aop ��ʵ�֣���˾������������� demo.
+
+#### demo01������ `@Around` ע��ʵ������
+
+���ǿ���ʹ�� `@Around` ע�����������������£�
+
+1.  ����һ��ע�⣺`@MyTransactional`
+
+```
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+@Documented
+public @interface MyTransactional {
+}
+
+```
+
+1.  ���� aop ����
+
+```
+@Aspect
+@Component
+public class MyAopAspectj {
+    @Pointcut("@annotation(org.springframework.learn.tx.demo02.MyTransactional)")
+    public void testAop(){
+
+    }
+
+    @Around("testAop()")
+    public Object around(ProceedingJoinPoint p) throws Throwable {
+        System.out.println("ִ��ǰ����������....");
+        try {
+            Object o = p.proceed();
+            System.out.println("ִ����ɣ��ύ����....");
+            return o;
+        } catch (Throwable e) {
+            System.out.println("�������쳣�������쳣���ͻع�����....");
+            throw e;
+        } finally {
+            System.out.println("ִ�к�....");
+        }
+    }
+
+}
+
+```
+
+1.  config������һЩ��Ҫ������
+
+```
+@Configuration
+@ComponentScan("org.springframework.learn.tx.demo02")
+@EnableAspectJAutoProxy(proxyTargetClass = true)
+public class TxDemo02Config {
+
+}
+
+```
+
+1.  ����һ�� service �࣬����һ���������� `@MyTransactional` ע��
+
+```
+@Service
+public class TxTestService {
+
+    @MyTransactional
+    public void test01() {
+        System.out.println("ִ��test01����");
+    }
+
+    public void test02() {
+        System.out.println("ִ��test02����");
+    }
+
+}
+
+```
+
+1.  ����
+
+```
+public class TxDemo02Main {
+
+    public static void main(String[] args) {
+        AnnotationConfigApplicationContext applicationContext
+                = new AnnotationConfigApplicationContext(TxDemo02Config.class);
+        TxTestService service = applicationContext.getBean(TxTestService.class);
+        System.out.println("-------------------");
+        service.test01();
+        System.out.println("-------------------");
+        service.test02();
+
+    }
+}
+
+```
+
+���У�������£�
+
+```
+-------------------
+ִ��ǰ����������....
+ִ��test01����
+ִ����ɣ��ύ����....
+ִ�к�....
+-------------------
+ִ��test02����
+
+```
+
+��� demo �У�����ʹ�� `@Around` ע��������ҵ�����ִ��ǰ�����������Կ�����`@Around` ע������ڴ�������ǰ�������dz����쳣ʱ����һЩ����IJ�����
+
+#### demo02���Զ��� `advisor` ʵ������
+
+�����ǻ����� spring aop �� `@Around` ע��Ĵ�����ʵ���� `@Around` ���ջ��װΪ `InstantiationModelAwarePointcutAdvisorImpl` ���󣬺���Ĵ����͸� `@Around` �޹��ˣ�`@Around` �� `InstantiationModelAwarePointcutAdvisorImpl` ����Ĺ��̣��ɲο� [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������ϣ�](https://my.oschina.net/funcy/blog/4678817).
+
+`InstantiationModelAwarePointcutAdvisorImpl` �Ǹ�ʲô�����أ����Ǹ� `advisor`��������˵���ǿ����ڷ�������ǿ������ spring aop ������ҵ���Ӧ���ڵ�ǰ������ `advisor` �ģ��ɲο� [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������£�](https://my.oschina.net/funcy/blog/4687961)��
+
+ͨ�����Ϸ������������ṩ����һ��˼·�����ǿ���ʵ�� `advisor` �ӿڣ����ƻ��Լ����߼����������£�
+
+1.  ׼�� `advice`
+
+```
+/**
+ * ���advice����advisor��һ�����ԣ������߼������ﴦ��
+ */
+public class MyAdvice implements MethodInterceptor {
+
+    @Override
+    public Object invoke(MethodInvocation invocation) throws Throwable {
+        System.out.println("ִ��ǰ����������....");
+        try {
+            Object val = invocation.proceed();
+            System.out.println("ִ����ɣ��ύ����....");
+            return val;
+        } catch (Throwable e) {
+            System.out.println("�������쳣�������쳣���ͻع�����....");
+            throw e;
+        } finally {
+            System.out.println("ִ�к�....");
+        }
+    }
+}
+
+```
+
+1.  ׼�� `pointcut`
+
+```
+/**
+ * �е�
+ * �ж���Щ���������ڸ�advisor
+ */
+public class MyPointcut extends StaticMethodMatcherPointcut {
+    /**
+     * ƥ�䷽������ @MyTransactional ����򷽷��ͷ���true
+     */
+    @Override
+    public boolean matches(Method method, Class<?> targetClass) {
+        return null != AnnotationUtils.getAnnotation(method, MyTransactional.class)
+                || null != AnnotationUtils.getAnnotation(targetClass, MyTransactional.class);
+    }
+}
+
+```
+
+1.  ׼�� `advisor`
+
+```
+/**
+ * advisor �ɿ����� advice �� pointcut �İ�װ
+ */
+@Component
+public class MyAdvisor extends AbstractBeanFactoryPointcutAdvisor {
+
+    private static final long serialVersionUID = 2651364800145442305L;
+
+    private MyPointcut pointcut;
+
+    public MyAdvisor() {
+        this.pointcut = new MyPointcut();
+        this.setAdvice(new MyAdvice());
+    }
+
+    @Override
+    public Pointcut getPointcut() {
+        return this.pointcut;
+    }
+
+}
+
+```
+
+�����Dz�ͬ��ע���ʵ�ַ�ʽ���������Ĵ������ע��һ���ˡ�
+
+1.  ׼��һ��ע�⣺`@MyTransactional`
+
+```
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+@Documented
+public @interface MyTransactional {
+}
+
+```
+
+1.  ������Ŀ����
+
+```
+@Configuration
+@ComponentScan("org.springframework.learn.tx.demo01")
+@EnableAspectJAutoProxy(proxyTargetClass = true)
+public class TxDemo01Config {
+
+}
+
+```
+
+1.  ׼��һ�� service
+
+```
+@Service
+public class TxTestService {
+
+    @MyTransactional
+    public void test01() {
+        System.out.println("ִ��test01����");
+    }
+
+    public void test02() {
+        System.out.println("ִ��test02����");
+    }
+
+}
+
+```
+
+1.  ����
+
+```
+public class TxDemo01Main {
+
+    public static void main(String[] args) {
+        AnnotationConfigApplicationContext applicationContext
+                = new AnnotationConfigApplicationContext(TxDemo01Config.class);
+        TxTestService service = applicationContext.getBean(TxTestService.class);
+        System.out.println("-------------------");
+        service.test01();
+        System.out.println("-------------------");
+        service.test02();
+
+    }
+}
+
+```
+
+���У�������£�
+
+```
+-------------------
+ִ��ǰ����������....
+ִ��test01����
+ִ����ɣ��ύ����....
+ִ�к�....
+-------------------
+ִ��test02����
+
+```
+
+### 2\. ʹ�� spring �������
+
+����ǰ�������С demo ��Ϊ��θ�ˣ����� spring �����������������һ����������ʶ��spring �ڴ�������ʱ��ʹ�õľ��ǵڶ��ַ�ʽ�������Զ���һ�� `advisor` ���ӵ� spring �����С����� spring ʵ������ľ���ϸ�ڣ����Ǵ��������������������һ�� demo������������ƽʱ����ôʹ������ġ�
+
+Ϊ�˽������ݿ����ӣ�������Ҫ�������ݿ����ӳأ���������ʹ�õ��� mysql����Ҫ�� `spring-learn.gradle` ������������
+
+```
+optional("mysql:mysql-connector-java:5.1.48")
+
+```
+
+���ž��Ǵ����ˡ�
+
+1.  ������
+
+```
+@Configuration
+@ComponentScan("org.springframework.learn.tx.demo03")
+@EnableTransactionManagement(proxyTargetClass = true)
+public class TxDemo01Config {
+
+    /**
+     * ��������Դ
+     * @return
+     * @throws Exception
+     */
+    @Bean
+    public DataSource dataSource() throws Exception {
+        Driver driver = new com.mysql.jdbc.Driver();
+        String url = "jdbc:mysql://localhost:3306/test";
+        String username = "root";
+        String password = "123";
+        return new SimpleDriverDataSource(driver, url, username, password);
+    }
+
+    /**
+     * ����jdbcTemplate�������������������������ݿ�IJ���
+     * @param dataSource
+     * @return
+     */
+    @Bean
+    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
+        return new JdbcTemplate(dataSource);
+    }
+
+    /**
+     * ���������
+     * @param dataSource
+     * @return
+     */
+    @Bean
+    public DataSourceTransactionManager transactionManager(DataSource dataSource) {
+        return new DataSourceTransactionManager(dataSource);
+    }
+
+}
+
+```
+
+1.  ���ݿ������
+
+```
+@Service
+public class UserService {
+
+    @Autowired
+    private JdbcTemplate jdbcTemplate;
+
+    /**
+     * ���ݿ���������ʹ�� @Transactional ��������
+     * @return
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public int insert() {
+        String sql = "insert into `user`(`login_name`, `nick`, `create_time`, `update_time`)"
+                + "values (?, ?, ?, ?)";
+        int result = jdbcTemplate.update(sql, "test", "test", new Date(), new Date());
+        if(true) {
+            //throw new RuntimeException("�׳����쳣");
+        }
+        System.out.println(result);
+        return result;
+    }
+
+}
+
+```
+
+1.  ����
+
+```
+public class TxDemo01Main {
+
+    public static void main(String[] args) {
+        AnnotationConfigApplicationContext applicationContext
+                = new AnnotationConfigApplicationContext(TxDemo01Config.class);
+        UserService userService = applicationContext.getBean(UserService.class);
+        userService.insert();
+
+    }
+}
+
+```
+
+demo �У�`DataSource` ʹ�� spring �Դ��� `SimpleDriverDataSource`��`orm` ���Ҳ�� spring �ṩ�� `jdbcTemplate`��ʹ�õ� `user` �� sql ���£�
+
+```
+CREATE TABLE `user` (
+  `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '����id',
+  `login_name` varchar(32) NOT NULL DEFAULT '0' COMMENT '��¼��',
+  `nick` varchar(32) NOT NULL DEFAULT '0' COMMENT '�dz�',
+  `create_time` datetime DEFAULT NULL COMMENT '����ʱ��',
+  `update_time` datetime DEFAULT NULL COMMENT '����ʱ��',
+  PRIMARY KEY (`id`),
+  KEY `create_time` (`create_time`)
+) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='�û���';
+
+```
+
+ִ�н�����£�
+
+��һ�β��׳��쳣�����ݿ�����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-30bbe23a8e0491d1f59378469ad04703e03.png)
+
+�ڶ����׳��쳣�����ݿ�����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-edf98369ccef9735d83813cef7af7ea1dcd.png)
+
+�����β��׳��쳣�����ݿ�����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-fab4169dbec7661f27bba203c5e77232f65.png)
+
+���Կ������ڶ����׳��쳣ʱ�����������ع��ˡ�
+
+����������������� demo���������йصĴ�����������
+
+*   `@EnableTransactionManagement(proxyTargetClass = true)`����������
+*   `DataSourceTransactionManager`�����������
+*   `@Transactional`��ָ����������ķ���
+
+����� aop �� `@EnableAspectJAutoProxy`��`@EnableTransactionManagement` �������������ڣ��������Ǿʹ����ע�����֣����� spring ������������̡�
+
+### 3. `@EnableTransactionManagement` ע��
+
+```
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Import(TransactionManagementConfigurationSelector.class)
+public @interface EnableTransactionManagement {
+
+    /**
+     * ѧ��aop����ض���������Ѿ�����Ϥ
+     * true: ��ʾǿ��ʹ��cglib����
+     * false�����Ŀ����ʵ���˽ӿڣ���ʹ��jdk��̬����������ʹ��cglib����
+     * ���� mode Ϊ PROXY ����Ч
+     */
+    boolean proxyTargetClass() default false;
+
+    /**
+     * adviceģʽ��ʹ�ô���������ʹ�� aspectJ
+     */
+    AdviceMode mode() default AdviceMode.PROXY;
+
+    /**
+     * ִ��˳�򣬵�һ�����������ж����ǿʱ����ʲô����˳����ִ��
+     */
+    int order() default Ordered.LOWEST_PRECEDENCE;
+
+}
+
+```
+
+���ע�Ȿ��ûʲô�����������ԣ�ע���Ѿ�����ȷ�ˣ����ǹؼ����ǿ����ע��������ࣺ`TransactionManagementConfigurationSelector`��
+
+```
+public class TransactionManagementConfigurationSelector extends 
+        AdviceModeImportSelector<EnableTransactionManagement> {
+    @Override
+    protected String[] selectImports(AdviceMode adviceMode) {
+        switch (adviceMode) {
+            case PROXY:
+                // ���ڴ��������������������������
+                return new String[] {AutoProxyRegistrar.class.getName(),
+                        ProxyTransactionManagementConfiguration.class.getName()};
+            case ASPECTJ:
+                // ����aspectJ���������������������࣬���IJ�����
+                return new String[] {determineTransactionAspectClass()};
+            default:
+                return null;
+        }
+    }
+    // ʡ������
+    ...
+
+}
+
+```
+
+���ڴ�������������������������ࣺ`AutoProxyRegistrar`��`ProxyTransactionManagementConfiguration`�����������Ǿ��������������ࡣ
+
+#### 3.1 `AutoProxyRegistrar`
+
+��������������`AutoProxyRegistrar` ��һ��ע���������ǵ�ǰ�� aop ��ע���� `AspectJAutoProxyRegistrar` ������һ������·��
+
+�������������澿������ɶ��
+
+```
+public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
+
+    private final Log logger = LogFactory.getLog(getClass());
+
+    @Override
+    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, 
+            BeanDefinitionRegistry registry) {
+        boolean candidateFound = false;
+        Set<String> annTypes = importingClassMetadata.getAnnotationTypes();
+        for (String annType : annTypes) {
+            AnnotationAttributes candidate = AnnotationConfigUtils
+                    .attributesFor(importingClassMetadata, annType);
+            if (candidate == null) {
+                continue;
+            }
+            Object mode = candidate.get("mode");
+            Object proxyTargetClass = candidate.get("proxyTargetClass");
+            // ����if�����ģ����� @EnableTransactionManagement ע��
+            if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&
+                    Boolean.class == proxyTargetClass.getClass()) {
+                candidateFound = true;
+                if (mode == AdviceMode.PROXY) {
+                    // ע�����������ע���� InfrastructureAdvisorAutoProxyCreator �࣬���������������
+                    AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
+                    if ((Boolean) proxyTargetClass) {
+                        // ʹ��cglib����
+                        AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
+                        return;
+                    }
+                }
+            }
+        }
+        if (!candidateFound && logger.isInfoEnabled()) {
+            String name = getClass().getSimpleName();
+            logger.info(...);
+        }
+    }
+}
+
+```
+
+���д���ؼ��ľ�ֻ�� if ��ļ��У���˵�� if ������`mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&Boolean.class == proxyTargetClass.getClass()`��ͨ������Ķ� `@EnableTransactionManagement`����˵�ľ������ˣ����� `mode == AdviceMode.PROXY`���������� `AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry)`��������������ĵ��ã����ǽ������������������Ȼ���� `proxyTargetClass`��������Ե������� `@EnableAspectJAutoProxy` �е� `proxyTargetClass` һ�£�Ҳ�ǿ���ǿ��ʹ�� cglib ������
+
+���������������� `AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry)` �Ĺ��̣��������룺
+
+> AopConfigUtils
+
+```
+    @Nullable
+    public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
+        // �������¿�
+        return registerAutoProxyCreatorIfNecessary(registry, null);
+    }
+
+    @Nullable
+    public static BeanDefinition registerAutoProxyCreatorIfNecessary(
+            BeanDefinitionRegistry registry, @Nullable Object source) {
+        // ���� InfrastructureAdvisorAutoProxyCreator �࣬��������
+        return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, 
+            registry, source);
+    }
+
+```
+
+��������Dz��������������Ϥ�У�aop �е� `AspectJAnnotationAutoProxyCreator` Ҳ ����ôע��ģ����� `AopConfigUtils#registerOrEscalateApcAsRequired` ������
+
+```
+// AopConfigUtils ��ע����඼��������
+private static final List<Class<?>> APC_PRIORITY_LIST = new ArrayList<>(3);
+
+static {
+    APC_PRIORITY_LIST.add(InfrastructureAdvisorAutoProxyCreator.class);
+    APC_PRIORITY_LIST.add(AspectJAwareAdvisorAutoProxyCreator.class);
+    APC_PRIORITY_LIST.add(AnnotationAwareAspectJAutoProxyCreator.class);
+}
+
+/**
+ * ע�����
+ */
+private static BeanDefinition registerOrEscalateApcAsRequired(
+        Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
+    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
+    //����Ѵ������bean
+    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
+        BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
+        //�ж����ȼ���������ȼ��ϸ����滻ԭ�ȵ�bean
+        if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
+            int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
+            int requiredPriority = findPriorityForClass(cls);
+            // �Ѵ����� �����ȼ� С������ע��ģ���ʹ������ע��ģ��Ѵ��ڵ�����������ȼ�Ϊ
+            // 0: InfrastructureAdvisorAutoProxyCreator(��������)
+            // 1: AspectJAwareAdvisorAutoProxyCreator(��������xml��aop)
+            // 2: AnnotationAwareAspectJAutoProxyCreator(��������ע���aop)
+            if (currentPriority < requiredPriority) {
+                apcDefinition.setBeanClassName(cls.getName());
+            }
+        }
+        return null;
+    }
+    //ע��XxxAutoProxyCreator��������
+    RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
+    beanDefinition.setSource(source);
+    beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
+    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
+    registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
+    return beanDefinition;
+}
+
+/**
+ * ����ע��������ȼ�
+ */
+private static int findPriorityForClass(@Nullable String className) {
+    for (int i = 0; i < APC_PRIORITY_LIST.size(); i++) {
+        Class<?> clazz = APC_PRIORITY_LIST.get(i);
+        if (clazz.getName().equals(className)) {
+            return i;
+        }
+    }
+    throw new IllegalArgumentException(
+            "Class name [" + className + "] is not a known auto-proxy creator class");
+}
+
+```
+
+`AopConfigUtils` ��ע���������������
+
+*   `InfrastructureAdvisorAutoProxyCreator`����������
+*   `AspectJAwareAdvisorAutoProxyCreator`���������� xml �� aop
+*   `AnnotationAwareAspectJAutoProxyCreator`����������ע��� aop
+
+�����ߵ����ȼ�Ϊ `AnnotationAwareAspectJAutoProxyCreator` > `AspectJAwareAdvisorAutoProxyCreator` > `InfrastructureAdvisorAutoProxyCreator`��ע��ʱ�����ж�ע��������ȼ������ȼ��ߵ����ջᱻע�뵽 spring �����С������͵�����һ�����⣺**�����Ŀ��ͬʱ������ aop (`@EnableAspectJAutoProxy`) ������ (`@EnableTransactionManagement`)����ô����ע�뵽�����Ľ��� `AnnotationAwareAspectJAutoProxyCreator`����Ҳ����˵��`AnnotationAwareAspectJAutoProxyCreator` Ҳ�ܴ�������** ��仰�dz��ؼ�������ζ������Ĵ������̣�ʵ���ϾͰ�����ǰ������� aop �Ĺ������ˣ�
+
+����Ҳ������ `InfrastructureAdvisorAutoProxyCreator`��
+
+```
+// �̳��� AbstractAdvisorAutoProxyCreator�������dz��ؼ�
+public class InfrastructureAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator {
+
+    @Nullable
+    private ConfigurableListableBeanFactory beanFactory;
+
+    @Override
+    protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
+        super.initBeanFactory(beanFactory);
+        this.beanFactory = beanFactory;
+    }
+
+    @Override
+    protected boolean isEligibleAdvisorBean(String beanName) {
+        return (this.beanFactory != null && 
+                this.beanFactory.containsBeanDefinition(beanName) 
+                &&  this.beanFactory.getBeanDefinition(beanName).getRole() 
+                                == BeanDefinition.ROLE_INFRASTRUCTURE);
+    }
+
+}
+
+```
+
+`InfrastructureAdvisorAutoProxyCreator` ��ʵ��û����ʲô�� aop ��ص��£������̳���һ���ؼ����ࣺ`AbstractAdvisorAutoProxyCreator`���������Ǵ�����ͷ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-2881f63ac07afc5095c449ddb9a0df2bb55.png)
+
+�Ӽ̳й�ϵ�����������̳��� `AbstractAutoProxyCreator`���� `AbstractAutoProxyCreator` ���������� - [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������ϣ�](https://my.oschina.net/funcy/blog/4678817) �� [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������£�](https://my.oschina.net/funcy/blog/4687961)���ص�����ġ���������IJ������ڣ�
+
+������������ `AnnotationAwareAspectJAutoProxyCreator`��`AspectJAwareAdvisorAutoProxyCreator` ��`InfrastructureAdvisorAutoProxyCreator` �����ߵĹ�ϵ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-acd72335503eeb686abe81d930b45f1f3f0.png)
+
+���Կ�����`AspectJAwareAdvisorAutoProxyCreator` ��`InfrastructureAdvisorAutoProxyCreator` ���̳��� `AbstractAdvisorAutoProxyCreator`��`AnnotationAwareAspectJAutoProxyCreator` �ּ̳��� `AspectJAwareAdvisorAutoProxyCreator`��
+
+ͨ�����Ϸ�����`AutoProxyRegistrar` ������ spring ����ע���� `InfrastructureAdvisorAutoProxyCreator`(`aop` δ���õ������)����������� `aop`�����ע�� `AspectJAwareAdvisorAutoProxyCreator`(���� `xml` �� `aop`) �� `AnnotationAwareAspectJAutoProxyCreator`(���� `annotation` �� `aop`)��
+
+#### 3.2 `ProxyTransactionManagementConfiguration`
+
+���������������� `ProxyTransactionManagementConfiguration` �ࡣ���������������Ǹ������ࣺ
+
+```
+@Configuration(proxyBeanMethods = false)
+public class ProxyTransactionManagementConfiguration 
+        extends AbstractTransactionManagementConfiguration {
+
+    /**
+     * ��ȡSpring�� @Transactional ע�⣬������Ӧ���������Թ�����Spring����������ṹ
+     */
+    @Bean
+    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+    public TransactionAttributeSource transactionAttributeSource() {
+        return new AnnotationTransactionAttributeSource();
+    }
+
+    /**
+     * TransactionInterceptor�̳���Advice��������Ǹ�advice���������������ִ�в���
+     * @param transactionAttributeSource������������� transactionAttributeSource() ����
+     */
+    @Bean
+    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+    public TransactionInterceptor transactionInterceptor(
+            TransactionAttributeSource transactionAttributeSource) {
+        TransactionInterceptor interceptor = new TransactionInterceptor();
+        // �����������Դ������󣬾����������� @Transactional ע�� �Ķ�ȡ
+        interceptor.setTransactionAttributeSource(transactionAttributeSource);
+        if (this.txManager != null) {
+            interceptor.setTransactionManager(this.txManager);
+        }
+        return interceptor;
+    }
+
+    /**
+     * ������ǿ��.
+     * @param transactionAttributeSource������������� transactionAttributeSource() ����
+     * @param transactionInterceptor������������� transactionInterceptor(...) ����
+     */
+    @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
+    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+    public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(
+            TransactionAttributeSource transactionAttributeSource,
+            TransactionInterceptor transactionInterceptor) {
+        BeanFactoryTransactionAttributeSourceAdvisor advisor 
+                = new BeanFactoryTransactionAttributeSourceAdvisor();
+        // ���������࣬�������� @Transactional ������
+        advisor.setTransactionAttributeSource(transactionAttributeSource);
+        // ����advice����advice�ﴦ������
+        advisor.setAdvice(transactionInterceptor);
+        if (this.enableTx != null) {
+            advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
+        }
+        return advisor;
+    }
+
+}
+
+```
+
+���Կ��������������һ Щ `bean`��
+
+*   `transactionAttributeSource`������Ϊ `AnnotationTransactionAttributeSource`���������� `@Transactional` ע�⣻
+*   `transactionInterceptor`������Ϊ `TransactionInterceptor`��`Advice` �����࣬����������߼���������
+*   `transactionAdvisor`������Ϊ `BeanFactoryTransactionAttributeSourceAdvisor`�����Ǹ� `Advisor`���������������߼����ڲ�������������������`transactionAttributeSource` �� `transactionInterceptor`��
+
+`ProxyTransactionManagementConfiguration` �̳��� `AbstractTransactionManagementConfiguration`���� `AbstractTransactionManagementConfiguration` ��Ҳ������һЩ `bean`��
+
+```
+@Configuration
+public abstract class AbstractTransactionManagementConfiguration implements ImportAware {
+
+    @Nullable
+    protected AnnotationAttributes enableTx;
+
+    /**
+     * �������������
+     */
+    @Nullable
+    protected TransactionManager txManager;
+
+    /**
+     * ������ ImportAware �ӿڵķ���
+     */
+    @Override
+    public void setImportMetadata(AnnotationMetadata importMetadata) {
+        this.enableTx = AnnotationAttributes.fromMap(importMetadata
+                .getAnnotationAttributes(EnableTransactionManagement.class.getName(), false));
+        if (this.enableTx == null) {
+            throw new IllegalArgumentException(
+                    "@EnableTransactionManagement is not present on importing class " 
+                    + importMetadata.getClassName());
+        }
+    }
+
+    /**
+     * �������������.
+     * ע��spring���������е� TransactionManagementConfigurer ����
+     * TransactionManagementConfigurer��ֻ��һ��������
+     *  TransactionManager annotationDrivenTransactionManager()
+     * ���������������һ�����������
+     */
+    @Autowired(required = false)
+    void setConfigurers(Collection<TransactionManagementConfigurer> configurers) {
+        if (CollectionUtils.isEmpty(configurers)) {
+            return;
+        }
+        if (configurers.size() > 1) {
+            throw new IllegalStateException("Only one TransactionManagementConfigurer may exist");
+        }
+        TransactionManagementConfigurer configurer = configurers.iterator().next();
+        this.txManager = configurer.annotationDrivenTransactionManager();
+    }
+
+    /**
+     * �����¼��������������� @TransactionalEventListener ע��ķ���.
+     */
+    @Bean(name = TransactionManagementConfigUtils.TRANSACTIONAL_EVENT_LISTENER_FACTORY_BEAN_NAME)
+    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+    public static TransactionalEventListenerFactory transactionalEventListenerFactory() {
+        return new TransactionalEventListenerFactory();
+    }
+
+}
+
+```
+
+*   `void setConfigurers(Collection<TransactionManagementConfigurer> configurers)`��ע�� `TransactionManagementConfigurer` ���󣬾����������ڴ���ע����˵����
+*   `TransactionalEventListenerFactory`������Ϊ `TransactionalEventListenerFactory`���������������¼�����Ҫ�� `@TransactionalEventListener` ע��ķ����������ⲿ�ֵ����ݣ����ľͲ�չ���ˣ���
+
+���ˣ�������Щ�����spring �Ϳ��Խ����������ˣ���Щ����������ƪ�����ٷ�����
+
+### 4\. �ܽ�
+
+�������Ǵ����� demo ���֣�ʾ����������������Լ�����һ������ spring aop �����������������ν��еģ���������һ�� demo ʾ�������ʹ�� spring �ṩ������������ܣ�Ȼ��;�������� spring ��������ע�� `@EnableTransactionManagement` �Ĺ��ܡ�
+
+`@EnableTransactionManagement` �� spring ��������������������ܵģ��� `AdviceMode` Ϊ `proxy` ģʽ�£���ע���� spring �������������ࣺ`AutoProxyRegistrar`��`ProxyTransactionManagementConfiguration`���������£�
+
+*   `AutoProxyRegistrar`��`aop` δ���õ�����£����� spring ������ע�� `InfrastructureAdvisorAutoProxyCreator`����������� `aop`�����ע�� `AspectJAwareAdvisorAutoProxyCreator`(���� `xml` �� `aop`) �� `AnnotationAwareAspectJAutoProxyCreator`(���� `annotation` �� `aop`)���������඼�� `AbstractAdvisorAutoProxyCreator` �����࣬�������ɴ�������
+
+*   `ProxyTransactionManagementConfiguration`������һ�������࣬ͨ������ `@Bean` ע��ķ�����������������һϵ�е� bean���������������߼�������Щ bean������ֻ�����˽⼴�ɡ�
+
+���ľ��ȵ������ˣ���ƪ���¼����������������ơ�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4773454](https://my.oschina.net/funcy/blog/4773454) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\344\270\211\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\351\232\224\347\246\273\347\272\247\345\210\253\344\270\216\344\274\240\346\222\255\346\226\271\345\274\217\347\232\204\345\244\204\347\220\20601.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\344\270\211\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\351\232\224\347\246\273\347\272\247\345\210\253\344\270\216\344\274\240\346\222\255\346\226\271\345\274\217\347\232\204\345\244\204\347\220\20601.md"
new file mode 100644
index 0000000..73a5691
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\344\270\211\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\351\232\224\347\246\273\347\272\247\345\210\253\344\270\216\344\274\240\346\222\255\346\226\271\345\274\217\347\232\204\345\244\204\347\220\20601.md"
@@ -0,0 +1,387 @@
+����һƪ���µ���������ᵽ�����ִ���� `TransactionAspectSupport#invokeWithinTransaction` �����У����Ľ����������������̽�� spring ��������ơ�
+
+ע��������̽�ֵ����ݿ��� `mysql`���������ݿ���ܻ��������졣
+
+### 1. ������ظ���
+
+����ʽ��������Դ��ǰ��һЩǰ��֪ʶ����Ҫ�˽�һ�µģ�������Ҫ������ spring ��ص�������
+
+#### 1.1 ����ĸ��뼶��
+
+�������Ĵ����� `ACID`���о����£�
+
+- ԭ���ԣ�`Atomicity`��
+- һ���ԣ�`Consistency`��
+- �����ԣ�`Isolation`��
+- �־��ԣ�`Durability`��
+
+������ĸ��뼶�����ǶԸ����ԣ�`Isolation`���Ľ�һ�����֣���Щ���뼶�����£�
+
+- `��δ�ύ`
+- `���ύ`
+- `���ظ���`
+- `���л�`
+
+������Щ����IJ������������������ص㻹�ǹ�ע spring ��ص����ݣ�spring ��������뼶��Ķ����� `org.springframework.transaction.annotation.Isolation` �У��������£�
+
+```
+public enum Isolation {
+
+    /**
+    * Ĭ��ֵ�������ø��뼶������ʹ�õ������ݿ����õĸ��뼶��
+    */
+    DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),
+
+    /**
+    * ��δ�ύ
+    */
+    READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),
+
+    /**
+    * ���ύ
+    */
+    READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED),
+
+    /**
+    * ���ظ���
+    */
+    REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ),
+
+    /**
+    * ���л�
+    */
+    SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE);
+
+    ...
+}
+```
+
+���ǿ���ʹ�� `@Transactional` ע��� `isolation` �����ø��뼶��
+
+#### 1.2 ����ij�ʱʱ��
+
+- ���Ը�����ָ��һ��ִ��ʱ�䣬���ִ�����ĵ�ʱ�䳬����ָ��ʱ�䣬����ͻ��׳��쳣�Ӷ��ع�
+- ������ `@Transactional` ע��� `timeout` �����ó�ʱʱ��
+
+#### 1.3 ֻ������
+
+- ���Խ���������Ϊ`ֻ��ģʽ`�������ƽʱ�û���û�õ����鵽һЩ����˵������������Ϊ`ֻ��ģʽ`�����������еĸ���ֻ�����񿴲�������ֻ�������в�����д��������ʵ���д���֤
+- ���ǿ���ʹ�� `@Transactional` ע��� `readOnly` ������ֻ��ģʽ
+
+#### 1.4 ����Ĵ�������
+
+��������һ�������`����A` ��`��ʽB` ��������������`����B` �е���`����A`�������`����A` ִ����ɺ�`����B` �����ˣ�����ʾ�����£�
+
+```
+class A {
+    // ����������
+    @Transactional
+    public void methdA() {
+        // ����һЩ����
+        ...
+    }
+}
+
+class B {
+    // ����������
+    @Transactional
+    public void methodB() {
+        // 1. ����һЩ����
+        ...
+        // 2. ���� methodA()
+        a.methodA();
+        // 3. ���ﱨ����
+        throw new RuntimeException();
+    }
+}
+```
+
+���ڿ���������`����B` ��һ����ع��ģ���ô`����A` Ҫ��Ҫ�ع��أ�
+
+- ������ǰ�`����A` ��`����B` �����񿴳���ͬһ������`����A` Ӧ��Ҳ��Ҫ�ع���
+- ������ǰ�`����A` ��`����B` ������������������������ִ�У�`����A` ��ִ����`����B` �ı����޹أ�`����A` �Ͳ�Ӧ�ûع�
+
+Ϊ�˴������־��ף�spring ������`����Ĵ�������`�ĸ�����ǿ���ʹ�� `@Transactional` ע��� `propagation` ������ֻ��ģʽ��
+
+```
+public @interface Transactional {
+    ...
+
+    // Ĭ�ϵļ���Ϊ Propagation.REQUIRED
+    Propagation propagation() default Propagation.REQUIRED;
+
+}
+```
+
+spring һ�������� 7 ������Ĵ������ͣ��о����£�
+
+| ���񴫲���Ϊ                | ����                                                         |
+| --------------------------- | ------------------------------------------------------------ |
+| `PROPAGATION_REQUIRED`      | ��Ĭ��ֵ�����衿��ǰ�������������������У������ǰ�߳���û����������һ���µ����������ǰ�߳����Ѿ����������򷽷������ڸ����������С� |
+| `PROPAGATION_MANDATORY`     | ��ǿ�ơ���ǰ�������������������У������ǰ�߳��в�����������**�׳��쳣** |
+| `PROPAGATION_SUPPORTS`      | ��֧�֡���ǰ������������ʱ����Ҫ���񣬵������ǰ�߳��д�������ʱ�������������������� |
+| `PROPAGATION_REQUIRES_NEW`  | �������񡿵�ǰ���������ڶ��������������У������ǰ�߳����Ѿ����������򽫸�����������¿���һ������ֱ���������н����ٻָ�֮ǰ������ |
+| `PROPAGATION_NESTED`        | ��Ƕ�ס���ǰ�������������������У������ǰ�߳��д��������򽫸������ע**�����**���γ�Ƕ������Ƕ�������е�����������쳣����Ӱ�쵽�����񱣴��֮ǰ�IJ����� |
+| `PROPAGATION_NOT_SUPPORTED` | ����֧�֡���ǰ�������������������У������ǰ�߳��д����������������ֱ���������н��� |
+| `PROPAGATION_NEVER`         | ������������ǰ���������������������У������ǰ�߳��д���������**�׳��쳣** |
+
+ע������������͵�����
+
+1. `PROPAGATION_REQUIRED` �� `PROPAGATION_MANDATORY`
+    - `PROPAGATION_REQUIRED`������Ҫ�����������У�û�������**����������**
+    - `PROPAGATION_MANDATORY`������Ҫ�����������У�û�������**���쳣**
+2. `PROPAGATION_NOT_SUPPORTED` �� `PROPAGATION_NEVER`
+    - `PROPAGATION_NOT_SUPPORTED`�������������������������**��������**
+    - `PROPAGATION_NEVER`�����������������У��������**���쳣**
+3. `PROPAGATION_REQUIRES_NEW` �� `PROPAGATION_NESTED`
+    - `PROPAGATION_REQUIRES_NEW`��������ִ����ɺ󣬾����񱨴���ֻ�ع������������񲻻ع���������ִ�б������¾�����һ��ع�
+    - `PROPAGATION_NESTED`��������ִ����ɺ󣬸����񱨴����ع�������㣻������ִ�б�����Ҳ�ǻع��������
+
+### 2. demo ׼��
+
+��ȷ�����ϸ���󣬽������Ϳ�ʼ�����ˣ�������׼�����򵥵� demo��
+
+����׼��һЩ���ã�
+
+```
+@Configuration
+@ComponentScan("org.springframework.learn.tx.demo03")
+@EnableTransactionManagement(proxyTargetClass = true)
+public class TxDemo03Config {
+
+    /**
+     * ��������Դ
+     */
+    @Bean
+    public DataSource dataSource() throws Exception {
+        Driver driver = new com.mysql.jdbc.Driver();
+        String url = "jdbc:mysql://localhost:3306/test";
+        String username = "root";
+        String password = "123";
+        return new SimpleDriverDataSource(driver, url, username, password);
+    }
+
+    /**
+     * ����jdbcTemplate�������������������������ݿ�IJ���
+     */
+    @Bean
+    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
+        return new JdbcTemplate(dataSource);
+    }
+
+    /**
+     * ���������
+     */
+    @Bean
+    public DataSourceTransactionManager transactionManager(DataSource dataSource) {
+        return new DataSourceTransactionManager(dataSource);
+    }
+
+}
+```
+
+�����ϴ���˵�����£�
+
+- ����Դ��ʹ�õ��� spring �ṩ�� `SimpleDriverDataSource`���������Դ���ܲ��࣬�ʺ�����򵥵� demo
+- ���� jdbc ��ز�����Ҳ��ʹ�� spring �ṩ�� `jdbcTemplate`����Ϊһ���򵥵� demo���������� `mybatis`��`jpa` ��
+- �����������ʹ�õ�Ҳ�� spring �ṩ�� `DataSourceTransactionManager` ���Ե�����Դ��˵�������ȫ������
+
+׼��һ�� mysql �IJ�����Ҫ��������
+
+```
+@Service
+public class UserService {
+
+    @Autowired
+    private JdbcTemplate jdbcTemplate;
+
+    /**
+     * ���ݿ���������ʹ�� @Transactional ��������
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public int insert() {
+        String sql = "insert into `user`(`login_name`, `nick`, `create_time`, `update_time`)" 
+                + "values (?, ?, ?, ?)";
+        int result = jdbcTemplate.update(sql, "test", "test", new Date(), new Date());
+        if(true) {
+            //throw new RuntimeException("�׳����쳣");
+        }
+        System.out.println(result);
+        return result;
+    }
+
+}
+```
+
+��������ࣺ
+
+```
+public class TxDemo03Main {
+
+    public static void main(String[] args) {
+        AnnotationConfigApplicationContext applicationContext
+                = new AnnotationConfigApplicationContext(TxDemo03Config.class);
+        UserService userService = applicationContext.getBean(UserService.class);
+        userService.insert();
+
+    }
+}
+```
+
+��� demo ʮ�ּ򵥣��Ͳ����������ˣ����ǽ�������ͨ����� demo ����һЩ���Ȳ�����̽���� spring ������ĸ��뼶�𡢴�����ʽ�Ĵ�����
+
+### 3. `TransactionAspectSupport#invokeWithinTransaction`
+
+����һ��ƪ���Ǿ�˵��������Ĵ����� `TransactionAspectSupport#invokeWithinTransaction` ���������������ǽ��ص�������������
+
+�ϴ��룺
+
+```
+protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
+        final InvocationCallback invocation) throws Throwable {
+    TransactionAttributeSource tas = getTransactionAttributeSource();
+
+    // 1. ��ȡ @Transactional ����������
+    final TransactionAttribute txAttr = (tas != null 
+            ? tas.getTransactionAttribute(method, targetClass) : null);
+
+    // 2. ��ȡ�����������IOC�����л�ȡ��
+    final TransactionManager tm = determineTransactionManager(txAttr);
+
+    // �ⲿ�ֵĴ�������� TransactionManager �� ReactiveTransactionManager ���������������
+    ...
+
+    // 3. �� TransactionManager ת��Ϊ PlatformTransactionManager
+    PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
+    // 4. ��ȡ������ȫ�޶�������ʽΪ��"����.����.������"
+    final String joinpointIdentification 
+            = methodIdentification(method, targetClass, txAttr);
+    if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
+        // 5. ��ȡ������Ϣ���������￪������
+        TransactionInfo txInfo = createTransactionIfNecessary(
+                ptm, txAttr, joinpointIdentification);
+        Object retVal;
+        try {
+            // 6. ִ�о����ҵ��
+            retVal = invocation.proceedWithInvocation();
+        }
+        catch (Throwable ex) {
+            // 7. �쳣�ع�
+            completeTransactionAfterThrowing(txInfo, ex);
+            throw ex;
+        }
+        finally {
+            // 8. ����������Ϣ�����ǽ�������Ϣ����Ϊ�ɵ�
+            cleanupTransactionInfo(txInfo);
+        }
+
+        if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
+            TransactionStatus status = txInfo.getTransactionStatus();
+            if (status != null && txAttr != null) {
+                retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
+            }
+        }
+        // 9. �ύ����
+        commitTransactionAfterReturning(txInfo);
+        return retVal;
+    }
+    else {
+        // ���� CallbackPreferringPlatformTransactionManager ���͵� TransactionManager����������
+        ...
+    }
+}
+```
+
+�� `TransactionAspectSupport#invokeWithinTransaction` ���������ݣ�ע��������ϸ˵����������Ϊ������������Щִ�й��̡�
+
+#### 3.1 ��ȡ `@Transactional` ����������
+
+������ǻ�ȡ `UserService#insert` �����ϱ�ǵ� `@Transactional` ���������ã��õ��Ľ�����£�
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-aefbe56da2db53982f73092a191e587fcc8.png)
+
+#### 3.2 ��ȡ���������
+
+��ȡ����������ķ���Ϊ `TransactionAspectSupport#determineTransactionManager`��ֱ�ӿ����룺
+
+```
+protected TransactionManager determineTransactionManager(@Nullable TransactionAttribute txAttr) {
+    if (txAttr == null || this.beanFactory == null) {
+        return getTransactionManager();
+    }
+
+    // ����� @Transaction ע����ָ����������������ʹ�spring�����л�ȡ������������
+    String qualifier = txAttr.getQualifier();
+    if (StringUtils.hasText(qualifier)) {
+        return determineQualifiedTransactionManager(this.beanFactory, qualifier);
+    }
+    // ָ��������������ƣ�����Ҳ�Ǵ�spring�����л�ȡ
+    else if (StringUtils.hasText(this.transactionManagerBeanName)) {
+        return determineQualifiedTransactionManager(
+            this.beanFactory, this.transactionManagerBeanName);
+    }
+    else {
+        // ָ���������������ֱ�ӷ���
+        TransactionManager defaultTransactionManager = getTransactionManager();
+        if (defaultTransactionManager == null) {
+            // �ӻ����л�ȡĬ�ϵ�
+            defaultTransactionManager = this.transactionManagerCache
+                    .get(DEFAULT_TRANSACTION_MANAGER_KEY);
+            if (defaultTransactionManager == null) {
+                // �������ʹ� spring �����л�ȡһ�����������
+                defaultTransactionManager = this.beanFactory.getBean(TransactionManager.class);
+                this.transactionManagerCache.putIfAbsent(
+                        DEFAULT_TRANSACTION_MANAGER_KEY, defaultTransactionManager);
+            }
+        }
+        return defaultTransactionManager;
+    }
+}
+```
+
+������Ȼ�е㳤�����߼��dz�����������Ը÷����������ܽ����£�
+
+1. ����� `@Transaction` ע����ָ����������������ʹ� spring �����л�ȡ�����������
+2. ���ָ��������������ƣ��ʹ� spring �����л�ȡ�����������
+3. ���ָ���������������ֱ�ӷ���
+4. ���϶������㣬ֱ�Ӵ� spring �����л�ȡ����Ϊ `TransactionManager` �� bean
+
+�� `TxDemo03Config` �У������������������Ϊ `DataSourceTransactionManager`��
+
+```
+public DataSourceTransactionManager transactionManager(DataSource dataSource) {
+    return new DataSourceTransactionManager(dataSource);
+}
+```
+
+����õ���Ҳ�� `DataSourceTransactionManager`��
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-34ac74501b184c44f95432b31b21a041619.png)
+
+#### 3.3 �� `TransactionManager` ת��Ϊ `PlatformTransactionManager`
+
+���ûɶ��˵�ģ�`DataSourceTransactionManager` ���� `PlatformTransactionManager` �����࣬����������һ������ת����
+
+```
+private PlatformTransactionManager asPlatformTransactionManager(
+        @Nullable Object transactionManager) {
+    if (transactionManager == null || transactionManager instanceof PlatformTransactionManager) {
+        return (PlatformTransactionManager) transactionManager;
+    } else {
+        // �׸��쳣
+        ...
+    }
+}
+```
+
+#### 3.4 ��ȡ������ȫ�޶���
+
+��һ�����õ�������ȫ�޶�������ʽΪ��"���������͡�������"����Ҳûɶ��˵�ģ���һ���õ��Ľ�����£�
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-656a73b9eb1cd3120d3586fe4f1302de373.png)
+
+����ƪ�������ľ��ȷ����������ˣ���ƪ���Ǽ�����
+
+------
+
+*����ԭ�����ӣ�https://my.oschina.net/funcy/blog/4773459 ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������*
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\344\272\214\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\346\211\247\350\241\214\346\265\201\347\250\213.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\344\272\214\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\346\211\247\350\241\214\346\265\201\347\250\213.md"
new file mode 100644
index 0000000..f086983
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\344\272\214\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\346\211\247\350\241\214\346\265\201\347\250\213.md"
@@ -0,0 +1,664 @@
+�� [spring ����֮��ʶ�������](https://my.oschina.net/funcy/blog/4773454)һ���У�����ͨ��һ�� demo ��ʾ�����ʹ�� spring ����������ܣ�Ȼ������� `@EnableTransactionManagement` ע��Ĺ��ܣ����Ľ��������� spring ������ش��롣
+
+### 1\. �������󴴽�����
+
+spring ������������ǻ��� aop �ģ�ʹ�ô������������������һϵ�в��������Ľ�ͨ�����Եķ�ʽ��������������Ĵ������̡�
+
+�� [spring ����֮��ʶ�������](https://my.oschina.net/funcy/blog/4773454)������ͨ������ `@EnableTransactionManagement` ע�⣬���ָ�ע����� spring ������ע�� `InfrastructureAdvisorAutoProxyCreator`��������� `AbstractAdvisorAutoProxyCreator` �����࣬�������ɴ�������ģ����ڽ����� `InfrastructureAdvisorAutoProxyCreator` ����������Ĵ������̡�
+
+> ���� `AbstractAdvisorAutoProxyCreator` �ķ����Լ�������������ɣ��� [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������ϣ�](https://my.oschina.net/funcy/blog/4678817) �� [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������£�](https://my.oschina.net/funcy/blog/4687961)�Ѿ�������ϸ����������������Ҫ������ aop �в���ĵط�����Ҫ��ϸ�˽� spring aop ����������β�����С��飬�����Ķ�������ƪ���¡�
+
+���������ǽ��� `AbstractAutoProxyCreator#postProcessBeforeInitialization`��
+
+```
+public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
+    ...
+    if (...) {
+        //1\. shouldSkip:
+        // - AspectJAwareAdvisorAutoProxyCreator �� shouldSkip �����ᴦ�� @Aspect ע����࣬
+        //   �����е�@Before/@After/@Around��ע���װΪAdvisor���ٵ��ø���(Ҳ����
+        //   AbstractAutoProxyCreator)��shouldSkip����
+        // - InfrastructureAdvisorAutoProxyCreatorֱ��ִ��AbstractAutoProxyCreator��shouldSkip����
+        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
+            this.advisedBeans.put(cacheKey, Boolean.FALSE);
+            return null;
+        }
+    }
+    if(...)  {
+        ...
+
+        // 2\. getAdvicesAndAdvisorsForBean����ȡ�������ڵ�ǰ�����advisor
+        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(
+            beanClass, beanName, targetSource);
+        Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
+        ...
+        return proxy;
+    }
+    return null;
+}
+
+```
+
+���������������ͬ�㣬�������Ѿ�ע�������еIJ��죬���� `shouldSkip`��ûɶ��˵�ģ������ص�չ�� `getAdvicesAndAdvisorsForBean(...)` ������
+
+#### 1.1 `BeanFactoryAdvisorRetrievalHelper#findAdvisorBeans`
+
+һ·���� `getAdvicesAndAdvisorsForBean(...)` ���������еIJ����� `AspectJAwareAdvisorAutoProxyCreator` �IJ�������̫�����𣬲����и�����������Ϊ��Ҫǿ���£��������£�
+
+> BeanFactoryAdvisorRetrievalHelper#findAdvisorBeans
+
+```
+public List<Advisor> findAdvisorBeans() {
+    String[] advisorNames = this.cachedAdvisorBeanNames;
+    if (advisorNames == null) {
+        // ���ҵ�ǰbeanFactory������ Advisor �� bean class
+        // Advisor�������û�ʵ��Advisor��ؽӿڣ�Ҳ������xmlָ����
+        advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
+                this.beanFactory, Advisor.class, true, false);
+        this.cachedAdvisorBeanNames = advisorNames;
+    }
+    ...
+    List<Advisor> advisors = new ArrayList<>();
+    for (String name : advisorNames) {
+        ...
+        // ����advisor��bean name����spring�����л�ȡ bean
+        advisors.add(this.beanFactory.getBean(name, Advisor.class));
+        ...
+    }
+    ...
+    return advisors;
+}
+
+```
+
+���������Ҫ�������ǻ�ȡ spring �����е����� `advisor`����ʵ�� `AnnotationAwareAspectJAutoProxyCreator` ��Ҳ����ô��ȡ�ģ�ֻ�����ڻ�ȡǰ��`AnnotationAwareAspectJAutoProxyCreator` ���� `shouldSkip(...)` �����а� `@Aspect` ���а��� `@Befor/@After/@Around` ��ע��ķ�����װ�ɶ�Ӧ�� `Advisor`���� `InfrastructureAdvisorAutoProxyCreator` �򲻻ᣬ����һ��ʼҲ�ᵽ���ˡ�
+
+�� [spring ����֮��ʶ�������](https://my.oschina.net/funcy/blog/4773454)һ���У����� `@EnableTransactionManagement` ע�⹦��ʱ�����Ƿ�������ע���ͨ�� `@Bean` ע���� spring ������ `BeanFactoryTransactionAttributeSourceAdvisor`����� bean �ͻ��� `BeanFactoryAdvisorRetrievalHelper#findAdvisorBeans` ����ȡ����
+
+#### 1.2 `AopUtils#canApply(...)`
+
+���ŷ���һ·�����ߣ����ž��������ж� `advisor` �ܷ�������Ŀ�� `class` �ĵط��ˣ�
+
+```
+/**
+ * �ж�advisor�ܷ�������Ŀ��class
+ */
+public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
+    ...
+    // �ж��Ƿ�Ϊ PointcutAdvisor�����������advisorΪBeanFactoryTransactionAttributeSourceAdvisor��
+    // ��ʵ����PointcutAdvisor���������Ĵ����ִ��
+    else if (advisor instanceof PointcutAdvisor) {
+        PointcutAdvisor pca = (PointcutAdvisor) advisor;
+        //ʹ�� PointcutAdvisor �����ж�
+        return canApply(pca.getPointcut(), targetClass, hasIntroductions);
+    }
+    ...
+}
+
+/**
+ * �ж�advisor�ܷ�������Ŀ��class
+ */
+public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
+    Assert.notNull(pc, "Pointcut must not be null");
+    //1\. �е����Ƿ�����ų��������
+    if (!pc.getClassFilter().matches(targetClass)) {
+        return false;
+    }
+    // ��ȡ����ƥ�����MethodMatcher.TRUE ΪĬ�ϵ� MethodMatcher ����
+    MethodMatcher methodMatcher = pc.getMethodMatcher();
+    if (methodMatcher == MethodMatcher.TRUE) {
+        return true;
+    }
+    ...
+    // classes����targetClass����Object�����и��ࡢ���нӿ�
+    Set<Class<?>> classes = new LinkedHashSet<>();
+    // ʡ�Ի�ȡtargetClass�ĸ��ಽ��
+    ...
+    for (Class<?> clazz : classes) {
+        // ��ȡ clazz ����ķ�����������ǰ��ķ�������Object������и��෽�����ӿڵ�Ĭ�Ϸ���
+        Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
+        for (Method method : methods) {
+            // 2\. ƥ��Ĺؼ�������
+            if (introductionAwareMethodMatcher != null ?
+                    introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
+                    methodMatcher.matches(method, targetClass)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+```
+
+��һ��Ĵ����� `AnnotationAwareAspectJAutoProxyCreator` һģһ�������Ƕ��ǵ���ͬ���ķ������жϣ������ڴ���ĵ� `advisor` ��ͬ�����յ��õ��ľ����ƥ�����Ҳ����ͬ��
+
+�Ӵ���ķ���������ƥ����߼����� `Pointcut` �У��� `Pointcut` �������� `Advisor`���ɼ� `Advisor` ʮ�ֹؼ������������ `Advisor` Ϊ `BeanFactoryTransactionAttributeSourceAdvisor`�����������Ǿ�����������ࡣ
+
+#### 1.3 `BeanFactoryTransactionAttributeSourceAdvisor` ƥ��������
+
+����һС �ڵķ����У�����֪���ж� `targetClass` �ܷ�Ӧ�õ�ǰ `advisor` �Ĺ�����Դ�� `advisor` �� `pointcut`��`pointcut` �������ط��������жϹ���
+
+*   ƥ���ࣺ`pc.getClassFilter().matches(targetClass)`
+*   ƥ�䷽����`pc.getMethodMatcher().matches(method, targetClass)`
+
+��һС �����Ǵ� `BeanFactoryTransactionAttributeSourceAdvisor` ���֣�һ��������ƥ�����
+
+```
+public class BeanFactoryTransactionAttributeSourceAdvisor 
+        extends AbstractBeanFactoryPointcutAdvisor {
+
+    @Nullable
+    private TransactionAttributeSource transactionAttributeSource;
+
+    /**
+     * ������� pointcut
+     */
+    private final TransactionAttributeSourcePointcut pointcut = 
+            new TransactionAttributeSourcePointcut() {
+        @Override
+        @Nullable
+        protected TransactionAttributeSource getTransactionAttributeSource() {
+            return transactionAttributeSource;
+        }
+    };
+
+    /**
+     * ���� transactionAttributeSource
+     */
+    public void setTransactionAttributeSource(TransactionAttributeSource 
+            transactionAttributeSource) {
+        this.transactionAttributeSource = transactionAttributeSource;
+    }
+
+    /**
+     * ���� ClassFilter
+     */
+    public void setClassFilter(ClassFilter classFilter) {
+        this.pointcut.setClassFilter(classFilter);
+    }
+
+    /**
+     * ��ȡ pointcut
+     */
+    @Override
+    public Pointcut getPointcut() {
+        return this.pointcut;
+    }
+}
+
+```
+
+����Ĵ���ؼ������Ѿ�ע���ˣ��������ܽ��£�`BeanFactoryTransactionAttributeSourceAdvisor#getPointcut` �õ��� `pointcut` Ϊ `TransactionAttributeSourcePointcut`�������� `private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {...}` �д����ġ�
+
+`BeanFactoryTransactionAttributeSourceAdvisor` �� `transactionAttributeSource` ��ʲô�أ������� `ProxyTransactionManagementConfiguration` �д��� `transactionAdvisor` �Ĵ��룺
+
+```
+public class ProxyTransactionManagementConfiguration 
+        extends AbstractTransactionManagementConfiguration {
+
+    // ʡ������
+    ...
+
+    /**
+     * ��ȡSpring�� @Transactional ע�⣬������Ӧ���������Թ�����Spring����������ṹ
+     */
+    @Bean
+    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+    public TransactionAttributeSource transactionAttributeSource() {
+        return new AnnotationTransactionAttributeSource();
+    }
+
+    /**
+     * ������ǿ��.
+     * transactionAttributeSource��transactionAttributeSource() ���صĶ���
+     */
+    @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
+    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+    public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(
+            TransactionAttributeSource transactionAttributeSource,
+            TransactionInterceptor transactionInterceptor) {
+        BeanFactoryTransactionAttributeSourceAdvisor advisor = 
+                new BeanFactoryTransactionAttributeSourceAdvisor();
+        // �������������࣬�������� @Transactional ������
+        advisor.setTransactionAttributeSource(transactionAttributeSource);
+        ...
+        return advisor;
+    }
+
+}
+
+```
+
+�ɴ˿�֪��`BeanFactoryTransactionAttributeSourceAdvisor` �� `transactionAttributeSource` ����Ϊ `AnnotationTransactionAttributeSource`.
+
+�����ٻص� `BeanFactoryTransactionAttributeSourceAdvisor`��������ķ�����֪��`getPointcut()` �õ����� `TransactionAttributeSourcePointcut` ����Ȼ���������ࣺ
+
+```
+abstract class TransactionAttributeSourcePointcut 
+        extends StaticMethodMatcherPointcut implements Serializable {
+
+    protected TransactionAttributeSourcePointcut() {
+        // �ڹ��췽�������� ClassFilter
+        setClassFilter(new TransactionAttributeSourceClassFilter());
+    }
+
+    /**
+     * pointcut �� matches ����
+     */
+    @Override
+    public boolean matches(Method method, Class<?> targetClass) {
+        // �õ��Ľ��ΪAnnotationTransactionAttributeSource
+        TransactionAttributeSource tas = getTransactionAttributeSource();
+        return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
+    }
+
+    /**
+     * �� BeanFactoryTransactionAttributeSourceAdvisor ����ָ��
+     */
+    @Nullable
+    protected abstract TransactionAttributeSource getTransactionAttributeSource();
+
+    /**
+     * �ڲ��࣬ʵ���� ClassFilter
+     */
+    private class TransactionAttributeSourceClassFilter implements ClassFilter {
+
+        /**
+         * ClassFilter �� matches
+         */
+        @Override
+        public boolean matches(Class<?> clazz) {
+            // �Ƿ�ΪTransactionalProxy��PlatformTransactionManager��PersistenceExceptionTranslator��ʵ����
+            if (TransactionalProxy.class.isAssignableFrom(clazz) ||
+                    PlatformTransactionManager.class.isAssignableFrom(clazz) ||
+                    PersistenceExceptionTranslator.class.isAssignableFrom(clazz)) {
+                return false;
+            }
+            //�ж� TransactionAttributeSource ��ȡ���������Ƿ�Ϊ��
+            // �õ��Ľ��ΪAnnotationTransactionAttributeSource
+            TransactionAttributeSource tas = getTransactionAttributeSource();
+            return (tas == null || tas.isCandidateClass(clazz));
+        }
+    }
+
+}
+
+```
+
+������ķ��������ǵõ���һ����Ҫ�Ĺ���
+
+*   ƥ���ࣺ`pc.getClassFilter().matches(targetClass)`��`ClassFilter` Ϊ `TransactionAttributeSourceClassFilter`
+
+ƥ����Ĺ������ҵ��ˣ���ƥ�䷽���Ĺ����أ����ǽ��� `TransactionAttributeSourcePointcut#getMethodMatcher()` ������������� `StaticMethodMatcherPointcut`��
+
+```
+public abstract class StaticMethodMatcherPointcut 
+        extends StaticMethodMatcher implements Pointcut {
+    // ʡ����һЩ����
+    ...
+
+    @Override
+    public final MethodMatcher getMethodMatcher() {
+        return this;
+    }
+}
+
+```
+
+���صľ�Ȼ�� `this`�����Ǹ�ɶ����Ҫ�ţ���ϸ�� `TransactionAttributeSourcePointcut`���������̳��� `StaticMethodMatcherPointcut`��
+
+```
+abstract class TransactionAttributeSourcePointcut 
+        extends StaticMethodMatcherPointcut implements Serializable {
+    // ʡ����һЩ����
+    ...
+}
+
+```
+
+���ԣ�`pc.getMethodMatcher()` �õ��ľ��� `TransactionAttributeSourcePointcut`���� `mathes(...)` �������� `TransactionAttributeSourcePointcut#matches`.
+
+�ڱ�С�ڵ�����������ܽ��·����Ľ����
+
+*   ƥ���ࣺ`pc.getClassFilter().matches(targetClass)`��`ClassFilter` Ϊ `TransactionAttributeSourceClassFilter`��
+*   ƥ�䷽����`pc.getMethodMatcher().matches(method, targetClass)`��`methodMatcher` Ϊ `TransactionAttributeSourcePointcut`��
+*   ���������������У�������� `TransactionAttributeSourcePointcut#getTransactionAttributeSource`������������صĽ��Ϊ `AnnotationTransactionAttributeSource`.
+
+#### 1.4 ƥ������
+
+�� 1.2 ���֣�����֪������ǰ `advisor` �ܷ�Ӧ����Ŀ�� class����Ҫͬʱ��������ƥ�����
+
+*   ƥ���ࣺ`pc.getClassFilter().matches(targetClass)`��`ClassFilter` Ϊ `TransactionAttributeSourceClassFilter`��
+*   ƥ�䷽����`pc.getMethodMatcher().matches(method, targetClass)`��`methodMatcher` Ϊ `TransactionAttributeSourcePointcut`��
+
+����������������������
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-133740c93d470e16ec8dc9a34106adb8fc8.png)
+
+*   `TransactionAttributeSourceClassFilter#matches`�����жϵ�ǰ���Ƿ�Ϊ�Ƿ�Ϊ `TransactionalProxy`��`PlatformTransactionManager`��`PersistenceExceptionTranslator` ����ʵ���࣬Ȼ����� `AnnotationTransactionAttributeSource#isCandidateClass` �����жϣ�
+*   `TransactionAttributeSourcePointcut#matches`������ `AnnotationTransactionAttributeSource#getTransactionAttribute`�����ڼ̳й�ϵ��ʵ�ʵ��õ��� `AbstractFallbackTransactionAttributeSource#getTransactionAttribute`���жϡ�
+
+���������Ǿ��������¾���ƥ�����̡�
+
+##### `AnnotationTransactionAttributeSource#isCandidateClass`
+
+������ֱ�����⣬���� `isCandidateClass` ������
+
+> AnnotationTransactionAttributeSource#isCandidateClass
+
+```
+@Override
+public boolean isCandidateClass(Class<?> targetClass) {
+    // �ҵ����е�annotationParsers��ѭ��ƥ��
+    for (TransactionAnnotationParser parser : this.annotationParsers) {
+        if (parser.isCandidateClass(targetClass)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+```
+
+���Կ�����������ѭ������� `TransactionAnnotationParser` �� `isCandidateClass` ������`this.annotationParsers` ��ɶ�أ�ͨ�����ԣ��������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-5e16d6769e5a74c2f3064afdd090de08d42.png)
+
+`this.annotationParsers` ��ֻ�� `SpringTransactionAnnotationParser`�����ǽ����� `isCandidateClass` ������
+
+```
+public class SpringTransactionAnnotationParser 
+        implements TransactionAnnotationParser, Serializable {
+
+    /**
+     * �ж������Ƿ��� @Transactional ע��
+     */
+    @Override
+    public boolean isCandidateClass(Class<?> targetClass) {
+        return AnnotationUtils.isCandidateClass(targetClass, Transactional.class);
+    }
+}
+
+```
+
+����������յ��õ��� `AnnotationUtils.isCandidateClass`�������ж�ָ���������Ƿ��� `@Transactional` ע�⡣
+
+��������Ǿ������ˣ�`TransactionAttributeSourceClassFilter#matches` ���ų�һЩ�� (`TransactionalProxy`/`PlatformTransactionManager`/`PersistenceExceptionTranslator` ��������) �����ջ�ƥ����� `@Transactional` ע����ࡣ
+
+##### `AnnotationTransactionAttributeSource#getTransactionAttribute`
+
+����ķ���ƥ��ɹ��󣬲����ܱ�ʾ�ɹ�ƥ�䣬����ƥ�� `TransactionAttributeSourcePointcut#matches`������ͬʱ����Ż�ƥ��ɹ���`TransactionAttributeSourcePointcut#matches` ���� `AnnotationTransactionAttributeSource#getTransactionAttribute` ���ƥ��ģ����Ǹ���ȥ��
+
+```
+public abstract class AbstractFallbackTransactionAttributeSource 
+        implements TransactionAttributeSource {
+
+    /**
+     * ��ȡ @Transactional ע�������
+     */
+    public TransactionAttribute getTransactionAttribute(Method method, 
+            @Nullable Class<?> targetClass) {
+        if (method.getDeclaringClass() == Object.class) {
+            return null;
+        }
+
+        // ʡ�Դӻ����л�ȡ
+        ...
+        else {
+            // ��ȡ Transaction ���ԣ��� @Transactional ע�������
+            TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
+            // ʡ�Է��뻺�����
+            ...
+            return txAttr;
+        }
+    }
+}
+
+```
+
+`AnnotationTransactionAttributeSource` �� `getTransactionAttribute` �Ǽ̳��� `AbstractFallbackTransactionAttributeSource` �ģ�������ǽ���ķ����� `AbstractFallbackTransactionAttributeSource#getTransactionAttribute`���������������ȡ�����ϵ� `@Transactional` ע������ԣ����Ǹ��� `computeTransactionAttribute(...)`��
+
+> AbstractFallbackTransactionAttributeSource
+
+```
+protected TransactionAttribute computeTransactionAttribute(Method method, 
+        @Nullable Class<?> targetClass) {
+    // Ĭ�ϱ���Ҫ public ������֧������
+    if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
+        return null;
+    }
+    // 1\. ��ȡȷ�еķ��������紫���class��IFoo��ʵ�ʵĵ�class��DefaultFoo��
+    //    ��ôӦ�ý� IFoo#method ת��Ϊ DefaultFoo#method
+    Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
+    // 2\. �ӷ����ϻ�ȡ @Transactional ������
+    TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
+    if (txAttr != null) {
+        return txAttr;
+    }
+    // 3\. �����ϻ�ȡ @Transaction ������
+    txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
+    if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
+        return txAttr;
+    }
+    if (specificMethod != method) {
+        // 4\. ȷ�еķ������Ҳ��������Ҵ���ķ����ϵ�
+        txAttr = findTransactionAttribute(method);
+        if (txAttr != null) {
+            return txAttr;
+        }
+        // 5\. ���϶�û�ҵ�������ȷ�е����ϵ�
+        txAttr = findTransactionAttribute(method.getDeclaringClass());
+        if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
+            return txAttr;
+        }
+    }
+    // 6\. û�л�ȡ�������շ���null
+    return null;
+}
+
+```
+
+�����Ϸ��������̣����ܽ��ȡ `@Transactional` �����������£�
+
+1.  ������ķ���ת��Ϊȷ�еķ��������紫��� `class` �� `IFoo`��ʵ�ʵĵ� `class` �� `DefaultFoo`������ͻὫ `IFoo#method` ת��Ϊ `DefaultFoo#method`
+2.  ��ȷ�еķ����ϻ�ȡ `@Transactional` ������
+3.  ���û�л�ȡ�����ʹ�ȷ�еĴ����ϻ�ȡ `@Transaction` ������
+4.  ���û�л�ȡ�����ʹ���ķ����ϻ�ȡ `@Transaction` ������
+5.  ���û�л�ȡ�����ʹ�������ϻ�ȡ `@Transaction` ������
+6.  ������϶�û�л�ȡ�����ͷ��� `null`
+
+spring ������δӷ��������ϻ�ȡ `@Transactional` �������أ���������ȥ��
+
+> AnnotationTransactionAttributeSource
+
+```
+    // �ӷ����ϻ�ȡ @Transactional ����
+    protected TransactionAttribute findTransactionAttribute(Method method) {
+        return determineTransactionAttribute(method);
+    }
+
+    // �����ϻ�ȡ @Transactional ����
+    protected TransactionAttribute findTransactionAttribute(Class<?> clazz) {
+        return determineTransactionAttribute(clazz);
+    }
+
+    // ���յ��õķ���
+    protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
+        for (TransactionAnnotationParser parser : this.annotationParsers) {
+            // ���� @Transactional ע�������
+            TransactionAttribute attr = parser.parseTransactionAnnotation(element);
+            if (attr != null) {
+                return attr;
+            }
+        }
+        return null;
+    }
+
+```
+
+�������Ƕ��ǵ��� `AnnotationTransactionAttributeSource#determineTransactionAttribute` ����ȡ�ģ����� `AnnotationTransactionAttributeSource#determineTransactionAttribute` ������ `TransactionAnnotationParser#parseTransactionAnnotation` ���������� `this.annotationParsers` ����������ǰ���Ѿ��������ˣ�����ֻ��һ���ࣺ`SpringTransactionAnnotationParser`�����Ǹ���ȥ��
+
+> SpringTransactionAnnotationParser
+
+```
+    /**
+     * ��ȡ Transactional ע�⣬����������������������򷵻� null
+     */
+    public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
+        // ��ȡ Transactional ע�⣬����������������������򷵻� null
+        AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
+                element, Transactional.class, false, false);
+        if (attributes != null) {
+            return parseTransactionAnnotation(attributes);
+        }
+        else {
+            return null;
+        }
+    }
+
+    /**
+     * ���� Transactional ע��ľ������
+     */
+    protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
+        RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
+        // ����Ĵ�����ʽ
+        Propagation propagation = attributes.getEnum("propagation");
+        rbta.setPropagationBehavior(propagation.value());
+        // ����ĸ��뼶��
+        Isolation isolation = attributes.getEnum("isolation");
+        rbta.setIsolationLevel(isolation.value());
+        // ����ij�ʱʱ��
+        rbta.setTimeout(attributes.getNumber("timeout").intValue());
+        // �Ƿ�Ϊֻ��
+        rbta.setReadOnly(attributes.getBoolean("readOnly"));
+        rbta.setQualifier(attributes.getString("value"));
+        // �����ع��쳣
+        List<RollbackRuleAttribute> rollbackRules = new ArrayList<>();
+        for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) {
+            rollbackRules.add(new RollbackRuleAttribute(rbRule));
+        }
+        for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
+            rollbackRules.add(new RollbackRuleAttribute(rbRule));
+        }
+        // �������ع��쳣
+        for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
+            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
+        }
+        for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
+            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
+        }
+        rbta.setRollbackRules(rollbackRules);
+
+        return rbta;
+    }
+
+```
+
+���Կ�����`Transactional` ע��ĸ����Խ������� `RuleBasedTransactionAttribute`.
+
+���ˣ����Ǿ������ˣ�`TransactionAttributeSourcePointcut#matches` ���������ж���򷽷�����û�� `Transactional` ע�⡣
+
+#### 1.5 ��������Ĵ���
+
+��������Ĵ����� `AbstractAutoProxyCreator#postProcessAfterInitialization` ��������ɵģ��������ͬ aop ���������һģһ��������Ͳ��ٷ����ˣ����˽��С���ɲ鿴 [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������£�](https://my.oschina.net/funcy/blog/4687961)��
+
+### 2\. ������ִ��
+
+������ִ�з��棬������ aop ��ִ�����̲�������һ����ͨ�� `Advisor` �ҵ���Ӧ�� `Advice`����ͨ�� `Advice` �ҵ���Ӧ�� `methodInterceptor`������ִ�е��� `MethodInterceptor#invoke` ���������������� `MethodInterceptor` Ϊ `TransactionInterceptor`����������� `ProxyTransactionManagementConfiguration` ��ͨ�� `@Bean` ע������ġ�
+
+���� aop �����̣����Dz��������������ط����� [spring aop ֮ jdk ��̬����](https://my.oschina.net/funcy/blog/4696654) ��[ spring aop ֮ cglib ����](https://my.oschina.net/funcy/blog/4696655) ������ϸ����������Ȥ��С�������в��ģ���������ֱ������ `TransactionInterceptor#invoke` ��ִ�����̡�
+
+����Ĵ����������� `TransactionInterceptor#invoke` �����У�
+
+> TransactionInterceptor#invoke
+
+```
+public Object invoke(MethodInvocation invocation) throws Throwable {
+    Class<?> targetClass = (invocation.getThis() != null 
+        ? AopUtils.getTargetClass(invocation.getThis()) : null);
+    // �������¿�
+    return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
+}
+
+```
+
+�����Ĵ����߼��� `TransactionAspectSupport#invokeWithinTransaction` �����У�
+
+> TransactionAspectSupport#invokeWithinTransaction
+
+```
+protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
+        final InvocationCallback invocation) throws Throwable {
+    TransactionAttributeSource tas = getTransactionAttributeSource();
+    // ��ȡ@Transactional����������
+    final TransactionAttribute txAttr = (tas != null 
+        ? tas.getTransactionAttribute(method, targetClass) : null);
+    // ��ȡ�����������IOC�����л�ȡ��
+    final TransactionManager tm = determineTransactionManager(txAttr);
+
+    // ʡ�� ReactiveTransactionManager �Ĵ���
+    ...
+
+    PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
+    // ��ȡ������ȫ�޶�������ʽΪ��"����.����.������"
+    final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
+
+    // ����Ĵ����߼�����Ҳ�����ǽ�������Ҫ�����ĵط�
+    if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
+        // 1\. ��������
+        TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
+        Object retVal;
+        try {
+            // 2\. ִ�о����ҵ��
+            retVal = invocation.proceedWithInvocation();
+        }
+        catch (Throwable ex) {
+            // 3\. �쳣�ع�
+            completeTransactionAfterThrowing(txInfo, ex);
+            throw ex;
+        }
+        finally {
+            // ����������Ϣ
+            cleanupTransactionInfo(txInfo);
+        }
+        if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
+            TransactionStatus status = txInfo.getTransactionStatus();
+            if (status != null && txAttr != null) {
+                retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
+            }
+        }
+        // 4\. �ύ���񣬴����л��ж��Ƿ���֧��
+        commitTransactionAfterReturning(txInfo);
+        return retVal;
+    }
+    else {
+        // ʡ������
+        ...
+    }
+}
+
+```
+
+���Ϸ������������ȫ�������ˣ��������£�
+
+1.  ��������
+2.  ִ��ҵ�����
+3.  �쳣�ع�
+4.  �ύ����
+
+��������ľ�����������ǽ�����һƪ���·���������ֻ��Ҫ������Ĵ��������д����˽⼴�ɡ�
+
+### 3\. �ܽ�
+
+������Ҫ�����������д�������Ĵ�����ִ�����̣�ʵ������Щ����ͬ aop ����һ�£��������ط������� aop ��ͬ�IJ��֣�
+
+*   �ڴ�������Ĵ������棬����������жϵ�ǰ�����ܷ�ʹ�� `BeanFactoryTransactionAttributeSourceAdvisor`���ص������ `TransactionAttributeSourceClassFilter#matches` �� `TransactionAttributeSourcePointcut#matches` �����������жϵĺ������ڣ�
+
+*   �ڷ�����ִ���ϵģ����Է����� `TransactionInterceptor#invoke` ��ִ�����̣���Щ����Ŀ������ύ���쳣�ع������̸�����ƽ��ʹ�õIJ�𲻴󣬲�������ľ���ϸ�����Dz�û�з�����
+
+�����ص�����������Ĵ�����ִ�����̣�����ִ�еľ���ϸ��������ƪ�ٷ�����
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4773457](https://my.oschina.net/funcy/blog/4773457) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\344\272\224\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\351\232\224\347\246\273\347\272\247\345\210\253\344\270\216\344\274\240\346\222\255\346\226\271\345\274\217\347\232\204\345\244\204\347\220\20603.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\344\272\224\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\351\232\224\347\246\273\347\272\247\345\210\253\344\270\216\344\274\240\346\222\255\346\226\271\345\274\217\347\232\204\345\244\204\347\220\20603.md"
new file mode 100644
index 0000000..8ac63de
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\344\272\224\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\351\232\224\347\246\273\347\272\247\345\210\253\344\270\216\344\274\240\346\222\255\346\226\271\345\274\217\347\232\204\345\244\204\347\220\20603.md"
@@ -0,0 +1,500 @@
+�����ǡ�����ĸ��뼶���봫����ʽ�Ĵ����������ĵ� 3 ƪ�������ģ����Ǽ�����
+
+�����������ᵽ������Ŀ�����`doBegin(...)`��������`suspend(...)`���봴������㣨`createAndHoldSavepoint(...)`���IJ��������Ľ���������Щ������ʵ�֡�
+
+### 1. `doBegin(...)`�������µ�����
+
+����������ķ���Ϊ `DataSourceTransactionManager#doBegin`���������£�
+
+```
+protected void doBegin(Object transaction, TransactionDefinition definition) {
+    DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
+    Connection con = null;
+
+    try {
+        // 1\. ��ȡ���ݿ�����
+        if (!txObject.hasConnectionHolder() ||
+                txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
+            // getConnection(): ��ȡ���ݿ����ӣ�obtainDataSource()����ȡ����Դ
+            Connection newCon = obtainDataSource().getConnection();
+            txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
+        }
+        // ���ｫ synchronizedWithTransaction ����Ϊtrue
+        txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
+        con = txObject.getConnectionHolder().getConnection();
+
+        // 2\. ��������ĸ��뼶��
+
+        Integer previousIsolationLevel 
+                = DataSourceUtils.prepareConnectionForTransaction(con, definition);
+        txObject.setPreviousIsolationLevel(previousIsolationLevel);
+        // ����ֻ������
+        txObject.setReadOnly(definition.isReadOnly());
+
+        // 3\. ��������
+        if (con.getAutoCommit()) {
+            txObject.setMustRestoreAutoCommit(true);
+            // �ر�������Զ��ύ��Ҳ���ǿ�������
+            con.setAutoCommit(false);
+        }
+        // 4\. �����ֻ����������������
+        prepareTransactionalConnection(con, definition);
+        // ��������ļ�����
+        txObject.getConnectionHolder().setTransactionActive(true);
+        // 5\. ��������ij�ʱʱ��
+        int timeout = determineTimeout(definition);
+        if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
+            txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
+        }
+
+        // 6\. ������Դ�����ӵ���ǰ�߳�
+        if (txObject.isNewConnectionHolder()) {
+            TransactionSynchronizationManager.bindResource(
+                    obtainDataSource(), txObject.getConnectionHolder());
+            }
+        }
+    } catch (Throwable ex) {
+        // �����쳣�������������������رո�����
+        if (txObject.isNewConnectionHolder()) {
+            DataSourceUtils.releaseConnection(con, obtainDataSource());
+            txObject.setConnectionHolder(null, false);
+        }
+        throw new CannotCreateTransactionException(...);
+    }
+}
+
+```
+
+���ϴ��뻹��ͦ�����ģ�ע��Ҳ����ȷ�ˣ�����Թؼ���������һ��������
+
+#### 1.1 ��ȡ���ݿ�����
+
+���ݿ����ӵĻ�ȡ���Ǻܼ򵥵ģ��������£�
+
+```
+Connection newCon = obtainDataSource().getConnection();
+
+```
+
+��ʵ���ǵ��� `javax.sql.DataSource#getConnection()` ������
+
+#### 1.2 ��������ĸ��뼶��
+
+�� `@Transactional` �У����ǿ���ʹ�� `isolation` ָ������ĸ��뼶��
+
+```
+public @interface Transactional {
+    /**
+     * ָ������ĸ��뼶��
+     */
+    Isolation isolation() default Isolation.DEFAULT;
+    ...
+}
+
+```
+
+�����ָ������ʹ��Ĭ�ϵĸ��뼶��Ҳ����ʹ�����ݿ����õġ�
+
+spring ����������뼶��ķ���Ϊ `DataSourceUtils#prepareConnectionForTransaction`���������£�
+
+```
+public static Integer prepareConnectionForTransaction(Connection con, 
+        @Nullable TransactionDefinition definition) throws SQLException {
+    Assert.notNull(con, "No Connection specified");
+    if (definition != null && definition.isReadOnly()) {
+        try {
+            // ����Ϊֻ��ģʽ
+            con.setReadOnly(true);
+        }
+        catch (SQLException | RuntimeException ex) {
+            ...
+        }
+    }
+
+    Integer previousIsolationLevel = null;
+    if (definition != null && definition.getIsolationLevel() 
+            != TransactionDefinition.ISOLATION_DEFAULT) {
+        int currentIsolation = con.getTransactionIsolation();
+        if (currentIsolation != definition.getIsolationLevel()) {
+            // �õ�֮ǰ�ĸ��뼶����������£���Ҫ����Ϊԭ���ĸ��뼶��
+            previousIsolationLevel = currentIsolation;
+            // �������������ݿ�ĸ��뼶�𣬵��õ��ǣ�
+            // java.sql.Connection.setTransactionIsolation
+            con.setTransactionIsolation(definition.getIsolationLevel());
+        }
+    }
+    return previousIsolationLevel;
+}
+
+```
+
+�� �������������������ã�
+
+1.  ����Ϊֻ��ģʽ�����õ��� `java.sql.Connection#setReadOnly` ����
+2.  ���ø��뼶�𣺵��õ��� `java.sql.Connection.setTransactionIsolation` ����
+
+����ֻ��ģʽ��Ҳ�ǿ����� `@Transactional` �����õģ�
+
+```
+public @interface Transactional {
+    /**
+     * ����ֻ������
+     */
+    boolean readOnly() default false;
+    ...
+}
+
+```
+
+#### 1.3 ��������
+
+�������ĵ�ʱ���������ˣ�ǰ���̵�����ô�࣬����Ϊ����һ���IJ������������񡣿�������Ĵ������£�
+
+```
+if (con.getAutoCommit()) {
+    txObject.setMustRestoreAutoCommit(true);
+    // �ر�������Զ��ύ��Ҳ���ǿ�������
+    con.setAutoCommit(false);
+}
+
+```
+
+��������Ϊ�����ж��Զ��ύ�Ƿ���������������ˣ��ͽ�������Ϊ false�����õ�Ҳ�� `java.sql` �ķ�����
+
+*   ��ȡ�Զ��ύ״̬��`java.sql.Connection#getAutoCommit`
+*   �����Զ��ύ״̬��`java.sql.Connection#setAutoCommit`
+
+#### 1.4 �����ֻ����������������
+
+��ǰ����� `1.2 ��������ĸ��뼶��`�У�ͨ������ `java.sql.Connection#setReadOnly` ����������Ϊֻ���ˣ����ﻹ����һ�����ã�����Ϊ `DataSourceTransactionManager#prepareTransactionalConnection`��
+
+```
+protected void prepareTransactionalConnection(Connection con, TransactionDefinition definition)
+        throws SQLException {
+    if (isEnforceReadOnly() && definition.isReadOnly()) {
+        try (Statement stmt = con.createStatement()) {
+            // ����ֻ������Ҫ����sql
+            stmt.executeUpdate("SET TRANSACTION READ ONLY");
+        }
+    }
+}
+
+```
+
+��һ����ͨ��ִ�� sql ��� `SET TRANSACTION READ ONLY` ����������Ϊֻ����
+
+#### 1.5 ��������ij�ʱʱ��
+
+�� `@Transactional` ע���У����ǿ���ʹ�� `timeout` ��ָ������ij�ʱʱ�䣺
+
+```
+public @interface Transactional {
+    /**
+     * ���ó�ʱʱ��
+     */
+    int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
+    ...
+}
+
+```
+
+�������õij�ʱʱ����������õ������ǽ��� `ResourceHolderSupport#setTimeoutInSeconds`��
+
+```
+public abstract class ResourceHolderSupport implements ResourceHolder {
+    /**
+     * ��ֹʱ��
+     */
+    private Date deadline;
+
+    /**
+     * ����ʱ�䣬��λ����
+     */
+    public void setTimeoutInSeconds(int seconds) {
+        setTimeoutInMillis(seconds * 1000L);
+    }
+
+    /**
+     * ����ʱ�䣬��λ������
+     * ����ת��Ϊ ��ֹʱ��
+     */
+    public void setTimeoutInMillis(long millis) {
+        this.deadline = new Date(System.currentTimeMillis() + millis);
+    }
+
+    /**
+     * ��ȡ��ֹʱ��
+     */
+    @Nullable
+    public Date getDeadline() {
+        return this.deadline;
+    }
+
+    /**
+     * ��ȡʣ��ʱ�䣬��λ����
+     */
+    public int getTimeToLiveInSeconds() {
+        double diff = ((double) getTimeToLiveInMillis()) / 1000;
+        int secs = (int) Math.ceil(diff);
+        checkTransactionTimeout(secs <= 0);
+        return secs;
+    }
+
+    /**
+     * ��ȡʣ��ʱ�䣬��λ������
+     */
+    public long getTimeToLiveInMillis() throws TransactionTimedOutException{
+        if (this.deadline == null) {
+            throw new IllegalStateException("No timeout specified for this resource holder");
+        }
+        long timeToLive = this.deadline.getTime() - System.currentTimeMillis();
+        checkTransactionTimeout(timeToLive <= 0);
+        return timeToLive;
+    }
+
+    ...
+}
+
+```
+
+�� `ResourceHolderSupport` ��ά����һ����Ա���� `deadline`����ֹʱ�䣩������ij�ʱʱ�����ն���ת��Ϊ `deadline`��
+
+��ȡʣ��ʱ��ʱ��Ҳ���� `deadline` ����õ������ص�ʣ��ʱ��������������֡�
+
+�������`txObject.getConnectionHolder().setTimeoutInSeconds(timeout)` ֻ�ǽ���ʱʱ�����õ� `ConnectionHolder` �ij�Ա�����У�`ConnectionHolder` �� `ResourceHolderSupport` �����ࣩ���ƺ������ݿ�ûɶ��ϵ�����ݿ�����ô��������ʱ���أ�
+
+���ò�˵�������ʱ�Ŀ������е����ң�������ͨ�������ҵ��ģ���ʱʱ����������� `DataSourceUtils#applyTimeout` �����У������п�ν�Ǿ�����ǧɽ��ˮ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-9fc1a75dc7b0644269b6dba16dfd5d0e676.png)
+
+��л���Թ��ܣ�û��������֪��Ҫ��ò����ҵ����ʱ������ã�������ʹ�õ��� `jdbcTemplate`�������� `orm` ����£����ó�ʱʱ��Ӧ�û�������ͬ ��
+
+���ǿ��� `DataSourceUtils#applyTimeout` ����ô���ó�ʱʱ��ģ�
+
+```
+public static void applyTimeout(Statement stmt, @Nullable DataSource dataSource, int timeout) 
+        throws SQLException {
+    Assert.notNull(stmt, "No Statement specified");
+    ConnectionHolder holder = null;
+    if (dataSource != null) {
+        holder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
+    }
+    if (holder != null && holder.hasTimeout()) {
+        // ������ǻ�ȡʣ��ij�ʱʱ�䣬�� ConnectionHolder.dateline ����õ���
+        stmt.setQueryTimeout(holder.getTimeToLiveInSeconds());
+    }
+    else if (timeout >= 0) {
+        // jdbcTemplate ����Ҳ�������ò�ѯ��ʱʱ��
+        stmt.setQueryTimeout(timeout);
+    }
+}
+
+```
+
+���յ��õ��� `java.sql.Statement#setQueryTimeout` �����ó�ʱʱ��ġ�
+
+#### 1.6 ������Դ�����ӵ���ǰ�߳�
+
+�������鴦����ɺ󣬽��������ǰ�����Դ�������ˣ���������Ϊ `TransactionSynchronizationManager#bindResource`:
+
+```
+/**
+ * resources ��ŵ�ǰ�߳��е�����Դ������
+ * ���д�ŵ�����Ϊһ�� Map��Map �� key Ϊ����Դ��value Ϊ����Դ��Ӧ������
+ */
+private static final ThreadLocal<Map<Object, Object>> resources =
+        new NamedThreadLocal<>("Transactional resources");
+
+/**
+ * �󶨲���
+ */
+public static void bindResource(Object key, Object value) throws IllegalStateException {
+    Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
+    Assert.notNull(value, "Value must not be null");
+    Map<Object, Object> map = resources.get();
+    if (map == null) {
+        map = new HashMap<>();
+        resources.set(map);
+    }
+    // ������Դ�����Ӵ�ŵ�map��
+    Object oldValue = map.put(actualKey, value);
+    if (oldValue instanceof ResourceHolder && ((ResourceHolder) oldValue).isVoid()) {
+        oldValue = null;
+    }
+    if (oldValue != null) {
+        throw new IllegalStateException("Already value [" + oldValue + "] for key [" +
+                actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
+    }
+
+```
+
+�� һ���IJ������DZȽϼ򵥵ģ����ǽ�����Դ�����ӷŽ� `resources` �У��Ӷ�����뵱ǰ�̵߳İ󶨲�����
+
+### 2. `suspend(...)`����������
+
+��������IJ���Ϊ `AbstractPlatformTransactionManager#suspend`���������£�
+
+```
+protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) 
+        throws TransactionException {
+    // �����ͬ�������������ȹ���ͬ��������
+    if (TransactionSynchronizationManager.isSynchronizationActive()) {
+        List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
+        try {
+            Object suspendedResources = null;
+            if (transaction != null) {
+                // �������
+                suspendedResources = doSuspend(transaction);
+            }
+            // ������������
+            String name = TransactionSynchronizationManager.getCurrentTransactionName();
+            TransactionSynchronizationManager.setCurrentTransactionName(null);
+            // ����ֻ��״̬
+            boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
+            TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
+            // ���ø��뼶��
+            Integer isolationLevel = TransactionSynchronizationManager
+                    .getCurrentTransactionIsolationLevel();
+            TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
+            // �������񼤻�״̬
+            boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
+            TransactionSynchronizationManager.setActualTransactionActive(false);
+            // ���ع��������
+            return new SuspendedResourcesHolder(
+                    suspendedResources, suspendedSynchronizations, name, readOnly, 
+                    isolationLevel, wasActive);
+        }
+        catch (RuntimeException | Error ex) {
+            doResumeSynchronization(suspendedSynchronizations);
+            throw ex;
+        }
+    }
+    else if (transaction != null) {
+        Object suspendedResources = doSuspend(transaction);
+        return new SuspendedResourcesHolder(suspendedResources);
+    }
+    else {
+        return null;
+    }
+}
+
+```
+
+`suspend(...)` ����������Ҫ�ľ��ǹ�������IJ����ˣ�Ҳ���� `doSuspend(transaction)`���÷��� λ�� `` �У�ֱ�ӿ����룺
+
+```
+protected Object doSuspend(Object transaction) {
+    DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
+    txObject.setConnectionHolder(null);
+    // �����
+    return TransactionSynchronizationManager.unbindResource(obtainDataSource());
+}
+
+```
+
+�������� `TransactionSynchronizationManager.unbindResource` ������
+
+```
+/**
+ * ����󶨲���
+ */
+public static Object unbindResource(Object key) throws IllegalStateException {
+    Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
+    // ��������
+    Object value = doUnbindResource(actualKey);
+    if (value == null) {
+        throw new IllegalStateException(...);
+    }
+    return value;
+}
+
+/**
+ * ����󶨲���
+ */
+private static Object doUnbindResource(Object actualKey) {
+    Map<Object, Object> map = resources.get();
+    if (map == null) {
+        return null;
+    }
+    // �Ƴ���Դ
+    Object value = map.remove(actualKey);
+    if (map.isEmpty()) {
+        resources.remove();
+    }
+    if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
+        value = null;
+    }
+    return value;
+}
+
+```
+
+�ڿ�������ʱ���ǽ�����Դ�����Ӱ󶨵���ǰ�̣߳�����ʱ ���ǽ�����Դ�����ӽ���뵱ǰ�̵߳İ󶨹�ϵ��
+
+### 3. `createAndHoldSavepoint(...)`�����������
+
+�����Ĵ����� `AbstractTransactionStatus#createAndHoldSavepoint` �����д������������£�
+
+```
+    // �����
+    private Object savepoint;
+
+    // ���������
+    public void createAndHoldSavepoint() throws TransactionException {
+        setSavepoint(getSavepointManager().createSavepoint());
+    }
+
+    protected void setSavepoint(@Nullable Object savepoint) {
+        this.savepoint = savepoint;
+    }
+
+```
+
+�ţ��������������ֻ������`�����`�ı��棨Ҳ���Ǹ�ֵ�� `AbstractTransactionStatus` �ij�Ա��������Ҫ�����˽Ᵽ���Ĵ��������ÿ� `getSavepointManager().createSavepoint()`�����뵽 `JdbcTransactionObjectSupport#createSavepoint`��
+
+```
+public Object createSavepoint() throws TransactionException {
+    ConnectionHolder conHolder = getConnectionHolderForSavepoint();
+    try {
+        if (!conHolder.supportsSavepoints()) {
+            throw new NestedTransactionNotSupportedException(...);
+        }
+        if (conHolder.isRollbackOnly()) {
+            throw new CannotCreateTransactionException(...);
+        }
+        // ���������
+        return conHolder.createSavepoint();
+    }
+    catch (SQLException ex) {
+        throw new CannotCreateTransactionException("Could not create JDBC savepoint", ex);
+    }
+}
+
+```
+
+���������õ��� `ConnectionHolder#createSavepoint` ������ԭ����������� `ConnectionHolder` �д����İ���������
+
+```
+// ���������ǰ׺
+public static final String SAVEPOINT_NAME_PREFIX = "SAVEPOINT_";
+
+// ���������
+private int savepointCounter = 0;
+
+public Savepoint createSavepoint() throws SQLException {
+    this.savepointCounter++;
+    // ���ﴴ������㣬���õ��� java.sql.Connection#setSavepoint(java.lang.String) ����
+    return getConnection().setSavepoint(SAVEPOINT_NAME_PREFIX + this.savepointCounter);
+}
+
+```
+
+���������ǰ׺Ϊ `SAVEPOINT_`��ÿ����һ������㣬`savepointCounter` �ļ������ͼ� 1�����ձ���������Ϊ `SAVEPOINT_1`��`SAVEPOINT_2`��...
+
+������������յ��õķ����� `java.sql.Connection#setSavepoint(java.lang.String)`����Ȼ�� jdk �ṩ�ķ�����������������ǻᷢ������Ĵ󲿷ֲ������� spring �� jdk �����ķ�װ��
+
+���ˣ����ĵķ������ȵ��ˣ�����������ύ���ع����ع�������㡢�ָ����������ȣ���ƪ���¼���������
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4947826](https://my.oschina.net/funcy/blog/4947826) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\345\205\255\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\351\232\224\347\246\273\347\272\247\345\210\253\344\270\216\344\274\240\346\222\255\346\226\271\345\274\217\347\232\204\345\244\204\347\220\20604.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\345\205\255\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\351\232\224\347\246\273\347\272\247\345\210\253\344\270\216\344\274\240\346\222\255\346\226\271\345\274\217\347\232\204\345\244\204\347\220\20604.md"
new file mode 100644
index 0000000..415c012
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\345\205\255\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\351\232\224\347\246\273\347\272\247\345\210\253\344\270\216\344\274\240\346\222\255\346\226\271\345\274\217\347\232\204\345\244\204\347\220\20604.md"
@@ -0,0 +1,433 @@
+�����ǡ�����ĸ��뼶���봫����ʽ�Ĵ����������ĵ� 4 ƪ�������ģ����Ǽ�����
+
+#### 3.6 ִ�о����ҵ��
+
+���������£�
+
+```
+retVal = invocation.proceedWithInvocation();
+
+```
+
+�������ջ���õ�ҵ�񷽷� `UserService#insert`�����IJ�����̽�������������һ�������ù�ȥ�ģ�Ҫ�˽���ù��̵�С�����Բο� aop ��ز�����
+
+*   [spring aop ֮ jdk ��̬����](https://my.oschina.net/funcy/blog/4696654)
+*   [spring aop ֮ cglib ����](https://my.oschina.net/funcy/blog/4696655)
+
+#### 3.7 �쳣�ع�
+
+�����쳣�ķ���Ϊ `TransactionAspectSupport#completeTransactionAfterThrowing`���������£�
+
+```
+protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
+    if (txInfo != null && txInfo.getTransactionStatus() != null) {
+        // �쳣���ϲŻع�
+        if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
+            try {
+                txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
+            }
+            catch (...) {
+                ...
+            }
+        }
+        else {
+            try {
+                // �쳣�����ϣ���ʹִ�г���Ҳ���ύ
+                txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
+            }
+            catch (...) {
+                ...
+            }
+        }
+    }
+}
+
+```
+
+����������������������쳣������ֱ�ӽ��лع��ģ�������Ҫ�ж��쳣���ͣ�������Ҫ�ع����쳣�Żع���
+
+##### �жϵ�ǰ�쳣�Ƿ�Ҫ�ع�
+
+�ж��쳣�Ƿ���ϵķ���Ϊ `RuleBasedTransactionAttribute#rollbackOn`��
+
+```
+public boolean rollbackOn(Throwable ex) {
+    RollbackRuleAttribute winner = null;
+    int deepest = Integer.MAX_VALUE;
+    if (this.rollbackRules != null) {
+        for (RollbackRuleAttribute rule : this.rollbackRules) {
+            // ��ȡ�쳣�����
+            int depth = rule.getDepth(ex);
+            // ���������������ʾ��ǰ�쳣��Ҫ�ع�
+            if (depth >= 0 && depth < deepest) {
+                deepest = depth;
+                winner = rule;
+            }
+        }
+    }
+    if (winner == null) {
+        return super.rollbackOn(ex);
+    }
+    return !(winner instanceof NoRollbackRuleAttribute);
+}
+
+```
+
+��ȡ����ķ���Ϊ `RollbackRuleAttribute#getDepth(Throwable)`���������£�
+
+```
+public int getDepth(Throwable ex) {
+    return getDepth(ex.getClass(), 0);
+}
+
+private int getDepth(Class<?> exceptionClass, int depth) {
+    if (exceptionClass.getName().contains(this.exceptionName)) {
+        // Found it!
+        return depth;
+    }
+    // If we've gone as far as we can go and haven't found it...
+    if (exceptionClass == Throwable.class) {
+        return -1;
+    }
+    // �ݹ��ȡ
+    return getDepth(exceptionClass.getSuperclass(), depth + 1);
+}
+
+```
+
+���ʵ�ֺܼ򵥣����ǵݹ��ȡ `exception` �ĸ��࣬�ҵ��˾ͷ��صݹ�Ĵ�������������ҵ����� `Throwable`���ͷ��� - 1.
+
+֮����ʹ���������ж��Ƿ���Ҫ�ع���ԭ�������ûع����쳣ʱ�����������쳣���ƣ�
+
+```
+public @interface Transactional {
+    ...
+
+    // ע������������ַ���
+    String[] rollbackForClassName() default {};
+}
+
+```
+
+��˲���ʹ�� `ex instanceof Exception` �ķ�ʽ���ж��ܷ�ع���
+
+`RuleBasedTransactionAttribute#rollbackOn` �е� `RollbackRuleAttribute` �� `NoRollbackRuleAttribute` ����ɶ�أ����� `rollbackFor` �� `noRollbackFor` �İ�װ�࣬�� `SpringTransactionAnnotationParser#parseTransactionAnnotation(AnnotationAttributes)` ���������ã��������£�
+
+```
+protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
+    RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
+    ...
+    // �����ع��쳣
+    List<RollbackRuleAttribute> rollbackRules = new ArrayList<>();
+    for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) {
+        rollbackRules.add(new RollbackRuleAttribute(rbRule));
+    }
+    for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
+        rollbackRules.add(new RollbackRuleAttribute(rbRule));
+    }
+    // �������ع��쳣
+    for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
+        rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
+    }
+    for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
+        rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
+    }
+    // ��������
+    rbta.setRollbackRules(rollbackRules);
+    return rbta;
+}
+
+```
+
+##### �ع�����
+
+�ع������� `AbstractPlatformTransactionManager#rollback` �����д������������ݿ�Ļع������⣬���������������һЩ�ص��������������ǾͲ������ˣ�ֱ�ӿ��ؼ��Ļع����롣��ǰ��ķ�������Ĵ�������ʱ����ഫ�������ǻع����񣬲��� `PROPAGATION_NESTED` ���⣬���ǻع�������㣬�������Ƿֱ��������ؼ����룺
+
+1. ����ع�
+
+   ��������ع��ķ���Ϊ `DataSourceTransactionManager#doRollback`�����յ��õ��� `java.sql.Connection` �ķ�����
+
+   ```
+   protected void doRollback(DefaultTransactionStatus status) {
+       DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
+       // ��ȡ���ӣ�Connection Ϊ java.sql.Connection
+       Connection con = txObject.getConnectionHolder().getConnection();
+       try {
+           con.rollback();
+       }
+       catch (SQLException ex) {
+           throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
+       }
+   }
+   
+   ```
+
+2. �ع�������� �����ع��������IJ����� `AbstractTransactionStatus#rollbackToHeldSavepoint` �����У�
+
+   ```
+   public void rollbackToHeldSavepoint() throws TransactionException {
+       Object savepoint = getSavepoint();
+       if (savepoint == null) {
+           throw new TransactionUsageException(...);
+       }
+       // �ع��������
+       getSavepointManager().rollbackToSavepoint(savepoint);
+       // �ͷű����
+       getSavepointManager().releaseSavepoint(savepoint);
+       // ���������Ϊnull
+       setSavepoint(null);
+   }
+   
+   ```
+
+   ���������Ҫ�������������ع�����������ͷű���㡣
+
+   �ع��������IJ����� `JdbcTransactionObjectSupport#rollbackToSavepoint` ������
+
+   ```
+   public void rollbackToSavepoint(Object savepoint) throws TransactionException {
+       ConnectionHolder conHolder = getConnectionHolderForSavepoint();
+       try {
+           conHolder.getConnection().rollback((Savepoint) savepoint);
+           conHolder.resetRollbackOnly();
+       }
+       catch (Throwable ex) {
+           throw new TransactionSystemException("Could not roll back to JDBC savepoint", ex);
+       }
+   }
+   
+   ```
+
+   �ͷű����IJ����� `JdbcTransactionObjectSupport#releaseSavepoint` ������
+
+   ```
+   public void releaseSavepoint(Object savepoint) throws TransactionException {
+       ConnectionHolder conHolder = getConnectionHolderForSavepoint();
+       try {
+           conHolder.getConnection().releaseSavepoint((Savepoint) savepoint);
+       }
+       catch (Throwable ex) {
+           logger.debug("Could not explicitly release JDBC savepoint", ex);
+       }
+   }
+   
+   ```
+
+   ���ն��ǵ��� `java.sql.Connection` �ṩ�ķ�������ɲ�����
+
+##### �ύ����
+
+���������ύ�����������ύ�����Ĵ���Ϊ
+
+```
+txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
+
+```
+
+���Ǹ������������һֱ���� `AbstractPlatformTransactionManager#processCommit`��
+
+```
+private void processCommit(DefaultTransactionStatus status) throws TransactionException {
+    try {
+        ...
+
+        try {
+            if (status.hasSavepoint()) {
+                ...
+                unexpectedRollback = status.isGlobalRollbackOnly();
+                // 1\. �ͷű����
+                status.releaseHeldSavepoint();
+            }
+            else if (status.isNewTransaction()) {
+                ...
+                unexpectedRollback = status.isGlobalRollbackOnly();
+                // 2\. �����ύ����
+                doCommit(status);
+            }
+            else if (isFailEarlyOnGlobalRollbackOnly()) {
+                ...
+            }
+
+            ...
+        }
+        catch (...) {
+            ...
+        }
+    }
+    finally {
+        // 3\. ������ɲ������������ָ����������(�ָ����ݿ�����)
+        cleanupAfterCompletion(status);
+    }
+}
+
+```
+
+���Ϸ���ʡ���˴������룬������� `TransactionSynchronization` �ص���صģ����Ǿۼ���Ҫ������
+
+1.  �ͷű���㣺��������������Ѿ��������ˣ�����Ͳ��ٷ�����
+2.  �����ύ�������ύ��������У�һ�������������ǻᷢ�����ǵ����� `java.sql.Connection` �ṩ�ķ���
+3.  ������ɲ�������������Ƚ���Ҫ���������ӵ���Ϣ���ָ������������Ӿ�����������е�
+
+�����������ύ������ֱ�ӽ������մ��룺`DataSourceTransactionManager#doCommit`
+
+```
+protected void doCommit(DefaultTransactionStatus status) {
+    DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
+    // ��ȡ���ӣ�Connection Ϊ java.sql.Connection
+    Connection con = txObject.getConnectionHolder().getConnection();
+    try {
+        // �ύ����
+        con.commit();
+    }
+    catch (SQLException ex) {
+        throw new TransactionSystemException("Could not commit JDBC transaction", ex);
+    }
+}
+
+```
+
+����Ҳ�ǵ��� `java.sql.Connection` �ṩ�ķ�����
+
+����������ɲ����Ĵ��������� `AbstractPlatformTransactionManager#cleanupAfterCompletion` ������
+
+```
+private void cleanupAfterCompletion(DefaultTransactionStatus status) {
+    status.setCompleted();
+    if (status.isNewSynchronization()) {
+        TransactionSynchronizationManager.clear();
+    }
+    if (status.isNewTransaction()) {
+        // ������������ӣ�����������ӣ��������ر�����
+        doCleanupAfterCompletion(status.getTransaction());
+    }
+    // ����й����������������лָ�
+    if (status.getSuspendedResources() != null) {
+        Object transaction = (status.hasTransaction() ? status.getTransaction() : null);
+        // �ָ����������
+        resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
+    }
+}
+
+```
+
+���������� `DataSourceTransactionManager#doCleanupAfterCompletion` ����:
+
+```
+protected void doCleanupAfterCompletion(Object transaction) {
+    DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
+
+    // �Ƴ�����Դ�����ӵİ󶨹�ϵ
+    if (txObject.isNewConnectionHolder()) {
+        TransactionSynchronizationManager.unbindResource(obtainDataSource());
+    }
+
+    // �������ӣ����ǽ�������Ϣ�ָ���ִ������ǰ��״̬
+    Connection con = txObject.getConnectionHolder().getConnection();
+    try {
+        if (txObject.isMustRestoreAutoCommit()) {
+            con.setAutoCommit(true);
+        }
+        DataSourceUtils.resetConnectionAfterTransaction(
+                con, txObject.getPreviousIsolationLevel(), txObject.isReadOnly());
+    }
+    catch (Throwable ex) {
+        logger.debug("Could not reset JDBC Connection after transaction", ex);
+    }
+    // ����������ӣ������������ر�����
+    if (txObject.isNewConnectionHolder()) {
+        // ���յ��õ��� java.sql.Connection#close
+        DataSourceUtils.releaseConnection(con, this.dataSource);
+    }
+
+    txObject.getConnectionHolder().clear();
+}
+
+```
+
+������������Ļָ�������Ҳ���� `resume(...)` ������������������󣬷������յ��õ��� `DataSourceTransactionManager#doResume` �������������£�
+
+```
+@Override
+protected void doResume(@Nullable Object transaction, Object suspendedResources) {
+    // ������Դ����������ݿ������뵱ǰ�̰߳�
+    TransactionSynchronizationManager.bindResource(obtainDataSource(), suspendedResources);
+}
+
+```
+
+��������һ���󣬴�ʱ������Դ����֮ǰ���������Դ�ˡ�
+
+#### 3.8 ����������Ϣ
+
+��ijЩ������ʽ�£����� `PROPAGATION_REQUIRES_NEW`��������Ҫ����ǰ����Ȼ�󴴽��µ�������������ִ����ɺ���Ҫ�ָ�ԭ�����������������������Ϣ���ǽ���ǰ������Ϣ�ָ�Ϊ������������Ϣ��ֻ�ǻָ���������Ϣ����������ݿ����Ӳ���������ָ�����
+
+```
+public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {
+
+    // ��ŵ�ǰʹ�õ�������Ϣ
+    private static final ThreadLocal<TransactionInfo> transactionInfoHolder =
+            new NamedThreadLocal<>("Current aspect-driven transaction");
+
+    // ����Ϊ�ɵ�������Ϣ
+    protected void cleanupTransactionInfo(@Nullable TransactionInfo txInfo) {
+        if (txInfo != null) {
+            txInfo.restoreThreadLocalStatus();
+        }
+    }
+
+    /**
+     * TransactionInfo: ����������Ϣ
+     */
+    protected static final class TransactionInfo {
+
+        // ��ǰ������״̬����
+        @Nullable
+        private TransactionStatus transactionStatus;
+
+        // �ɵ�������Ϣ��Ҳ���ǹ����������Ϣ��
+        @Nullable
+        private TransactionInfo oldTransactionInfo;
+
+        ...
+
+        private void restoreThreadLocalStatus() {
+            // ����Ϊ�ɵ�������Ϣ
+            transactionInfoHolder.set(this.oldTransactionInfo);
+        }
+
+        ...
+    }
+
+}
+
+```
+
+���Կ�����`TransactionInfo` �Ի�������һ���������Ϣ��`oldTransactionInfo` �ij�Ա�����������û���һ��������Ϣʱ��ֻ�Ǽ򵥵ؽ� `oldTransactionInfo` ���õ���Ϊ `transactionInfoHolder` �� `ThreadLocal` �
+
+#### 3.9 �ύ����
+
+���������ύ�Ĵ���Ϊ `TransactionAspectSupport#commitTransactionAfterReturning`���������£�
+
+```
+protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) {
+    // �ж��������״̬
+    if (txInfo != null && txInfo.getTransactionStatus() != null) {
+        // �����ύ��������ǰ���Ѿ���������
+        txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
+    }
+}
+
+```
+
+�ڸ÷����У������ֿ��������д��룺
+
+```
+txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
+
+```
+
+����Ѿ�����**�쳣����������ύ**�з������ˣ��Ͳ��ٷ����ˡ�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4947800](https://my.oschina.net/funcy/blog/4947800) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\345\233\233\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\351\232\224\347\246\273\347\272\247\345\210\253\344\270\216\344\274\240\346\222\255\346\226\271\345\274\217\347\232\204\345\244\204\347\220\20602.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\345\233\233\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\351\232\224\347\246\273\347\272\247\345\210\253\344\270\216\344\274\240\346\222\255\346\226\271\345\274\217\347\232\204\345\244\204\347\220\20602.md"
new file mode 100644
index 0000000..eba0726
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\344\272\213\345\212\241/Spring\344\272\213\345\212\241\357\274\210\345\233\233\357\274\211\357\274\232\344\272\213\345\212\241\347\232\204\351\232\224\347\246\273\347\272\247\345\210\253\344\270\216\344\274\240\346\222\255\346\226\271\345\274\217\347\232\204\345\244\204\347\220\20602.md"
@@ -0,0 +1,580 @@
+�����ǡ�����ĸ��뼶���봫����ʽ�Ĵ����������ĵ� 2 ƪ�������ģ����Ǽ�����
+
+#### 3.5 ��ȡ������Ϣ
+
+�������Ϣ���� `TransactionAspectSupport#createTransactionIfNecessary` �����л�ȡ����������dz���Ҫ��ǰ����ܸ��뼶�𡢴�����ʽ��������������ﴦ�����÷����������£�
+
+```
+protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
+        @Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
+    // ���δָ�����ƣ��򽫷�����������������
+    if (txAttr != null && txAttr.getName() == null) {
+        txAttr = new DelegatingTransactionAttribute(txAttr) {
+            @Override
+            public String getName() {
+                return joinpointIdentification;
+            }
+        };
+    }
+
+    TransactionStatus status = null;
+    if (txAttr != null) {
+        if (tm != null) {
+            // ��ȡ����״̬�������ǰû�����񣬿��ܻᴴ������
+            status = tm.getTransaction(txAttr);
+        }
+    }
+    // ׼��������Ϣ�����ǽ�ǰ��õ�����Ϣ��װ�� TransactionInfo
+    return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
+}
+
+```
+
+���������Ҫ������������
+
+1.  ��ȡ����״̬
+2.  ׼��������Ϣ
+
+�������»�ȡ����״̬�����̣�����Ϊ `AbstractPlatformTransactionManager#getTransaction`��
+
+```
+public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
+        throws TransactionException {
+
+    TransactionDefinition def = (definition != null ? 
+            definition : TransactionDefinition.withDefaults());
+
+    // ��ȡ�������
+    Object transaction = doGetTransaction();
+    boolean debugEnabled = logger.isDebugEnabled();
+
+    // �Ƿ�������񣬴����򷵻�
+    if (isExistingTransaction(transaction)) {
+        return handleExistingTransaction(def, transaction, debugEnabled);
+    }
+    // ���е������������ǰû������
+
+    // ��鳬ʱʱ��������Ƿ����
+    if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
+        throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
+    }
+
+    // PROPAGATION_MANDATORY�����������������У�����û������ֱ�����쳣
+    // No existing transaction found -> check propagation behavior to find out how to proceed.
+    if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
+        throw new IllegalTransactionStateException(...);
+    }
+    // ����ǰ���񣬴���������
+    else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
+            def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
+            def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
+        // suspend(...) ����null�������ͬ�����������ͬ�����񣬷���ʲôҲ����
+        SuspendedResourcesHolder suspendedResources = suspend(null);
+        try {
+            boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
+            // �����������
+            DefaultTransactionStatus status = newTransactionStatus(
+                    def, transaction, true, newSynchronization, debugEnabled, suspendedResources);
+            // ��������
+            doBegin(transaction, def);
+            // ���� TransactionSynchronizationManager ������
+            prepareSynchronization(status, def);
+            return status;
+        }
+        catch (RuntimeException | Error ex) {
+            resume(null, suspendedResources);
+            throw ex;
+        }
+    }
+    else {
+        boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
+        return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
+    }
+}
+
+```
+
+��������е㳤����������������
+
+##### 1. `doGetTransaction(...)`����ȡ�������
+
+��ȡ�������ķ���Ϊ `DataSourceTransactionManager#doGetTransaction`��
+
+```
+protected Object doGetTransaction() {
+    DataSourceTransactionObject txObject = new DataSourceTransactionObject();
+    txObject.setSavepointAllowed(isNestedTransactionAllowed());
+    // ��ȡ������Ϣ��obtainDataSource()����ȡ����Դ
+    ConnectionHolder conHolder = 
+            (ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
+    txObject.setConnectionHolder(conHolder, false);
+    return txObject;
+}
+
+```
+
+����������������
+
+1.  ��ȡ����Դ
+2.  ��ȡ `ConnectionHolder`
+
+����������������Դ����λ�ȡ�ģ�
+
+```
+public class DataSourceTransactionManager extends AbstractPlatformTransactionManager
+        implements ResourceTransactionManager, InitializingBean {
+
+    @Nullable
+    private DataSource dataSource;
+
+    /**
+     * ���췽������������Դ
+     */
+    public DataSourceTransactionManager(DataSource dataSource) {
+        this();
+        setDataSource(dataSource);
+        afterPropertiesSet();
+    }
+
+    /**
+     * ��������Դ
+     */
+    public void setDataSource(@Nullable DataSource dataSource) {
+        if (dataSource instanceof TransactionAwareDataSourceProxy) {
+            this.dataSource = ((TransactionAwareDataSourceProxy) dataSource)
+                    .getTargetDataSource();
+        }
+        else {
+            this.dataSource = dataSource;
+        }
+    }
+
+    @Nullable
+    public DataSource getDataSource() {
+        return this.dataSource;
+    }
+
+    /**
+     * ��ȡ����Դ
+     */
+    protected DataSource obtainDataSource() {
+        DataSource dataSource = getDataSource();
+        Assert.state(dataSource != null, "No DataSource set");
+        return dataSource;
+    }
+
+    ...
+}
+
+```
+
+`obtainDataSource()` ʵ�����ǵ����� `getDataSource()` ���������ص��� `dataSource` ��Ա�������� `dataSource` ������ `DataSourceTransactionManager` �Ĺ��췽���ﴫ��ģ���ˣ��õ��Ľ����ǣ������ȡ������Դ�������������� `DataSourceTransactionManager` ʱ����ģ�
+
+```
+@Configuration
+public class TxDemo03Config {
+
+    /**
+     * ��������Դ
+     * @return
+     * @throws Exception
+     */
+    @Bean
+    public DataSource dataSource() throws Exception {
+        Driver driver = new com.mysql.jdbc.Driver();
+        String url = "jdbc:mysql://localhost:3306/test";
+        String username = "root";
+        String password = "123";
+        return new SimpleDriverDataSource(driver, url, username, password);
+    }
+
+    /**
+     * ���������
+     * @param dataSource
+     * @return
+     */
+    @Bean
+    public DataSourceTransactionManager transactionManager(DataSource dataSource) {
+        return new DataSourceTransactionManager(dataSource);
+    }
+
+    ...
+
+}
+
+```
+
+���������Դ������ `SimpleDriverDataSource`.
+
+������������ `ConnectionHolder` �Ļ�ȡ���÷���Ϊ `TransactionSynchronizationManager#getResource` ���������£�
+
+```
+// �� ThreadLocal �����  ConnectionHolder ��Ϣ
+private static final ThreadLocal<Map<Object, Object>> resources =
+        new NamedThreadLocal<>("Transactional resources");
+
+/**
+ * ��ȡ ConnectionHolder
+ */
+public static Object getResource(Object key) {
+    // ��װ�´���� key
+    Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
+    // �������ȡ������Ϣ
+    Object value = doGetResource(actualKey);
+    return value;
+}
+
+/**
+ * ����Ļ�ȡ����
+ */
+private static Object doGetResource(Object actualKey) {
+    // ��ThreadLocal�л�ȡ
+    Map<Object, Object> map = resources.get();
+    if (map == null) {
+        return null;
+    }
+    Object value = map.get(actualKey);
+    if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
+        map.remove(actualKey);
+        if (map.isEmpty()) {
+            resources.remove();
+        }
+        value = null;
+    }
+    return value;
+}
+
+```
+
+�Ӵ���������`TransactionSynchronizationManager` ����һ�� `ThreadLocal` ��ʵ�������д����һ�� `Map`���� `Map` �� `key` Ϊ `datasource`��`value` Ϊ `ConnectionHolder`.
+
+��ô��� `ConnectionHolder` ��ʲô�أ����Լ򵥵ؽ�������Ϊ `Connection`(���ݿ�����) �İ�װ�࣬��������Ҫ�����Ծ��� `Connection` �ˣ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-d8c4ae3884177f485fbb95d1828fdb39ae2.png)
+
+���ˣ�������Ͱ� `doGetTransaction(xxx)` �����������ˣ�������������������صĽ����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-0944429e31a6c0b67e121674202dd5ec0fd.png)
+
+##### 2. `isExistingTransaction(...)`���Ƿ��������
+
+��ȡ��������� `DataSourceTransactionObject` �󣬽����������ж��Ƿ���������ˣ��жϷ����� `DataSourceTransactionManager#isExistingTransaction`���������£�
+
+```
+protected boolean isExistingTransaction(Object transaction) {
+    DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
+    return (txObject.hasConnectionHolder() 
+            && txObject.getConnectionHolder().isTransactionActive());
+}
+
+```
+
+`ConnectionHolder` ����һ����Ա���� `transactionActive`����������ǰ `ConnectionHolder` �������Ƿ��ڼ���״̬��`isExistingTransaction(...)` ������Ҫ�Ǹ��������жϵ�ǰ��������Ƿ��������ġ�
+
+##### 3\. �����Ѵ��ڵ�����`handleExistingTransaction(...)`
+
+�������������������ǰ��������spring ����ô�����ģ������Ѵ�������ķ���Ϊ `AbstractPlatformTransactionManager#handleExistingTransaction`���������£�
+
+```
+private TransactionStatus handleExistingTransaction(TransactionDefinition definition, 
+        Object transaction, boolean debugEnabled) throws TransactionException {
+    // ��������ʽΪ����ʹ������ʱ���׳��쳣
+    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
+        throw new IllegalTransactionStateException(
+                "Existing transaction found for transaction marked with propagation 'never'");
+    }
+    // ��������ʽΪ����֧������ʱ������ǰ����Ȼ�����������״̬������
+    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
+        // 1\. suspend()�������������
+        Object suspendedResources = suspend(transaction);
+        boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
+        return prepareTransactionStatus(
+                definition, null, false, newSynchronization, debugEnabled, suspendedResources);
+    }
+
+    // ��������ʽΪ�����µ����������С�ʱ������ǰ����Ȼ�������µ�����
+    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
+        // �����������
+        SuspendedResourcesHolder suspendedResources = suspend(transaction);
+        try {
+            boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
+            DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true,
+                    newSynchronization, debugEnabled, suspendedResources);
+            // 2\. doBegin()�������µ�����
+            doBegin(transaction, definition);
+            prepareSynchronization(status, definition);
+            return status;
+        }
+        catch (RuntimeException | Error beginEx) {
+            resumeAfterBeginException(transaction, suspendedResources, beginEx);
+            throw beginEx;
+        }
+    }
+
+    // ��������ʽΪ��Ƕ��ִ�С�ʱ�� ��������ı����
+    // �������񣬽��������ע����㣬�γ�Ƕ������
+    // Ƕ�������е�����������쳣����Ӱ�쵽�����񱣴��֮ǰ�IJ�����
+    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
+        if (!isNestedTransactionAllowed()) {
+            throw new NestedTransactionNotSupportedException(...);
+        }
+        // 3\. createAndHoldSavepoint(...)����������㣬�ع�ʱֻ�ع����ñ����
+        if (useSavepointForNestedTransaction()) {
+            DefaultTransactionStatus status = prepareTransactionStatus(definition, transaction,
+                    false, false, debugEnabled, null);
+            status.createAndHoldSavepoint();
+            return status;
+        }
+        else {
+            boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
+            DefaultTransactionStatus status = newTransactionStatus(
+                    definition, transaction, true, newSynchronization, debugEnabled, null);
+            // �����֧�ֱ���㣬�������µ�����
+            doBegin(transaction, definition);
+            prepareSynchronization(status, definition);
+            return status;
+        }
+    }
+    if (isValidateExistingTransaction()) {
+        // ������֤��������������
+        ...
+    }
+    boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
+    return prepareTransactionStatus(definition, transaction, false, 
+            newSynchronization, debugEnabled, null);
+}
+
+```
+
+���Կ��������������ʹ���������ĸ��뼶����߼�����صĴ����Ѿ�����ע�ͣ�����Ͳ���˵�ˣ����������м���������Ҫ�ر������
+
+1.  `suspend()`�������������
+2.  `doBegin()`�������µ�����
+3.  `createAndHoldSavepoint(...)`����������㣬�ع�ʱֻ�ع����ñ����
+
+�⼸����������������������������������ͳһ������
+
+##### 4\. ���� `AbstractPlatformTransactionManager#getTransaction`
+
+�������ٻص� `AbstractPlatformTransactionManager#getTransaction` ����������ʣ�µ����̣�
+
+```
+public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
+        throws TransactionException {
+
+    // ǰ���Ѿ��������ˣ�ʡ��
+    ...
+
+    // ���е������������ǰû������
+
+    // ��鳬ʱʱ��������Ƿ����
+    if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
+        throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
+    }
+
+    // PROPAGATION_MANDATORY�����������������У�����û������ֱ�����쳣
+    if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
+        throw new IllegalTransactionStateException(...);
+    }
+    // ����ǰ���񣬴���������
+    else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
+            def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
+            def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
+        // suspend(...) ����null�������ͬ�����������ͬ�����񣬷���ʲôҲ����
+        SuspendedResourcesHolder suspendedResources = suspend(null);
+        try {
+            boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
+            // �����������
+            DefaultTransactionStatus status = newTransactionStatus(
+                    def, transaction, true, newSynchronization, debugEnabled, suspendedResources);
+            // ��������
+            doBegin(transaction, def);
+            // ���� TransactionSynchronizationManager ������
+            prepareSynchronization(status, def);
+            return status;
+        }
+        catch (RuntimeException | Error ex) {
+            resume(null, suspendedResources);
+            throw ex;
+        }
+    }
+    else {
+        boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
+        return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
+    }
+}
+
+```
+
+`handleExistingTransaction(...)` �����Ĺ�����**���������ʱ����Щ����������Ҫ��ô����**��`getTransaction(...)` �������²��ֵĹ����ǣ�**���������ʱ����Щ������������Ҫ��ô����**�����Կ�������������Ȼ������ `suspend(...)`��`doBegin(...)` �ȷ�������Щ����������һ��Ҳͳһ������
+
+##### 5\. ׼�����ؽ����`prepareTransactionStatus(...)`
+
+`handleExistingTransaction(...)` ������ `getTransaction(...)` �����ڴ������ؽ��ʱ����ʹ���� `prepareTransactionStatus(...)` ������
+
+```
+// `handleExistingTransaction(...)`����
+return prepareTransactionStatus(definition, transaction, false, 
+            newSynchronization, debugEnabled, null);
+
+// `getTransaction(...)`����
+return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
+
+```
+
+�������������������������ɶ������ `AbstractPlatformTransactionManager#prepareTransactionStatus`��
+
+```
+protected final DefaultTransactionStatus prepareTransactionStatus(
+        TransactionDefinition definition, @Nullable Object transaction, boolean newTransaction,
+        boolean newSynchronization, boolean debug, @Nullable Object suspendedResources) {
+
+    // ������һ�� DefaultTransactionStatus ����
+    DefaultTransactionStatus status = newTransactionStatus(
+            definition, transaction, newTransaction, newSynchronization, debug, suspendedResources);
+    // ׼�� Synchronization
+    prepareSynchronization(status, definition);
+    return status;
+}
+
+/**
+ *����һ�� TransactionStatus ʵ��
+ */
+protected DefaultTransactionStatus newTransactionStatus(
+        TransactionDefinition definition, @Nullable Object transaction, boolean newTransaction,
+        boolean newSynchronization, boolean debug, @Nullable Object suspendedResources) {
+
+    boolean actualNewSynchronization = newSynchronization &&
+            !TransactionSynchronizationManager.isSynchronizationActive();
+    // ���� DefaultTransactionStatus �Ĺ��췽��
+    return new DefaultTransactionStatus(
+            transaction, newTransaction, actualNewSynchronization,
+            definition.isReadOnly(), debug, suspendedResources);
+}
+
+```
+
+�������������Ҫ����Ϊ�˴��� `DefaultTransactionStatus` ����������������һ�������н����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-a491ee7ca22238b2d9c698c55ae9dd6d005.png)
+
+##### 6\. ׼��������Ϣ��`TransactionAspectSupport#prepareTransactionInfo`
+
+�ص� `TransactionAspectSupport#createTransactionIfNecessary` ������
+
+```
+protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
+        @Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
+    ...
+    TransactionStatus status = null;
+    if (txAttr != null) {
+        if (tm != null) {
+            // ��ȡ����״̬�������ǰû�����񣬿��ܻᴴ������
+            status = tm.getTransaction(txAttr);
+        }
+    }
+    // ׼��������Ϣ�����ǽ�ǰ��õ�����Ϣ��װ�� TransactionInfo
+    return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
+}
+
+```
+
+ǰ���������ô�ֻ࣬�ǵõ��� `TransactionStatus`�������ٽ���������������׼��������Ϣ�ķ��� `prepareTransactionInfo(...)`��
+
+```
+protected TransactionInfo prepareTransactionInfo(@Nullable PlatformTransactionManager tm,
+        @Nullable TransactionAttribute txAttr, String joinpointIdentification,
+        @Nullable TransactionStatus status) {
+    TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
+
+    if (txAttr != null) {
+        txInfo.newTransactionStatus(status);
+    }
+
+    // ʡ��log�Ĵ�ӡ
+    ...
+
+    // ���̰߳�
+    txInfo.bindToThread();
+    return txInfo;
+}
+
+```
+
+�ţ�ͬ `prepareTransactionStatus(...)` ���ƣ��������Ҳ�Ǵ�����һ�� `TransactionInfo` ���󣬲��ҽ� `TransactionInfo` �뵱ǰ�̰߳󶨣��󶨵Ĵ������£�
+
+```
+public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {
+
+    // ��ŵ�ǰʹ�õ�������Ϣ
+    private static final ThreadLocal<TransactionInfo> transactionInfoHolder =
+            new NamedThreadLocal<>("Current aspect-driven transaction");
+
+    // ����Ϊ�ɵ�������Ϣ
+    protected void cleanupTransactionInfo(@Nullable TransactionInfo txInfo) {
+        if (txInfo != null) {
+            txInfo.restoreThreadLocalStatus();
+        }
+    }
+
+    /**
+     * TransactionInfo: ����������Ϣ
+     */
+    protected static final class TransactionInfo {
+
+        // ��ǰ������״̬����
+        @Nullable
+        private TransactionStatus transactionStatus;
+
+        // �ɵ�������Ϣ��Ҳ���ǹ����������Ϣ��
+        @Nullable
+        private TransactionInfo oldTransactionInfo;
+
+        /**
+         * ��������Ϣ�󶨵���ǰ�߳�
+         */
+        private void bindToThread() {
+            // �õ��ɵ�������Ϣ
+            this.oldTransactionInfo = transactionInfoHolder.get();
+            // ���ó����µ�������Ϣ
+            transactionInfoHolder.set(this);
+        }
+
+        /**
+         * ������ɺ󣬻Ὣ�ɵ�������Ϣ�󶨵���ǰ�߳�
+         */
+        private void restoreThreadLocalStatus() {
+            // ����Ϊ�ɵ�������Ϣ
+            transactionInfoHolder.set(this.oldTransactionInfo);
+        }
+
+        ...
+    }
+
+}
+
+```
+
+`TransactionAspectSupport` ����һ�� `ThreadLocal`��������ŵ�ǰ�� `TransactionInfo` ���󣬽����̰߳�ʱ�������õ��ɵ�������Ϣ�������� `TransactionInfo` �ij�Ա���� `oldTransactionInfo` �У�Ȼ���µ� `TransactionInfo` ���� `ThreadLocal` �У�������ִ����ɺ󣬻�� `TransactionInfo` �ij�Ա���� `oldTransactionInfo` ���õ��ɵ�������Ϣ���ٽ��ɵ�������Ϣ���� `ThreadLocal` �У������������� "�� - �� - ��" ���л�.
+
+��һ���õ��� `TransactionInfo` ���£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-ab882613ce67ba3bf7afcbd2eab01c6cf27.png)
+
+���� `TransactionInfo` �Ľṹ��������һЩ˵����
+
+*   ������ `TransactionAspectSupport.TransactionInfo`���� `TransactionAspectSupport` ��һ���ڲ��࣬��װ�������һЩ��Ϣ
+*   `transactionManager`: ����������������������õ� `DataSourceTransactionManager`
+*   `transactionAttribute`: ��������ֵ���������� `@Transactional` ע�������ֵ
+*   `joinpointIdentification`: ������ȫ�޶�������ʽΪ��"���������͡�������"��
+*   `transactionStatus`: �������Ͽ����Ǽ�¼�����״̬��ʵ��������󲻽���¼�������״̬���������ش������£�
+    *   `complete`: ��������״̬
+    *   `connectionHolder`: ��ǰ���е����ݿ�����
+    *   `suspendedResources`: ��������ݿ����ӣ�����Ҫ�ָ����������ʱ�������ܹ��ö����õ���������ݿ�����
+*   `oldTransactionInfo`: ��һ������Ҳ���ǹ�������񣩵���Ϣ��ִ���굱ǰ����󣬻�ָ�����һ�������ִ��
+
+һ��С����д����ô���ˣ����ľ��ȷ����������ˣ�`suspend(...)`��`doBegin(...)` �ȷ�����ƪ�ٷ����ɡ�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4947799](https://my.oschina.net/funcy/blog/4947799) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\200\357\274\211\357\274\232\345\220\257\345\212\250\346\265\201\347\250\213\346\246\202\350\247\210.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\200\357\274\211\357\274\232\345\220\257\345\212\250\346\265\201\347\250\213\346\246\202\350\247\210.md"
new file mode 100644
index 0000000..841ee00
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\200\357\274\211\357\274\232\345\220\257\345\212\250\346\265\201\347\250\213\346\246\202\350\247\210.md"
@@ -0,0 +1,230 @@
+在前面的文章中，我们成功的编译了 spring 源码，也构建了第一个 spring 测试 demo，接下来我们就基于[第一个 spring 源码调试 demo](https://my.oschina.net/funcy/blog/4533250 "第一个spring源码调试demo") 中的代码，来对 spring 源码进行源码分析。
+
+### 1\. spring 启动流程概览
+
+在前面 demo 的 `main()` 方法中，有这么一行：
+
+```
+ApplicationContext context =
+        new AnnotationConfigApplicationContext("org.springframework.learn.demo01");
+
+```
+
+这短短的一行就是 spring 的整个启动流程了。上面的代码中，声明了一个 `ApplicationContext` 类型的对象 `context`，右边使用其子类 `AnnotationConfigApplicationContext` 实例化，并在构造方法中传入了包名 `org.springframework.learn.demo01`，这个包名就表明了接下来要扫描哪些包。
+
+> 这里我们接触到了 spring 的第一个组件：`ApplicationContext`，关于 `ApplicationContext` 的分析，可以参考我的文章 [spring 组件（一）：ApplicationContext](https://my.oschina.net/funcy/blog/4597456 "spring组件（一）：ApplicationContext")。
+
+进入到 `AnnotationConfigApplicationContext`，代码如下：
+
+> AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
+
+```
+public AnnotationConfigApplicationContext(String... basePackages) {
+     // 1\. 调用无参构造函数，会先调用父类GenericApplicationContext的构造函数
+     // 2\. 父类的构造函数里面就是初始化DefaultListableBeanFactory，并且赋值给beanFactory
+     // 3\. 本类的构造函数里面，初始化了一个读取器：AnnotatedBeanDefinitionReader read，
+     //    一个扫描器ClassPathBeanDefinitionScanner scanner
+     // 4\. 这个scanner，就是下面 scan(basePackages) 调用的对象
+     this();
+
+     //对传入的包进行扫描，扫描完成后，会得到一个 BeanDefinition 的集合
+     scan(basePackages);
+
+     //启动spring，在这里完成spring容器的初始化操作，
+     //包括bean的实例化、属性注入，将bean保存到spring容器中等
+     refresh();
+}
+
+```
+
+这个类就三行，相关操作都已在代码中注释了，这里稍微再总结下，这段代码主要做了三件事：
+
+1.  调用无参构造，进行属性初始化
+2.  进行包扫描，得到 BeanDefinition
+3.  启用 spring 容器。
+
+接着，我们再来看看 spring 启动流程中，做了哪些事：
+
+> AbstractApplicationContext#refresh
+
+```
+public void refresh() throws BeansException, IllegalStateException {
+    // 使用synchronized是为了避免refresh() 还没结束，再次发起启动或者销毁容器引起的冲突
+    synchronized (this.startupShutdownMonitor) {
+        // 做一些准备工作，记录容器的启动时间、标记“已启动”状态、检查环境变量等
+        prepareRefresh();
+
+        // 初始化BeanFactory容器、注册BeanDefinition, 最终获得了DefaultListableBeanFactory
+        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
+
+        // 还是一些准备工作:
+        // 1\. 设置了一个类加载器
+        // 2\. 设置了bean表达式解析器
+        // 3\. 添加了属性编辑器的支持
+        // 4\. 添加了一个后置处理器：ApplicationContextAwareProcessor
+        // 5\. 设置了一些忽略自动装配的接口
+        // 6\. 设置了一些允许自动装配的接口，并且进行了赋值操作
+        // 7\. 在容器中还没有XX的bean的时候，帮我们注册beanName为XX的singleton bean
+        prepareBeanFactory(beanFactory);
+
+        try {
+            // Spring的一个扩展点. 如果有Bean实现了BeanFactoryPostProcessor接口，
+            // 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。
+            // 具体的子类可以在这步的时候添加特殊的 BeanFactoryPostProcessor 的实现类，来做些事
+            postProcessBeanFactory(beanFactory);
+
+            // 调用BeanFactoryPostProcessor各个实现类的postProcessBeanFactory(factory) 方法
+            invokeBeanFactoryPostProcessors(beanFactory);
+
+            // 扩展点,注册 BeanPostProcessor 的实现类，注意不是BeanFactoryPostProcessor
+            registerBeanPostProcessors(beanFactory);
+
+            // 初始化当前 ApplicationContext 的 MessageSource，用在国际化操作中
+            initMessageSource();
+
+            // 这个方法主要为初始化当前 ApplicationContext 的事件广播器
+            initApplicationEventMulticaster();
+
+            // 这也是spring的一个扩展点
+            onRefresh();
+
+            // Check for listener beans and register them.
+            // 注册事件监听器
+            registerListeners();
+
+            // 初始化所有的 singleton beans
+            finishBeanFactoryInitialization(beanFactory);
+
+            // 完成启动，
+            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.
+            // 销毁已经初始化的的Bean
+            destroyBeans();
+
+            // Reset 'active' flag.
+            // 重置 'active' 状态
+            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();
+        }
+    }
+}
+
+```
+
+这个方法虽然代码不多，但包含了 spring bean 的整个创建过程，每个方法做了些什么，在代码中都有注释，这里就不赘述了。
+
+实际上，`refresh()` 涵盖了 spring 整个创建 bean 的流程，在后面的文章中，我们也将重点展开这里面的方法来分析，在现阶段只需要大致了解这些方法做了什么事即可。
+
+整个流程总结如下：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-9307fefa65470e5c36ae6044631b5416aef.png)
+
+### 2\. spring 启动中 `beanFactory` 的变化
+
+本文中的源码解读就到这里了，接下来我们来看看，spring 启动中 `beanFactory` 有些什么变化。
+
+> `beanFactory` 是 spring 的重要组件之一，直译为 spring bean 工厂，是 spring 生产 bean 与保存 bean 的地方，关于 `beanFactory` 的详细分析，可以查看 [spring BeanFactory 分析](https://my.oschina.net/funcy/blog/4597529 "spring BeanFactory分析")。
+
+我们将断点打在 `AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)` 的 `this()` 方法上，然后运行 demo01 的 `main()` 方法：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-c3c672a675d9b06f03ea29cb31f6ed5d012.png)
+
+此时的变量中，并没有 `beanFactory`，我们自己添加 `beanFactory` 到调度窗口的变量列表中：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-e9d8ae8fdd3b02b2279376303e3eae4cf2f.png)
+
+这样就能看到对应的值了：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-44d1ade26f0cb667425b0dd99d82666877f.png)
+
+可以看到，此时的 `beanFactory` 为 null，表明 `beanFactory` 并未实例化，我们继续运行：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-664780be9dfef73c12a3f163b349e7e54d8.png)
+
+当运行完 `this()` 后，发现 `beanFactory` 已经有值了，类型为 `DefaultListableBeanFactory`。但是，在查看 `beanFactory` 对象时，发现 `beanFactory` 的属性太多了，我们应该重点关注啥呢？
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-1b617cf7edda29c652a7661d4be3779ec85.png)
+
+我们这部分主要关注 spring bean 的创建，因此只需要关注 `beanFactory` 的两个属性就可以了：
+
+*   beanDefinitionMap：存放 beanDefinition 的 map.
+*   singletonObjects：存放 spring bean 的 map，spring bean 创建后都存放在这里，也即直观上理解的 `spring 容器`.
+
+> `BeanDefinition` 是 spring 重要组件之一，为‘spring bean 的描述’，简单来说，就是说明了一个 spring bean 应该如何创建。关于 `BeanDefinition` 的详细分析，可以查看 [spring BeanDefinition 分析](https://my.oschina.net/funcy/blog/4597536)。
+
+我们手动添加变量，如下：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-0c6368478258f8b9f76b47fc1c85b02f13f.png)
+
+可以看到，此时的 `beanDefinitionMap` 中已经有 4 个对象了，显然是在 `this()` 方法中添加的，关于这块我们后面会分析。
+
+接着运行，发现 `beanDefinitionMap` 又多了两个：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-a493061fbd4b4066f9a4d91e91ff61e8c4e.png)
+
+这里的 `beanObj1` 与 `beanObj2` 就是我们自己的类了，由此可以判断出 **spring 就是在 `AnnotationConfigApplicationContext#scan` 方法中对包进行扫描的**。
+
+接下来，代码执行进入 `AbstractApplicationContext#refresh` 方法，我们一行行运行下去，发现运行到 `prepareBeanFactory(beanFactory);` 时，`singletonObjects` 中第一次出现了对象：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-8cebcb82f5a8754fd1bb4bb3eb3c57dda2d.png)
+
+可以看到，这里出现了 3 个类，基本都跟系统、环境相关，如 `environment` 是 spring 当前使用的环境 (`profile`)，`systemProperties` 当前系统的属性（操作系统、操作系统版本等）。
+
+继续往下运行，发现代码运行到 `invokeBeanFactoryPostProcessors(beanFactory)` 时，又多了 4 个类：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-baa09e51272baa384418cb2c82b9dfb079b.png)
+
+关于这几个类的作用，我们后面的文章中会分析，这里先不必管。继续往下运行，发现在 `registerBeanPostProcessors(beanFactory);` 中，又多了一个对象：
+
+```
+org.springframework.context.annotation.internalAutowiredAnnotationProcessor
+
+```
+
+这里我们依旧不用管这个对象，接着运行下去，可以看到在运行 `initMessageSource()` 时，又多了一个对象：
+
+```
+messageSource -> {DelegatingMessageSource@1847} "Empty MessageSource"
+
+```
+
+显然，这个对象是用来处理国际化问题的，不过由于 demo01 中并没有用到国际化，所以这里显示 `Empty MessageSource`。继续运行，发现运行到 `initApplicationEventMulticaster();` 时，又多了一个对象：
+
+```
+applicationEventMulticaster -> {SimpleApplicationEventMulticaster@1869} 
+
+```
+
+显然，这个对象是用来处理 `ApplicationContext` 的广播事件的，我们的 demo 中并没有用到，暂时不必理会。继续下去，发现在运行完 `finishBeanFactoryInitialization(beanFactory);`，`singletonObjects` 中终于出现了我们期待的对象：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-68b1ee71e468ef8cf839230c07b64c45563.png)
+
+由此可见，对象就是在该方法中创建的。
+
+### 总结
+
+1.  spring 包的描述：`AnnotationConfigApplicationContext#scan`
+2.  spring bean 的创建：`AbstractApplicationContext#finishBeanFactoryInitialization`
+
+本文主要是了解 spring 启动流程，从整体上把握 spring 启动过程中的 beanFactory 的变化。本文意在了解 spring 的整体启动流程，后续的分析中，我们将对这些流程进行展开分析。
+
+* * *
+
+_本文原文链接：[https://my.oschina.net/funcy/blog/4597493](https://my.oschina.net/funcy/blog/4597493) ，限于作者个人水平，文中难免有错误之处，欢迎指正！原创不易，商业转载请联系作者获得授权，非商业转载请注明出处。_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\203\357\274\211\357\274\232\345\233\275\351\231\205\345\214\226\344\270\216\344\272\213\344\273\266\345\244\204\347\220\206.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\203\357\274\211\357\274\232\345\233\275\351\231\205\345\214\226\344\270\216\344\272\213\344\273\266\345\244\204\347\220\206.md"
new file mode 100644
index 0000000..4f97b54
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\203\357\274\211\357\274\232\345\233\275\351\231\205\345\214\226\344\270\216\344\272\213\344\273\266\345\244\204\347\220\206.md"
@@ -0,0 +1,166 @@
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-ed6b80d76ba4b2ddb0f8d15e070a0c32df7.png)
+
+�����ģ����Ǽ������� spring ���������̡�
+
+### 7\. ���ʻ�: `initMessageSource()`
+
+���������������ʼ�� `MessageSource` �ģ��������£�
+
+```
+public abstract class AbstractApplicationContext extends DefaultResourceLoader
+        implements ConfigurableApplicationContext {
+
+    ...
+
+    /**
+     * ��ʼ�� MessageSource
+     */
+    protected void initMessageSource() {
+        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
+        // ���beanFactory���MessageSource�������� ParentMessageSource
+        if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
+            this.messageSource = beanFactory.getBean(
+                    MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
+            if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
+                HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
+                if (hms.getParentMessageSource() == null) {
+                    // ����ParentMessageSource
+                    hms.setParentMessageSource(getInternalParentMessageSource());
+                }
+            }
+        }
+        // ���beanFactory�в�����MessageSource���� ����-����-ע��
+        else {
+            DelegatingMessageSource dms = new DelegatingMessageSource();
+            dms.setParentMessageSource(getInternalParentMessageSource());
+            this.messageSource = dms;
+            // ����ParentMessageSource
+            beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
+        }
+    }
+
+    /**
+     * ���ظ������� messageSource
+     */
+    @Nullable
+    protected MessageSource getInternalParentMessageSource() {
+        return (getParent() instanceof AbstractApplicationContext ?
+                ((AbstractApplicationContext) getParent()).messageSource : getParent());
+    }
+
+    ...
+}
+
+```
+
+���Կ���������������Ҫ�Dz��� `MessageSource`����Ҫ�߼�Ϊ������Ѿ����� `MessageSource` �ˣ�������һЩ���ԣ�����ʹ��� `MessageSource`��������Щ ���ԣ����ע�ᵽ `beanFactory` �С�
+
+���� `MessageSource` �ľ������ã����ľͲ�չ���ˡ�
+
+### 8\. ��ʼ���¼��㲥����`initApplicationEventMulticaster()`
+
+`AbstractApplicationContext#initApplicationEventMulticaster` �������£�
+
+```
+protected void initApplicationEventMulticaster() {
+    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
+    // ����û��������Զ����¼��㲥������ʹ���û���
+    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
+        this.applicationEventMulticaster =
+                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, 
+                        ApplicationEventMulticaster.class);
+    }
+    else {
+        // �û�û�����ù㲥������ʹ��Ĭ�ϵ��¼��㲥��
+        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
+        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, 
+                this.applicationEventMulticaster);
+    }
+}
+
+```
+
+����߼�Ҳ�ܼ򵥣�����Ѵ����¼��㲥������ʹ���Ѵ��ڵģ�����ʹ���һ�������� `ApplicationEventMulticaster`����Ҫ���������㲥�¼��ģ���������¼������ݣ����Բο� [spring ̽��֮ spring �¼�����](https://my.oschina.net/funcy/blog/4713339).
+
+### 9\. ��չ�㣺onRefresh ()
+
+`AbstractApplicationContext#onRefresh` �� spring �ṩ��һ����չ�㣬�����������ݣ�
+
+```
+protected void onRefresh() throws BeansException {
+
+}
+
+```
+
+�����Ҫ�����ض��IJ�����������������ʵ�֡�
+
+��ǰʹ�õ� `ApplicationContext` �� `AnnotationConfigApplicationContext`������ `onRefresh()` �������Ͳ���������ˡ�
+
+### 10\. ע���¼���������registerListeners ()
+
+`AbstractApplicationContext#registerListeners` ��ش������£�
+
+> AbstractApplicationContext
+
+```
+/** �������������ż������� */
+private final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<>();
+
+/** ���ص�ǰ���еļ����� */
+public Collection<ApplicationListener<?>> getApplicationListeners() {
+    return this.applicationListeners;
+}
+
+/**
+ * ���Ӽ�����
+ */
+public void addApplicationListener(ApplicationListener<?> listener) {
+    Assert.notNull(listener, "ApplicationListener must not be null");
+    if (this.applicationEventMulticaster != null) {
+        this.applicationEventMulticaster.addApplicationListener(listener);
+    }
+    this.applicationListeners.add(listener);
+}
+
+/**
+ * ע�������
+ */
+protected void registerListeners() {
+    // �������ֶ�set��һЩ������
+    // getApplicationListeners() ��ȡ�ļ�����������ͨ������ addApplicationListener(...) ���ӵ�
+    for (ApplicationListener<?> listener : getApplicationListeners()) {
+        getApplicationEventMulticaster().addApplicationListener(listener);
+    }
+    // ��ȡȡ�������������ƣ����õ��㲥��
+    // ��ʱ��ȡ�ļ������Ǵ� beanFactory �л�ȡ�ģ�����springͨ����ɨ��õ���
+    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
+    for (String listenerBeanName : listenerBeanNames) {
+        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
+    }
+    // �����������Ӧ���¼����㲥
+    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
+    this.earlyApplicationEvents = null;
+    if (earlyEventsToProcess != null) {
+        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
+            //  �㲥�����¼�
+            getApplicationEventMulticaster().multicastEvent(earlyEvent);
+        }
+    }
+}
+
+```
+
+������������̴������£�
+
+1.  ���� `AbstractApplicationContext#applicationListeners` �еļ������� `ApplicationEventMulticaster` ��
+2.  �� `beanFactory` ��ȡ�������� `beanName`�����ӵ� `ApplicationEventMulticaster` ��
+3.  ����������¼����ͽ��й㲥
+
+���� spring ���¼������IJ�������չ����������˽���࣬�ɲο� [spring ̽��֮ spring �¼�����](https://my.oschina.net/funcy/blog/4713339).
+
+���ĵķ����͵������ˡ�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4892120](https://my.oschina.net/funcy/blog/4892120) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\211\357\274\211\357\274\232\345\214\205\347\232\204\346\211\253\346\217\217\346\265\201\347\250\213.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\211\357\274\211\357\274\232\345\214\205\347\232\204\346\211\253\346\217\217\346\265\201\347\250\213.md"
new file mode 100644
index 0000000..f7c7a4d
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\270\211\357\274\211\357\274\232\345\214\205\347\232\204\346\211\253\346\217\217\346\265\201\347\250\213.md"
@@ -0,0 +1,800 @@
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-3ed1cf4bd6fc2ef3f569376093a6462987d.png)
+
+�� [applicationContext �Ĵ���](https://my.oschina.net/funcy/blog/4608767)�У����Ƿ����� `applicationContext` �Ĵ������̣��ڱ����У����ǽ����� spring ����ν��а�ɨ��ġ�
+
+������ `AnnotationConfigApplicationContext` �Ĺ��췽����
+
+```
+public AnnotationConfigApplicationContext(String... basePackages) {
+    this();
+    //�Դ���İ�����ɨ�裬ɨ����ɺ󣬻�õ�һ�� BeanDefinition �ļ���
+    scan(basePackages);
+    refresh();
+}
+
+```
+
+������ǽ�Ŀ����� `scan(basePackages);` �ϣ�����÷�����
+
+> AnnotationConfigApplicationContext#scan
+
+```
+public void scan(String... basePackages) {
+     Assert.notEmpty(basePackages, "At least one base package must be specified");
+     // �����scanner���������this()�����
+     this.scanner.scan(basePackages);
+}
+
+```
+
+��������ؼ������� `this.scanner.scan(basePackages);`����� `scanner` ������ `this()` �д����Ķ���
+
+```
+public AnnotationConfigApplicationContext() {
+    this.reader = new AnnotatedBeanDefinitionReader(this);
+    // scanner ���������ﴴ����
+    this.scanner = new ClassPathBeanDefinitionScanner(this);
+}
+
+```
+
+����׷�٣��������ǶԲ���Ҫ�ķ������������������ص��עɨ����Ĺ��̣�
+
+```
+AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
+ |-AnnotationConfigApplicationContext#scan
+  |-ClassPathBeanDefinitionScanner#scan
+   |-ClassPathBeanDefinitionScanner#doScan
+
+```
+
+`ClassPathBeanDefinitionScanner#doScan` �������£�
+
+```
+protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
+    Assert.notEmpty(basePackages, "At least one base package must be specified");
+    Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
+    //������Ҫɨ��İ�·��
+    for (String basePackage : basePackages) {
+        //��ȡ���з���������BeanDefinition
+        Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
+        for (BeanDefinition candidate : candidates) {
+            //��BeanDefinition��Scope
+            ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
+            candidate.setScope(scopeMetadata.getScopeName());
+            //�鿴�Ƿ��������Ƿ�ָ��bean�����ƣ���ûָ����ʹ����������ĸСд
+            String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
+            //��������if�Ǵ���lazy��Autowire��DependencyOn��initMethod��enforceInitMethod��destroyMethod��
+            // enforceDestroyMethod��Primary��Role��Description��Щ�߼���
+            if (candidate instanceof AbstractBeanDefinition) {
+                postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
+            }
+            if (candidate instanceof AnnotatedBeanDefinition) {
+                AnnotationConfigUtils.processCommonDefinitionAnnotations(
+                        (AnnotatedBeanDefinition) candidate);
+            }
+            //���bean�Ƿ����
+            if (checkCandidate(beanName, candidate)) {
+                //�ְ�װ��һ��
+                BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
+                //���scope�Ƿ񴴽�����δ��������д���
+                definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(
+                        scopeMetadata, definitionHolder, this.registry);
+                beanDefinitions.add(definitionHolder);
+                //ע�� beanDefinition
+                registerBeanDefinition(definitionHolder, this.registry);
+            }
+        }
+    }
+    return beanDefinitions;
+}
+
+```
+
+��δ�����ɵĹ��ܺ����ˣ��������������¼����£�
+
+1.  ���ݰ�·�����õ����������� BeanDefinition
+2.  ���� BeanDefinition����һ���ḻ beanDefinition ��Ϣ
+3.  �� BeanDefinition ���ӵ� beanFactory
+
+> BeanDefinition Ҳ�� spring ����Ҫ���֮һ������ BeanDefinition �ķ������ɲο� [spring ���֮ BeanDefinition](https://my.oschina.net/funcy/blog/4597536 "spring���֮BeanDefinition")��
+
+������������Ҫ�����������IJ�����
+
+### 1\. ���ݰ�·���õ� BeanDefinition
+
+��һ����Ҫ������ `Set<BeanDefinition> candidates = findCandidateComponents(basePackage);`�����Ǹ���ȥ���������ִ�У��������ɶԲ���Ҫ����������������÷����ĵ������£�
+
+```
+AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
+ |-AnnotationConfigApplicationContext#scan
+  |-ClassPathBeanDefinitionScanner#scan
+   |-ClassPathBeanDefinitionScanner#doScan
+    |-ClassPathScanningCandidateComponentProvider#findCandidateComponents
+     |-ClassPathScanningCandidateComponentProvider#scanCandidateComponents
+
+```
+
+���յ��õ��� `ClassPathScanningCandidateComponentProvider#scanCandidateComponents`���������� (��ɾ��)��
+
+```
+private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
+    Set<BeanDefinition> candidates = new LinkedHashSet<>();
+    //��װɨ��·������װ��ɺ������ָ�ʽ��classpath*:org/springframework/learn/demo01/**/*.class��
+    String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
+            resolveBasePackage(basePackage) + '/' + this.resourcePattern;
+    //����·����ȡ��Դ���󣬼�ɨ�����·���µĵ�����class�ļ����õ� Resource
+    Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
+    for (Resource resource : resources) {
+        if (resource.isReadable()) {
+            //������Դ�����ȡ��Դ�����MetadataReader
+            MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
+            // �������������£�
+            // 1\. �Ƿ���Ҫ��ʼ��Ϊspring bean�����Ƿ��� @Component��@Service��ע��
+            // 2\. �鿴�������Ƿ���@Conditionalһϵ�е�ע�⣬Ȼ���Ƿ�����ע��Bean������
+            if (isCandidateComponent(metadataReader)) {
+                ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
+                sbd.setResource(resource);
+                sbd.setSource(resource);
+                if (isCandidateComponent(sbd)) {
+                    candidates.add(sbd);
+                }
+            }
+        }
+    }
+    return candidates;
+}
+
+```
+
+���Կ��������ϴ������������£�
+
+1.  ���ݴ���� basePackage �õ�ɨ��·��
+2.  ����ɨ��·���õ���·���µ����� class �ļ���Ӧ�� Resource
+3.  �� Resource ת��Ϊ beanDefinition
+
+���������Ǿ����ϴ�����з�����
+
+#### 1.1 ���� basePackage �õ���ɨ��·��
+
+��һ��ûɶ�÷���������һ���ַ�����ƴ�����滻��������� `org.springframework.learn.demo01` ת��Ϊ `classpath*:org/springframework/learn/demo01/**/*.class`����ش����һ�У�
+
+```
+String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
+        resolveBasePackage(basePackage) + '/' + this.resourcePattern;
+
+```
+
+#### 1.2 ɨ���·��
+
+�õ���ɨ��·���󣬽��������ǽ���ɨ���ˡ�spring ��ɨ��ʱ�����ɨ��·���µ����� class �ļ�ɨ�������Ȼ���װ�� `Resource`����������
+
+```
+Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
+
+```
+
+�������룬ͬ���أ����ǶԲ���Ҫ�ķ���������ֻ�����������ã�
+
+```
+AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
+ |-AnnotationConfigApplicationContext#scan
+  |-ClassPathBeanDefinitionScanner#scan
+   |-ClassPathBeanDefinitionScanner#doScan
+    |-ClassPathScanningCandidateComponentProvider#findCandidateComponents
+     |-ClassPathScanningCandidateComponentProvider#scanCandidateComponents
+      |- GenericApplicationContext#getResources
+       |-AbstractApplicationContext#getResources
+        |-PathMatchingResourcePatternResolver#getResources
+         |-PathMatchingResourcePatternResolver#findPathMatchingResources
+
+```
+
+���ǽ�����ۼ��� `PathMatchingResourcePatternResolver#findPathMatchingResources`:
+
+```
+protected Resource[] findPathMatchingResources(String locationPattern) throws IOException {
+    // ����� locationPattern �� classpath*:org/springframework/learn/demo01/**/*.class
+    // rootDirPath �� classpath*:org/springframework/learn/demo01/
+    String rootDirPath = determineRootDir(locationPattern);
+
+    // subPattern �� **/*.class
+    String subPattern = locationPattern.substring(rootDirPath.length());
+
+    // ���ﷵ�ص� Resource �� rootDirPath �ľ���·��(��url��ʾ)
+    // URL [file:/xxx/spring-learn/build/classes/java/main/org/springframework/learn/demo01/]
+    Resource[] rootDirResources = getResources(rootDirPath);
+
+    Set<Resource> result = new LinkedHashSet<>(16);
+    for (Resource rootDirResource : rootDirResources) {
+        rootDirResource = resolveRootDirResource(rootDirResource);
+        URL rootDirUrl = rootDirResource.getURL();
+        if (equinoxResolveMethod != null && rootDirUrl.getProtocol().startsWith("bundle")) {
+            URL resolvedUrl = (URL) ReflectionUtils.invokeMethod(equinoxResolveMethod, null, rootDirUrl);
+            if (resolvedUrl != null) {
+                rootDirUrl = resolvedUrl;
+            }
+            rootDirResource = new UrlResource(rootDirUrl);
+        }
+        // ���� vfs ��Դ����
+        if (rootDirUrl.getProtocol().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) {
+            result.addAll(VfsResourceMatchingDelegate
+                    .findMatchingResources(rootDirUrl, subPattern, getPathMatcher()));
+        }
+        // ����jar���ļ�����
+        else if (ResourceUtils.isJarURL(rootDirUrl) || isJarResource(rootDirResource)) {
+            result.addAll(doFindPathMatchingJarResources(rootDirResource, rootDirUrl, subPattern));
+        }
+        // �����ļ�·���µ��ļ�����
+        else {
+            result.addAll(doFindPathMatchingFileResources(rootDirResource, subPattern));
+        }
+    }
+    return result.toArray(new Resource[0]);
+}
+
+```
+
+ͨ�����������ָ���Ĵ����������£�
+
+1.  ͨ������� locationPattern �õ��� pattern �µ� url ����·������װΪ Resource
+2.  �������ص�·�������� class �ļ�����װΪ Resource
+
+���������� spring ����ν� pattrn ת��Ϊ url ·���ģ����Ǹ������룺
+
+```
+|-PathMatchingResourcePatternResolver#getResources
+ |-PathMatchingResourcePatternResolver#findAllClassPathResources
+  |-PathMatchingResourcePatternResolver#doFindAllClassPathResources
+
+```
+
+���մ��뵽�� `PathMatchingResourcePatternResolver#doFindAllClassPathResources`:
+
+```
+protected Set<Resource> doFindAllClassPathResources(String path) throws IOException {
+    Set<Resource> result = new LinkedHashSet<>(16);
+    ClassLoader cl = getClassLoader();
+    // path��Ӧ��url
+    Enumeration<URL> resourceUrls = (cl != null ? cl.getResources(path) : 
+            ClassLoader.getSystemResources(path));
+    while (resourceUrls.hasMoreElements()) {
+        URL url = resourceUrls.nextElement();
+        // ��urlת��ΪResource�������ӵ������
+        result.add(convertClassLoaderURL(url));
+    }
+    if ("".equals(path)) {
+        addAllClassLoaderJarRoots(cl, result);
+    }
+    return result;
+}
+
+// ��urlת��ΪResource
+protected Resource convertClassLoaderURL(URL url) {
+    return new UrlResource(url);
+}
+
+```
+
+��ʱ����� `path` Ϊ `org/springframework/learn/demo01/`���Ӵ����֪�����յ����� java �� `ClassLoader` ��������ȡ path ��Ӧ�� url��Ȼ�� url ת��Ϊ `Resource` ���ӵ�������в����ء�
+
+�õ���ľ���·��֮�󣬽��¾��Ƕ�·�����б������õ� class �ļ��ˡ��������ٻص� `PathMatchingResourcePatternResolver#findPathMatchingResources`��spring ɨ��ʱ������ݴ���� url ���ͣ���ɨ�� 3 ���ط���
+
+1.  vfs
+2.  jar ��
+3.  �ļ�·��
+
+`vfs` ע����˵�� "URL protocol for a general JBoss VFS resource"����ͨ�� JBoss VFS ��Դ�� URL Э�飬���ﲻ��������Ŀ�������� jar ������Ҫɨ�� jar �е�·�����ͻ�ʹ�� jar ��ɨ�跽ʽ���� class �ļ����ң����ڵ���ʱ��`demo01` ��ʹ���ļ���ʽɨ��ģ�������ص�����ļ�ɨ�跽ʽ������ jar �����ɨ��ģ�����Ȥ��С���������о��¡�
+
+���Ǹ��� `findPathMatchingResources` ������
+
+```
+|-PathMatchingResourcePatternResolver#findPathMatchingResources
+ |-PathMatchingResourcePatternResolver#doFindPathMatchingFileResources
+  |-PathMatchingResourcePatternResolver#doFindMatchingFileSystemResources
+
+```
+
+```
+protected Set<Resource> doFindMatchingFileSystemResources(File rootDir, 
+            String subPattern) throws IOException {
+    // ��������ļ�����
+    Set<File> matchingFiles = retrieveMatchingFiles(rootDir, subPattern);
+    Set<Resource> result = new LinkedHashSet<>(matchingFiles.size());
+    for (File file : matchingFiles) {
+        result.add(new FileSystemResource(file));
+    }
+    return result;
+}
+
+```
+
+�� `PathMatchingResourcePatternResolver#doFindMatchingFileSystemResources` �У�spring ��ɨ�赽�� File ת��Ϊ `FileSystemResource` ���棬�������������ĵڶ��� `Resource` ������ (ǰ��Ϊ `UrlResource`������Ϊ `FileSystemResource`).
+
+���������ص��ע `Set<File> matchingFiles = retrieveMatchingFiles(rootDir, subPattern);`������ spring ���������ļ����ҵģ�
+
+```
+|-PathMatchingResourcePatternResolver#findPathMatchingResources
+ |-PathMatchingResourcePatternResolver#doFindPathMatchingFileResources
+  |-PathMatchingResourcePatternResolver#doFindMatchingFileSystemResources
+   |-PathMatchingResourcePatternResolver#retrieveMatchingFiles
+    |-PathMatchingResourcePatternResolver#doRetrieveMatchingFiles
+
+```
+
+```
+protected void doRetrieveMatchingFiles(String fullPattern, File dir, Set<File> result) 
+        throws IOException {
+    for (File content : listDirectory(dir)) {
+        String currPath = StringUtils.replace(content.getAbsolutePath(), File.separator, "/");
+        if (content.isDirectory() && getPathMatcher().matchStart(fullPattern, currPath + "/")) {
+            if (!content.canRead()) {
+            }
+            else {
+                // ������ļ��У��ݹ����
+                doRetrieveMatchingFiles(fullPattern, content, result);
+            }
+        }
+        // ������ļ����ļ�·��
+        if (getPathMatcher().match(fullPattern, currPath)) {
+            result.add(content);
+        }
+    }
+}
+
+```
+
+���ϴ���Ƚϼ򵥣�������ƽ�������ļ��ķ�ʽ��һ���ġ�
+
+ֵ��һ����ǣ�`getPathMatcher().match(fullPattern, currPath)` ���յ��õ����� `AntPathMatcher#doMatch`������һ�� ant ����·��ƥ����֤����·���д��� `*`���紫��� pattern �� `/xxx/spring-framework/spring-learn/build/classes/java/main/org/springframework/learn/demo01/**/*.class`����ʾƥ�� `/xxx/spring-framework/spring-learn/build/classes/java/main/org/springframework/learn/demo01/` �������ļ�����������`.class` �ļ���β���ļ�����ǰ����� path �� `/xxx/spring-framework/spring-learn/build/classes/java/main/org/springframework/learn/demo01/BeanObj2.class`����Ȼƥ�䡣���� `AntPathMatcher#doMatch` ��������ν���ƥ��ģ�����Ͳ�����չ���ˡ�
+
+���������ϲ��裬�������ڵõ��� class �ļ���Ӧ�� Resource ��.
+
+#### 1.3 �� Resource ת��Ϊ BeanDefinition
+
+�� Resource ת��Ϊ BeanDefinition��������
+
+> ClassPathScanningCandidateComponentProvider#scanCandidateComponents
+
+```
+// �� resource �õ� MetadataReader
+MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
+
+// �������������£�
+// 1\. �Ƿ���Ҫ��ʼ��Ϊspring bean�����Ƿ��� @Component��@Service��ע��
+// 2\. �鿴�������Ƿ���@Conditionalһϵ�е�ע�⣬Ȼ���Ƿ�����ע��Bean������
+if (isCandidateComponent(metadataReader)) {
+    // �� metadataReader ת��Ϊ ScannedGenericBeanDefinition����Ҳ��BeanDefinition�����е�һԱ
+    ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
+    ...
+}
+
+```
+
+##### 1\. �� Resource �õ� MetadataReader
+
+����׷���� `MetadataReader` �Ļ�ȡ��
+
+```
+|-ClassPathScanningCandidateComponentProvider#scanCandidateComponents
+ |-CachingMetadataReaderFactory#getMetadataReader
+  |-SimpleMetadataReaderFactory#getMetadataReader(Resource)
+   |-SimpleMetadataReader#SimpleMetadataReader
+
+```
+
+�����������е��� `SimpleMetadataReader` �Ĺ��췽��:
+
+```
+SimpleMetadataReader(Resource resource, @Nullable ClassLoader classLoader) throws IOException {
+    SimpleAnnotationMetadataReadingVisitor visitor 
+        = new SimpleAnnotationMetadataReadingVisitor(classLoader);
+    // ���﷢����class�ļ��Ķ�ȡ�����
+    getClassReader(resource).accept(visitor, PARSING_OPTIONS);
+    this.resource = resource;
+    this.annotationMetadata = visitor.getMetadata();
+}
+
+```
+
+�ٽ�һ��׷�٣����� class �ļ��Ķ�ȡ����������� `ClassReader` �ࣺ
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-595687d3a766ffaacf69f31216a5b09f9d5.png)
+
+�����ʹ�� asm ����ȡ class �ļ�������Ƚϸ��ӣ��Ͳ���ˡ�
+
+һֱ�������Ҷ���Ϊ spring ��ͨ����������ȡ����Ϣ�ģ��������֪����**ԭ�� spring ��ͨ�� asm ֱ�Ӷ�ȡ class �ļ�����ȡ�����Ϣ��** ��
+
+������������µõ��� `MetadataReader` �Ľ����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-9df07587a3a8191231da87fe21d80052357.png)
+
+�����ص��ע `annotations` ���ԣ�������һ�� `annotations` �� `mappings`��`annotations` ����Ϊ `@Service`��`mappings` ��һ�����飬����Ϊ
+
+```
+0-@Service
+1-@Component
+2-@Index
+
+```
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-f5c7e8768b92b7a4303c4e1beb58863fe03.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-38b493e0b4b7b73dda5f06f371b66f16d3e.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-930a4e6844efd3f9f52c6d3f4e13a200337.png)
+
+`annotations` ���˲²��� `BeanObj1` �ϵ�ע�⣺
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-77271c438dde39f2bc905aa9f2cf9fb73d8.png)
+
+���� `mappings` ��ɶ���Ҳ��ò²⣬����Ҳ���Դ�ע���з���һЩ���ߣ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-f31efb6252beb2108dc0ce93d482666f8d0.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-a8ce5d11b4b02907f0ff497c6369a1c1dde.png)
+
+`@Service` ���� `@Component` ע�⣬`@Component` ���� `@Indexed`���������߶��������� `mappings` �У��⿴������ר������������ע��֮�ϵ�ע��ģ�����������ˣ����Ҿ͵������⹦�ܰɣ�**ע�⣺`mappings` ��������ݺ���Ҫ�������������**
+
+##### 2. `isCandidateComponent(MetadataReader)`���ж��Ƿ���Ҫʵ����Ϊ spring bean
+
+����һ���У����ǵõ��� basePackage ��**������**�� `MetadataReader` �����ļ���ע��������**������**������Щ���Dz��Ƕ�Ҫת�� `spring bean`���йܵ� spring �����أ������ `isCandidateComponent(MetadataReader)` �Ĺ����ˡ��ϻ���˵���ϴ��룺
+
+```
+protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
+    // ʡ�Բ��ִ���
+    for (TypeFilter tf : this.includeFilters) {
+        // �����ж��Ƿ���Ҫ�йܵ�spring����
+        if (tf.match(metadataReader, getMetadataReaderFactory())) {
+            // �ж��Ƿ���@Conditionalһϵ�е�ע��
+            return isConditionMatch(metadataReader);
+        }
+    }
+    return false;
+}
+
+```
+
+�����Ҫ�����������жϣ�
+
+*   �Ƿ���ҪΪ spring bean
+*   �Ƿ��� `@Conditional` ��һϵ�е�ע��
+
+����������������һ���жϡ�
+
+�� spring �У����� spring bean ��ע���кܶ࣬�� `@Component`��`@Repository`��`@Service`��`@Controller`��`@Configuration`�����������Լ�д��ע���ֻ࣬Ҫ���������Щע�⣬��
+
+```
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+// ���� @Component �� @Service �� @Repository ������֮һ
+@Component
+public @interface MySpringBean {
+    ...
+}
+
+```
+
+���ܱ� spring ʶ������� spring �ṩ��ע�⣨`@Component`��`@Repository` �ȣ������ж��Dz��� spring bean ʱ��ֻ��Ҫ������
+
+```
+if(annotation == Component.class || annotation == Repository.class) {
+    ...
+}
+
+```
+
+���жϾ����ˡ��������Զ����ע�� `@MySpringBean`��spring ����ô֪������ spring bean �أ������Ƕ��� `@MySpringBean` ʱ��һ��Ҫ���������� `@Component` �� `@Service` �� `@Repository` ������֮һ���ܱ� spring ʶ����������ʲô�����أ����Ǹ������� `AbstractTypeHierarchyTraversingFilter#match(MetadataReader, MetadataReaderFactory)`���������ǶԲ���Ҫ�Ĵ�������ֻ������������
+
+```
+|-ClassPathScanningCandidateComponentProvider#isCandidateComponent(MetadataReader)
+ |-AbstractTypeHierarchyTraversingFilter#match(MetadataReader, MetadataReaderFactory)
+  |-AnnotationTypeFilter#matchSelf
+
+```
+
+�������յ��� `AnnotationTypeFilter#matchSelf`:
+
+```
+@Override
+protected boolean matchSelf(MetadataReader metadataReader) {
+    AnnotationMetadata metadata = metadataReader.getAnnotationMetadata();
+    // �����annotationType���� @Component
+    return metadata.hasAnnotation(this.annotationType.getName()) ||
+        (this.considerMetaAnnotations && metadata.hasMetaAnnotation(this.annotationType.getName()));
+}
+
+```
+
+�ؼ��������ˣ�
+
+```
+metadata.hasAnnotation(this.annotationType.getName())
+��
+this.considerMetaAnnotations && metadata.hasMetaAnnotation(this.annotationType.getName())
+
+```
+
+�����ȿ� `metadata.hasAnnotation(this.annotationType.getName())` �ıȽϣ�
+
+```
+// AnnotationMetadata#hasAnnotation
+default boolean hasAnnotation(String annotationName) {
+    return getAnnotations().isDirectlyPresent(annotationName);
+}
+
+```
+
+����� `getAnnotations()` �õ��Ľ����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-3e46b2ece5ddb2328342a469dc7dd554d9e.png)
+
+mappings ���������
+
+```
+0-@Service
+1-@Component
+2-@Index
+
+```
+
+����ʵ��������ǰ��õ��� `MetadataReader` ������ݣ�
+
+��׷����ȥ������ `isDirectlyPresent` �����ж� `annotations` �� `mappings` ����û�г��� `@Component`:
+
+```
+private boolean isPresent(Object requiredType, boolean directOnly) {
+    // �ж� annotations ����û�г��� @Component
+    for (MergedAnnotation<?> annotation : this.annotations) {
+        Class<? extends Annotation> type = annotation.getType();
+        if (type == requiredType || type.getName().equals(requiredType)) {
+            return true;
+        }
+    }
+    if (!directOnly) {
+        // �ж� mappings ����û�г��� @Component
+        for (AnnotationTypeMappings mappings : this.mappings) {
+            for (int i = 1; i < mappings.size(); i++) {
+                AnnotationTypeMapping mapping = mappings.get(i);
+                if (isMappingForType(mapping, requiredType)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+```
+
+�������������� `this.considerMetaAnnotations && metadata.hasMetaAnnotation(this.annotationType.getName())`���鿴���ã�
+
+```
+|-AnnotationTypeFilter#matchSelf
+ |-AnnotationMetadata#hasMetaAnnotation
+  |-MergedAnnotationsCollection#get(String, Predicate)
+   |-MergedAnnotationsCollection#get(String, Predicate, MergedAnnotationSelector)
+    |-MergedAnnotationsCollection#find
+
+```
+
+���յIJ��ҷ����� `MergedAnnotationsCollection#find`:
+
+```
+private <A extends Annotation> MergedAnnotation<A> find(Object requiredType,
+        @Nullable Predicate<? super MergedAnnotation<A>> predicate,
+        @Nullable MergedAnnotationSelector<A> selector) {
+
+    MergedAnnotation<A> result = null;
+    for (int i = 0; i < this.annotations.length; i++) {
+        MergedAnnotation<?> root = this.annotations[i];
+        AnnotationTypeMappings mappings = this.mappings[i];
+        // mappings ���� mappings
+        for (int mappingIndex = 0; mappingIndex < mappings.size(); mappingIndex++) {
+            AnnotationTypeMapping mapping = mappings.get(mappingIndex);
+            if (!isMappingForType(mapping, requiredType)) {
+                continue;
+            }
+            // ����������ҵ��� @Component ע��
+            MergedAnnotation<A> candidate = (mappingIndex == 0
+                ? (MergedAnnotation<A>) root
+                : TypeMappedAnnotation.createIfPossible(mapping, root, IntrospectionFailureLogger.INFO));
+            if (candidate != null && (predicate == null || predicate.test(candidate))) {
+                if (selector.isBestCandidate(candidate)) {
+                    return candidate;
+                }
+                result = (result != null ? selector.select(result, candidate) : candidate);
+            }
+        }
+    }
+    return result;
+}
+
+```
+
+���Կ��������ҷ�ʽ������� `metadata.hasAnnotation(this.annotationType.getName())` �߶����ơ�
+
+���Ͼ��� spring �����ж��Ƿ���� `@Service`��`@Component` ��ע����߼��ˡ�
+
+�� `java` �У�ע���Dz��ܼ̳еģ���
+
+```
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface Base {
+
+}
+
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface Child extends  Base {
+
+}
+
+```
+
+�����﷨�� java �в��������ģ�spring ���Dz��������`ע���ע��`�ķ�ʽ��ʵ���������ڼ̳еĹ��ܡ�
+
+�������������� `ClassPathScanningCandidateComponentProvider#isConditionMatch` ������ʵ���ϣ���������������ж����Ƿ��� `@Conditional` ע��ģ������������ʶ��Ϊ spring bean���������յ��õ��� `ConditionEvaluator#shouldSkip(AnnotatedTypeMetadata, ConfigurationCondition.ConfigurationPhase)`:
+
+```
+public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
+    // ʡ����һЩ����
+
+    // �õ� condition ����
+    List<Condition> conditions = new ArrayList<>();
+        for (String[] conditionClasses : getConditionClasses(metadata)) {
+            for (String conditionClass : conditionClasses) {
+                Condition condition = getCondition(conditionClass, this.context.getClassLoader());
+                conditions.add(condition);
+            }
+        }
+    }
+
+    AnnotationAwareOrderComparator.sort(conditions);
+    // �������ж� condition �����Ƿ����
+    for (Condition condition : conditions) {
+        ConfigurationPhase requiredPhase = null;
+        if (condition instanceof ConfigurationCondition) {
+            requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
+        }
+        if ((requiredPhase == null || requiredPhase == phase) 
+                // �ж� condition �����Ƿ������һ����������ͷ���true
+                && !condition.matches(this.context, metadata)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+// ͨ�������ȡ Condition ����
+private Condition getCondition(String conditionClassName, @Nullable ClassLoader classloader) {
+    Class<?> conditionClass = ClassUtils.resolveClassName(conditionClassName, classloader);
+    return (Condition) BeanUtils.instantiateClass(conditionClass);
+}
+
+```
+
+�������������£�
+
+1.  ��ȡ condition ����
+2.  ���� condition ���󣬵��� `condition.matches()` �������ж������Ƿ����
+
+##### 3\. �� `MetadataReader` �õ� `ScannedGenericBeanDefinition`
+
+�����������һ���򵥵ĸ�ֵ������ `ScannedGenericBeanDefinition` �Ĺ��췽���������ˣ�
+
+> ScannedGenericBeanDefinition#ScannedGenericBeanDefinition
+
+```
+public ScannedGenericBeanDefinition(MetadataReader metadataReader) {
+    Assert.notNull(metadataReader, "MetadataReader must not be null");
+    this.metadata = metadataReader.getAnnotationMetadata();
+    setBeanClassName(this.metadata.getClassName());
+}
+
+```
+
+����Ƚϼ򵥣��Ͳ����������ˡ�
+
+### 2\. �ḻ beanDefinition ��Ϣ
+
+����ǧ�����գ����ڵõ��� `beanDefinition`������ʱ `beanDefinition` �����ḻ�����������ǽ�һ����չ `beanDefinition` ����Ϣ�ˡ���Щ��Ϣ���� `bean������`��`bean��������`��`@Lazy` ע�⡢`@Primary` ע�⡢`@DependsOn` ע��ȣ��������£�
+
+```
+public abstract class AnnotationConfigUtils {
+
+    ...
+
+    /**
+     * ��һ���ḻ BeanDefinition
+     */
+    static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, 
+            AnnotatedTypeMetadata metadata) {
+        // ���� @Lazy
+        AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
+        if (lazy != null) {
+            abd.setLazyInit(lazy.getBoolean("value"));
+        }
+        else if (abd.getMetadata() != metadata) {
+            lazy = attributesFor(abd.getMetadata(), Lazy.class);
+            if (lazy != null) {
+                abd.setLazyInit(lazy.getBoolean("value"));
+            }
+        }
+        // ���� @Primary
+        if (metadata.isAnnotated(Primary.class.getName())) {
+            abd.setPrimary(true);
+        }
+        // ���� @DependsOn
+        AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
+        if (dependsOn != null) {
+            abd.setDependsOn(dependsOn.getStringArray("value"));
+        }
+        // ���� @Role
+        AnnotationAttributes role = attributesFor(metadata, Role.class);
+        if (role != null) {
+            abd.setRole(role.getNumber("value").intValue());
+        }
+        // ���� @Description
+        AnnotationAttributes description = attributesFor(metadata, Description.class);
+        if (description != null) {
+            abd.setDescription(description.getString("value"));
+        }
+    }
+}
+
+```
+
+### 3.` registerBeanDefinition(definitionHolder, this.registry)`: ���� BeanDefinition �� beanFactory
+
+�� `BeanDefinition` �� `beanFactory` �IJ����Ƚϼ򵥣��ؼ��Ĵ������£�
+
+```
+|-ClassPathBeanDefinitionScanner#registerBeanDefinition
+ |-BeanDefinitionReaderUtils#registerBeanDefinition
+  |-GenericApplicationContext#registerBeanDefinition
+   |-DefaultListableBeanFactory#registerBeanDefinition
+
+```
+
+> DefaultListableBeanFactory#registerBeanDefinition
+
+```
+this.beanDefinitionMap.put(beanName, beanDefinition);
+
+```
+
+�� `ClassPathBeanDefinitionScanner#registerBeanDefinition` �� `DefaultListableBeanFactory#registerBeanDefinition`����������Ȼ������һЩ�������ƣ������ɲ����������ҵ��ؼ��Ĵ��롣
+
+���ˣ������ϵ� class �ļ������� spring ɨ�裬���ڱ���� `BeanDefinition`�������� `BeanFactory` ���ˡ�
+
+### 4\. �ܽ�
+
+���ıȽϳ�����Ҫ������ spring ɨ���·���õ� `beanDefinition` �Ĺ��̣���Ҫ�������£�
+
+1.  ���ݰ����õ�·�� `Resource`��
+2.  ����·�� `Resouce` �õ���·�������� class �ļ��� `Resouce`��
+3.  ���� class �ļ��� `Resouce` ͨ�� asm �����õ� `MetadataReader`��ע�⣺����� `MetadataReader` �������� class �ļ��� `MetadataReader`��
+4.  �� `MetadataReader` ���ҵ���Ҫ spring �йܵ� `MetadataReader`������ת��Ϊ `ScannedGenericBeanDefinition`��`ScannedGenericBeanDefinition` Ϊ `BeanDefinition` �����ࣻ
+5.  ��һ���ḻ `ScannedGenericBeanDefinition` ����Ϣ��
+6.  ������õ��� `BeanDefinition` ���ӵ� `BeanFactory` ��
+
+���ˣ�����ת��Ϊ `BeanDefinition` ��ɡ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-f8ff2e4071ba3941e2a0664f6e478b78961.png)
+
+���Ļ�������ֵ��ע��ĵط���
+
+1.  spring �ڻ�ȡ���ϵ�ע��ʱ������ͨ�����䣬����ʹ�� asm ֱ�ӽ��� class �ļ���Ȼ���ٻ�ȡ���ϵ�ע���
+2.  �ڴ���ע��ʱ��spring ͨ������ ��ע���ע�⡱ ʵ����һ��������ע��̳еķ�ʽ����Ҳ�� spring ��ʶ�� `@Component`��`@Service` �����ǿ������Զ���ע���ԭ��
+
+�õ��� `BeanDefinition` �󣬽��ž��� spring �����ij�ʼ���ˣ�������ƪ�����ټ���
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4614071](https://my.oschina.net/funcy/blog/4614071) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\271\235\357\274\211\357\274\232\345\215\225\344\276\213bean\347\232\204\345\210\233\345\273\272.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\271\235\357\274\211\357\274\232\345\215\225\344\276\213bean\347\232\204\345\210\233\345\273\272.md"
new file mode 100644
index 0000000..9690e98
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\271\235\357\274\211\357\274\232\345\215\225\344\276\213bean\347\232\204\345\210\233\345\273\272.md"
@@ -0,0 +1,1105 @@
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-1f1ac8f3d8241fad9693d9684048ab7f3ae.png)
+
+�����ģ����������Ƿ��� `finishBeanFactoryInitialization(beanFactory)`�����Ľ��ص�������� bean �Ĵ������̡�
+
+����һƪ�����У����ǽ����� `AbstractApplicationContext#finishBeanFactoryInitialization` ��ִ�й��̣����Ľ�����ϸ�ڣ����� spring bean �Ĵ������̡�
+
+```
+|-AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#finishBeanFactoryInitialization
+   |-DefaultListableBeanFactory#preInstantiateSingletons
+    |-AbstractBeanFactory#getBean(java.lang.String)
+     |-AbstractBeanFactory#doGetBean
+      |-AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])
+
+```
+
+����ֱ�ӿ� `AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])`�������Ĵ������£�
+
+```
+@Override
+protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+    	throws BeanCreationException {
+
+    RootBeanDefinition mbdToUse = mbd;
+
+    // ȷ�� BeanDefinition �е� Class ������
+    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
+    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
+        mbdToUse = new RootBeanDefinition(mbd);
+        mbdToUse.setBeanClass(resolvedClass);
+    }
+
+    // ׼��������д�����bean�ж����� <lookup-method /> �� <replaced-method />
+    try {
+        mbdToUse.prepareMethodOverrides();
+    }
+    catch (BeanDefinitionValidationException ex) {
+        ...
+    }
+
+    try {
+        // ����д����Ļ�ֱ�ӷ���
+        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
+        if (bean != null) {
+            return bean;
+        }
+    }
+    catch (Throwable ex) {
+        ...
+    }
+
+    try {
+        // ���� bean
+        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
+        return beanInstance;
+    }
+    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
+        ...
+    }
+    catch (Throwable ex) {
+        ...
+    }
+}
+
+```
+
+���Կ������÷��������ļ��£�
+
+1.  ȷ�� class ������
+2.  �����
+3.  ���Ҵ������������򷵻�
+4.  ���� spring bean
+
+����ǰ���������������IJ���ע�����ǽ������ĸ����������� `AbstractAutowireCapableBeanFactory#doCreateBean`:
+
+```
+protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, 
+          final @Nullable Object[] args)  throws BeanCreationException {
+
+    BeanWrapper instanceWrapper = null;
+    if (mbd.isSingleton()) {
+        //����� factoryBean��ӻ���ɾ��
+        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
+    }
+    if (instanceWrapper == null) {
+         // ʵ���� Bean�����������������յ�
+         instanceWrapper = createBeanInstance(beanName, mbd, args);
+    }
+    //beanʵ��
+    final Object bean = instanceWrapper.getWrappedInstance();
+    //bean����
+    Class<?> beanType = instanceWrapper.getWrappedClass();
+    if (beanType != NullBean.class) {
+        mbd.resolvedTargetType = beanType;
+    }
+
+    synchronized (mbd.postProcessingLock) {
+        if (!mbd.postProcessed) {
+            try {
+                // ѭ������MergedBeanDefinitionPostProcessor��postProcessMergedBeanDefinition���������磬
+                // 1\. ���� AutowiredAnnotationBeanPostProcessor.postProcessMergedBeanDefinition Ϊ���ҵ�
+                //  ����@Autowired��@Value ע������Ժͷ���
+                // 2\. ���� CommonAnnotationBeanPostProcessor.postProcessMergedBeanDefinition Ϊ���ҵ�
+                // 	����@Resource ע������Ժͷ���
+                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
+            }
+            catch (Throwable ex) {
+                ...
+            }
+            mbd.postProcessed = true;
+        }
+    }
+
+    // ���ѭ����������, �Ƿ�����ѭ������, allowCircularReferencesĬ��Ϊtrue�����Թر�
+    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
+            isSingletonCurrentlyInCreation(beanName));
+    if (earlySingletonExposure) {
+        // ѭ�������Ľ��������ᵥ������
+        ...
+    }
+
+    Object exposedObject = bean;
+    try {
+        // ��������װ��, Ҳ�������dz���˵���Զ�ע�룬����Ҫ
+        populateBean(beanName, mbd, instanceWrapper);
+        // �����Ǵ���bean��ʼ����ɺ�ĸ��ֻص���
+        // ����init-method��InitializingBean �ӿڡ�BeanPostProcessor �ӿ�
+        exposedObject = initializeBean(beanName, exposedObject, mbd);
+    }
+    catch (Throwable ex) {
+        ...
+    }
+
+    //ͬ���ģ��������ѭ������
+    if (earlySingletonExposure) {
+        // ѭ�������Ľ��������ᵥ������
+        ...
+    }
+
+    // ��beanע�ᵽ��Ӧ��Scope��
+    try {
+        registerDisposableBeanIfNecessary(beanName, bean, mbd);
+    }
+    catch (BeanDefinitionValidationException ex) {
+        ...
+    }
+
+    return exposedObject;
+}
+
+```
+
+���Կ�����spring �ڴ��� bean ʱ����Ҫ�������������£�
+
+1.  ����ʵ��
+2.  ��������
+3.  ע������
+4.  ��ʼ�� bean
+
+�����������Ǿ���Ҫ�������ĸ����衣
+
+#### 1\. ����ʵ��
+
+spring ����ʵ���ķ����� `AbstractAutowireCapableBeanFactory#createBeanInstance`���������£�
+
+```
+protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, 
+        @Nullable Object[] args) {
+    // ȷ���Ѿ������˴� class
+    Class<?> beanClass = resolveBeanClass(mbd, beanName);
+
+    // У����ķ���Ȩ��
+    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) 
+                && !mbd.isNonPublicAccessAllowed()) {
+        throw new BeanCreationException(...);
+    }
+
+    // �Ƿ�������bean������Supplier��Supplier��java8�ṩ���࣬���Դ���һ��lambda����ʽ
+    // ���� AbstractBeanDefinition#setInstanceSupplier ָ��
+    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
+    if (instanceSupplier != null) {
+        return obtainFromSupplier(instanceSupplier, beanName);
+    }
+
+    if (mbd.getFactoryMethodName() != null) {
+        // ���ù�������ʵ����
+        return instantiateUsingFactoryMethod(beanName, mbd, args);
+    }
+
+    // �Ƿ��һ��
+    boolean resolved = false;
+    // �Ƿ���ù��캯��ע��
+    boolean autowireNecessary = false;
+    if (args == null) {
+        synchronized (mbd.constructorArgumentLock) {
+            if (mbd.resolvedConstructorOrFactoryMethod != null) {
+                resolved = true;
+                autowireNecessary = mbd.constructorArgumentsResolved;
+            }
+        }
+    }
+    if (resolved) {
+        if (autowireNecessary) {
+            return autowireConstructor(beanName, mbd, null, null);
+        }
+        else {
+            // �޲ι��캯��
+            return instantiateBean(beanName, mbd);
+        }
+    }
+
+    // Candidate constructors for autowiring?
+    // �ж��Ƿ�����вι��캯��
+    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
+    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
+            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
+        return autowireConstructor(beanName, mbd, ctors, args);
+    }
+
+    ctors = mbd.getPreferredConstructors();
+    if (ctors != null) {
+        // ���캯������ע��
+        return autowireConstructor(beanName, mbd, ctors, null);
+    }
+
+    // �����޲ι��캯��
+    return instantiateBean(beanName, mbd);
+}
+
+```
+
+�����ϴ���������spring ��ʵ���� bean ʱ���� 4 �ַ�ʽ��
+
+1.  ʹ��ʵ����������obtainFromSupplier
+2.  ʹ�ù���������instantiateUsingFactoryMethod
+3.  ʹ���вι��죺autowireConstructor
+4.  ʹ���޲ι��죺instantiateBean
+
+����ǰ���������������ǿ�����ָ���ķ�����ûɶ��˵�ģ��������������� spring �������ʵ�������ѡ���췽������ʵ�����ġ�����һ�� bean ��˵�����δ�ṩ�κι��췽�����ṩ���޲ι��췽��������� `AbstractAutowireCapableBeanFactory#instantiateBean` ������ʵ������������� `AbstractAutowireCapableBeanFactory#autowireConstructor` ����ʵ������ʵ���ϣ��������������ն���ִ�е� `BeanUtils#instantiateClass(Constructor<T>, Object...)`:
+
+```
+public static <T> T instantiateClass(Constructor<T> ctor, Object... args) 
+            throws BeanInstantiationException {
+    Assert.notNull(ctor, "Constructor must not be null");
+    try {
+        ReflectionUtils.makeAccessible(ctor);
+        if (KotlinDetector.isKotlinReflectPresent() 
+                   && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
+            return KotlinDelegate.instantiateClass(ctor, args);
+        }
+        else {
+            Class<?>[] parameterTypes = ctor.getParameterTypes();
+            Assert.isTrue(args.length <= parameterTypes.length, "...");
+            Object[] argsWithDefaultValues = new Object[args.length];
+            for (int i = 0 ; i < args.length; i++) {
+                if (args[i] == null) {
+                    Class<?> parameterType = parameterTypes[i];
+                    argsWithDefaultValues[i] = (parameterType.isPrimitive() 
+                                        ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
+                }
+                else {
+                    argsWithDefaultValues[i] = args[i];
+                }
+            }
+            // �������ʵ����
+            return ctor.newInstance(argsWithDefaultValues);
+        }
+    }
+    catch (...) {
+        ...
+    }
+}
+
+```
+
+���Կ��������յ��õ��� `java.lang.reflect.Constructor#newInstance`������� jdk �ķ����ˡ�
+
+���⣬�� bean �ṩ�˶� �����췽��ʱ��spring �����һ�׸��ӵ��ƶϻ��ƣ��ƶϳ���ѵĹ��췽��������Ͳ�չ���ˡ�
+
+#### 2\. ��������
+
+���󴴽��󣬽��������ǽ�������ע���ˣ�������ע������ǰ����Ҫ֪����������Щ������Ҫע�롣spring ���Բ������� `AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors` �е��ú��ô��������в����ģ�
+
+```
+protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, 
+        Class<?> beanType, String beanName) {
+    for (BeanPostProcessor bp : getBeanPostProcessors()) {
+        if (bp instanceof MergedBeanDefinitionPostProcessor) {
+            // ���ú��ô�����
+            MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
+            bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
+        }
+    }
+}
+
+```
+
+����Щ���ô������У�
+
+1.  ���� `AutowiredAnnotationBeanPostProcessor.postProcessMergedBeanDefinition` ���Ҵ��� `@Autowired`��`@Value` ע������Ժͷ���
+2.  ���� `CommonAnnotationBeanPostProcessor.postProcessMergedBeanDefinition` ���Ҵ��� `@Resource` ע������Ժͷ���
+
+����Ϊ�˷���˵�� `@Autowired` ��ע�����̣������� demo01 �� `org.springframework.learn.demo01.BeanObj1` ���������д��룺
+
+```
+package org.springframework.learn.demo01;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class BeanObj1 {
+
+    // ��������Ϊ�¼���Ĵ���
+    @Autowired
+    private BeanObj2 beanObj2;
+
+    public BeanObj1() {
+        System.out.println("����beanObj1�Ĺ��췽��");
+    }
+
+    @Override
+    public String toString() {
+        return "BeanObj1{}";
+    }
+}
+
+```
+
+���� `AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition` ������
+
+```
+@Override
+public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, 
+        Class<?> beanType, String beanName) {
+    // ���������뷽��
+    InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
+    // ��֤���ҵ��������뷽������ע�ᵽbeanDefinition
+    metadata.checkConfigMembers(beanDefinition);
+}
+
+```
+
+һ·���� `AutowiredAnnotationBeanPostProcessor#findAutowiringMetadata` ������������ `AutowiredAnnotationBeanPostProcessor#buildAutowiringMetadata`:
+
+```
+private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
+     ...
+    // ��������һ��ѭ�������굱ǰ���ҵ�ǰ��ĸ��ֱ࣬��Object��
+    do {
+        final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
+
+        // ��������
+        ReflectionUtils.doWithLocalFields(targetClass, field -> {
+            MergedAnnotation<?> ann = findAutowiredAnnotation(field);
+            if (ann != null) {
+                if (Modifier.isStatic(field.getModifiers())) {
+                    return;
+                }
+                boolean required = determineRequiredStatus(ann);
+                // ���Է�װ�� AutowiredFieldElement
+                currElements.add(new AutowiredFieldElement(field, required));
+            }
+        });
+
+        // ���ҷ���
+        ReflectionUtils.doWithLocalMethods(targetClass, method -> {
+            Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
+            if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
+                return;
+            }
+            MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
+            if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
+                if (Modifier.isStatic(method.getModifiers())) {
+                    return;
+                }
+                if (method.getParameterCount() == 0) {
+                }
+                boolean required = determineRequiredStatus(ann);
+                PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
+                // ������װ�� AutowiredMethodElement
+                currElements.add(new AutowiredMethodElement(method, required, pd));
+            }
+        });
+
+        elements.addAll(0, currElements);
+        targetClass = targetClass.getSuperclass();
+    }
+    while (targetClass != null && targetClass != Object.class);
+
+    return InjectionMetadata.forElements(elements, clazz);
+}
+
+```
+
+���ϴ�����Dz��ҹ��̣��ܽ����£�
+
+*   ѭ����ѯ���࣬�ӵ�ǰ�࿪ʼ�����굱ǰ����ҵ�ǰ��ĸ��ֱ࣬�� Object Ϊֹ��
+*   ���������뷽���������ҵ����װΪ `AutowiredFieldElement`�������ҵ����װΪ `AutowiredMethodElement`��
+*   �����Dz������Ի��Ƿ�����ʹ�õĶ��� `findAutowiredAnnotation` ����
+
+�����������ǾͿ��� `findAutowiredAnnotation` ��������ν��в��ҵġ����� `AutowiredAnnotationBeanPostProcessor#findAutowiredAnnotation` �������������£�
+
+```
+private final Set<Class<? extends Annotation>> autowiredAnnotationTypes 
+        = new LinkedHashSet<>(4);
+
+// Ĭ�Ϲ��췽����ָ����@Autowired��@Valueע��
+@SuppressWarnings("unchecked")
+public AutowiredAnnotationBeanPostProcessor() {
+    this.autowiredAnnotationTypes.add(Autowired.class);
+    this.autowiredAnnotationTypes.add(Value.class);
+    ...
+}
+
+// ������Dz��ҷ���
+@Nullable
+private MergedAnnotation<?> findAutowiredAnnotation(AccessibleObject ao) {
+    MergedAnnotations annotations = MergedAnnotations.from(ao);
+    // autowiredAnnotationTypes ������ @Autowired��@Valueע��
+    for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
+        MergedAnnotation<?> annotation = annotations.get(type);
+        if (annotation.isPresent()) {
+            return annotation;
+        }
+    }
+    return null;
+}
+
+```
+
+���ϴ���ע��ú������ˣ�����Ͳ���˵�ˡ�
+
+�ҵ������뷽���󣬽��ž���ע�ᵽ `beanDefinition` �ˣ����� `InjectionMetadata#checkConfigMembers` �����Ĺ�����
+
+```
+public void checkConfigMembers(RootBeanDefinition beanDefinition) {
+    Set<InjectedElement> checkedElements = new LinkedHashSet<>(this.injectedElements.size());
+    for (InjectedElement element : this.injectedElements) {
+        Member member = element.getMember();
+        if (!beanDefinition.isExternallyManagedConfigMember(member)) {
+            // ע�ᵽ beanDefinition
+            beanDefinition.registerExternallyManagedConfigMember(member);
+            checkedElements.add(element);
+        }
+    }
+    this.checkedElements = checkedElements;
+}
+
+```
+
+��ν��ע�ᣬ��ʵҲ�൱�򵥣������� `beanDefinition` ���е� `externallyManagedConfigMembers` ����������һ����¼��
+
+> RootBeanDefinition#registerExternallyManagedConfigMember
+
+```
+public void registerExternallyManagedConfigMember(Member configMember) {
+    synchronized (this.postProcessingLock) {
+        if (this.externallyManagedConfigMembers == null) {
+            this.externallyManagedConfigMembers = new HashSet<>(1);
+        }
+        // ��set����������һ����¼
+        this.externallyManagedConfigMembers.add(configMember);
+    }
+}
+
+```
+
+#### 3\. ע������
+
+spring ������ע�����ڷ��� `AbstractAutowireCapableBeanFactory#populateBean` �д����ģ��������£�
+
+```
+protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
+    if (bw == null) {
+        if (mbd.hasPropertyValues()) {
+            throw new BeanCreationException(...);
+        }
+        else {
+            return;
+        }
+    }
+
+    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
+        for (BeanPostProcessor bp : getBeanPostProcessors()) {
+            if (bp instanceof InstantiationAwareBeanPostProcessor) {
+                // ���þ���ĺ��ô���������������
+                // AutowiredAnnotationBeanPostProcessor.postProcessProperties ���� @Autowired��@Value ע��
+                // CommonAnnotationBeanPostProcessor.postProcessProperties ���� @Resourceע��
+                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
+                // ������� false����������Ҫ���к�����������ֵ��Ҳ����Ҫ�پ��������� BeanPostProcessor �Ĵ���
+                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
+                    return;
+                }
+            }
+        }
+    }
+
+    // bean����������
+    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
+
+    int resolvedAutowireMode = mbd.getResolvedAutowireMode();
+    // ����ע������ΪbyType����byName��ע��@Autowired �Ȳ���byTypeҲ����byName,������ﷵ��false
+    if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
+        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
+        // ͨ�������ҵ���������ֵ������� bean �������ȳ�ʼ�������� bean����¼������ϵ
+        if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
+            autowireByName(beanName, mbd, bw, newPvs);
+        }
+        // ͨ������װ�䡣����һЩ
+        if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
+            autowireByType(beanName, mbd, bw, newPvs);
+        }
+        pvs = newPvs;
+    }
+
+    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
+    boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
+
+    PropertyDescriptor[] filteredPds = null;
+    if (hasInstAwareBpps) {
+        if (pvs == null) {
+            pvs = mbd.getPropertyValues();
+        }
+        for (BeanPostProcessor bp : getBeanPostProcessors()) {
+            if (bp instanceof InstantiationAwareBeanPostProcessor) {
+            // ���ú��ô��������ע�͵��������
+            // ����@Autowiredע����� AutowiredAnnotationBeanPostProcessor
+            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
+            PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
+            if (pvsToUse == null) {
+                if (filteredPds == null) {
+                    filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
+                }
+                // ��������Ϸ������ᵽ���ö�@Autowired������һ��BeanPostProcessor��
+                // ��������б��@Autowired��@Value ע������Խ�����ֵ
+                pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, 
+                        bw.getWrappedInstance(), beanName);
+                if (pvsToUse == null) {
+                    return;
+                }
+            }
+            pvs = pvsToUse;
+            }
+        }
+    }
+    if (needsDepCheck) {
+        if (filteredPds == null) {
+             filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
+        }
+        checkDependencies(beanName, mbd, filteredPds, pvs);
+    }
+
+    if (pvs != null) {
+        // ���� bean ʵ��������ֵ
+        applyPropertyValues(beanName, mbd, bw, pvs);
+    }
+}
+
+```
+
+spring ������������ں��ô������н��еģ�`@Autowired` ��������䷽��Ϊ `AutowiredAnnotationBeanPostProcessor#postProcessProperties`:
+
+```
+public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
+     // ���� findAutowiringMetadata ������ȷ����ע @Autowired @Value ע��������뷽����ȡ�ɹ�
+     // findAutowiringMetadata ���Է��֣���������һ�����棬ֻ�е�һ�βŻ�����ȥ��ȡ��֮�󶼴ӻ����л�ȡ
+     InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
+     try {
+         // �����������ע��
+         metadata.inject(bean, beanName, pvs);
+     }
+     catch (...) {
+         ...
+     }
+}
+
+```
+
+�����ٽ��� `InjectionMetadata#inject`��
+
+```
+public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) 
+        throws Throwable {
+    Collection<InjectedElement> checkedElements = this.checkedElements;
+    Collection<InjectedElement> elementsToIterate =
+            (checkedElements != null ? checkedElements : this.injectedElements);
+    if (!elementsToIterate.isEmpty()) {
+        // ����� InjectedElement�������� AutowiredAnnotationBeanPostProcessor#findAutowiringMetadata
+        // �в��ҵ��ģ�field ���װΪ AutowiredFieldElement��method ����װΪ AutowiredMethodElement
+        for (InjectedElement element : elementsToIterate) {
+            element.inject(target, beanName, pvs);
+        }
+    }
+}
+
+```
+
+�����ٸ��� `element.inject(target, beanName, pvs)`��������õ����� `AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject`��
+
+```
+@Override
+protected void inject(Object bean, @Nullable String beanName, 
+                @Nullable PropertyValues pvs) throws Throwable {
+        Field field = (Field) this.member;
+        Object value;
+        if (this.cached) {
+            value = resolvedCachedArgument(beanName, this.cachedFieldValue);
+        }
+        else {
+            DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
+            desc.setContainingClass(bean.getClass());
+            Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
+            Assert.state(beanFactory != null, "No BeanFactory available");
+            TypeConverter typeConverter = beanFactory.getTypeConverter();
+            try {
+                // ��һ�о��ǻ�ȡע���bean
+                value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
+            }
+            catch (BeansException ex) {
+                ...
+            }
+            ...
+        }
+        // ͨ���������������ֵ
+        if (value != null) {
+            ReflectionUtils.makeAccessible(field);
+            field.set(bean, value);
+        }
+    }
+}
+
+```
+
+���ϴ����е�࣬������ֻҪ��Ҫ��ע���д�������ˣ�
+
+1.  ��ȡ��Ҫע��� bean: `value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter)`
+2.  ʹ�÷������� bean��`ReflectionUtils.makeAccessible(field);field.set(bean, value);`
+
+���ڵ� 2 �㣬���յ��õ��� jdk �ṩ�ķ��䷽����ûʲô��˵�ġ����������ص������� spring ����λ�ȡ��Ҫע��� bean��
+
+���� `beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter)`������Բ���Ҫ�Ĵ�����������������������£�
+
+```
+|-AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#finishBeanFactoryInitialization
+   |-DefaultListableBeanFactory#preInstantiateSingletons
+    |-AbstractBeanFactory#getBean(String)
+     |-AbstractBeanFactory#doGetBean
+      |-DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)
+       |-AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])
+        |-AbstractAutowireCapableBeanFactory#doCreateBean
+         |-AbstractAutowireCapableBeanFactory#populateBean
+          |-AutowiredAnnotationBeanPostProcessor#postProcessProperties
+           |-InjectionMetadata#inject
+            |-AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
+             |-DefaultListableBeanFactory#resolveDependency
+              |-DefaultListableBeanFactory#doResolveDependency
+
+```
+
+�������е� `DefaultListableBeanFactory#doResolveDependency`:
+
+```
+@Nullable
+public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
+         @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) 
+         throws BeansException {
+
+    InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
+    try {
+        ...
+        // 1\.  �������Ͳ������е�beanClass��map�б��������Ϊ��beanName -> Class
+        Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
+           ...
+        String autowiredBeanName;
+        Object instanceCandidate;
+        // 2\. ����ҵ���bean�ж��������������1
+        if (matchingBeans.size() > 1) {
+            // ���ȡע���������
+            autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
+            if (autowiredBeanName == null) {
+                if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
+                    return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
+                }
+                else {
+                    return null;
+                }
+            }
+            // 3\. ����ע����������� ���������ҳ�����map<beanName, Class>�����ң�
+            // �õ�bean��Class����
+            instanceCandidate = matchingBeans.get(autowiredBeanName);
+        }
+        else {
+            Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
+            autowiredBeanName = entry.getKey();
+            instanceCandidate = entry.getValue();
+        }
+        if (autowiredBeanNames != null) {
+            autowiredBeanNames.add(autowiredBeanName);
+        }
+        if (instanceCandidate instanceof Class) {
+            // ����class ��ȡ bean�����bean�����ڣ���ᴴ��bean
+            instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
+        }
+        Object result = instanceCandidate;
+        if (result instanceof NullBean) {
+            if (isRequired(descriptor)) {
+                raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
+            }
+            result = null;
+        }
+        if (!ClassUtils.isAssignableValue(type, result)) {
+            throw new BeanNotOfRequiredTypeException(...);
+        }
+        return result;
+    }
+    finally {
+        ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
+    }
+}
+
+```
+
+���� bean �Ļ�ȡ���������ܽ��£�
+
+1.  ���� bean ���ʹ� spring �л�ȡ bean �� Class ����ע�⣺����õ��Ķ���Ϊ Class���һ�ȡ���� Class ����� spring �л�ȡ beanClass �����ж����
+2.  ����õ��� Class �����ж�������ȡע������������������������Ҵӵ� 1 ���õ��� Class �����в��ҷ��������� 1 �� Class ����
+3.  ���� Class ����� spring �л�ȡ bean.
+
+���磬���ڽӿ� `Inter`��ʵ���� `A` �� `B`�����߹�ϵ���£�
+
+```
+interface Inter {
+
+}
+
+@Service
+class A implements Inter {
+
+}
+
+@Service
+class B implements Inter {
+
+}
+
+```
+
+���� `C` �У�ע�� `Inter` ���ͣ�
+
+```
+@Service
+class C {
+    @Autowired
+    private Inter b;
+}
+
+```
+
+��ע��ʱ��
+
+1.  spring ��ͨ�� `Inter.class` ���ң��õ������ࣺ`A.class` �� `B.class`�������˶�� bean Class ����
+2.  �õ�ע����������������� `b`��Ȼ��ʹ�� `b` �����ϵõ��� bean Class �����ҵ����ϵ� bean Class ������Ȼ��`B.class` ���ϣ�
+3.  �� spring �����л�ȡ `B.class` ��Ӧ�� bean.
+
+������и�С���⣺����� `C` ������ע��:
+
+```
+@Service
+class C {
+    @Autowired
+    private Inter inter;
+}
+
+```
+
+�� `Inter` ��������Ϊ `inter`���� spring ����û������Ϊ `inter` �� bean Class ����������ע��ɹ���
+
+��ʵ�ϣ�����ע�벻��ɹ����� spring �ᱨ�쳣������Ȥ��С�������Լ����ԡ�
+
+�����������������θ��� class �� spring �л�ȡ��Ӧ�� bean���� `instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this)`������ȥ��
+
+> DependencyDescriptor#resolveCandidate
+
+```
+public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
+        throws BeansException {
+    // ���õ��� AbstractBeanFactory#getBean(String)
+    return beanFactory.getBean(beanName);
+}
+
+```
+
+��������൱�򵥣���ֻ��һ�У�`beanFactory.getBean(beanName)`���ع��µ�������
+
+```
+|-AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#finishBeanFactoryInitialization
+   |-DefaultListableBeanFactory#preInstantiateSingletons
+    // �����һ�ε�����AbstractBeanFactory#getBean
+    // ��ʱ����IJ���ΪbeanObj1
+    |-AbstractBeanFactory#getBean(String)
+     |-AbstractBeanFactory#doGetBean
+      |-DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)
+       |-AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])
+        |-AbstractAutowireCapableBeanFactory#doCreateBean
+         |-AbstractAutowireCapableBeanFactory#populateBean
+          |-AutowiredAnnotationBeanPostProcessor#postProcessProperties
+           |-InjectionMetadata#inject
+            |-AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
+             |-DefaultListableBeanFactory#resolveDependency
+              |-DefaultListableBeanFactory#doResolveDependency
+               |-DependencyDescriptor#resolveCandidate
+                // �����һ�ε�����AbstractBeanFactory#getBean��
+                // ��ʱ����IJ���ΪbeanObj2
+                |-AbstractBeanFactory#getBean(String)
+                 .. ���濪ʼ����`beanObj2`��ʵ�������ʼ������
+
+```
+
+��ϵ�������ǰ��������Կ�����
+
+*   �ڻ�ȡ `beanObj1` ʱ��һ�ε��� `AbstractBeanFactory#getBean(String)`�����ڴ�ʱ spring �в����� `beanObj1`���Ϳ�ʼ�� `beanObj1` �Ĵ�����
+*   `beanObj1` ʵ������ɺ󣬽��žͽ�������ע�룬`beanObj1` ���и����� `BeanObj2 beanObj2`��ͬ������ `AbstractBeanFactory#getBean(String)` �� spring �л�ȡ `beanObj2` ����
+*   ���ڴ�ʱ spring �в����� `beanObj2`�����žͽ����� `beanObj2` ����Ĵ������̣����������ͬ��Ҳ��� `beanObj2` ����ע�롢���г�ʼ�������Ȳ��������� `beanObj1` �IJ������ƣ�
+*   �õ� `beanObj2` �����ע�뵽 `beanObj1` �� `BeanObj2 beanObj2` �����У�Ȼ����� `beanObj1` �ĺ���������
+
+��������Կ���������ע��ʱ�����ܻ�ʹ bean ��ʼ����ǰ��ͬʱ������������ζ�����������������dz������� A ��Ҫע�� B��B Ҫע�� C����ô�� A ������ע��ʱ�������ʼ�� B���� B �ڳ�ʼ��ʱ���ֻ��ʼ�� C��
+
+���� bean ��ʵ�������ʼ����������Ҫ��ȷ�£�
+
+*   ʵ��������ָ��������IJ���������ʹ�� new ������ƣ�δ���� spring ����ע�뼰֮������г�ʼ�����������浽 spring ������һϵ�в�����
+*   ��ʼ������ʵ������Ķ����������ע�롢���г�ʼ�����������ձ��浽 spring ������
+
+#### 4\. ��ʼ�� bean
+
+spring ��ʼ�� bean �ķ����� `AbstractAutowireCapableBeanFactory#initializeBean(String, Object, RootBeanDefinition)`:
+
+```
+protected Object initializeBean(final String beanName, final Object bean, 
+             @Nullable RootBeanDefinition mbd) {
+    // 1\. ���� invokeAwareMethods
+    if (System.getSecurityManager() != null) {
+        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
+             invokeAwareMethods(beanName, bean);
+             return null;
+        }, getAccessControlContext());
+    }
+    else {
+        invokeAwareMethods(beanName, bean);
+    }
+
+    // 2\. ���� applyBeanPostProcessorsBeforeInitialization
+    Object wrappedBean = bean;
+    if (mbd == null || !mbd.isSynthetic()) {
+        // ִ�� spring ���е����ô���������xxxPostProcessor-------@PostConstruct
+        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
+    }
+
+    try {
+        // 3\. ִ�� InitializingBean ��ʼ��
+        invokeInitMethods(beanName, wrappedBean, mbd);
+    }
+    catch (Throwable ex) {
+        ...
+    }
+    if (mbd == null || !mbd.isSynthetic()) {
+        // 4\. ���� applyBeanPostProcessorsAfterInitialization
+        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
+    }
+
+    return wrappedBean;
+}
+
+```
+
+���ϴ�����Ҫ���������� 4 ��������
+
+1.  invokeAwareMethods(beanName, bean);
+2.  applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
+3.  invokeInitMethods(beanName, wrappedBean, mbd);
+4.  applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
+
+##### 4.1 ���� Aware bean �ķ���
+
+`invokeAwareMethods` ����ִ�� Aware bean ����ط�����
+
+```
+private void invokeAwareMethods(final String beanName, final Object bean) {
+    if (bean instanceof Aware) {
+        if (bean instanceof BeanNameAware) {
+            ((BeanNameAware) bean).setBeanName(beanName);
+        }
+        if (bean instanceof BeanClassLoaderAware) {
+            ClassLoader bcl = getBeanClassLoader();
+            if (bcl != null) {
+                ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
+            }
+        }
+        if (bean instanceof BeanFactoryAware) {
+            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
+        }
+    }
+}
+
+```
+
+���Ϸ����Ƚϼ򵥣��Ͳ���˵�ˡ�
+
+##### 4.2 ���к��ô������� `postProcessBeforeInitialization` ����
+
+���������� `AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization` ������
+
+```
+public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
+         throws BeansException {
+    Object result = existingBean;
+    for (BeanPostProcessor processor : getBeanPostProcessors()) {
+        // ���ú��ô�����
+        Object current = processor.postProcessBeforeInitialization(result, beanName);
+        if (current == null) {
+            return result;
+        }
+        result = current;
+    }
+    return result;
+}
+
+```
+
+������Ҫ���� `ApplicationContextAwareProcessor#postProcessBeforeInitialization` �������������£�
+
+```
+@Override
+@Nullable
+public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+    if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
+              bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
+              bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
+        return bean;
+    }
+    AccessControlContext acc = null;
+    if (System.getSecurityManager() != null) {
+        acc = this.applicationContext.getBeanFactory().getAccessControlContext();
+    }
+    if (acc != null) {
+        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
+           invokeAwareInterfaces(bean);
+           return null;
+        }, acc);
+    }
+    else {
+        // �����
+        invokeAwareInterfaces(bean);
+    }
+    return bean;
+}
+
+private void invokeAwareInterfaces(Object bean) {
+    if (bean instanceof EnvironmentAware) {
+        ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
+    }
+    if (bean instanceof EmbeddedValueResolverAware) {
+        ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
+    }
+    if (bean instanceof ResourceLoaderAware) {
+        ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
+    }
+    if (bean instanceof ApplicationEventPublisherAware) {
+        ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
+    }
+    if (bean instanceof MessageSourceAware) {
+        ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
+    }
+    // װ�� ʵ����ApplicationContextAware����� applicationContext
+    if (bean instanceof ApplicationContextAware) {
+        ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
+    }
+}
+
+```
+
+��ʵ����������Ǹ����� `XxxAware` ��ֵ��������������� `ApplicationContextAware` ��ֵҲ����������С�
+
+˳��һ����ǣ������ bean �У��������� `@PostConstruct` ע�⣺
+
+```
+@PostConstruct
+public void test() {
+    System.out.println("PostConstruct");
+}
+
+```
+
+�÷��������� `InitDestroyAnnotationBeanPostProcessor#postProcessBeforeInitialization` �н��е��ã�����Ƚϼ򵥣�Ҳ�������� jdk �ķ�����ƣ�����Ͳ���˵�ˡ�
+
+##### 4.3 ���� bean �ij�ʼ������
+
+���������� `AbstractAutowireCapableBeanFactory#invokeInitMethods` ����:
+
+```
+protected void invokeInitMethods(String beanName, final Object bean, 
+        @Nullable RootBeanDefinition mbd)  throws Throwable {
+    // ִ�� InitializingBean#afterPropertiesSet ����
+    boolean isInitializingBean = (bean instanceof InitializingBean);
+    if (isInitializingBean && (mbd == null || 
+                 !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
+        if (System.getSecurityManager() != null) {
+            try {
+                AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
+                    ((InitializingBean) bean).afterPropertiesSet();
+                    return null;
+                }, getAccessControlContext());
+            }
+            catch (PrivilegedActionException pae) {
+                throw pae.getException();
+            }
+        }
+        else {
+            // ���beanʵ���� InitializingBean �ӿڣ������ afterPropertiesSet()
+            ((InitializingBean) bean).afterPropertiesSet();
+        }
+    }
+
+    // ִ���Զ���ij�ʼ������������xml�У�ͨ�� init-method ָ���ķ���
+    if (mbd != null && bean.getClass() != NullBean.class) {
+        String initMethodName = mbd.getInitMethodName();
+        if (StringUtils.hasLength(initMethodName) &&
+                !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
+                !mbd.isExternallyManagedInitMethod(initMethodName)) {
+            invokeCustomInitMethod(beanName, bean, mbd);
+        }
+    }
+}
+
+```
+
+������Ҫ����������������
+
+1.  ��� bean ʵ���� InitializingBean �ӿڣ������ afterPropertiesSet ()
+2.  ���ָ���� init-method������ `invokeCustomInitMethod` �����У�Ҳ��ͨ�� jdk ������������еģ��Ͳ���˵�ˡ�
+
+##### 4.4 ���к��ô������� `postProcessAfterInitialization` ����
+
+��һ����Ҫ������ `BeanPostProcessor#postProcessAfterInitialization`�������е� `BeanPostProcessor` �� `ApplicationListenerDetector`:
+
+```
+@Override
+public Object postProcessAfterInitialization(Object bean, String beanName) {
+    if (bean instanceof ApplicationListener) {
+        Boolean flag = this.singletonNames.get(beanName);
+        if (Boolean.TRUE.equals(flag)) {
+            this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
+        }
+        else if (Boolean.FALSE.equals(flag)) {
+            this.singletonNames.remove(beanName);
+        }
+    }
+    return bean;
+}
+
+```
+
+����������������� `ApplicationListener` �ģ������ bean ʵ���� `ApplicationListener`���������������ӵ� spring �ļ������б��ġ�
+
+#### 5\. �ܽ�
+
+������Ҫ������ spring bean �������̣���������ܽ����£�
+
+1.  ʵ���� bean��ָ���˳�ʼ��������ָ���� `factory method`�������ƶϹ��췽���ȷ�ʽ��
+
+2.  ��ѯ��ע������Ի򷽷�������Щ���Ի򷽷��ϱ�ע�� `@Autowird`/`@Value`/`@Resource`
+
+    *   `AutowiredAnnotationBeanPostProcessor.postProcessMergedBeanDefinition` �������Ҵ��� @Autowired��@Value ע������Ժͷ���
+    *   `CommonAnnotationBeanPostProcessor.postProcessMergedBeanDefinition` �������Ҵ��� @Resource ע������Ժͷ���
+3.  �������
+
+    *   `AutowiredAnnotationBeanPostProcessor.postProcessProperties` ���� `@Autowired`��`@Value` ע�⣬`CommonAnnotationBeanPostProcessor.postProcessProperties` ���� `@Resource` ע��
+    *   ���� `@Autowired` ʱ���ȸ��������ҵ����е� `Class`������ж�����ٸ���ע�����Ե����Ʋ��ҷ��ϵ� `Class`�������� `beanFactory.getBean(...)` �� spring ��ȡҪע��Ķ���ͨ���������Ϊ��Ӧ����������ֵ��
+4.  ��ʼ�� bean
+
+    1.  ִ�� Aware bean ����ط���
+    2.  ���� `BeanPostProcessor#postProcessBeforeInitialization` ����
+        *   �� `ApplicationContextAwareProcessor#postProcessBeforeInitialization` ��ִ�� Aware bean ����ط���
+        *   �� `InitDestroyAnnotationBeanPostProcessor#postProcessBeforeInitialization` �д��� `@PostConstruct` ע��
+    3.  ִ�г�ʼ������
+        *   ִ�� `InitializingBean#afterPropertiesSet` ����
+        *   ִ���Զ���� `init-method` ����
+    4.  ���� `BeanPostProcessor#postProcessAfterInitialization` ����
+        *   �� `ApplicationListenerDetector#postProcessAfterInitialization` ��� spring ������
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-b7a4d4bc1bfbd76537e40cf843b0d18df93.png)
+
+���� spring bean �Ĵ������̾��ȷ����������ˣ����� spring �ڴ��� bean �Ĺ����У���һ���޷����ӵ������ѭ�������������ⷽ��Ĵ��������Բο���
+
+*   [spring ̽��֮ѭ�������Ľ����һ�������ۻ�ʯ](https://my.oschina.net/funcy/blog/4659555)
+*   [spring ̽��֮ѭ�������Ľ����������Դ�����](https://my.oschina.net/funcy/blog/4815992)
+
+*   * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4659524](https://my.oschina.net/funcy/blog/4659524) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\272\214\357\274\211\357\274\232ApplicationContext\347\232\204\345\210\233\345\273\272.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\272\214\357\274\211\357\274\232ApplicationContext\347\232\204\345\210\233\345\273\272.md"
new file mode 100644
index 0000000..9b9d16e
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\272\214\357\274\211\357\274\232ApplicationContext\347\232\204\345\210\233\345\273\272.md"
@@ -0,0 +1,161 @@
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-07194ddebd25cb2b71ee5e422bf84e8a397.png)
+
+��ǰ��һƪ�����У����Ƿ����� spring �������������̣�����ƪ��ʼ �����ǽ������������е�һЩ�ؼ�������з�����
+
+���������ǻ��ڵ� `demo01`������ֱ�ӽ��� `ApplicationContext context = new AnnotationConfigApplicationContext("org.springframework.learn.demo01");` ��ִ���У�
+
+> AnnotationConfigApplicationContext
+
+```
+public AnnotationConfigApplicationContext(String... basePackages) {
+    this();
+    scan(basePackages);
+    refresh();
+}
+
+```
+
+�������ֻ�����У�ÿ�д���������� [spring �������̸���](https://my.oschina.net/funcy/blog/4597493 "spring�������̸���")������˵�����������ǽ�����Щ����չ������ϸ������������ݡ�
+
+### 1. `beanFacotry` �Ĵ���
+
+����ֱ�ӽ��� `this()` �������������£�
+
+> AnnotationConfigApplicationContext
+
+```
+public AnnotationConfigApplicationContext() {
+    // AnnotatedBeanDefinitionReader ���� @Configuration
+    this.reader = new AnnotatedBeanDefinitionReader(this);
+    this.scanner = new ClassPathBeanDefinitionScanner(this);
+}
+
+```
+
+�����Ͽ�������ֻ�����У��������������󡣵���Ϥ java �����﷨�Ķ�֪���������ڵ��ù��췽��ʱ�����ȵ��ø���Ĺ��췽����ִ�����๹�췽���Ĵ��룬��Щ���ǻ���Ҫ��������ĸ��๹�췽��������ʲô��
+
+> GenericApplicationContext
+
+```
+public GenericApplicationContext() {
+    this.beanFactory = new DefaultListableBeanFactory();
+}
+
+```
+
+���Կ���������Ĺ��췽���������һ���£����� `beanFactory`���Դˣ����ǿ���֪����**`AnnotationConfigApplicationContext` ʹ�õ� `BeanFacotry` Ϊ `DefaultListableBeanFactory`**��
+
+�����ٻص� `AnnotationConfigApplicationContext` �Ĺ��췽����
+
+> AnnotationConfigApplicationContext
+
+```
+public AnnotationConfigApplicationContext() {
+    // AnnotatedBeanDefinitionReader ���� @Configuration
+    this.reader = new AnnotatedBeanDefinitionReader(this);
+    this.scanner = new ClassPathBeanDefinitionScanner(this);
+}
+
+```
+
+���������Ȼֻ�����У�����ȴ��С���������� `new AnnotatedBeanDefinitionReader(this);` ���£��������еķ������ò�����Ҫ��������ṩ��������
+
+```
+AnnotationConfigApplicationContext#AnnotationConfigApplicationContext()
+ |-AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader(BeanDefinitionRegistry)
+  |-AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader(BeanDefinitionRegistry, Environment)
+   |-AnnotationConfigUtils#registerAnnotationConfigProcessors(BeanDefinitionRegistry)
+    |-AnnotationConfigUtils#registerAnnotationConfigProcessors(BeanDefinitionRegistry, Object)
+
+```
+
+���Կ����������ǵ����� `AnnotationConfigUtils#registerAnnotationConfigProcessors(BeanDefinitionRegistry, Object)`�����Dz鿴�¸÷�����Ϊ��ֱ�۲鿴������ʡ���˲���Ҫ�Ĵ��룬���ǽ���ע��Ҫ�����̼��ɣ�
+
+```
+public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
+        BeanDefinitionRegistry registry, @Nullable Object source) {
+    // ���beanFactory
+    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
+
+    // -------- ��beanFactory�����Ӵ�����
+    if (beanFactory != null) {
+        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
+        beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
+        }
+        if (!(beanFactory.getAutowireCandidateResolver() 
+                instanceof ContextAnnotationAutowireCandidateResolver)) {
+            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
+        }
+    }
+
+    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
+
+    // ------------  ��beanFactory������beanDefinition
+    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
+        RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
+        def.setSource(source);
+        beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
+    }
+
+    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
+        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
+        def.setSource(source);
+        beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
+    }
+
+    // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
+    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
+        RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
+        def.setSource(source);
+        beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
+    }
+
+    // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
+    if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
+        RootBeanDefinition def = new RootBeanDefinition();
+        try {
+            def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
+                AnnotationConfigUtils.class.getClassLoader()));
+        }
+        catch (ClassNotFoundException ex) {
+            throw new IllegalStateException(...);
+        }
+        def.setSource(source);
+        beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
+    }
+
+    if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
+        RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
+        def.setSource(source);
+        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
+    }
+
+    if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
+        RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
+        def.setSource(source);
+        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
+    }
+    return beanDefs;
+}
+
+```
+
+�������������Ȼ�е㳤��������ȴ�൱ֱ�ף������� `beanFactory` ���� `annotation` ��صĴ�������ʵ���ϣ��� [spring �������̸���](https://my.oschina.net/funcy/blog/4597493 "spring�������̸���")�ᵽ�� beanDefinitionMap �� 4 ��Ĭ�ϵ� beanDefinition �������������ӵģ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-a490052bdc1379ef24a7754c65584214c1c.png)
+
+���������ٹ�ע `this.scanner = new ClassPathBeanDefinitionScanner(this)`�����dz�ʼ�� `scanner` ��������Ϊ `ClassPathBeanDefinitionScanner`������������Ͽ��Կ����������� `classPath` ��صģ�`beanDefinition` ɨ������ͨ�׵�˵������**ɨ�� classPath ·������ java class �ļ���װ�� `beanDefinition` ����**��
+
+### 2\. �ܽ�
+
+`AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)` �� `this()` ��ִ�оͷ����������ˣ���һ �д�����Ҫ�����⼸���£�
+
+1.  ����������Ϊ `DefaultListableBeanFactory` �� `beanFactory`
+2.  ����������Ϊ `AnnotatedBeanDefinitionReader` �� reader�����䴴���Ĺ����У����� `beanFactory` ���� annotation ��صĴ�����
+3.  ����������Ϊ `ClassPathBeanDefinitionScanner` �� `scanner`
+
+��������ͼʾ���£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-b7a7a01b4d38769419a0e25e8f60037cbb5.png)
+
+���ľ��ȵ������ˣ����������������Ǽ������������Ĵ��롣
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\272\224\357\274\211\357\274\232\346\211\247\350\241\214BeanFactoryPostProcessor.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\272\224\357\274\211\357\274\232\346\211\247\350\241\214BeanFactoryPostProcessor.md"
new file mode 100644
index 0000000..1aea867
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\344\272\224\357\274\211\357\274\232\346\211\247\350\241\214BeanFactoryPostProcessor.md"
@@ -0,0 +1,495 @@
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-c8c446fca94a382109bdc7b6babd6db4c0d.png)
+
+�����ģ����Ǽ���������
+
+### 4\. ��չ�㣺`postProcessBeanFactory(beanFactory)`
+
+������� spring �ṩ����չ�㣬���������κι��ܣ���������ʵ�֣�`AbstractApplicationContext` �� `postProcessBeanFactory` �����������£�
+
+```
+    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
+    }
+
+```
+
+��ǰ����ʹ�õ� `ApplicationContext` �� `AnnotationConfigApplicationContext`����û��ʵ�����������
+
+### 5\. ִ�� `BeanFactoryPostProcessors`: `invokeBeanFactoryPostProcessors(beanFactory)`
+
+> `BeanFactoryPostProcessor` ��Ϊ beanFactory �ĺ��ô����������޸� beanFactory ��һЩ��Ϊ������ `BeanFactoryPostProcessor` ����ϸ���������Բο� [spring ���֮ BeanFactoryPostProcessors](https://my.oschina.net/funcy/blog/4597545)��
+
+���� `BeanFactoryPostProcessor`�������Ἰ�㣺
+
+*   `BeanFactoryPostProcessor` ��Ϊ���֣�`BeanFactoryPostProcessor` �� `BeanDefinitionRegistryPostProcessor`
+*   `BeanDefinitionRegistryPostProcessor` �� `BeanFactoryPostProcessor` ������
+*   ��ִ�� `BeanDefinitionRegistryPostProcessor` �ķ�������ִ�� `BeanFactoryPostProcessor` �ķ���
+
+�˽���Щ�����Ǹ������룬����Բ���Ҫ��������ֻ���������������£�
+
+```
+|-AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#invokeBeanFactoryPostProcessors
+   |-PostProcessorRegistrationDelegate
+     #invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory, List<BeanFactoryPostProcessor>)
+
+```
+
+����ֱ�ӿ� `invokeBeanFactoryPostProcessors` ������
+
+```
+public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, 
+            List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
+
+    // ���д��ڵ�BeanDefinitionRegistryPostProcessor������
+    Set<String> processedBeans = new HashSet<>();
+
+    //beanFactory��DefaultListableBeanFactory����BeanDefinitionRegistry��ʵ���࣬���Կ϶�����if
+    if (beanFactory instanceof BeanDefinitionRegistry) {
+        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
+
+        //regularPostProcessors �������BeanFactoryPostProcessor
+        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
+
+        //registryProcessors �������BeanDefinitionRegistryPostProcessor
+        //BeanDefinitionRegistryPostProcessor ��չ�� BeanFactoryPostProcessor
+        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
+
+        // ѭ����������beanFactoryPostProcessors����������£�beanFactoryPostProcessors�϶�û������
+        // ��ΪbeanFactoryPostProcessors�ǻ���ֶ����ӵģ�������springɨ���
+        // ֻ���ֶ�����annotationConfigApplicationContext.addBeanFactoryPostProcessor(XXX)�Ż�������
+        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
+            // �ж�postProcessor�Dz���BeanDefinitionRegistryPostProcessor��
+            // ��ΪBeanDefinitionRegistryPostProcessor ��չ��BeanFactoryPostProcessor��
+            // ����������Ҫ�ж��Dz���BeanDefinitionRegistryPostProcessor, �ǵĻ���ֱ��ִ��
+            // postProcessBeanDefinitionRegistry������Ȼ��Ѷ���װ��registryProcessors����ȥ
+            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
+                BeanDefinitionRegistryPostProcessor registryProcessor =
+                        (BeanDefinitionRegistryPostProcessor) postProcessor;
+                registryProcessor.postProcessBeanDefinitionRegistry(registry);
+                registryProcessors.add(registryProcessor);
+            }
+            else {
+                //���ǵĻ�����װ��regularPostProcessors
+                regularPostProcessors.add(postProcessor);
+            }
+        }
+
+        // һ����ʱ����������װ��BeanDefinitionRegistryPostProcessor
+        // BeanDefinitionRegistry�̳���PostProcessorBeanFactoryPostProcessor
+        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
+
+        // ���ʵ��BeanDefinitionRegistryPostProcessor�ӿڵ����BeanName
+        // ���������spring�ڲ��ṩ��BeanDefinitionRegistryPostProcessor
+        // �Լ��������Լ�ʵ�ֵ�BeanDefinitionRegistryPostProcessor
+        String[] postProcessorNames =
+            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
+        for (String ppName : postProcessorNames) {
+            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
+               //���ConfigurationClassPostProcessor�࣬���ҷŵ�currentRegistryProcessors
+               //ConfigurationClassPostProcessor�Ǻ���Ҫ��һ���࣬��ʵ����
+               //BeanDefinitionRegistryPostProcessor�ӿڣ�
+               //BeanDefinitionRegistryPostProcessor�ӿ���ʵ����BeanFactoryPostProcessor�ӿ�
+               //ConfigurationClassPostProcessor�Ǽ�����Ҫ����, ����ִ����
+               //ɨ�� @Bean��@Import��@ImportResource �ȸ��ֲ���
+               currentRegistryProcessors.add(beanFactory.getBean(
+                   ppName, BeanDefinitionRegistryPostProcessor.class));
+               processedBeans.add(ppName);
+            }
+        }
+
+       //��������
+       sortPostProcessors(currentRegistryProcessors, beanFactory);
+
+       //�ϲ�Processors��ΪʲôҪ�ϲ�����ΪregistryProcessors��
+       //װ��BeanDefinitionRegistryPostProcessor��
+       //һ��ʼ��ʱ��springֻ��ִ��BeanDefinitionRegistryPostProcessor���еķ���
+       //������ִ��BeanDefinitionRegistryPostProcessor����ķ�������BeanFactoryProcessor�ķ���
+       //����������Ҫ�Ѵ���������һ�������У�����ͳһִ�и���ķ���
+       registryProcessors.addAll(currentRegistryProcessors);
+
+       //��������Ϊִ��ConfigurationClassPostProcessor��postProcessBeanDefinitionRegistry����
+       invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
+       //��ΪcurrentRegistryProcessors��һ����ʱ������������Ҫ���
+       currentRegistryProcessors.clear();
+
+       // �ٴθ���BeanDefinitionRegistryPostProcessor���BeanName��
+       // �����BeanName�Ƿ��Ѿ���ִ�й��ˣ���û��ʵ��Ordered�ӿ�
+       // ���û�б�ִ�й���Ҳʵ����Ordered�ӿڵĻ����Ѷ������͵�currentRegistryProcessors��
+       // �������͵�processedBeans
+       // ���û��ʵ��Ordered�ӿڵĻ������ﲻ�����ݼӵ�currentRegistryProcessors��
+       // processedBeans��������������
+       // ����ſ��Ի�����Ƕ����ʵ����BeanDefinitionRegistryPostProcessor��Bean
+       postProcessorNames = beanFactory.getBeanNamesForType(
+              BeanDefinitionRegistryPostProcessor.class, true, false);
+       for (String ppName : postProcessorNames) {
+           if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
+              currentRegistryProcessors.add(beanFactory.getBean(
+                  ppName, BeanDefinitionRegistryPostProcessor.class));
+              processedBeans.add(ppName);
+           }
+       }
+       //��������
+       sortPostProcessors(currentRegistryProcessors, beanFactory);
+       //�ϲ�Processors
+       registryProcessors.addAll(currentRegistryProcessors);
+       //ִ�������Զ����BeanDefinitionRegistryPostProcessor
+       invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
+       //�����ʱ����
+       currentRegistryProcessors.clear();
+       // ����Ĵ�����ִ����ʵ����Ordered�ӿڵ�BeanDefinitionRegistryPostProcessor��
+       // ����Ĵ������ִ��û��ʵ��Ordered�ӿڵ�BeanDefinitionRegistryPostProcessor
+       boolean reiterate = true;
+       while (reiterate) {
+           reiterate = false;
+           postProcessorNames = beanFactory.getBeanNamesForType(
+                    BeanDefinitionRegistryPostProcessor.class, true, false);
+           for (String ppName : postProcessorNames) {
+                if (!processedBeans.contains(ppName)) {
+                    currentRegistryProcessors.add(beanFactory.getBean(
+                            ppName, BeanDefinitionRegistryPostProcessor.class));
+                    processedBeans.add(ppName);
+                    reiterate = true;
+                }
+           }
+           sortPostProcessors(currentRegistryProcessors, beanFactory);
+           registryProcessors.addAll(currentRegistryProcessors);
+           invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
+           currentRegistryProcessors.clear();
+       }
+
+       // registryProcessors����װ��BeanDefinitionRegistryPostProcessor
+       // ����Ĵ�����ִ��������еķ�����������Ҫ�ٰѸ���ķ���Ҳִ��һ��
+       invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
+       invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
+    }
+
+    else {
+        //regularPostProcessorsװ��BeanFactoryPostProcessor��ִ��BeanFactoryPostProcessor�ķ���
+        //����regularPostProcessorsһ������£��Dz��������ݵģ�
+        //ֻ���������ֶ�����BeanFactoryPostProcessor���Ż�������
+        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
+    }
+
+    String[] postProcessorNames =
+            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
+
+    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
+    List<String> orderedPostProcessorNames = new ArrayList<>();
+    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
+    //ѭ��BeanName����
+    for (String ppName : postProcessorNames) {
+        //������Bean��ִ�й��ˣ�����
+        if (processedBeans.contains(ppName)) {
+
+        }
+        //���ʵ����PriorityOrdered�ӿڣ����뵽priorityOrderedPostProcessors
+        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
+            priorityOrderedPostProcessors.add(beanFactory
+                .getBean(ppName, BeanFactoryPostProcessor.class));
+        }
+        //���ʵ����Ordered�ӿڣ����뵽orderedPostProcessorNames
+        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
+            orderedPostProcessorNames.add(ppName);
+        }
+        //�����û��ʵ��PriorityOrdered��Ҳû��ʵ��Ordered�����뵽nonOrderedPostProcessorNames
+        else {
+            nonOrderedPostProcessorNames.add(ppName);
+        }
+    }
+
+    // ������priorityOrderedPostProcessors����ʵ����PriorityOrdered�ӿڵ�BeanFactoryPostProcessor
+    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
+
+    // ִ��priorityOrderedPostProcessors
+    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
+
+    // ִ��ʵ����Ordered�ӿڵ�BeanFactoryPostProcessor
+    List<BeanFactoryPostProcessor> orderedPostProcessors 
+            = new ArrayList<>(orderedPostProcessorNames.size());
+    for (String postProcessorName : orderedPostProcessorNames) {
+        orderedPostProcessors.add(beanFactory.getBean(
+            postProcessorName, BeanFactoryPostProcessor.class));
+    }
+    sortPostProcessors(orderedPostProcessors, beanFactory);
+    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
+
+    // ִ�м�û��ʵ��PriorityOrdered�ӿڣ�Ҳû��ʵ��Ordered�ӿڵ�BeanFactoryPostProcessor
+    List<BeanFactoryPostProcessor> nonOrderedPostProcessors 
+            = new ArrayList<>(nonOrderedPostProcessorNames.size());
+    for (String postProcessorName : nonOrderedPostProcessorNames) {
+        nonOrderedPostProcessors.add(beanFactory.getBean(
+                postProcessorName, BeanFactoryPostProcessor.class));
+    }
+    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
+
+    beanFactory.clearMetadataCache();
+}
+
+```
+
+��������dz��dz��������������������ѣ�ִ��������ѭ�⼸������
+
+*   ��ִ�� `BeanDefinitionRegistryPostProcessor`����ִ�� `BeanFactoryPostProcessor`
+*   ִ�� `BeanDefinitionRegistryPostProcessor` ��˳�����£�
+    1.  ִ�в�������� `BeanDefinitionRegistryPostProcessor`
+    2.  ִ�� spring �ڲ��ṩ�ģ������ִ��һ���dz���Ҫ�� `BeanDefinitionRegistryPostProcessor`����`ConfigurationClassPostProcessor`�����ᴦ����Ŀ�е� `@ComponentScan`��`@Component`��`@Import`��`@Bean` ��ע�⣬�����û��Զ���� `BeanDefinitionRegistryPostProcessor`��`BeanFactoryPostProcessor`
+    3.  ִ��ʣ�µ� `BeanDefinitionRegistryPostProcessor`��Ҳ��������һ���м��ص��� `BeanDefinitionRegistryPostProcessor`
+*   ִ�� `BeanFactoryPostProcessor` ��˳�����£�
+    1.  ִ��ʵ���� `PriorityOrdered` �ӿڵ� `BeanFactoryPostProcessor`
+    2.  ִ��ʵ���� `Ordered` �ӿڵ� `BeanFactoryPostProcessor`
+    3.  ִ��ʣ�µ� `BeanFactoryPostProcessor`
+*   `BeanDefinitionRegistryPostProcessor` �� `BeanFactoryPostProcessor` �����࣬ͬ��Ҫִ�� `BeanFactoryPostProcessor` �ķ���
+
+����˵��ִ�� `BeanDefinitionRegistryPostProcessor`����ִָ�� `PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors`��ִ�� `BeanFactoryPostProcessor` ��ִָ�� `BeanFactoryPostProcessor#postProcessBeanFactory`
+
+�����������ݺ󣬽��������Ƕ����Ϸ�������ϸ�����ˣ�
+
+1.  ִ�� `BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry`:
+    1.  ִ�п������ֶ����� `applicationContext.addBeanFactoryPostProcessor` ���ӵ� `BeanDefinitionRegistryPostProcessor` �� `postProcessBeanDefinitionRegistry` ������һ������£������߲����ֶ����ø÷�����;
+    2.  ִ�� spring �ڲ��ṩ�ġ�ʵ���� `PriorityOrdered` �ӿڵ� `BeanDefinitionRegistryPostProcessor` �� `postProcessBeanDefinitionRegistry` ������
+    3.  ִ��ʵ���� `Ordered` �ӿ���δִ�й��� `BeanDefinitionRegistryPostProcessor` �� `postProcessBeanDefinitionRegistry` ������
+    4.  ִ������δִ�й��� `BeanDefinitionRegistryPostProcessor` �� `postProcessBeanDefinitionRegistry` ������
+2.  ִ�� `BeanFactoryPostProcessor#postProcessBeanFactory` ������
+    1.  ִ�п����ߵ��� `applicationContext.addBeanFactoryPostProcessor` ���ӵ� `BeanDefinitionRegistryPostProcessor` �� `postProcessBeanFactory` ������һ������£������߲����ֶ����ø÷�����;
+    2.  ִ�����ϴ�δִ�й��ġ�ʵ���� `PriorityOrdered` �� `BeanFactoryPostProcessor` �� `postProcessBeanFactory` ������
+    3.  ִ�����ϴ�δִ�й��ġ�ʵ���� `Ordered` �� `BeanFactoryPostProcessor` �� `postProcessBeanFactory` ������
+    4.  ִ�����ϴ�δִ�й��� `BeanFactoryPostProcessor` �� `postProcessBeanFactory` ����
+
+���Կ������������ʵ�ʾ���Ϊ��ִ������������`BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry` �� `BeanFactoryPostProcessor#postProcessBeanFactory`����Ҫע����ǣ�`BeanDefinitionRegistryPostProcessor` �� `BeanFactoryPostProcessor` �����࣬�ڵ��� `BeanFactoryPostProcessor#postProcessBeanFactory` ʱ ��ʵ����Ҳ������ `BeanDefinitionRegistryPostProcessor` �� `postProcessBeanFactory` ����.
+
+�����ϵ� `BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry` �� `BeanFactoryPostProcessor#postProcessBeanFactory` ִ���У�����ִ������Щ�����أ���������ͨ������ `demo01`������ִ�еĴ������£�
+
+1.  �� `1.2` ����ʱ��ִ���� `ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry`
+2.  �� `1.4` ����ʱ��ִ���� `ConfigurationClassPostProcessor#postProcessBeanFactory`
+3.  �� `2.4` ����ʱ��ִ���� `EventListenerMethodProcessor#postProcessBeanFactory`
+
+���ţ����DZ������������������չ����������������ʲô��
+
+#### 5.1 `ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry` ��ִ������
+
+����һ����ȥ���Բ���Ҫ�ķ���ֻ��ʾ����ջ��
+
+```
+AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.String...)
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#invokeBeanFactoryPostProcessors
+   |-PostProcessorRegistrationDelegate
+      #invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory, List)
+    |-PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors
+     |-ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry
+      |-ConfigurationClassPostProcessor#processConfigBeanDefinitions
+
+```
+
+����ֱ�ӽ��� `ConfigurationClassPostProcessor#processConfigBeanDefinitions`��
+
+```
+public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
+    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
+    String[] candidateNames = registry.getBeanDefinitionNames();
+
+    //ѭ��candidateNames����
+    for (String beanName : candidateNames) {
+    BeanDefinition beanDef = registry.getBeanDefinition(beanName);
+
+    // �ڲ����������λ������Ƿ��Ѿ���������
+    // ���������һ����֪ʶä��
+    // ������ע���������ʱ�򣬿��Բ���Configurationע�⣬
+    // ֱ��ʹ��Component ComponentScan Import ImportResourceע�⣬��֮ΪLite������
+    // �������Configurationע�⣬�ͳ�֮ΪFull������
+    // �������ע����Lite�����࣬����getBean��������࣬�ᷢ��������ԭ�����Ǹ�������
+    // �������ע����Full�����࣬����getBean��������࣬�ᷢ�����Ѿ�����ԭ���Ǹ��������ˣ�
+    // �����Ѿ���cgilb����������
+    if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
+            if (logger.isDebugEnabled()) {
+                logger.debug(...);
+            }
+        }
+        // �ж��Ƿ�Ϊ�����࣬��������������
+       // 1\. ���� @Configuration ע�� �� proxyBeanMethods != false ���࣬spring ����Ϊ Full ������
+       // 2\. ���� @Configuration ע�� �� proxyBeanMethods == false,
+       // �� ���� @Component��@ComponentScan��@Import��@ImportResource��
+       // @Bean ����֮һע����࣬spring ����Ϊ Lite ������
+       // Full��Lite��beanDef����б�ʶ
+       else if (ConfigurationClassUtils
+               .checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
+           configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
+       }
+    }
+
+    // ���û�������ֱ࣬�ӷ���
+    if (configCandidates.isEmpty()) {
+         return;
+    }
+
+    // ��������
+    configCandidates.sort((bd1, bd2) -> {
+         int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
+         int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
+         return Integer.compare(i1, i2);
+    });
+
+    SingletonBeanRegistry sbr = null;
+    // DefaultListableBeanFactory���ջ�ʵ��SingletonBeanRegistry�ӿڣ����Կ��Խ��뵽���if
+    if (registry instanceof SingletonBeanRegistry) {
+        sbr = (SingletonBeanRegistry) registry;
+        if (!this.localBeanNameGeneratorSet) {
+            //spring�п����޸�Ĭ�ϵ�bean������ʽ��������ǿ��û���û���Զ���bean������ʽ
+            BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
+                     AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
+            if (generator != null) {
+                this.componentScanBeanNameGenerator = generator;
+                this.importBeanNameGenerator = generator;
+            }
+        }
+    }
+
+    if (this.environment == null) {
+         this.environment = new StandardEnvironment();
+    }
+
+    ConfigurationClassParser parser = new ConfigurationClassParser(
+            this.metadataReaderFactory, this.problemReporter, this.environment,
+            this.resourceLoader, this.componentScanBeanNameGenerator, registry);
+
+    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
+    Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
+    do {
+        //���������࣬��������˺ܶ��£�
+        //�磺��@Component��@PropertySources��@ComponentScans��@ImportResource�ȵĴ���
+        parser.parse(candidates);
+        parser.validate();
+
+        Set<ConfigurationClass> configClasses
+                = new LinkedHashSet<>(parser.getConfigurationClasses());
+        configClasses.removeAll(alreadyParsed);
+
+        if (this.reader == null) {
+            this.reader = new ConfigurationClassBeanDefinitionReader(
+                registry, this.sourceExtractor, this.resourceLoader, this.environment,
+                this.importBeanNameGenerator, parser.getImportRegistry());
+        }
+        // ֱ����һ���Ű�Import���࣬@Bean @ImportRosource ת����BeanDefinition
+        this.reader.loadBeanDefinitions(configClasses);
+        // ��configClasses���뵽alreadyParsed
+        alreadyParsed.addAll(configClasses);
+
+        candidates.clear();
+        // ���ע��������BeanDefinition������ �� candidateNames���бȽ�
+        // ������ڵĻ���˵�����µ�BeanDefinitionע�������
+        if (registry.getBeanDefinitionCount() > candidateNames.length) {
+            String[] newCandidateNames = registry.getBeanDefinitionNames();
+            Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
+            Set<String> alreadyParsedClasses = new HashSet<>();
+            // ѭ��alreadyParsed�����������뵽alreadyParsedClasses
+            for (ConfigurationClass configurationClass : alreadyParsed) {
+                alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
+            }
+            for (String candidateName : newCandidateNames) {
+                if (!oldCandidateNames.contains(candidateName)) {
+                    BeanDefinition bd = registry.getBeanDefinition(candidateName);
+                    if (ConfigurationClassUtils
+                                .checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
+                            !alreadyParsedClasses.contains(bd.getBeanClassName())) {
+                        candidates.add(new BeanDefinitionHolder(bd, candidateName));
+                    }
+                }
+            }
+            candidateNames = newCandidateNames;
+        }
+    }
+    while (!candidates.isEmpty());
+
+    if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
+        sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
+    }
+
+    if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
+        ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
+    }
+}
+
+```
+
+���Ϸ������Ƕ� `BeanDefinition` ��Ϣ�Ľ�һ�����ƣ������� `@Configuration`��`@PropertySources`��`@ComponentScans`��`@ImportResource` �ȵĴ��������� demo01 û����Щע�⣬�������ǾͲ�չ���ˣ����������ٷ�����
+
+#### 5.2 ִ�� `ConfigurationClassPostProcessor#postProcessBeanFactory` ������
+
+`ConfigurationClassPostProcessor` �� `postProcessBeanFactory` �����Ƚϼ򵥣��������»��Ƕ� `@Configuration` ����ǿ��
+
+```
+@Override
+public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
+    // ʡ����������
+
+    // �� ConfigurationClasses ����ǿ
+    enhanceConfigurationClasses(beanFactory);
+    beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
+}
+
+public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
+    // ʡ����������
+
+    // ȫ�����ࣺ��������
+    ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
+    for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
+        AbstractBeanDefinition beanDef = entry.getValue();
+        // If a @Configuration class gets proxied, always proxy the target class
+        beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
+        // Set enhanced subclass of the user-specified bean class
+        // �����������ǿ��
+        Class<?> configClass = beanDef.getBeanClass();
+        Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
+        if (configClass != enhancedClass) {
+            beanDef.setBeanClass(enhancedClass);
+        }
+    }
+}
+
+```
+
+���� demo01 û������ `@Configuration`������Ͳ�չ���ˣ����������ٷ�����
+
+#### 5.3 ִ�� `EventListenerMethodProcessor#postProcessBeanFactory` ������
+
+������������������¼��������ģ�����ֱ���ϴ��룺
+
+```
+@Override
+public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
+    this.beanFactory = beanFactory;
+    Map<String, EventListenerFactory> beans 
+          = beanFactory.getBeansOfType(EventListenerFactory.class, false, false);
+
+    List<EventListenerFactory> factories = new ArrayList<>(beans.values());
+    AnnotationAwareOrderComparator.sort(factories);
+    this.eventListenerFactories = factories;
+}
+
+```
+
+���Կ���������� spring �����У��ó������е� `EventListenerFactory`��Ȼ��ֵ�� `this.eventListenerFactories`������Ͳ�չ���ˡ�
+
+#### 5.4 �ܽ�
+
+���Ľ����� `invokeBeanFactoryPostProcessors` ��ִ�����̣���������������Ϊ��ִ������������`BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry` �� `BeanFactoryPostProcessor#postProcessBeanFactory`��������������ִ�й������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-b6188601112b2b2c031b0a70f64f2cc885f.png)
+
+ͨ�����Է��֣�`invokeBeanFactoryPostProcessors` һ��ִ���� `BeanFactoryPostProcessor`��
+
+1.  `ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry`
+2.  `ConfigurationClassPostProcessor#postProcessBeanFactory`
+3.  `EventListenerMethodProcessor#postProcessBeanFactory`
+
+���У�`ConfigurationClassPostProcessor` ��һ���dz��dz���Ҫ�� `BeanFactoryPostProcessor`���������Ľ�һ���������Բο��������£�
+
+*   [spring ̽��֮ ConfigurationClassPostProcessor ֮���� @ComponentScan ע��](https://my.oschina.net/funcy/blog/4836178)
+*   [spring ̽��֮ ConfigurationClassPostProcessor ֮���� @Bean ע��](https://my.oschina.net/funcy/blog/4492878)
+*   [spring ̽��֮ ConfigurationClassPostProcessor ֮���� @Import ע��](https://my.oschina.net/funcy/blog/4678152)
+*   [spring ̽��֮ ConfigurationClassPostProcessor ֮���� @Conditional ע��](https://my.oschina.net/funcy/blog/4873444)
+
+*   * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4641114](https://my.oschina.net/funcy/blog/4641114) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\205\253\357\274\211\357\274\232\345\256\214\346\210\220BeanFactory\347\232\204\345\210\235\345\247\213\345\214\226.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\205\253\357\274\211\357\274\232\345\256\214\346\210\220BeanFactory\347\232\204\345\210\235\345\247\213\345\214\226.md"
new file mode 100644
index 0000000..a7372b9
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\205\253\357\274\211\357\274\232\345\256\214\346\210\220BeanFactory\347\232\204\345\210\235\345\247\213\345\214\226.md"
@@ -0,0 +1,377 @@
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-1f1ac8f3d8241fad9693d9684048ab7f3ae.png)
+
+�����ģ����ļ������� spring ������ ���̡�
+
+### 11\. ��ʼ������ bean: `finishBeanFactoryInitialization(beanFactory)`
+
+���Ľ�����һ��**�dz���Ҫ**�ķ��� `AbstractApplicationContext#finishBeanFactoryInitialization` �ˡ�
+
+�����ĵ������£�
+
+```
+|-AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#finishBeanFactoryInitialization
+   |-DefaultListableBeanFactory#preInstantiateSingletons
+
+```
+
+����ֱ�ӽ��� `DefaultListableBeanFactory#preInstantiateSingletons`:
+
+```
+public void preInstantiateSingletons() throws BeansException {
+    // this.beanDefinitionNames ���������е� beanNames
+    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
+
+    for (String beanName : beanNames) {
+        // �ϲ��� Bean �е����ã�ע��<bean id=""  parent="" /> �е� parent����
+        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
+        // ���dz����ࡢ�ǵ������Ҳ��������ص�
+        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
+            // ���� FactoryBean
+            if (isFactoryBean(beanName)) {
+                //�� beanName ǰ����ϡ�&�� ����
+                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
+                if (bean instanceof FactoryBean) {
+                     final FactoryBean<?> factory = (FactoryBean<?>) bean;
+                     // �жϵ�ǰ FactoryBean �Ƿ��� SmartFactoryBean ��ʵ��
+                     boolean isEagerInit;
+                     if (System.getSecurityManager() != null 
+                            && factory instanceof SmartFactoryBean) {
+                        isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
+                                ((SmartFactoryBean<?>) factory)::isEagerInit,
+                                getAccessControlContext());
+                     }
+                     else {
+                          isEagerInit = (factory instanceof SmartFactoryBean &&
+                             ((SmartFactoryBean<?>) factory).isEagerInit());
+                     }
+                     if (isEagerInit) {
+                           // ����FactoryBean��ֱ��ʹ�ô˷������г�ʼ��
+                           getBean(beanName);
+                     }
+                }
+            }
+            else {
+                getBean(beanName);
+            }
+        }
+    }
+
+    // Trigger post-initialization callback for all applicable beans...
+    // ���beanʵ���� SmartInitializingSingleton �ӿڵģ���ô������õ��ص�
+    for (String beanName : beanNames) {
+        Object singletonInstance = getSingleton(beanName);
+        if (singletonInstance instanceof SmartInitializingSingleton) {
+            final SmartInitializingSingleton smartSingleton = 
+                    (SmartInitializingSingleton) singletonInstance;
+            if (System.getSecurityManager() != null) {
+                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
+                    smartSingleton.afterSingletonsInstantiated();
+                    return null;
+                }, getAccessControlContext());
+            }
+            else {
+                smartSingleton.afterSingletonsInstantiated();
+            }
+        }
+    }
+}
+
+```
+
+���ϴ��룬���ƺܶ࣬���ؼ�����ɼ����£�
+
+```
+List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
+for (String beanName : beanNames) {
+    RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
+    if(... && bd.isSingleton() && ...) {
+        getBean(beanName);
+    }
+}
+
+```
+
+> ���ϴ���ļ��У�ʡ��������ϸ�ڣ������ж��Ƿ����ʵ����ʱ����Ҫ�ж��Ƿ�Ϊ�����࣬�Ƿ�Ϊ�������Ƿ�Ϊ�����صȣ�ͬʱ�� bean Ҳ�ж����Ƿ�Ϊ��ͨ bean ���� `FactoryBean`�����ʵ���� `SmartInitializingSingleton` �ӿڵ� bean����Ҫ���⴦���ȡ��������dz����Ķ�������˵���Ѿ����ۼ���Ҫ���̾����ˣ�����һЩ������ϸ�ڣ������Ȳ����ᣬ���˽����ϸ�ڣ������ڰ�����Ҫ���̵�����£������ٿ������ھ���������ϸ�ڣ��������Լ�ץ��ס�ص㣬��ʧ��Դ���С�
+
+����һ�򻯣��Ϳ������������÷����Ĺ��ܣ�
+
+1.  ��ȡ `beanFactory` �е� `beanNames` ��������
+2.  ͨ�� `beanName` ��ȡ `BeanDefinition`�����������жϣ����Ƿ�Ϊ������
+3.  �������� `getBean(beanName)` ���� bean ���������ӵ� spring �С�
+
+�Ӽ򻯺�Ĵ�����Կ���������ƽƽ����� `getBean(beanName)`������ spring ʵ���� bean �Ĺؼ��������������ǻ��Ǻ����������룬ֻ��ע��Ҫ���̣�����������ȥ��
+
+```
+|-AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#finishBeanFactoryInitialization
+   |-DefaultListableBeanFactory#preInstantiateSingletons
+    |-AbstractBeanFactory#getBean(java.lang.String)
+     |-AbstractBeanFactory#doGetBean
+
+```
+
+> AbstractBeanFactory#doGetBean
+
+```
+protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
+         @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
+
+    // ��Ҫ�߼����������FactoryBean�Ͱ�&ȥ��,����DZ����ͰѸ��ݱ�����ȡ��ʵ����
+    final String beanName = transformedBeanName(name);
+    //���ķ���ֵ
+    Object bean;
+
+    // ����Ƿ��ѳ�ʼ��
+    Object sharedInstance = getSingleton(beanName);
+    // ����Ѿ���ʼ�����ˣ���û�д�args�����ʹ�����get��ֱ��ȡ������
+    if (sharedInstance != null && args == null) {
+        // �����������ͨBean �Ļ���ֱ�ӷ��أ������ FactoryBean �Ļ����������������Ǹ�ʵ������
+        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
+    }
+    else {
+        // �������prototype���͵����bean
+        if (isPrototypeCurrentlyInCreation(beanName)) {
+            throw new BeanCurrentlyInCreationException(beanName);
+        }
+
+        // �����ǰBeanDefinition���������bean�Ҿ��и�BeanFactory
+        BeanFactory parentBeanFactory = getParentBeanFactory();
+        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
+            String nameToLookup = originalBeanName(name);
+            if (parentBeanFactory instanceof AbstractBeanFactory) {
+                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
+                   nameToLookup, requiredType, args, typeCheckOnly);
+            }
+            else if (args != null) {.
+                 // ���ظ������IJ�ѯ���
+                 return (T) parentBeanFactory.getBean(nameToLookup, args);
+            }
+            else if (requiredType != null) {
+                return parentBeanFactory.getBean(nameToLookup, requiredType);
+            }
+            else {
+                return (T) parentBeanFactory.getBean(nameToLookup);
+            }
+        }
+
+        if (!typeCheckOnly) {
+            // typeCheckOnly Ϊ false������ǰ beanName ����һ�� alreadyCreated �� Set �����С�
+            markBeanAsCreated(beanName);
+        }
+
+        // �����Ҫ����bean��
+        try {
+            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
+            checkMergedBeanDefinition(mbd, beanName, args);    
+            // �ȳ�ʼ������������ Bean�� depends-on �ж��������
+            String[] dependsOn = mbd.getDependsOn();
+            if (dependsOn != null) {
+                for (String dep : dependsOn) {
+                    // ����Dz�����ѭ������
+                    if (isDependent(beanName, dep)) {
+                        throw new BeanCreationException(...);
+                    }
+                    // ע��һ��������ϵ
+                    registerDependentBean(dep, beanName);
+                    try {
+                        // �ȳ�ʼ����������
+                        getBean(dep);
+                    }
+                    catch (NoSuchBeanDefinitionException ex) {
+                        throw new BeanCreationException(...);
+                    }
+                }
+            }
+
+            // ����ǵ�����
+            if (mbd.isSingleton()) {
+                sharedInstance = getSingleton(beanName, () -> {
+                    try {
+                        // ִ�д��� Bean
+                        return createBean(beanName, mbd, args);
+                    }
+                    catch (BeansException ex) {
+                        destroySingleton(beanName);
+                        throw ex;
+                    }
+                });
+                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
+            }
+            // �����prototype
+            else if (mbd.isPrototype()) {
+                Object prototypeInstance = null;
+                try {
+                    beforePrototypeCreation(beanName);
+                    // ִ�д��� Bean
+                    prototypeInstance = createBean(beanName, mbd, args);
+                }
+                finally {
+                    afterPrototypeCreation(beanName);
+                }
+                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
+            }
+            // ������� singleton �� prototype, ��ô�����Զ����scope(����Web��Ŀ�е�session������)��
+            // ����ͽ����Զ���scope��Ӧ�÷�ȥʵ��
+            else {
+                String scopeName = mbd.getScope();
+                final Scope scope = this.scopes.get(scopeName);
+                if (scope == null) {
+                  throw new IllegalStateException(...);
+                }
+                try {
+                    Object scopedInstance = scope.get(beanName, () -> {
+                        beforePrototypeCreation(beanName);
+                        try {
+                            // ִ�д��� Bean
+                            return createBean(beanName, mbd, args);
+                        }
+                        finally {
+                            afterPrototypeCreation(beanName);
+                        }
+                    });
+                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
+                }
+                catch (IllegalStateException ex) {
+                  throw new BeanCreationException(...);
+                }
+            }
+        }
+        catch (BeansException ex) {
+            cleanupAfterBeanCreationFailure(beanName);
+            throw ex;
+        }
+    }
+
+    //���bean������
+    if (requiredType != null && !requiredType.isInstance(bean)) {
+        try {
+            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
+            if (convertedBean == null) {
+                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
+            }
+            return convertedBean;
+        }
+        catch (TypeMismatchException ex) {
+            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
+        }
+    }
+    return (T) bean;
+}
+
+```
+
+����Ĵ�������ϸ�����ע�ͣ� ����Ͳ����� �����ˡ�spring ���ܱȽϸ��ӣ����ǵĶ���Ҳ�Ƚ϶࣬��������������������жϣ�Ӧ�Զ��������������ǽ����� demo01 ����� (`singleton` ���)�����ϴ���ؼ����£�
+
+```
+//���ķ���ֵ
+Object bean;
+
+// ������������������
+// 1\. ��ȡ��������ͬʱҲ�ṩ��һ��lambda����ʽ����������bean�Ĵ���
+sharedInstance = getSingleton(beanName, () -> {
+    try {
+        // ִ�д��� Bean
+        return createBean(beanName, mbd, args);
+    }
+    catch (BeansException ex) {
+        destroySingleton(beanName);
+        throw ex;
+    }
+});
+
+// 2\. ��һ������sharedInstance��Ȼ�󷵻�bean����ʵ�ϣ����������Ҫ�������ǣ�
+// �����FactoryBean���ͷ��ط������������Ǹ�ʵ�����󣬷����ֱ�ӷ���
+bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
+
+return (T) bean;
+
+```
+
+�����Ĵ��룬���� spring ���� bean �����̡��������Ǿͷֱ𿴿����������������ݣ�����ɾ����һЩ����Ҫ�Ĵ��룺
+
+> `DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)`
+
+```
+public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
+    synchronized (this.singletonObjects) {
+        boolean newSingleton = false;
+        try {
+            // �������������������
+            singletonObject = singletonFactory.getObject();
+            newSingleton = true;
+        }
+        catch (... ex) {
+            ...
+        }
+        finally {
+            // ������ɺ���һЩ�жϲ������봴�����̹�ϵ����
+            afterSingletonCreation(beanName);
+        }
+        if (newSingleton) {
+            // ���ӵ�  beanFactory ����
+            addSingleton(beanName, singletonObject);
+        }
+        return singletonObject;
+    }
+}
+
+```
+
+�����ϴ�����Կ�����bean �Ĵ��������� `singletonFactory.getObject()`�������������ִ����ʲô�����ǻ�Ӧ�ý�� `AbstractBeanFactory#doGetBean`.
+
+���ȣ����ǽ��� `ObjectFactory#getObject`�����ִ������£�
+
+```
+@FunctionalInterface
+public interface ObjectFactory<T> {
+    T getObject() throws BeansException;
+}
+
+```
+
+����һ������ʽ��̽ӿڣ�jdk8 �ṩ�����﷨���ٿ��� `AbstractBeanFactory#doGetBean` ��������Ķ���
+
+```
+sharedInstance = getSingleton(beanName, () -> {
+    try {
+        // ִ�д��� Bean
+        return createBean(beanName, mbd, args);
+    }
+    catch (BeansException ex) {
+        destroySingleton(beanName);
+        throw ex;
+    }
+});
+
+```
+
+���ﴫ�����һ�� lambda ����ʽ��������ִ�� `singletonFactory.getObject()` ʱ��ʵ����ִ�е���
+
+```
+try {
+    // ִ�д��� Bean
+    return createBean(beanName, mbd, args);
+}
+catch (BeansException ex) {
+    destroySingleton(beanName);
+    throw ex;
+}
+
+```
+
+�� `AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])`��ǰ��������������ô�࣬spring ����Ҫ���� bean �Ĵ����ˣ�
+
+���� spring ����Ĵ��������ǻ��ں�������¼�����������������ֻ��ע `AbstractBeanFactory#getBean` �� `DefaultSingletonBeanRegistry#getSingleton`��������Ϸ��������Ƕ�������������һ���ܽ᣺
+
+*   `AbstractBeanFactory#getBean`������ scope Ϊ `PropertyType` �� bean ��˵���÷�����ֱ�Ӵ��� bean������ scope Ϊ `singleton` �� bean ��˵���÷��������ж� `beanFactory` �Ƿ���ڸ� bean����������ֱ�ӷ��أ�������ȴ����ٷ��ء�
+
+*   `DefaultSingletonBeanRegistry#getSingleton`������������Ǵ� `beanFactory` ��ȡ singleton bean �ķ�������������ֱ�ӷ��أ�������ȴ����ٷ��ء�
+
+���ľ��ȷ����������ˣ���ƪ���������ٷ��� spring bean �������̡�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4658230](https://my.oschina.net/funcy/blog/4658230) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\205\255\357\274\211\357\274\232\346\263\250\345\206\214BeanPostProcessor.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\205\255\357\274\211\357\274\232\346\263\250\345\206\214BeanPostProcessor.md"
new file mode 100644
index 0000000..ebdc18b
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\205\255\357\274\211\357\274\232\346\263\250\345\206\214BeanPostProcessor.md"
@@ -0,0 +1,146 @@
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-be7f7797a27a2dc5ab1ad8d11327b140c90.png)
+
+�����ģ����Ǽ���������
+
+### 6\. ע�� `BeanPostProcessor`: `registerBeanPostProcessors(beanFactory)`
+
+����ʽ����ǰ����Ҫ��ȷ�������
+
+*   `BeanFactoryPostProcessor`������Ϊ `BeanFactory` �ĺ��ô����������Զ� `BeanFactory` ����һЩ������
+*   `BeanPostProcessor`������Ϊ `Bean` �ĺ��ô����������Զ� `Bean` ����һЩ������
+
+��Ҫ�����ĵ� `BeanPostProcessor` ��ǰ��� `BeanFactoryPostProcessor` Ū���ˡ�
+
+������Ҫ�Ƕ� `BeanPostProcessor` �� `register` ���� (`registerBeanPostProcessors(beanFactory)`)������ `BeanPostProcessor` ע�ᵽ `BeanFactory` �У���ô��������ʲôʱ���أ���Ȼ�Ƕ� `Bean` �IJ�������Ȼ������ bean ֮���������ˡ�
+
+> `BeanPostProcessor` Ҳ�� spring ��һ����Ҫ��������ڸ��������ϸ���������Բο� [spring ���֮ BeanPostProcessors](https://my.oschina.net/funcy/blog/4597551)
+
+�ϻ�����˵��ֱ���ϴ��룬ͬ���أ��Բ���Ҫ�ķ�������ֻ������������
+
+```
+|-AbstractApplicationContext#refresh
+ |-AbstractApplicationContext#registerBeanPostProcessors
+  |-PostProcessorRegistrationDelegate
+    #registerBeanPostProcessors(ConfigurableListableBeanFactory, AbstractApplicationContext)
+
+```
+
+���յ��õ��� `PostProcessorRegistrationDelegate#registerBeanPostProcessors`���������£�
+
+```
+public static void registerBeanPostProcessors(
+        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
+
+    // ��ȡspring�����е� BeanPostProcessor���������һ��bean: 
+    // org.springframework.context.annotation.internalAutowiredAnnotationProcessor��
+    // �� AutowiredAnnotationBeanPostProcessor
+    String[] postProcessorNames = beanFactory
+            .getBeanNamesForType(BeanPostProcessor.class, true, false);
+
+    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() 
+            + 1 + postProcessorNames.length;
+    beanFactory.addBeanPostProcessor(
+            new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
+
+    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
+    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
+    List<String> orderedPostProcessorNames = new ArrayList<>();
+    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
+
+    // �Ȼ�ȡʵ����PriorityOrdered��BeanPostProcessor
+    // �ٻ�ȡʵ����Ordered��BeanPostProcessor
+    // ����ٻ�ȡ����������������BeanPostProcessor
+    for (String ppName : postProcessorNames) {
+        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
+            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
+            priorityOrderedPostProcessors.add(pp);
+            if (pp instanceof MergedBeanDefinitionPostProcessor) {
+                internalPostProcessors.add(pp);
+            }
+        }
+        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
+            orderedPostProcessorNames.add(ppName);
+        }
+        else {
+            nonOrderedPostProcessorNames.add(ppName);
+        }
+    }
+
+    // ����priorityOrderedPostProcessor������Ȼ�����ӵ�beanFactory��
+    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
+    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
+
+    List<BeanPostProcessor> orderedPostProcessors 
+            = new ArrayList<>(orderedPostProcessorNames.size());
+    for (String ppName : orderedPostProcessorNames) {
+        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
+        orderedPostProcessors.add(pp);
+        if (pp instanceof MergedBeanDefinitionPostProcessor) {
+            internalPostProcessors.add(pp);
+        }
+    }
+    // ����orderedPostProcessor������Ȼ�����ӵ�beanFactory��
+    sortPostProcessors(orderedPostProcessors, beanFactory);
+    registerBeanPostProcessors(beanFactory, orderedPostProcessors);
+
+    List<BeanPostProcessor> nonOrderedPostProcessors 
+            = new ArrayList<>(nonOrderedPostProcessorNames.size());
+    for (String ppName : nonOrderedPostProcessorNames) {
+        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
+        nonOrderedPostProcessors.add(pp);
+        if (pp instanceof MergedBeanDefinitionPostProcessor) {
+            internalPostProcessors.add(pp);
+        }
+    }
+    // �������µ�BeanPostProcessor������Ȼ�����ӵ�beanFactory��
+    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);    
+    // ����internalPostProcessor������Ȼ�����ӵ�beanFactory��
+    // AutowiredAnnotationBeanPostProcessorʵ����MergedBeanDefinitionPostProcessor��
+    // ���������ٴ�ע��
+    sortPostProcessors(internalPostProcessors, beanFactory);
+    registerBeanPostProcessors(beanFactory, internalPostProcessors);
+
+    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
+}
+
+```
+
+��������Ҫ�Ƕ� `BeanFactoryPostProcessor` ����ע��������������£�
+
+*   ��ʵ���� `PriorityOrdered` �� `BeanPostProcessor` ע�ᵽ `beanFactory` �У�
+*   ��ʵ���� `Ordered` �� `BeanPostProcessor` ע�ᵽ `beanFactory` �У�
+*   ���������������������� `BeanPostProcessor` ע�ᵽ `beanFactory` �У�
+*   ������ʵ���� `MergedBeanDefinitionPostProcessor` �� `BeanPostProcessor` �ٴ�ע�ᵽ `beanFactory` �С�
+
+��ʵ�ϣ��� demo01 ���ԣ�����ע��� bean ֻ��һ����`AutowiredAnnotationBeanPostProcessor`����ͬʱʵ���� `MergedBeanDefinitionPostProcessor` �� `PriorityOrdered`����˻�ע�����Ρ�
+
+����ע���˶�� `AutowiredAnnotationBeanPostProcessor`��������ֻ�����һ���������ǽ��� `registerBeanPostProcessors` ���� spring �����ע��ģ�һ·����ȥ�����뵽�� `AbstractBeanFactory#addBeanPostProcessor`:
+
+> AbstractBeanFactory#addBeanPostProcessor
+
+```
+private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();
+
+@Override
+public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
+    Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
+    // �Ƚ����Ƴ�����˶��ע��beanPostProcessorsҲֻ����һ��
+    this.beanPostProcessors.remove(beanPostProcessor);
+    if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
+        this.hasInstantiationAwareBeanPostProcessors = true;
+    }
+    if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
+        this.hasDestructionAwareBeanPostProcessors = true;
+    }
+    this.beanPostProcessors.add(beanPostProcessor);
+}
+
+```
+
+���Կ�������ν��ע�ᵽ `BeanFactory`����ʵ���ǰ� `beanPostProcessor` ���뵽 `BeanFactory` �� `beanPostProcessors` �С�
+
+���Ľ����� `beanPostProcessor` ��ע�ᣬ���� `beanPostProcessor` �ĵ��ã������ķ������ᵽ�����ĵķ������ȵ�����ɣ�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4657181](https://my.oschina.net/funcy/blog/4657181) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\215\201\344\270\200\357\274\211\357\274\232\345\220\257\345\212\250\346\265\201\347\250\213\346\200\273\347\273\223.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\215\201\344\270\200\357\274\211\357\274\232\345\220\257\345\212\250\346\265\201\347\250\213\346\200\273\347\273\223.md"
new file mode 100644
index 0000000..1820d8f
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\215\201\344\270\200\357\274\211\357\274\232\345\220\257\345\212\250\346\265\201\347\250\213\346\200\273\347\273\223.md"
@@ -0,0 +1,15 @@
+�������spring �������������������Ƿ�������ˣ�����ʹ��һ��ͼ���ܽ������������̣�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-72a4008f2ad3401de6b4f2d5c7f697923a3.png)
+
+��ϵ�д� `AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)` ���������������� `AnnotationConfigApplicationContext` ���޲ι��췽������ɨ�����̡��������������̵ȣ��ⲿ�����ݱȽ϶࣬�ص��������£�
+
+1.  ��ɨ������
+2.  ���� `beanFactoryProcessor`
+3.  ��ʼ������ bean
+
+�ڷ��������У����Ǻ���������ϸ�ڣ�����ע����Ҫ���̣���ϸ�ڸ���Ȥ��С�����Ը����ṩ�����ӽ�����Ӧ�����Ķ���
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4659519](https://my.oschina.net/funcy/blog/4659519) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\215\201\357\274\211\357\274\232\345\220\257\345\212\250\345\256\214\346\210\220\347\232\204\345\244\204\347\220\206.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\215\201\357\274\211\357\274\232\345\220\257\345\212\250\345\256\214\346\210\220\347\232\204\345\244\204\347\220\206.md"
new file mode 100644
index 0000000..a60a4d6
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\215\201\357\274\211\357\274\232\345\220\257\345\212\250\345\256\214\346\210\220\347\232\204\345\244\204\347\220\206.md"
@@ -0,0 +1,158 @@
+
+
+�����ģ��������� spring ���������̡�
+
+12. �����������: finishRefresh()
+
+AbstractApplicationContext#finishRefresh �������£�
+
+    protected void finishRefresh() {
+        // �����־�֪���ˣ�������ʼ��������һϵ�в���ʹ�õ�����Դ����
+        clearResourceCaches();
+        // ��ʼ��LifecycleProcessor
+        initLifecycleProcessor();
+        // ����������ڲ�ʵ������������ʵ����Lifecycle�ӿڵ�bean
+        getLifecycleProcessor().onRefresh();
+        // ����ContextRefreshedEvent�¼�
+        publishEvent(new ContextRefreshedEvent(this));
+        // ���spring.liveBeansView.mbeanDomain�Ƿ���ڣ��оͻᴴ��һ��MBeanServer
+        LiveBeansView.registerApplicationContext(this);
+    }
+
+
+����������벻�࣬�ͼ������������Ƿֱ���������
+
+1. ������Դ���棺clearResourceCaches()
+
+clearResourceCaches() �����������£�
+
+    public class DefaultResourceLoader implements ResourceLoader {
+    
+        private final Map<Class<?>, Map<Resource, ?>> resourceCaches
+            = new ConcurrentHashMap<>(4);
+    
+        public void clearResourceCaches() {
+            this.resourceCaches.clear();
+        }
+    
+        // ʡ���������ĺö����
+        ...
+    
+    }
+
+
+������������������� resourceCaches �ģ����Ǹ� Map���������������� Resource��
+
+��ʲô�� Resource �أ���ǰ�����ɨ����Ĺ����У����ǻ��Ȱ� class �ļ���ȡ������ת���� Resource ���ٽ�һ�������������� Resource ������ FileSystemResource��UrlResource �ȣ�resourceCaches ���Ǵ����Щ Resource �ġ�
+
+2. ���� LifecycleProcessor
+
+������������ʲô�� LifecycleProcessor��
+
+    /**
+     * ����������������رղ���
+     */
+    public interface LifecycleProcessor extends Lifecycle {
+    
+        /**
+         * �����������ʱ����
+         */
+        void onRefresh();
+    
+        /**
+         * �����ر�ʱ����
+         */
+        void onClose();
+    
+    }
+
+
+����ӿ�����������������������������رղ��������������Լ�ʵ�ָýӿڣ�Ȼ����д onRefresh() �� onClose()���Ա�������������ر�ʱ��һЩ��������������
+
+    @Component
+    public class MyLifecycleProcessor implements LifecycleProcessor {
+    
+        @Override
+        public void onRefresh() {
+            System.out.println("��������");
+        }
+    
+        @Override
+        public void onClose() {
+            System.out.println("�����ر�");
+        }
+    }
+
+
+�� LifecycleProcessor ��صķ�����������initLifecycleProcessor()��getLifecycleProcessor()������һ��һΪ����������������
+
+AbstractApplicationContext
+
+    private LifecycleProcessor lifecycleProcessor;
+    
+    /**
+     * ��ʼ�� LifecycleProcessor
+     */
+    protected void initLifecycleProcessor() {
+        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
+        // ���ڣ�ֱ��ʹ��
+        if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
+            this.lifecycleProcessor =
+                    beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
+        }
+        // �������򴴽���Ĭ��ʹ��DefaultLifecycleProcessor
+        else {
+            DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
+            defaultProcessor.setBeanFactory(beanFactory);
+            this.lifecycleProcessor = defaultProcessor;
+            beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
+        }
+    }
+    
+    /**
+     * ���� lifecycleProcessor
+     */
+    LifecycleProcessor getLifecycleProcessor() throws IllegalStateException {
+        if (this.lifecycleProcessor == null) {
+            throw new IllegalStateException(...);
+        }
+        return this.lifecycleProcessor;
+    }
+
+
+initLifecycleProcessor �����ľ������� AbstractApplicationContext#lifecycleProcessor ���ԣ���� beanFactory �д��� initLifecycleProcessor ��ֱ��ʹ�ã�����ʹ���һ����
+
+getLifecycleProcessor() ����ֻ�Ƿ����� AbstractApplicationContext#lifecycleProcessor ���ԡ�
+
+�� getLifecycleProcessor().onRefresh() �У��������� onRefresh() ����������һ�������� DefaultLifecycleProcessor#onRefresh ����ʲô��
+
+    @Override
+    public void onRefresh() {
+        startBeans(true);
+        this.running = true;
+    }
+
+
+�ӱ��������������������ֻ�Ǹ���һ������״̬��
+
+3. ���� ContextRefreshedEvent �¼�
+
+���� publishEvent(new ContextRefreshedEvent(this)) ������ ContextRefreshedEvent�������Լ�Ҳ�������������¼��������¼������IJ����������룬���� spring �¼�����ϸ���������Բο� spring ̽��֮ spring �¼����ơ�
+
+13. �������: resetCommonCaches()
+
+�÷����������£�
+
+    protected void resetCommonCaches() {
+        ReflectionUtils.clearCache();
+        AnnotationUtils.clearCache();
+        ResolvableType.clearCache();
+        CachedIntrospectionResults.clearClassLoader(getClassLoader());
+    }
+
+
+�ӷ�������������ִ�и��ֻ��棬ִ�бȽϼ򵥣��Ͳ���ˡ�
+
+---
+
+����ԭ�����ӣ�https://my.oschina.net/funcy/blog/4892555 ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\233\233\357\274\211\357\274\232\345\220\257\345\212\250\345\211\215\347\232\204\345\207\206\345\244\207\345\267\245\344\275\234.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\233\233\357\274\211\357\274\232\345\220\257\345\212\250\345\211\215\347\232\204\345\207\206\345\244\207\345\267\245\344\275\234.md"
new file mode 100644
index 0000000..10070df
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\345\220\257\345\212\250\346\265\201\347\250\213/Spring\345\220\257\345\212\250\346\265\201\347\250\213\357\274\210\345\233\233\357\274\211\357\274\232\345\220\257\345\212\250\345\211\215\347\232\204\345\207\206\345\244\207\345\267\245\344\275\234.md"
@@ -0,0 +1,230 @@
+��ɰ���ɨ��󣬽��žͿ�ʼ�� spring �������ˣ��� `AbstractApplicationContext#refresh` �������÷���һ������ 13 ������������Ҳ spring �������������̣�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-88c3a2486c24ccd0ad390ba9b62b986a6b2.png)
+
+��ϵ�дӱ��Ŀ�ʼ���𲽷����� 13 ��������̽�� spring ���������̡�
+
+### 1\. ����ǰ׼����`prepareRefresh()`
+
+���� `prepareRefresh()` ���������������£�
+
+```
+|-AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(String...)
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#prepareRefresh
+
+```
+
+�������£�
+
+```
+protected void prepareRefresh() {
+    // Switch to active.
+    this.startupDate = System.currentTimeMillis();
+    this.closed.set(false);
+    this.active.set(true);
+
+    // ��ʼ�����������ļ���������û�о���ʵ�֣�һ�������û�����չ��
+    initPropertySources();
+
+    // ��黷������
+    getEnvironment().validateRequiredProperties();
+
+    if (this.earlyApplicationListeners == null) {
+        this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
+    } else {
+        this.applicationListeners.clear();
+        this.applicationListeners.addAll(this.earlyApplicationListeners);
+    }
+
+    this.earlyApplicationEvents = new LinkedHashSet<>();
+}
+
+```
+
+��δ���Ƚϼ򵥣�����������������ʱ�䡢����������״̬�����������ļ�顢���Եij�ʼ���ȡ�
+
+### 2\. ��ȡ `beanFactory: obtainFreshBeanFactory()`
+
+�����ٸ��� `obtainFreshBeanFactory()` �������������£�
+
+> AbstractApplicationContext#obtainFreshBeanFactory
+
+```
+protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
+    refreshBeanFactory();
+    // ���ظոմ����� BeanFactory
+    return getBeanFactory();
+}
+
+```
+
+����������� `refresh` �� `BeanFactory`��Ȼ���ٷ����� `BeanFactory`�����Ǽ������� `refreshBeanFactory()`��
+
+> GenericApplicationContext#refreshBeanFactory
+
+```
+@Override
+protected final void refreshBeanFactory() throws IllegalStateException {
+    // ʡ����һЩ�жϴ���
+    this.beanFactory.setSerializationId(getId());
+}
+
+```
+
+��������ؼ�����ֻ��һ�У��������������� beanFactory �� `SerializationId`.
+
+�����ٻع�ͷ������ `getBeanFactory()` ������
+
+> GenericApplicationContext#getBeanFactory
+
+```
+public final ConfigurableListableBeanFactory getBeanFactory() {
+    return this.beanFactory;
+}
+
+```
+
+��������͸����ˣ����������˵�ǰ��� `beanFactory`����� `beanFactory` ���������ڷ��� `AnnotationConfigApplicationContext` ���췽��ʱ�����ģ�����Ϊ `DefaultListableBeanFactory`.
+
+### 3\. ׼�� `beanFactory: prepareBeanFactory(beanFactory)`
+
+���Ǽ��������� `prepareBeanFactory(beanFactory)` ������
+
+> AbstractApplicationContext#prepareBeanFactory
+
+```
+protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
+    // ����Ϊ���ص�ǰApplicationContext����������
+    beanFactory.setBeanClassLoader(getClassLoader());
+    // ���� BeanExpressionResolver����bean����ʽ������
+    beanFactory.setBeanExpressionResolver(
+            new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
+    // ���Ա༭��֧��
+    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
+
+    // ������Spring����һ����չ��
+    // ������ʵ����Aware�ӿڵ�bean�ڳ�ʼ����ʱ����� processor����ص���
+    // ������Ǻܳ��ã������ǻ�Ϊ�˻�ȡ ApplicationContext �� implement ApplicationContextAware
+    // ע�⣺���������ص� ApplicationContextAware�����Ḻ��ص� EnvironmentAware��ResourceLoaderAware ��
+    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
+
+    // ���漸�е���˼���ǣ����ij�� bean ���������¼����ӿڵ�ʵ���࣬
+    // ���Զ�װ���ʱ��������ǣ�Spring ��ͨ��������ʽ��������Щ������
+    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
+    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
+    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
+    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
+    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
+    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
+
+    // ���漸�о���Ϊ����ļ��� bean ��ֵ������� bean ���������¼�������ע�������Ӧ��ֵ
+    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
+    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
+    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
+    beanFactory.registerResolvableDependency(ApplicationContext.class, this);
+
+     // ����һ�����ô�������ApplicationListenerDetector���˺��ô�����ʵ����BeanPostProcessor�ӿ�
+     beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
+
+    // �������bean����ΪloadTimeWeaver��bean��ע��һ��BeanPostProcessor
+    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
+        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
+        // Set a temporary ClassLoader for type matching.
+        beanFactory.setTempClassLoader(
+                new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
+    }
+
+    // ���û�ж��� "environment" ��� bean����ô Spring �� "�ֶ�" ע��һ��
+    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
+        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
+    }
+    // ���û�ж��� "systemProperties" ��� bean����ô Spring �� "�ֶ�" ע��һ��
+    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
+        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, 
+                getEnvironment().getSystemProperties());
+    }
+    // ���û�ж��� "systemEnvironment" ��� bean����ô Spring �� "�ֶ�" ע��һ��
+    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
+        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, 
+                getEnvironment().getSystemEnvironment());
+    }
+}
+
+```
+
+��������Ƕ� beanFactory ��һЩ׼��������һЩ���ԣ�����һЩ bean �����ȣ����붼��ע�⣬����Ͳ��ظ�˵�ˡ�
+
+������ beanFactory ������ `ApplicationListenerDetector` ��Ҫ���£���ش���Ϊ `beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));`�����ǿ��� `ApplicationListenerDetector` ����ࣺ
+
+> org.springframework.context.support.ApplicationContextAwareProcessor
+
+```
+class ApplicationContextAwareProcessor implements BeanPostProcessor {
+    @Override
+    @Nullable
+    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+    // ʡ����һЩ����
+    AccessControlContext acc = null;
+    if (System.getSecurityManager() != null) {
+        acc = this.applicationContext.getBeanFactory().getAccessControlContext();
+    }
+    if (acc != null) {
+        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
+            invokeAwareInterfaces(bean);
+            return null;
+        }, acc);
+    } else {
+        invokeAwareInterfaces(bean);
+    }
+        return bean;
+    }
+
+    // �ص� Aware�ӿ�
+    private void invokeAwareInterfaces(Object bean) {
+        // ���� EnvironmentAware#setEnvironment ����
+        if (bean instanceof EnvironmentAware) {
+            ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
+        }
+        // ���� EmbeddedValueResolverAware#setEmbeddedValueResolver ����
+        if (bean instanceof EmbeddedValueResolverAware) {
+            ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
+        }
+        // ���� ResourceLoaderAware#setResourceLoader ����
+        if (bean instanceof ResourceLoaderAware) {
+            ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
+        }
+        // ���� ApplicationEventPublisherAware#setApplicationEventPublisher ����
+        if (bean instanceof ApplicationEventPublisherAware) {
+            ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
+        }
+        // ���� MessageSourceAware#setMessageSource ����
+        if (bean instanceof MessageSourceAware) {
+            ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
+        }
+        // ���� ApplicationContextAware#setApplicationContext ����
+        if (bean instanceof ApplicationContextAware) {
+            ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
+        }
+    }
+
+    // ʡ����������
+}
+
+```
+
+���Կ�����
+
+1.  �����ʵ���� `BeanPostProcessor` �ӿڣ�
+2.  ���� `postProcessBeforeInitialization` �� `BeanPostProcessor` �ṩ����Ϊ�ؼ��Ĵ�����` invokeAwareInterfaces(bean);`��
+3.  `invokeAwareInterfaces` ֻ��һϵ�еķ�������
+
+���� `BeanPostProcessor` �ĵķ��������Բο� [spring ���֮ BeanPostProcessors ](https://my.oschina.net/funcy/blog/4597551)�����ڸ�������ã����������������
+
+���ˣ����ĵķ����͵������ˣ����Ľ������� spring ����ʱ�� beanFactory ��׼�������ݽϼ򵥣������һ��ͼ���ܽ��±������ݣ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-1e10d7aff080b2e0bbfbef5d79c56cc54c9.png)
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4633169](https://my.oschina.net/funcy/blog/4633169) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2207\357\274\232AOP\345\256\236\347\216\260\345\216\237\347\220\206\350\257\246\350\247\243.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232AOP\345\256\236\347\216\260\345\216\237\347\220\206\350\257\246\350\247\243.md"
similarity index 96%
rename from "docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2207\357\274\232AOP\345\256\236\347\216\260\345\216\237\347\220\206\350\257\246\350\247\243.md"
rename to "docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232AOP\345\256\236\347\216\260\345\216\237\347\220\206\350\257\246\350\247\243.md"
index 03b0de6..e77af01 100644
--- "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2207\357\274\232AOP\345\256\236\347\216\260\345\216\237\347\220\206\350\257\246\350\247\243.md"
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232AOP\345\256\236\347\216\260\345\216\237\347\220\206\350\257\246\350\247\243.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [AOP实现原理——找到Spring处理AOP的源头](#aop实现原理找到spring处理aop的源头)
   * [解析增强器advisor](#解析增强器advisor)
   * [解析切面的过程](#解析切面的过程)
@@ -35,14 +34,14 @@
 前言
 
 前面写了六篇文章详细地分析了Spring Bean加载流程，这部分完了之后就要进入一个比较困难的部分了，就是AOP的实现原理分析。为了探究AOP实现原理，首先定义几个类，一个Dao接口：
-
+````
 public interface Dao {
 public void select();
 public void insert();
 }
 Dao接口的实现类DaoImpl：
 
-```
+
 public class DaoImpl implements Dao {
 
     @Override
@@ -57,7 +56,7 @@ public class DaoImpl implements Dao {
 
 }
 
-```
+````
 
 定义一个TimeHandler，用于方法调用前后打印时间，在AOP中，这扮演的是横切关注点的角色：
 
@@ -1110,3 +1109,34 @@ chain.get(2)：AspectJAfterAdvice，用于在实际方法调用之后的处理
 这里我们看到了与JDK动态代理同样的获取拦截器链的过程，并且CglibMethodInvokcation继承了我们在JDK动态代理看到的ReflectiveMethodInvocation，但是并没有重写其proceed方法，只是重写了执行目标方法的逻辑，所以整体上是大同小异的。
 
 到这里，整个Spring 动态AOP的源码就分析完了，Spring还支持静态AOP，这里就不过多赘述了，有兴趣的读者可以查阅相关资料来学习。
+
+
+## 微信公众号
+
+### 个人公众号：黄小斜
+
+黄小斜是跨考软件工程的 985 硕士，自学 Java 两年，拿到了 BAT 等近十家大厂 offer，从技术小白成长为阿里工程师。
+
+作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得和程序人生，目前黄小斜的CSDN博客有百万+访问量，知乎粉丝2W+，全网已有10W+读者。
+
+黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
+
+**原创电子书:**
+关注公众号【黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》
+
+**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。
+
+**考研复习资料：**
+计算机考研大礼包，都是我自己考研复习时用的一些复习资料,包括公共课和专业的复习视频，这里也推荐给大家，关注公众号后，后台回复关键字 **“考研”** 即可免费获取。
+
+![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
+
+
+### 技术公众号：Java技术江湖
+
+如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
+
+**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
+
+![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
+ 
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232JDK\345\222\214cglib\345\212\250\346\200\201\344\273\243\347\220\206\345\216\237\347\220\206\350\257\246\350\247\243.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232JDK\345\222\214cglib\345\212\250\346\200\201\344\273\243\347\220\206\345\216\237\347\220\206\350\257\246\350\247\243.md"
new file mode 100644
index 0000000..65471de
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232JDK\345\222\214cglib\345\212\250\346\200\201\344\273\243\347\220\206\345\216\237\347\220\206\350\257\246\350\247\243.md"
@@ -0,0 +1,427 @@
+#目录
+* [前言](#前言)
+* [Java代理介绍](#java代理介绍)
+* [静态代理](#静态代理)
+* [JDK动态代理](#jdk动态代理)
+    * [JDK动态代理实现原理](#jdk动态代理实现原理)
+    * [Proxy类中的newProxyInstance](#proxy类中的newproxyinstance)
+    * [字节码生成](#字节码生成)
+* [代理类的方法调用](#代理类的方法调用)
+* [深入理解CGLIB动态代理机制](#深入理解cglib动态代理机制)
+    * [CGLIB动态代理示例](#cglib动态代理示例)
+    * [生成代理类对象](#生成代理类对象)
+    * [对委托类进行代理](#对委托类进行代理)
+
+
+转自 https://www.jianshu.com/u/668d0795a95b
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+文章将同步到我的个人博客：
+> www.how2playlife.com
+
+本文是微信公众号【Java技术江湖】的《Spring和SpringMVC源码分析》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+
+该系列博文会告诉你如何从spring基础入手，一步步地学习spring基础和springmvc的框架知识，并上手进行项目实战，spring框架是每一个Java工程师必须要学习和理解的知识点，进一步来说，你还需要掌握spring甚至是springmvc的源码以及实现原理，才能更完整地了解整个spring技术体系，形成自己的知识框架。
+
+后续还会有springboot和springcloud的技术专题，陆续为大家带来，敬请期待。
+
+为了更好地总结和检验你的学习成果，本系列文章也会提供部分知识点对应的面试题以及参考答案。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+<!-- more -->  
+## 前言
+AOP的基础是Java动态代理，了解和使用两种动态代理能让我们更好地理解 AOP，在讲解AOP之前，让我们先来看看Java动态代理的使用方式以及底层实现原理。
+
+本文是基于jdk1.8来对动态代理的底层机制进行探究的
+
+## Java代理介绍
+
+Java中代理的实现一般分为三种：JDK静态代理、JDK动态代理以及CGLIB动态代理。在Spring的AOP实现中，主要应用了JDK动态代理以及CGLIB动态代理。但是本文着重介绍JDK动态代理机制，CGLIB动态代理后面会接着探究。
+
+代理一般实现的模式为JDK静态代理：创建一个接口，然后创建被代理的类实现该接口并且实现该接口中的抽象方法。之后再创建一个代理类，同时使其也实现这个接口。在代理类中持有一个被代理对象的引用，而后在代理类方法中调用该对象的方法。
+
+其实就是代理类为被代理类预处理消息、过滤消息并在此之后将消息转发给被代理类，之后还能进行消息的后置处理。代理类和被代理类通常会存在关联关系(即上面提到的持有的被带离对象的引用)，代理类本身不实现服务，而是通过调用被代理类中的方法来提供服务。
+
+## 静态代理
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140729721-1002455386.png)
+
+接口
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140729978-492174823.png)
+
+被代理类
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140730312-501564524.png)
+
+代理类
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140730518-1275832673.png)
+
+测试类以及输出结果
+
+我们可以看出，使用JDK静态代理很容易就完成了对一个类的代理操作。但是JDK静态代理的缺点也暴露了出来：由于代理只能为一个类服务，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐。
+
+下面我们使用JDK动态代理来做同样的事情
+
+## JDK动态代理
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140729721-1002455386.png)
+
+接口
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140729978-492174823.png)
+
+被代理类
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140731035-1119549632.png)
+
+代理类
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140731317-1929161422.png)
+
+测试类以及输出结果
+
+### JDK动态代理实现原理
+
+JDK动态代理其实也是基本接口实现的。因为通过接口指向实现类实例的多态方式，可以有效地将具体实现与调用解耦，便于后期的修改和维护。
+
+通过上面的介绍，我们可以发现JDK静态代理与JDK动态代理之间有些许相似，比如说都要创建代理类，以及代理类都要实现接口等。但是不同之处也非常明显----在静态代理中我们需要对哪个接口和哪个被代理类创建代理类，所以我们在编译前就需要代理类实现与被代理类相同的接口，并且直接在实现的方法中调用被代理类相应的方法；但是动态代理则不同，我们不知道要针对哪个接口、哪个被代理类创建代理类，因为它是在运行时被创建的。
+
+让我们用一句话来总结一下JDK静态代理和JDK动态代理的区别，然后开始探究JDK动态代理的底层实现机制：  
+JDK静态代理是通过直接编码创建的，而JDK动态代理是利用反射机制在运行时创建代理类的。  
+其实在动态代理中，核心是InvocationHandler。每一个代理的实例都会有一个关联的调用处理程序(InvocationHandler)。对待代理实例进行调用时，将对方法的调用进行编码并指派到它的调用处理器(InvocationHandler)的invoke方法。所以对代理对象实例方法的调用都是通过InvocationHandler中的invoke方法来完成的，而invoke方法会根据传入的代理对象、方法名称以及参数决定调用代理的哪个方法。
+
+我们从JDK动态代理的测试类中可以发现代理类生成是通过Proxy类中的newProxyInstance来完成的，下面我们进入这个函数看一看：
+
+### Proxy类中的newProxyInstance
+
+```  
+ public static Object newProxyInstance(ClassLoader loader,                                          Class<?>[] interfaces,                                          InvocationHandler h)        throws IllegalArgumentException    {        //如果h为空将抛出异常  
+        Objects.requireNonNull(h);  
+        final Class<?>[] intfs = interfaces.clone();//拷贝被代理类实现的一些接口，用于后面权限方面的一些检查  
+        final SecurityManager sm = System.getSecurityManager();        if (sm != null) {            //在这里对某些安全权限进行检查，确保我们有权限对预期的被代理类进行代理  
+            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);        }  
+        /*         * 下面这个方法将产生代理类  
+         */        Class<?> cl = getProxyClass0(loader, intfs);  
+        /*         * 使用指定的调用处理程序获取代理类的构造函数对象  
+         */        try {            if (sm != null) {                checkNewProxyPermission(Reflection.getCallerClass(), cl);            }  
+            final Constructor<?> cons = cl.getConstructor(constructorParams);            final InvocationHandler ih = h;            //假如代理类的构造函数是private的，就使用反射来set accessible  
+            if (!Modifier.isPublic(cl.getModifiers())) {                AccessController.doPrivileged(new PrivilegedAction<Void>() {                    public Void run() {                        cons.setAccessible(true);                        return null;                    }                });            }            //根据代理类的构造函数来生成代理类的对象并返回  
+            return cons.newInstance(new Object[]{h});        } catch (IllegalAccessException|InstantiationException e) {            throw new InternalError(e.toString(), e);        } catch (InvocationTargetException e) {            Throwable t = e.getCause();            if (t instanceof RuntimeException) {                throw (RuntimeException) t;            } else {                throw new InternalError(t.toString(), t);            }        } catch (NoSuchMethodException e) {            throw new InternalError(e.toString(), e);        }    }  
+```  
+
+所以代理类其实是通过getProxyClass方法来生成的：
+
+```  
+ /**     * 生成一个代理类，但是在调用本方法之前必须进行权限检查  
+     */    private static Class<?> getProxyClass0(ClassLoader loader,                                           Class<?>... interfaces) {        //如果接口数量大于65535，抛出非法参数错误  
+        if (interfaces.length > 65535) {            throw new IllegalArgumentException("interface limit exceeded");        }  
+        // 如果在缓存中有对应的代理类，那么直接返回  
+        // 否则代理类将有 ProxyClassFactory 来创建  
+        return proxyClassCache.get(loader, interfaces);    }  
+```  
+
+那么ProxyClassFactory是什么呢？
+
+```  
+   /**     *  里面有一个根据给定ClassLoader和Interface来创建代理类的工厂函数    
+     *  
+     */    private static final class ProxyClassFactory        implements BiFunction<ClassLoader, Class<?>[], Class<?>>    {        // 代理类的名字的前缀统一为“$Proxy”  
+        private static final String proxyClassNamePrefix = "$Proxy";  
+        // 每个代理类前缀后面都会跟着一个唯一的编号，如$Proxy0、$Proxy1、$Proxy2  
+        private static final AtomicLong nextUniqueNumber = new AtomicLong();  
+        @Override        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {  
+            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);            for (Class<?> intf : interfaces) {                /*                 * 验证类加载器加载接口得到对象是否与由apply函数参数传入的对象相同  
+                 */                Class<?> interfaceClass = null;                try {                    interfaceClass = Class.forName(intf.getName(), false, loader);                } catch (ClassNotFoundException e) {                }                if (interfaceClass != intf) {                    throw new IllegalArgumentException(                        intf + " is not visible from class loader");                }                /*                 * 验证这个Class对象是不是接口  
+                 */                if (!interfaceClass.isInterface()) {                    throw new IllegalArgumentException(                        interfaceClass.getName() + " is not an interface");                }                /*                 * 验证这个接口是否重复  
+                 */                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {                    throw new IllegalArgumentException(                        "repeated interface: " + interfaceClass.getName());                }            }  
+            String proxyPkg = null;     // 声明代理类所在的package  
+            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;  
+            /*             * 记录一个非公共代理接口的包，以便在同一个包中定义代理类。同时验证所有非公共  
+             * 代理接口都在同一个包中  
+             */            for (Class<?> intf : interfaces) {                int flags = intf.getModifiers();                if (!Modifier.isPublic(flags)) {                    accessFlags = Modifier.FINAL;                    String name = intf.getName();                    int n = name.lastIndexOf('.');                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));                    if (proxyPkg == null) {                        proxyPkg = pkg;                    } else if (!pkg.equals(proxyPkg)) {                        throw new IllegalArgumentException(                            "non-public interfaces from different packages");                    }                }            }  
+            if (proxyPkg == null) {                // 如果全是公共代理接口，那么生成的代理类就在com.sun.proxy package下  
+                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";            }  
+            /*             * 为代理类生成一个name  package name + 前缀+唯一编号  
+             * 如 com.sun.proxy.$Proxy0.class             */            long num = nextUniqueNumber.getAndIncrement();            String proxyName = proxyPkg + proxyClassNamePrefix + num;  
+            /*             * 生成指定代理类的字节码文件  
+             */            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(                proxyName, interfaces, accessFlags);            try {                return defineClass0(loader, proxyName,                                    proxyClassFile, 0, proxyClassFile.length);            } catch (ClassFormatError e) {                /*                 * A ClassFormatError here means that (barring bugs in the                 * proxy class generation code) there was some other                 * invalid aspect of the arguments supplied to the proxy                 * class creation (such as virtual machine limitations                 * exceeded).                 */                throw new IllegalArgumentException(e.toString());            }        }    }  
+```  
+
+### 字节码生成
+
+由上方代码byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);可以看到，其实生成代理类字节码文件的工作是通过 ProxyGenerate类中的generateProxyClass方法来完成的。
+
+```  
+ public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);       // 真正用来生成代理类字节码文件的方法在这里  
+        final byte[] var4 = var3.generateClassFile();       // 保存代理类的字节码文件  
+        if(saveGeneratedFiles) {            AccessController.doPrivileged(new PrivilegedAction() {                public Void run() {                    try {                        int var1 = var0.lastIndexOf(46);                        Path var2;                        if(var1 > 0) {                            Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar),                                                                                   new String[0]);  
+                            Files.createDirectories(var3, new FileAttribute[0]);                            var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");                        } else {                            var2 = Paths.get(var0 + ".class", new String[0]);                        }  
+                        Files.write(var2, var4, new OpenOption[0]);                        return null;                    } catch (IOException var4x) {                        throw new InternalError("I/O exception saving generated file: " + var4x);                    }                }            });        }  
+        return var4;    }  
+```  
+
+下面来看看真正用于生成代理类字节码文件的generateClassFile方法：
+
+```  
+private byte[] generateClassFile() {  
+        //下面一系列的addProxyMethod方法是将接口中的方法和Object中的方法添加到代理方法中(proxyMethod)  
+        this.addProxyMethod(hashCodeMethod, Object.class);        this.addProxyMethod(equalsMethod, Object.class);        this.addProxyMethod(toStringMethod, Object.class);        Class[] var1 = this.interfaces;        int var2 = var1.length;  
+        int var3;        Class var4;       //获得接口中所有方法并添加到代理方法中  
+        for(var3 = 0; var3 < var2; ++var3) {            var4 = var1[var3];            Method[] var5 = var4.getMethods();            int var6 = var5.length;  
+            for(int var7 = 0; var7 < var6; ++var7) {                Method var8 = var5[var7];                this.addProxyMethod(var8, var4);            }        }  
+        Iterator var11 = this.proxyMethods.values().iterator();        //验证具有相同方法签名的方法的返回类型是否一致  
+        List var12;        while(var11.hasNext()) {            var12 = (List)var11.next();            checkReturnTypes(var12);        }  
+        //后面一系列的步骤用于写代理类Class文件  
+        Iterator var15;        try {             //生成代理类的构造函数  
+            this.methods.add(this.generateConstructor());            var11 = this.proxyMethods.values().iterator();  
+            while(var11.hasNext()) {                var12 = (List)var11.next();                var15 = var12.iterator();  
+                while(var15.hasNext()) {                    ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();                    //将代理类字段声明为Method，并且字段修饰符为 private static.                   //因为 10 是 ACC_PRIVATE和ACC_STATIC的与运算 故代理类的字段都是 private static Method ***                    this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName,                                   "Ljava/lang/reflect/Method;", 10));  
+                   //生成代理类的方法  
+                    this.methods.add(var16.generateMethod());                }            }           //为代理类生成静态代码块对某些字段进行初始化  
+            this.methods.add(this.generateStaticInitializer());        } catch (IOException var10) {            throw new InternalError("unexpected I/O Exception", var10);        }  
+        if(this.methods.size() > '\uffff') { //代理类中的方法数量超过65535就抛异常  
+            throw new IllegalArgumentException("method limit exceeded");        } else if(this.fields.size() > '\uffff') {// 代理类中字段数量超过65535也抛异常  
+            throw new IllegalArgumentException("field limit exceeded");        } else {            // 后面是对文件进行处理的过程  
+            this.cp.getClass(dotToSlash(this.className));            this.cp.getClass("java/lang/reflect/Proxy");            var1 = this.interfaces;            var2 = var1.length;  
+            for(var3 = 0; var3 < var2; ++var3) {                var4 = var1[var3];                this.cp.getClass(dotToSlash(var4.getName()));            }  
+            this.cp.setReadOnly();            ByteArrayOutputStream var13 = new ByteArrayOutputStream();            DataOutputStream var14 = new DataOutputStream(var13);  
+            try {                var14.writeInt(-889275714);                var14.writeShort(0);                var14.writeShort(49);                this.cp.write(var14);                var14.writeShort(this.accessFlags);                var14.writeShort(this.cp.getClass(dotToSlash(this.className)));                var14.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));                var14.writeShort(this.interfaces.length);                Class[] var17 = this.interfaces;                int var18 = var17.length;  
+                for(int var19 = 0; var19 < var18; ++var19) {                    Class var22 = var17[var19];                    var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));                }  
+                var14.writeShort(this.fields.size());                var15 = this.fields.iterator();  
+                while(var15.hasNext()) {                    ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();                    var20.write(var14);                }  
+                var14.writeShort(this.methods.size());                var15 = this.methods.iterator();  
+                while(var15.hasNext()) {                    ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();                    var21.write(var14);                }  
+                var14.writeShort(0);                return var13.toByteArray();            } catch (IOException var9) {                throw new InternalError("unexpected I/O Exception", var9);            }        }    }  
+```  
+
+## 代理类的方法调用
+
+下面是将接口与Object中一些方法添加到代理类中的addProxyMethod方法：
+
+```  
+private void addProxyMethod(Method var1, Class<?> var2) {  
+        String var3 = var1.getName();//获得方法名称  
+        Class[] var4 = var1.getParameterTypes();//获得方法参数类型  
+        Class var5 = var1.getReturnType();//获得方法返回类型  
+        Class[] var6 = var1.getExceptionTypes();//异常类型  
+        String var7 = var3 + getParameterDescriptors(var4);//获得方法签名  
+        Object var8 = (List)this.proxyMethods.get(var7);//根据方法前面获得proxyMethod的value  
+        if(var8 != null) {//处理多个代理接口中方法重复的情况  
+            Iterator var9 = ((List)var8).iterator();  
+            while(var9.hasNext()) {                ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next();                if(var5 == var10.returnType) {                    ArrayList var11 = new ArrayList();                    collectCompatibleTypes(var6, var10.exceptionTypes, var11);                    collectCompatibleTypes(var10.exceptionTypes, var6, var11);                    var10.exceptionTypes = new Class[var11.size()];                    var10.exceptionTypes = (Class[])var11.toArray(var10.exceptionTypes);                    return;                }            }        } else {            var8 = new ArrayList(3);            this.proxyMethods.put(var7, var8);        }  
+        ((List)var8).add(new ProxyGenerator.ProxyMethod(var3, var4, var5, var6, var2, null));    }```  
+  
+这就是最终真正的代理类，它继承自Proxy并实现了我们定义的Subject接口。我们通过  
+  
+```  
+````
+HelloInterface helloInterface = (HelloInterface ) Proxy.newProxyInstance(loader, interfaces, handler);
+````  
+  
+*   1  
+  
+得到的最终代理类对象就是上面这个类的实例。那么我们执行如下语句：  
+  
+```  
+helloInterface.hello("Tom");
+```  
+  
+*   1  
+  
+实际上就是执行上面类的相应方法，也就是：  
+  
+```  
+public final void hello(String paramString)  {    try    {      this.h.invoke(this, m3, new Object[] { paramString });      //就是调用我们自定义的InvocationHandlerImpl的 invoke方法：  
+return;    }    catch (Error|RuntimeException localError)    {      throw localError;    }    catch (Throwable localThrowable)    {      throw new UndeclaredThrowableException(localThrowable);    }  }```
+
+注意这里的`this.h.invoke`中的h，它是类Proxy中的一个属性
+
+```  
+ protected InvocationHandler h;```  
+  
+因为这个代理类继承了Proxy，所以也就继承了这个属性，而这个属性值就是我们定义的  
+  
+```  
+InvocationHandler handler = new InvocationHandlerImpl(hello);
+```  
+  
+*   1  
+  
+同时我们还发现，invoke方法的第一参数在底层调用的时候传入的是`this`，也就是最终生成的代理对象ProxySubject，这是JVM自己动态生成的，而不是我们自己定义的代理对象。  
+  
+## 深入理解CGLIB动态代理机制  
+  
+Cglib是什么  
+  
+Cglib是一个强大的、高性能的代码生成包，它广泛被许多AOP框架使用，为他们提供方法的拦截。下图是我网上找到的一张Cglib与一些框架和语言的关系：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/801753-20170403122105941-1116862243.gif)  
+  
+对此图总结一下：  
+  
+*   最底层的是字节码Bytecode，字节码是Java为了保证“一次编译、到处运行”而产生的一种虚拟指令格式，例如iload_0、iconst_1、if_icmpne、dup等  
+*   位于字节码之上的是ASM，这是一种直接操作字节码的框架，应用ASM需要对Java字节码、Class结构比较熟悉  
+*   位于ASM之上的是CGLIB、Groovy、BeanShell，后两种并不是Java体系中的内容而是脚本语言，它们通过ASM框架生成字节码变相执行Java代码，这说明在JVM中执行程序并不一定非要写Java代码----只要你能生成Java字节码，JVM并不关心字节码的来源，当然通过Java代码生成的JVM字节码是通过编译器直接生成的，算是最“正统”的JVM字节码  
+*   位于CGLIB、Groovy、BeanShell之上的就是Hibernate、Spring AOP这些框架了，这一层大家都比较熟悉  
+*   最上层的是Applications，即具体应用，一般都是一个Web项目或者本地跑一个程序  
+  
+本文是基于CGLIB 3.1进行探究的  
+  
+cglib is a powerful, high performance and quality Code Generation Library, It is used to extend JAVA classes and implements interfaces at runtime.  
+  
+在Spring AOP中，通常会用它来生成AopProxy对象。不仅如此，在Hibernate中PO(Persistant Object 持久化对象)字节码的生成工作也要靠它来完成。  
+  
+本文将深入探究CGLIB动态代理的实现机制，配合下面这篇文章一起食用口味更佳：  
+[深入理解JDK动态代理机制](https://www.jianshu.com/p/471c80a7e831)  
+  
+### CGLIB动态代理示例  
+  
+下面由一个简单的示例开始我们对CGLIB动态代理的介绍：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140731697-1665999459.png)  
+  
+为了后续编码的顺利进行，我们需要使用Maven引入CGLIB的包  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140732067-1529903146.png)  
+  
+图1.1 被代理类  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140732309-293903217.png)  
+  
+图1.2 实现MethodInterceptor接口生成方法拦截器  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140732746-1527907182.png)  
+  
+图1.3 生成代理类对象并打印在代理类对象调用方法之后的执行结果  
+  
+JDK代理要求被代理的类必须实现接口，有很强的局限性。而CGLIB动态代理则没有此类强制性要求。简单的说，CGLIB会让生成的代理类继承被代理类，并在代理类中对代理方法进行强化处理(前置处理、后置处理等)。在CGLIB底层，其实是借助了ASM这个非常强大的Java字节码生成框架。  
+  
+### 生成代理类对象  
+  
+从图1.3中我们看到，代理类对象是由Enhancer类创建的。Enhancer是CGLIB的字节码增强器，可以很方便的对类进行拓展，如图1.3中的为类设置Superclass。  
+  
+创建代理对象的几个步骤:  
+  
+*   生成代理类的二进制字节码文件；  
+*   加载二进制字节码，生成Class对象( 例如使用Class.forName()方法 )；  
+*   通过反射机制获得实例构造，并创建代理类对象  
+  
+我们来看看将代理类Class文件反编译之后的Java代码  
+  
+````
+package proxy;
+
+import java.lang.reflect.Method;  
+import net.sf.cglib.core.ReflectUtils;  
+import net.sf.cglib.core.Signature;  
+import net.sf.cglib.proxy.Callback;  
+import net.sf.cglib.proxy.Factory;  
+import net.sf.cglib.proxy.MethodInterceptor;  
+import net.sf.cglib.proxy.MethodProxy;
+
+public class HelloServiceImpl$EnhancerByCGLIB$82ef2d06  
+extends HelloServiceImpl  implements Factory{  
+private boolean CGLIB$BOUND;  private static final ThreadLocal CGLIB$THREAD_CALLBACKS;  private static final Callback[] CGLIB$STATIC_CALLBACKS;  private MethodInterceptor CGLIB$CALLBACK_0;  private static final Method CGLIB$sayHello$0$Method;  private static final MethodProxy CGLIB$sayHello$0$Proxy;  private static final Object[] CGLIB$emptyArgs;  private static final Method CGLIB$finalize$1$Method;  private static final MethodProxy CGLIB$finalize$1$Proxy;  private static final Method CGLIB$equals$2$Method;  private static final MethodProxy CGLIB$equals$2$Proxy;  private static final Method CGLIB$toString$3$Method;  private static final MethodProxy CGLIB$toString$3$Proxy;  private static final Method CGLIB$hashCode$4$Method;  private static final MethodProxy CGLIB$hashCode$4$Proxy;  private static final Method CGLIB$clone$5$Method;  private static final MethodProxy CGLIB$clone$5$Proxy;  
+static void CGLIB$STATICHOOK1()  {    CGLIB$THREAD_CALLBACKS = new ThreadLocal();    CGLIB$emptyArgs = new Object[0];    Class localClass1 = Class.forName("proxy.HelloServiceImpl$EnhancerByCGLIB$82ef2d06");    Class localClass2;    Method[] tmp95_92 = ReflectUtils.findMethods(new String[] { "finalize", "()V", "equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;" }, (localClass2 = Class.forName("java.lang.Object")).getDeclaredMethods());    CGLIB$finalize$1$Method = tmp95_92[0];    CGLIB$finalize$1$Proxy = MethodProxy.create(localClass2, localClass1, "()V", "finalize", "CGLIB$finalize$1");    Method[] tmp115_95 = tmp95_92;    CGLIB$equals$2$Method = tmp115_95[1];    CGLIB$equals$2$Proxy = MethodProxy.create(localClass2, localClass1, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");    Method[] tmp135_115 = tmp115_95;    CGLIB$toString$3$Method = tmp135_115[2];    CGLIB$toString$3$Proxy = MethodProxy.create(localClass2, localClass1, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");    Method[] tmp155_135 = tmp135_115;    CGLIB$hashCode$4$Method = tmp155_135[3];    CGLIB$hashCode$4$Proxy = MethodProxy.create(localClass2, localClass1, "()I", "hashCode", "CGLIB$hashCode$4");    Method[] tmp175_155 = tmp155_135;    CGLIB$clone$5$Method = tmp175_155[4];    CGLIB$clone$5$Proxy = MethodProxy.create(localClass2, localClass1, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");    tmp175_155;    Method[] tmp223_220 = ReflectUtils.findMethods(new String[] { "sayHello", "()V" }, (localClass2 = Class.forName("proxy.HelloServiceImpl")).getDeclaredMethods());    CGLIB$sayHello$0$Method = tmp223_220[0];    CGLIB$sayHello$0$Proxy = MethodProxy.create(localClass2, localClass1, "()V", "sayHello", "CGLIB$sayHello$0");    tmp223_220;    return;  }  
+final void CGLIB$sayHello$0()  {    super.sayHello();  }  
+public final void sayHello()  {    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;    if (tmp4_1 == null)    {      tmp4_1;      CGLIB$BIND_CALLBACKS(this);    }    if (this.CGLIB$CALLBACK_0 != null) {      return;    }    super.sayHello();  }  
+final void CGLIB$finalize$1()    throws Throwable  {    super.finalize();  }  
+protected final void finalize()    throws Throwable  {    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;    if (tmp4_1 == null)    {      tmp4_1;      CGLIB$BIND_CALLBACKS(this);    }    if (this.CGLIB$CALLBACK_0 != null) {      return;    }    super.finalize();  }  
+final boolean CGLIB$equals$2(Object paramObject)  {    return super.equals(paramObject);  }  
+public final boolean equals(Object paramObject)  {    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;    if (tmp4_1 == null)    {      tmp4_1;      CGLIB$BIND_CALLBACKS(this);    }    MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;    if (tmp17_14 != null)    {      Object tmp41_36 = tmp17_14.intercept(this, CGLIB$equals$2$Method, new Object[] { paramObject }, CGLIB$equals$2$Proxy);      tmp41_36;      return tmp41_36 == null ? false : ((Boolean)tmp41_36).booleanValue();    }    return super.equals(paramObject);  }  
+final String CGLIB$toString$3()  {    return super.toString();  }  
+public final String toString()  {    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;    if (tmp4_1 == null)    {      tmp4_1;      CGLIB$BIND_CALLBACKS(this);    }    MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;    if (tmp17_14 != null) {      return (String)tmp17_14.intercept(this, CGLIB$toString$3$Method, CGLIB$emptyArgs, CGLIB$toString$3$Proxy);    }    return super.toString();  }  
+final int CGLIB$hashCode$4()  {    return super.hashCode();  }  
+public final int hashCode()  {    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;    if (tmp4_1 == null)    {      tmp4_1;      CGLIB$BIND_CALLBACKS(this);    }    MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;    if (tmp17_14 != null)    {      Object tmp36_31 = tmp17_14.intercept(this, CGLIB$hashCode$4$Method, CGLIB$emptyArgs, CGLIB$hashCode$4$Proxy);      tmp36_31;      return tmp36_31 == null ? 0 : ((Number)tmp36_31).intValue();    }    return super.hashCode();  }  
+final Object CGLIB$clone$5()    throws CloneNotSupportedException  {    return super.clone();  }  
+protected final Object clone()    throws CloneNotSupportedException  {    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;    if (tmp4_1 == null)    {      tmp4_1;      CGLIB$BIND_CALLBACKS(this);    }    MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;    if (tmp17_14 != null) {      return tmp17_14.intercept(this, CGLIB$clone$5$Method, CGLIB$emptyArgs, CGLIB$clone$5$Proxy);    }    return super.clone();  }  
+public static MethodProxy CGLIB$findMethodProxy(Signature paramSignature)  {    String tmp4_1 = paramSignature.toString();    switch (tmp4_1.hashCode())    {    case -1574182249:      if (tmp4_1.equals("finalize()V")) {  
+return CGLIB$finalize$1$Proxy;      }      break;    }  }  
+public HelloServiceImpl$EnhancerByCGLIB$82ef2d06()  {    CGLIB$BIND_CALLBACKS(this);  }  
+public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] paramArrayOfCallback)  {    CGLIB$THREAD_CALLBACKS.set(paramArrayOfCallback);  }  
+public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] paramArrayOfCallback)  {    CGLIB$STATIC_CALLBACKS = paramArrayOfCallback;  }  
+private static final void CGLIB$BIND_CALLBACKS(Object paramObject)  {    82ef2d06 local82ef2d06 = (82ef2d06)paramObject;    if (!local82ef2d06.CGLIB$BOUND)    {      local82ef2d06.CGLIB$BOUND = true;      Object tmp23_20 = CGLIB$THREAD_CALLBACKS.get();      if (tmp23_20 == null)      {        tmp23_20;        CGLIB$STATIC_CALLBACKS;      }      local82ef2d06.CGLIB$CALLBACK_0 = (// INTERNAL ERROR //
+````
+  
+### 对委托类进行代理  
+  
+我们上面贴出了生成的代理类源码。以我们上面的例子为参考，下面我们总结一下CGLIB在进行代理的时候都进行了哪些工作呢  
+  
+*   生成的代理类HelloServiceImpl$EnhancerByCGLIB$82ef2d06继承被代理类HelloServiceImpl。在这里我们需要注意一点：如果委托类被final修饰，那么它不可被继承，即不可被代理；同样，如果委托类中存在final修饰的方法，那么该方法也不可被代理；  
+*   代理类会为委托方法生成两个方法，一个是重写的sayHello方法，另一个是CGLIB$sayHello$0方法，我们可以看到它是直接调用父类的sayHello方法；  
+*   当执行代理对象的sayHello方法时，会首先判断一下是否存在实现了MethodInterceptor接口的CGLIB$CALLBACK_0;，如果存在，则将调用MethodInterceptor中的intercept方法，如图2.1。  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140733103-2101709172.png)  
+  
+图2.1 intercept方法  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140733381-1955520660.png)  
+  
+图2.2 代理类为每个委托方法都会生成两个方法  
+  
+在intercept方法中，我们除了会调用委托方法，还会进行一些增强操作。在Spring AOP中，典型的应用场景就是在某些敏感方法执行前后进行操作日志记录。  
+  
+我们从图2.1中看到，调用委托方法是通过代理方法的MethodProxy对象调用invokeSuper方法来执行的，下面我们看看invokeSuper方法中的玄机：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140733825-816756585.png)  
+  
+图2.3 invokeSuper方法  
+  
+在这里好像不能直接看出代理方法的调用。没关系，我会慢慢介绍。  
+我们知道，在JDK动态代理中方法的调用是通过反射来完成的。如果有对此不太了解的同学，可以看下我之前的博客----[深入理解JDK动态代理机制](https://www.jianshu.com/p/471c80a7e831)。但是在CGLIB中，方法的调用并不是通过反射来完成的，而是直接对方法进行调用：FastClass对Class对象进行特别的处理，比如将会用数组保存method的引用，每次调用方法的时候都是通过一个index下标来保持对方法的引用。比如下面的getIndex方法就是通过方法签名来获得方法在存储了Class信息的数组中的下标。  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140734172-226519980.png)  
+  
+图2.4 getIndex方法  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825140734361-1715137603.png)  
+  
+图2.5 FastClassInfo类中持有两个FastClass对象的引用.png  
+  
+以我们上面的sayHello方法为例，f1指向委托类对象，f2指向代理类对象，i1和i2分别代表着sayHello方法以及CGLIB$sayHello$0方法在对象信息数组中的下标。  
+  
+到此为止CGLIB动态代理机制就介绍完了，下面给出三种代理方式之间对比。  
+
+
+| 代理方式 | 实现 | 优点 | 缺点 | 特点 | 
+| --- | --- | --- | --- | --- |  
+| JDK静态代理 | 代理类与委托类实现同一接口，并且在代理类中需要硬编码接口 | 实现简单，容易理解 | 代理类需要硬编码接口，在实际应用中可能会导致重复编码，浪费存储空间并且效率很低 | 好像没啥特点 |  
+| JDK动态代理 | 代理类与委托类实现同一接口，主要是通过代理类实现InvocationHandler并重写invoke方法来进行动态代理的，在invoke方法中将对方法进行增强处理 | 不需要硬编码接口，代码复用率高 | 只能够代理实现了接口的委托类 | 底层使用反射机制进行方法的调用 |  
+| CGLIB动态代理 | 代理类将委托类作为自己的父类并为其中的非final委托方法创建两个方法，一个是与委托方法签名相同的方法，它在方法中会通过super调用委托方法；另一个是代理类独有的方法。在代理方法中，它会判断是否存在实现了MethodInterceptor接口的对象，若存在则将调用intercept方法对委托方法进行代理 | 可以在运行时对类或者是接口进行增强操作，且委托类无需实现接口 | 不能对final类以及final方法进行代理 | 底层将方法全部存入一个数组中，通过数组索引直接进行方法调用 |  
+  
+  
+## 微信公众号  
+  
+### 个人公众号：黄小斜  
+  
+黄小斜是跨考软件工程的 985 硕士，自学 Java 两年，拿到了 BAT 等近十家大厂 offer，从技术小白成长为阿里工程师。  
+  
+作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得和程序人生，目前黄小斜的CSDN博客有百万+访问量，知乎粉丝2W+，全网已有10W+读者。  
+  
+黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！  
+  
+**原创电子书:**  
+关注公众号【黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》  
+  
+**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。  
+  
+**考研复习资料：**  
+计算机考研大礼包，都是我自己考研复习时用的一些复习资料,包括公共课和专业的复习视频，这里也推荐给大家，关注公众号后，后台回复关键字 **“考研”** 即可免费获取。  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20190829222750556.jpg)  
+  
+  
+### 技术公众号：Java技术江湖  
+  
+如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！  
+  
+**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。  
+  
+![我的公众号](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20190805090108984.jpg)
\ No newline at end of file
diff --git "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2206\357\274\232Spring AOP\346\246\202\350\277\260.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232SpringAOP\346\246\202\350\277\260.md"
similarity index 90%
rename from "docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2206\357\274\232Spring AOP\346\246\202\350\277\260.md"
rename to "docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232SpringAOP\346\246\202\350\277\260.md"
index 87e1208..efb7e69 100644
--- "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2206\357\274\232Spring AOP\346\246\202\350\277\260.md"	
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232SpringAOP\346\246\202\350\277\260.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [我们为什么要使用 AOP](#我们为什么要使用-aop)
   * [使用装饰器模式](#使用装饰器模式)
   * [使用代理模式](#使用代理模式)
@@ -467,6 +466,34 @@ public class PermissionHandler {
 后记
 文章演示了从原生代码到使用AOP的过程，一点一点地介绍了每次演化的优缺点，最后以实际例子分析了AOP可以做什么事情。
 
-> 微信公众号【黄小斜】作者是蚂蚁金服 JAVA 工程师，专注于 JAVA
-> 后端技术栈：SpringBoot、SSM全家桶、MySQL、分布式、中间件、微服务，同时也懂点投资理财，坚持学习和写作，相信终身学习的力量！关注公众号后回复”架构师“即可领取
-> Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
+
+
+## 微信公众号
+
+### 个人公众号：黄小斜
+
+黄小斜是跨考软件工程的 985 硕士，自学 Java 两年，拿到了 BAT 等近十家大厂 offer，从技术小白成长为阿里工程师。
+
+作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得和程序人生，目前黄小斜的CSDN博客有百万+访问量，知乎粉丝2W+，全网已有10W+读者。
+
+黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
+
+**原创电子书:**
+关注公众号【黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》
+
+**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。
+
+**考研复习资料：**
+计算机考研大礼包，都是我自己考研复习时用的一些复习资料,包括公共课和专业的复习视频，这里也推荐给大家，关注公众号后，后台回复关键字 **“考研”** 即可免费获取。
+
+![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
+
+
+### 技术公众号：Java技术江湖
+
+如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
+
+**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
+
+![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
+ 
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232SpringIOC\345\256\271\345\231\250\347\232\204\345\212\240\350\275\275\350\277\207\347\250\213.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232SpringIOC\345\256\271\345\231\250\347\232\204\345\212\240\350\275\275\350\277\207\347\250\213.md"
new file mode 100644
index 0000000..1a346f2
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232SpringIOC\345\256\271\345\231\250\347\232\204\345\212\240\350\275\275\350\277\207\347\250\213.md"
@@ -0,0 +1,699 @@
+# 目录
+* [spring ioc 容器的加载流程](#spring-ioc-容器的加载流程)
+* [Spring Ioc Demo](#spring-ioc-demo)
+* [ApplicationContext 继承结构](#applicationcontext-继承结构)
+* [Spring Ioc容器加载过程源码详解](#spring-ioc容器加载过程源码详解)
+* [refresh()方法](#refresh方法)
+  * [调试栈截图](#调试栈截图)
+  * [整体流程](#整体流程)
+  * [bean.xml的处理](#beanxml的处理)
+  * [loadBeanDefinitions](#loadbeandefinitions)
+    * [loadBeanDefinitions: 源码阅读](#loadbeandefinitions-源码阅读)
+* [loadBeanDefinitions](#loadbeandefinitions-1)
+
+
+本文转自五月的仓颉 https://www.cnblogs.com/xrq730
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+文章将同步到我的个人博客：
+> www.how2playlife.com
+
+本文是微信公众号【Java技术江湖】的《Spring和SpringMVC源码分析》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+
+该系列博文会告诉你如何从spring基础入手，一步步地学习spring基础和springmvc的框架知识，并上手进行项目实战，spring框架是每一个Java工程师必须要学习和理解的知识点，进一步来说，你还需要掌握spring甚至是springmvc的源码以及实现原理，才能更完整地了解整个spring技术体系，形成自己的知识框架。
+
+后续还会有springboot和springcloud的技术专题，陆续为大家带来，敬请期待。
+
+为了更好地总结和检验你的学习成果，本系列文章也会提供部分知识点对应的面试题以及参考答案。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+<!-- more -->  
+
+## spring ioc 容器的加载流程
+
+**1.目标：**熟练使用spring，并分析其源码，了解其中的思想。这篇主要介绍spring ioc 容器的加载
+
+**2.前提条件：**会使用debug
+
+**3.源码分析方法：**Intellj idea debug 模式下源码追溯  
+通过ClassPathXmlApplicationContext 进行xml 件的读取，从每个堆栈中读取程序的运行信息
+
+**4.注意：**由于Spring的类继承体系比较复杂,不能全部贴图，所以只将分析源码之后发现的最主要的类继承结构类图贴在下方。
+
+**5.关于Spring Ioc  
+Demo：**我们从demo入手一步步进行代码追溯。
+
+## Spring Ioc Demo
+
+* * *  
+
+> 1.定义数据访问接口IUserDao.java
+
+```  
+public interface IUserDao {    
+    public void InsertUser(String username,String password);  
+}  
+  
+```  
+
+2.定义IUserDao.java实现类IUserDaoImpl.java
+
+```  
+public class UserDaoImpl implements IUserDao {      
+    @Override      
+    public void InsertUser(String username, String password) {   
+        System.out.println("----UserDaoImpl --addUser----");      
+    }  
+}  
+  
+```  
+
+3.定义业务逻辑接口UserService.java
+
+```  
+public interface UserService {      
+    public void addUser(String username,String password);  
+}  
+  
+```  
+
+4.定义UserService.java实现类UserServiceImpl.java
+
+```  
+public class UserServiceImpl implements UserService {      
+    private     IUserDao  userDao;    //set方法    
+    public void  setUserDao(IUserDao  userDao) {          
+        this.userDao = userDao;     
+    }      
+    @Override      
+    public void addUser(String username,String password) {   
+        userDao.InsertUser(username,password);      
+    }  
+}  
+  
+```  
+
+bean.xml配置文件
+
+```  
+<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-3.0.xsd         ">    
+ <!--id名字自己取，class表示他代表的类，如果在包里的话需要加上包名-->      
+ <bean id="userService"  class="UserServiceImpl" >        
+        <!--property代表是通过set方法注入,ref的值表示注入的内容-->  
+        <property  name="userDao"  ref="userDao"/> </bean>      
+  <bean id="userDao"  class="UserDaoImpl"/>  
+</beans>  
+  
+```  
+
+## ApplicationContext 继承结构
+
+* * *  
+
+> 1.顶层接口：ApplicationContext  
+> 2.ClassPathXmlApplicationContext实现类继承AbstractXmlApplication 抽象类  
+> 3.AbstractXmlApplication 继承AbstractRefreshableConfigApplicationContext  
+> 4.AbstractRefreshableConfigApplicationContext抽象类继承AbstractRefreshableApplicationContext  
+> 5.AbstractRefreshableApplicationContext 继承 AbstractApplicationContext  
+> 6.AbstractApplicationContext 实现ConfigurableApplicationContext 接口  
+> 7.ConfigurableApplicationContext 接口继承  
+> ApplicationContext接口  
+> 总体来说继承实现结构较深，内部使用了大量适配器模式。  
+> 以ClassPathXmlApplicationContext为例，继承类图如下图所示：
+>
+> ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825134835291-1628501369.png)
+
+## Spring Ioc容器加载过程源码详解
+
+* * *  
+
+在开始之前，先介绍一个整体的概念。即spring ioc容器的加载，大体上经过以下几个过程：  
+资源文件定位、解析、注册、实例化
+
+> **1.资源文件定位**  
+> 其中资源文件定位，一般是在ApplicationContext的实现类里完成的，因为ApplicationContext接口继承ResourcePatternResolver 接口，ResourcePatternResolver接口继承ResourceLoader接口，ResourceLoader其中的getResource()方法，可以将外部的资源，读取为Resource类。
+
+* * *  
+
+**2.解析**DefaultBeanDefinitionDocumentReader，  
+解析主要是在BeanDefinitionReader中完成的，最常用的实现类是XmlBeanDefinitionReader，其中的loadBeanDefinitions()方法，负责读取Resource，并完成后续的步骤。ApplicationContext完成资源文件定位之后，是将解析工作委托给XmlBeanDefinitionReader来完成的  
+解析这里涉及到很多步骤，最常见的情况，资源文件来自一个XML配置文件。首先是BeanDefinitionReader，将XML文件读取成w3c的Document文档。
+
+
+DefaultBeanDefinitionDocumentReader对Document进行进一步解析。然后DefaultBeanDefinitionDocumentReader又委托给BeanDefinitionParserDelegate进行解析。如果是标准的xml namespace元素，会在Delegate内部完成解析，如果是非标准的xml namespace元素，则会委托合适的NamespaceHandler进行解析最终解析的结果都封装为BeanDefinitionHolder，至此解析就算完成。  
+**后续会进行细致讲解。**
+
+* * *  
+
+**3.注册**  
+然后bean的注册是在BeanFactory里完成的，BeanFactory接口最常见的一个实现类是DefaultListableBeanFactory，它实现了BeanDefinitionRegistry接口，所以其中的registerBeanDefinition()方法，可以对BeanDefinition进行注册这里附带一提，最常见的XmlWebApplicationContext不是自己持有BeanDefinition的，它继承自AbstractRefreshableApplicationContext，其持有一个DefaultListableBeanFactory的字段，就是用它来保存BeanDefinition  
+所谓的注册，其实就是将BeanDefinition的name和实例，保存到一个Map中。
+
+
+刚才说到，最常用的实现DefaultListableBeanFactory，其中的字段就是beanDefinitionMap，是一个ConcurrentHashMap。  
+代码如下：  
+**>1.DefaultListableBeanFactory继承实现关系**
+
+```  
+public class DefaultListableBeanFactory  
+extends AbstractAutowireCapableBeanFactory   implements  
+ConfigurableListableBeanFactory, BeanDefinitionRegistry,  
+Serializable {   
+     // DefaultListableBeanFactory的实例中最终保存了所有注册的bean    beanDefinitionMap  
+     /** Map of bean definition objects, keyed by bean name */     private final Map<String, BeanDefinition> beanDefinitionMap     = new ConcurrentHashMap<String, BeanDefinition>(64);   
+     //实现BeanDefinitionRegistry中定义的registerBeanDefinition()抽象方法  
+     public void registerBeanDefinition(String beanName, BeanDefinition    beanDefinition)      throws BeanDefinitionStoreException {     }  
+```  
+
+**>2.BeanDefinitionRegistry接口**
+
+```  
+public interface BeanDefinitionRegistry extends AliasRegistry {     
+    //定义注册BeanDefinition实例的抽象方法  
+    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)         throws BeanDefinitionStoreException;  
+```  
+
+**4.实例化**
+
+* * *  
+
+注册也完成之后，在BeanFactory的getBean()方法之中，会完成初始化，也就是依赖注入的过程  
+大体上的流程就是这样。
+
+# refresh()方法
+
+> **1.目标：**  
+> 这篇记录debug 追溯源码的过程，大概分三个篇幅，这是第一篇，现整体了解一下运行流程，定位资源加载，资源解析，bean 注册发生的位置。  
+> 2.**记录结构：**  
+> 1.调试栈截图  
+> 2.整体流程  
+> 3.bean.xml的处理  
+> **每段代码下面有相应的讲解**
+
+## 调试栈截图
+
+* * *  
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825134839933-520783623.png)
+
+每个栈帧中方法的行号都有标明，按照行号追溯源码，然后配合教程能够快速学习。
+
+## 整体流程
+
+* * *  
+
+ioc容器实例化代码
+
+```  
+ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");  
+  
+```  
+
+进入代码中一步步追溯，发现重要方法：refresh();  
+如下所示：
+
+```  
+public void refresh() throws BeansException, IllegalStateException {  
+  
+        synchronized (this.startupShutdownMonitor) {            // Prepare this context for refreshing.            prepareRefresh();            //beanFactory实例化方法 单步调试入口  
+            // 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) {                // Destroy already created singletons to avoid dangling resources.                destroyBeans();  
+                // Reset 'active' flag.                cancelRefresh(ex);  
+                // Propagate exception to caller.                throw ex;            }        }    }  
+```  
+
+首先这个方法是同步的，以避免重复刷新。然后刷新的每个步骤，都放在单独的方法里，比较清晰，可以按顺序一个个看
+
+首先是prepareRefresh()方法
+
+```  
+protected void prepareRefresh() {  
+        this.startupDate = System.currentTimeMillis();  
+        synchronized (this.activeMonitor) {            this.active = true;        }  
+        if (logger.isInfoEnabled()) {            logger.info("Refreshing " + this);        }  
+        // Initialize any placeholder property sources in the context environment        initPropertySources();  
+        // Validate that all properties marked as required are resolvable        // see ConfigurablePropertyResolver#setRequiredProperties        this.environment.validateRequiredProperties();    }  
+```  
+
+这个方法里做的事情不多，记录了开始时间，输出日志，另外initPropertySources()方法和validateRequiredProperties()方法一般都没有做什么事。
+
+然后是核心的obtainFreshBeanFactory()方法，这个方法是初始化BeanFactory，是整个refresh()方法的核心，其中完成了配置文件的加载、解析、注册，后面会专门详细说 。
+
+这里要说明一下，ApplicationContext实现了BeanFactory接口，并实现了ResourceLoader、MessageSource等接口，可以认为是增强的BeanFactory。但是ApplicationContext并不自己重复实现BeanFactory定义的方法，而是委托给DefaultListableBeanFactory来实现。这种设计思路也是值得学习的。  
+后面的 prepareBeanFactory()、postProcessBeanFactory()、invokeBeanFactoryPostProcessors()、registerBeanPostProcessors()、initMessageSource()、initApplicationEventMulticaster()、onRefresh()、registerListeners()、finishBeanFactoryInitialization()、finishRefresh()等方法，是添加一些后处理器、广播、拦截器等，就不一个个细说了
+
+其中的关键方法是finishBeanFactoryInitialization()，在这个方法中，会对刚才注册的Bean（不延迟加载的），进行实例化，所以也是一个核心方法。
+
+## bean.xml的处理
+
+* * *  
+
+从整体上介绍完了流程，接下来就重点看obtainFreshBeanFactory()方法，上文说到，在这个方法里，完成了配置文件的加载、解析、注册
+
+```  
+protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {  
+        refreshBeanFactory();        ConfigurableListableBeanFactory beanFactory = getBeanFactory();        if (logger.isDebugEnabled()) {            logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);        }        return beanFactory;    }  
+```  
+
+这个方法做了2件事，首先通过refreshBeanFactory()方法，创建了DefaultListableBeanFactory的实例，并进行初始化。
+
+```  
+protected final void refreshBeanFactory() throws BeansException {  
+        if (hasBeanFactory()) {            destroyBeans();            closeBeanFactory();        }        try {            DefaultListableBeanFactory beanFactory = createBeanFactory();            beanFactory.setSerializationId(getId());            customizeBeanFactory(beanFactory);            loadBeanDefinitions(beanFactory);            synchronized (this.beanFactoryMonitor) {                this.beanFactory = beanFactory;            }        }        catch (IOException ex) {            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);        }    }  
+```  
+
+首先如果已经有BeanFactory实例，就先清空。然后通过createBeanFactory()方法，创建一个DefaultListableBeanFactory的实例
+
+```  
+protected DefaultListableBeanFactory createBeanFactory() {  
+        return new DefaultListableBeanFactory(getInternalParentBeanFactory());    }  
+```  
+
+接下来设置ID唯一标识
+
+```  
+beanFactory.setSerializationId(getId());  
+  
+```  
+
+然后允许用户进行一些自定义的配置
+
+```  
+protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {  
+        if (this.allowBeanDefinitionOverriding != null) {            beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);        }        if (this.allowCircularReferences != null) {            beanFactory.setAllowCircularReferences(this.allowCircularReferences);        }        beanFactory.setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());    }  
+```  
+
+最后，就是核心的loadBeanDefinitions()方法
+
+```  
+protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {  
+        // Create a new XmlBeanDefinitionReader for the given BeanFactory.        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);  
+        // Configure the bean definition reader with this context's        // resource loading environment.        beanDefinitionReader.setEnvironment(this.getEnvironment());        beanDefinitionReader.setResourceLoader(this);        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));  
+        // Allow a subclass to provide custom initialization of the reader,        // then proceed with actually loading the bean definitions.        initBeanDefinitionReader(beanDefinitionReader);        loadBeanDefinitions(beanDefinitionReader);    }  
+```  
+
+这里首先会创建一个XmlBeanDefinitionReader的实例，然后进行初始化。这个XmlBeanDefinitionReader中其实传递的BeanDefinitionRegistry类型的实例，为什么可以传递一个beanFactory呢，因为DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，这里是多态的使用。
+
+```  
+protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {  
+        // Create a new XmlBeanDefinitionReader for the given BeanFactory.        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);  
+        // Configure the bean definition reader with this context's        // resource loading environment.        beanDefinitionReader.setEnvironment(this.getEnvironment());        beanDefinitionReader.setResourceLoader(this);        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));  
+        // Allow a subclass to provide custom initialization of the reader,        // then proceed with actually loading the bean definitions.        initBeanDefinitionReader(beanDefinitionReader);}  
+  
+```  
+
+这里要说明一下，ApplicationContext并不自己负责配置文件的加载、解析、注册，而是将这些工作委托给XmlBeanDefinitionReader来做。
+
+```  
+loadBeanDefinitions(beanDefinitionReader);  
+  
+```  
+
+这行代码，就是Bean定义读取实际发生的地方。这里的工作，主要是XmlBeanDefinitionReader来完成的，下一篇博客会详细介绍这个过程。
+
+## loadBeanDefinitions
+
+### loadBeanDefinitions: 源码阅读
+
+* * *  
+
+入口是loadBeanDefinitions方法
+
+```  
+protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {  
+        String[] configLocations = getConfigLocations();        if (configLocations != null) {            for (String configLocation : configLocations) {                reader.loadBeanDefinitions(configLocation);            }        }}  
+  
+```  
+
+这是解析过程最外围的代码，首先要获取到配置文件的路径，这在之前已经完成了。  
+然后将每个配置文件的路径，作为参数传给BeanDefinitionReader的loadBeanDefinitions方法里
+
+```  
+public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {  
+        return loadBeanDefinitions(location, null);}  
+  
+```  
+
+这个方法又调用了重载方法
+
+```  
+public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {  
+        ResourceLoader resourceLoader = getResourceLoader();        if (resourceLoader == null) {            throw new BeanDefinitionStoreException(                    "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");        }  
+        if (resourceLoader instanceof ResourcePatternResolver) {            // Resource pattern matching available.            try {                Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);                int loadCount = loadBeanDefinitions(resources);                if (actualResources != null) {                    for (Resource resource : resources) {                        actualResources.add(resource);                    }                }                if (logger.isDebugEnabled()) {                    logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");                }                return loadCount;            }            catch (IOException ex) {                throw new BeanDefinitionStoreException(                        "Could not resolve bean definition resource pattern [" + location + "]", ex);            }        }        else {            // Can only load single resources by absolute URL.            Resource resource = resourceLoader.getResource(location);            int loadCount = loadBeanDefinitions(resource);            if (actualResources != null) {                actualResources.add(resource);            }            if (logger.isDebugEnabled()) {                logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");            }            return loadCount;        }    }  
+```  
+
+首先getResourceLoader()的实现的前提条件是因为XmlBeanDefinitionReader在实例化的时候已经确定了创建了实例ResourceLoader实例, 代码位于 AbstractBeanDefinitionReader
+
+```  
+protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {     
+     Assert.notNull(registry, "BeanDefinitionRegistry must not be null");   
+     this.registry = registry;     
+     // Determine ResourceLoader to use.    
+     if (this.registry instanceof ResourceLoader) {       
+         this.resourceLoader = (ResourceLoader) this.registry;     
+      }  else {        
+         this.resourceLoader = new PathMatchingResourcePatternResolver();    
+      }     
+     // Inherit Environment if possible     
+     if (this.registry instanceof EnvironmentCapable) {        
+          this.environment = ((EnvironmentCapable)this.registry).getEnvironment();    
+      }  else {        
+          this.environment = new StandardEnvironment();   
+      }  
+}  
+  
+```  
+
+这个方法比较长，BeanDefinitionReader不能直接加载配置文件，需要把配置文件封装成Resource，然后才能调用重载方法loadBeanDefinitions()。所以这个方法其实就是2段，第一部分是委托ResourceLoader将配置文件封装成Resource，第二部分是调用loadBeanDefinitions()，对Resource进行解析
+
+而这里的ResourceLoader，就是前面的XmlWebApplicationContext，因为ApplicationContext接口，是继承自ResourceLoader接口的
+
+Resource也是一个接口体系，在web环境下，这里就是ServletContextResource
+
+接下来进入重载方法loadBeanDefinitions()
+
+```  
+public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {  
+        Assert.notNull(resources, "Resource array must not be null");        int counter = 0;        for (Resource resource : resources) {            counter += loadBeanDefinitions(resource);        }        return counter;    }  
+```  
+
+这里就不用说了，就是把每一个Resource作为参数，继续调用重载方法。读spring源码，会发现重载方法特别多。
+
+```  
+public int loadBeanDefinitions(Resource resource)  throws  
+ BeanDefinitionStoreException {        return loadBeanDefinitions(new EncodedResource(resource));}  
+  
+```  
+
+还是重载方法，不过这里对传进来的Resource又进行了一次封装，变成了编码后的Resource。
+
+```  
+public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {  
+        Assert.notNull(encodedResource, "EncodedResource must not be null");        if (logger.isInfoEnabled()) {            logger.info("Loading XML bean definitions from " + encodedResource.getResource());        }  
+        Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();        if (currentResources == null) {            currentResources = new HashSet<EncodedResource>(4);            this.resourcesCurrentlyBeingLoaded.set(currentResources);        }        if (!currentResources.add(encodedResource)) {            throw new BeanDefinitionStoreException(                    "Detected cyclic loading of " + encodedResource + " - check your import definitions!");        }        try {            InputStream inputStream = encodedResource.getResource().getInputStream();            try {                InputSource inputSource = new InputSource(inputStream);                if (encodedResource.getEncoding() != null) {                    inputSource.setEncoding(encodedResource.getEncoding());                }                return doLoadBeanDefinitions(inputSource, encodedResource.getResource());            }            finally {                inputStream.close();            }        }        catch (IOException ex) {            throw new BeanDefinitionStoreException(                    "IOException parsing XML document from " + encodedResource.getResource(), ex);        }        finally {            currentResources.remove(encodedResource);            if (currentResources.isEmpty()) {                this.resourcesCurrentlyBeingLoaded.remove();            }        }    }  
+```  
+
+这个就是loadBeanDefinitions()的最后一个重载方法，比较长，可以拆看来看。
+
+```  
+Assert.notNull(encodedResource, "EncodedResource must not be null");  
+        if (logger.isInfoEnabled()) {            logger.info("Loading XML bean definitions from " + encodedResource.getResource());        }  
+        Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();        if (currentResources == null) {            currentResources = new HashSet<EncodedResource>(4);            this.resourcesCurrentlyBeingLoaded.set(currentResources);        }        if (!currentResources.add(encodedResource)) {            throw new BeanDefinitionStoreException(                    "Detected cyclic loading of " + encodedResource + " - check your import definitions!");        }  
+```  
+
+这第一部分，是处理线程相关的工作，把当前正在解析的Resource，设置为当前Resource。
+
+```  
+try {  
+            InputStream inputStream = encodedResource.getResource().getInputStream();            try {                InputSource inputSource = new InputSource(inputStream);                if (encodedResource.getEncoding() != null) {                    inputSource.setEncoding(encodedResource.getEncoding());                }                return doLoadBeanDefinitions(inputSource, encodedResource.getResource());            }            finally {                inputStream.close();            }        }  
+```  
+
+这里是第二部分，是核心，首先把Resource还原为InputStream，然后调用实际解析的方法doLoadBeanDefinitions()。**可以看到，这种命名方式是很值得学习的，一种业务方法，比如parse()，可能需要做一些外围的工作，然后实际解析的方法，可以命名为doParse()。这种doXXX()的命名方法，在很多开源框架中都有应用，比如logback等。**  
+接下来就看一下这个doLoadBeanDefinitions()方法
+
+```  
+protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)  
+            throws BeanDefinitionStoreException {        try {            Document doc = doLoadDocument(inputSource, resource);return registerBeanDefinitions(doc, resource);            return registerBeanDefinitions(doc, resource);        }        catch (BeanDefinitionStoreException ex) {            throw ex;        }        catch (SAXParseException ex) {            throw new XmlBeanDefinitionStoreException(resource.getDescription(),                    "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);        }        catch (SAXException ex) {            throw new XmlBeanDefinitionStoreException(resource.getDescription(),                    "XML document from " + resource + " is invalid", ex);        }        catch (ParserConfigurationException ex) {            throw new BeanDefinitionStoreException(resource.getDescription(),                    "Parser configuration exception parsing XML from " + resource, ex);        }        catch (IOException ex) {            throw new BeanDefinitionStoreException(resource.getDescription(),                    "IOException parsing XML document from " + resource, ex);        }        catch (Throwable ex) {            throw new BeanDefinitionStoreException(resource.getDescription(),                    "Unexpected exception parsing XML document from " + resource, ex);        }    }  
+```  
+
+抛开异常处理：核心代码如下：
+
+```  
+ Document doc = doLoadDocument(inputSource, resource); return  registerBeanDefinitions(doc, resource);  
+```  
+
+doLoadDocument方法将InputStream读取成标准的Document对象，然后调用registerBeanDefinitions()，进行解析工作。
+
+```  
+protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {     
+    return this.documentLoader.loadDocument(inputSource,    
+                                            getEntityResolver(), this.errorHandler,    
+                                            getValidationModeForResource(resource),    
+                                            isNamespaceAware());  
+}  
+  
+```  
+
+接下来就看一下这个核心方法registerBeanDefinitions
+
+```  
+public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {  
+        //创建的其实是DefaultBeanDefinitionDocumentReader 的实例，利用反射创建的。  
+        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();        documentReader.setEnvironment(this.getEnvironment());        int countBefore = getRegistry().getBeanDefinitionCount();        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));        return getRegistry().getBeanDefinitionCount() - countBefore;}  
+  
+```  
+
+**这里注意两点 :**
+
+> **1.Document对象**  
+> 首先这个Document对象，是W3C定义的标准XML对象，跟spring无关。其次这个registerBeanDefinitions方法，我觉得命名有点误导性。因为这个时候实际上解析还没有开始，怎么直接就注册了呢。比较好的命名，我觉得可以是parseAndRegisterBeanDefinitions()。  
+> **2.documentReader的创建时使用反射创建的，代码如下**
+
+```  
+protected BeanDefinitionDocumentReader      
+ createBeanDefinitionDocumentReader() {     
+          return BeanDefinitionDocumentReader.class.cast(BeanUtils.  
+            instantiateClass(this.documentReaderClass));}  
+  
+```  
+
+instantiateClass方法中传入了一个Class类型的参数。追溯发现下述代码：
+
+```  
+private Class<?> documentReaderClass = DefaultBeanDefinitionDocumentReader.class;  
+  
+```  
+
+所以创建的documentReaderClass是DefaultBeanDefinitionDocumentReader类的实例。  
+接下来就进入BeanDefinitionDocumentReader 中定义的registerBeanDefinitions()方法看看
+
+```  
+public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {  
+        this.readerContext = readerContext;        logger.debug("Loading bean definitions");        Element root = doc.getDocumentElement();        doRegisterBeanDefinitions(root);    }  
+```  
+
+处理完外围事务之后，进入doRegisterBeanDefinitions()方法，这种命名规范，上文已经介绍过了
+
+```  
+protected void doRegisterBeanDefinitions(Element root) {  
+        String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);        if (StringUtils.hasText(profileSpec)) {            Assert.state(this.environment != null, "environment property must not be null");            String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);            if (!this.environment.acceptsProfiles(specifiedProfiles)) {                return;            }        }        // any nested <beans> elements will cause recursion in this method. In        // order to propagate and preserve <beans> default-* attributes correctly,        // keep track of the current (parent) delegate, which may be null. Create        // the new (child) delegate with a reference to the parent for fallback purposes,        // then ultimately reset this.delegate back to its original (parent) reference.        // this behavior emulates a stack of delegates without actually necessitating one.        BeanDefinitionParserDelegate parent = this.delegate;        this.delegate = createHelper(readerContext, root, parent);        preProcessXml(root);        parseBeanDefinitions(root, this.delegate);        postProcessXml(root);        this.delegate = parent;}  
+  
+```  
+
+这个方法也比较长，拆开来看
+
+```  
+String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);  
+        if (StringUtils.hasText(profileSpec)) {            Assert.state(this.environment != null, "environment property must not be null");            String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);            if (!this.environment.acceptsProfiles(specifiedProfiles)) {                return;            }}  
+  
+```  
+
+如果配置文件中元素，配有profile属性，就会进入这一段，不过一般都是不会的
+
+```  
+        BeanDefinitionParserDelegate parent = this.delegate;        this.delegate = createHelper(readerContext, root, parent);        preProcessXml(root);        parseBeanDefinitions(root, this.delegate);        postProcessXml(root);        this.delegate = parent;  
+```  
+
+然后这里创建了BeanDefinitionParserDelegate对象，preProcessXml()和postProcessXml()都是空方法，核心就是parseBeanDefinitions()方法。这里又把BeanDefinition解析和注册的工作，委托给了BeanDefinitionParserDelegate对象，在parseBeanDefinitions()方法中完成  
+总的来说，解析工作的委托链是这样的：ClassPathXmlApplicationContext，XmlBeanDefinitionReader，DefaultBeanDefinitionDocumentReader，BeanDefinitionParserDelegate  
+ClassPathXmlApplicationContext作为最外围的组件，发起解析的请求  
+XmlBeanDefinitionReader将配置文件路径封装为Resource，读取出w3c定义的Document对象，然后委托给DefaultBeanDefinitionDocumentReader  
+DefaultBeanDefinitionDocumentReader就开始做实际的解析工作了，但是涉及到bean的具体解析，它还是会继续委托给BeanDefinitionParserDelegate来做。  
+接下来在parseBeanDefinitions()方法中发生了什么，以及BeanDefinitionParserDelegate类完成的工作，在下一篇博客中继续介绍。
+
+# loadBeanDefinitions
+
+> BeanDefinition的解析,已经走到了DefaultBeanDefinitionDocumentR  
+> eader里，这时候配置文件已经被加载，并解析成w3c的Document对象。这篇博客就接着介绍，DefaultBeanDefinitionDocumentReader和BeanDefinitionParserDelegate类，是怎么协同完成bean的解析和注册的。
+
+```  
+        BeanDefinitionParserDelegate parent = this.delegate;        this.delegate = createHelper(readerContext, root, parent);        preProcessXml(root);        parseBeanDefinitions(root, this.delegate);        postProcessXml(root);        this.delegate = parent;  
+```  
+
+这段代码，创建了一个BeanDefinitionParserDelegate组件，然后就是preProcessXml()、parseBeanDefinitions()、postProcessXml()方法  
+其中preProcessXml()和postProcessXml()默认是空方法，接下来就看下parseBeanDefinitions()方法
+
+```  
+protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {  
+        if (delegate.isDefaultNamespace(root)) {            NodeList nl = root.getChildNodes();            for (int i = 0; i < nl.getLength(); i++) {                Node node = nl.item(i);                if (node instanceof Element) {                    Element ele = (Element) node;                    if (delegate.isDefaultNamespace(ele)) {                        parseDefaultElement(ele, delegate);                    }                    else {                        delegate.parseCustomElement(ele);                    }                }            }        }        else {            delegate.parseCustomElement(root);        }    }  
+```  
+
+从这个方法开始，BeanDefinitionParserDelegate就开始发挥作用了，判断当前解析元素是否属于默认的命名空间，如果是的话，就调用parseDefaultElement()方法，否则调用delegate上parseCustomElement()方法
+
+```  
+public boolean isDefaultNamespace(String namespaceUri) {  
+        return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri));    }    public boolean isDefaultNamespace(Node node) {        return isDefaultNamespace(getNamespaceURI(node));    }  
+```  
+
+只有**[http://www.springframework.org/schema/beans](https://link.jianshu.com/?t=http://www.springframework.org/schema/beans)**，会被认为是默认的命名空间。也就是说，beans、bean这些元素，会认为属于默认的命名空间，而像task:scheduled这些，就认为不属于默认命名空间。  
+根节点beans的一个子节点bean，是属于默认命名空间的，所以会进入parseDefaultElement()方法
+
+```  
+private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {  
+        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {            importBeanDefinitionResource(ele);        }        else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {            processAliasRegistration(ele);        }        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {            processBeanDefinition(ele, delegate);        }        else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {            // recurse            doRegisterBeanDefinitions(ele);        }    }  
+```  
+
+这里可能会有4种情况，import、alias、bean、beans，分别有一个方法与之对应，这里解析的是bean元素，所以会进入processBeanDefinition()方法
+
+```  
+protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {  
+        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);        if (bdHolder != null) {            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);            try {                // Register the final decorated instance.                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());            }            catch (BeanDefinitionStoreException ex) {                getReaderContext().error("Failed to register bean definition with name '" +                        bdHolder.getBeanName() + "'", ele, ex);            }            // Send registration event.            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));        }    }  
+```  
+
+这里主要有3个步骤，先是委托delegate对bean进行解析，然后委托delegate对bean进行装饰，最后由一个工具类来完成BeanDefinition的注册  
+可以看出来，DefaultBeanDefinitionDocumentReader不负责任何具体的bean解析，它面向的是xml Document对象，根据其元素的命名空间和名称，起一个类似路由的作用（不过，命名空间的判断，也是委托给delegate来做的）。所以这个类的命名，是比较贴切的，突出了其面向Document的特性。具体的工作，是由BeanDefinitionParserDelegate来完成的  
+下面就看下parseBeanDefinitionElement()方法
+
+```  
+public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {  
+        String id = ele.getAttribute(ID_ATTRIBUTE);        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);        List<String> aliases = new ArrayList<String>();        if (StringUtils.hasLength(nameAttr)) {            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);            aliases.addAll(Arrays.asList(nameArr));        }        String beanName = id;        if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {            beanName = aliases.remove(0);            if (logger.isDebugEnabled()) {                logger.debug("No XML 'id' specified - using '" + beanName +                        "' as bean name and " + aliases + " as aliases");            }        }        if (containingBean == null) {            checkNameUniqueness(beanName, aliases, ele);        }        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);        if (beanDefinition != null) {            if (!StringUtils.hasText(beanName)) {                try {                    if (containingBean != null) {                        beanName = BeanDefinitionReaderUtils.generateBeanName(                                beanDefinition, this.readerContext.getRegistry(), true);                    }                    else {                        beanName = this.readerContext.generateBeanName(beanDefinition);                        // Register an alias for the plain bean class name, if still possible,                        // if the generator returned the class name plus a suffix.                        // This is expected for Spring 1.2/2.0 backwards compatibility.                        String beanClassName = beanDefinition.getBeanClassName();                        if (beanClassName != null &&                                beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&                      !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {                            aliases.add(beanClassName);                        }                    }                    if (logger.isDebugEnabled()) {                        logger.debug("Neither XML 'id' nor 'name' specified - " +                                "using generated bean name [" + beanName + "]");                    }                }                catch (Exception ex) {                    error(ex.getMessage(), ele);                    return null;                }            }            String[] aliasesArray = StringUtils.toStringArray(aliases);            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);        }        return null;    }  
+```  
+
+这个方法很长，可以分成三段来看
+
+```  
+String id = ele.getAttribute(ID_ATTRIBUTE);  
+        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);        List<String> aliases = new ArrayList<String>();        if (StringUtils.hasLength(nameAttr)) {            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);            aliases.addAll(Arrays.asList(nameArr));        }        String beanName = id;        if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {            beanName = aliases.remove(0);            if (logger.isDebugEnabled()) {                logger.debug("No XML 'id' specified - using '" + beanName +                        "' as bean name and " + aliases + " as aliases");            }        }        if (containingBean == null) {            checkNameUniqueness(beanName, aliases, ele);        }  
+```  
+
+这一段，主要是处理一些跟alias，id等标识相关的东西
+
+```  
+AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);  
+  
+```  
+
+这一行是核心，进行实际的解析
+
+```  
+if (beanDefinition != null) {  
+            if (!StringUtils.hasText(beanName)) {                try {                    if (containingBean != null) {                        beanName = BeanDefinitionReaderUtils.generateBeanName(                                beanDefinition, this.readerContext.getRegistry(), true);                    }                    else {                        beanName = this.readerContext.generateBeanName(beanDefinition);                        // Register an alias for the plain bean class name, if still possible,                        // if the generator returned the class name plus a suffix.                        // This is expected for Spring 1.2/2.0 backwards compatibility.                        String beanClassName = beanDefinition.getBeanClassName();                        if (beanClassName != null &&                                beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&                                !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {                            aliases.add(beanClassName);                        }                    }                    if (logger.isDebugEnabled()) {                        logger.debug("Neither XML 'id' nor 'name' specified - " +                                "using generated bean name [" + beanName + "]");                    }                }                catch (Exception ex) {                    error(ex.getMessage(), ele);                    return null;                }            }            String[] aliasesArray = StringUtils.toStringArray(aliases);            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);        }  
+```  
+
+这段是后置处理，对beanName进行处理  
+前置处理和后置处理，不是核心，就不细看了，重点看下核心的那一行调用
+
+```  
+public AbstractBeanDefinition parseBeanDefinitionElement(  
+            Element ele, String beanName, BeanDefinition containingBean) {        this.parseState.push(new BeanEntry(beanName));        String className = null;        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();        }        try {            String parent = null;            if (ele.hasAttribute(PARENT_ATTRIBUTE)) {                parent = ele.getAttribute(PARENT_ATTRIBUTE);            }            AbstractBeanDefinition bd = createBeanDefinition(className, parent);            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));            parseMetaElements(ele, bd);            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());            parseReplacedMethodSubElements(ele,   bd.getMethodOverrides());            parseConstructorArgElements(ele, bd);            parsePropertyElements(ele, bd);            parseQualifierElements(ele, bd);            bd.setResource(this.readerContext.getResource());            bd.setSource(extractSource(ele));            return bd;        }        catch (ClassNotFoundException ex) {            error("Bean class [" + className + "] not found", ele, ex);        }        catch (NoClassDefFoundError err) {            error("Class that bean class [" + className + "] depends on not found", ele, err);        }        catch (Throwable ex) {            error("Unexpected failure during bean definition parsing", ele, ex);        }        finally {            this.parseState.pop();        }        return null;    }  
+```  
+
+这个方法也挺长的，拆开看看
+
+```  
+this.parseState.push(new BeanEntry(beanName));  
+        String className = null;        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();        }  
+```  
+
+这段是从配置中抽取出类名。接下来的长长一段，把异常处理先抛开，看看实际的业务
+
+```  
+            String parent = null;            if (ele.hasAttribute(PARENT_ATTRIBUTE)) {                parent = ele.getAttribute(PARENT_ATTRIBUTE);            }            AbstractBeanDefinition bd = createBeanDefinition(className, parent);            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));  
+            parseMetaElements(ele, bd);            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());            parseConstructorArgElements(ele, bd);            parsePropertyElements(ele, bd);            parseQualifierElements(ele, bd);            bd.setResource(this.readerContext.getResource());            bd.setSource(extractSource(ele));            return bd;  
+```  
+
+这里每个方法的命名，就说明了是要干什么，可以一个个跟进去看，本文就不细说了。总之，经过这里的解析，就得到了一个完整的BeanDefinitionHolder。只是说明一下，如果在配置文件里，没有对一些属性进行设置，比如autowire-candidate等，那么这个解析生成的BeanDefinition，都会得到一个默认值  
+**然后，对这个Bean做一些必要的装饰**
+
+```  
+public BeanDefinitionHolder decorateBeanDefinitionIfRequired(  
+            Element ele, BeanDefinitionHolder definitionHolder, BeanDefinition containingBd) {        BeanDefinitionHolder finalDefinition = definitionHolder;        // Decorate based on custom attributes first.        NamedNodeMap attributes = ele.getAttributes();        for (int i = 0; i < attributes.getLength(); i++) {            Node node = attributes.item(i);            finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);        }        // Decorate based on custom nested elements.        NodeList children = ele.getChildNodes();        for (int i = 0; i < children.getLength(); i++) {            Node node = children.item(i);            if (node.getNodeType() == Node.ELEMENT_NODE) {                finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);            }        }        return finalDefinition;    }  
+```  
+
+持续单步调试，代码继续运行到DefaultBeanDefinitionDocumentReader中的processBeanDefinition中的registerBeanDefinition()
+
+```  
+BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());  
+  
+```  
+
+单步进入代码发现BeanDefinitionReaderUtils静态方法registerBeanDefinition()
+
+```  
+public static void registerBeanDefinition(  
+            BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)            throws BeanDefinitionStoreException {        // Register bean definition under primary name.        String beanName = definitionHolder.getBeanName();        // 其实调用的是DefaultListableBeanFactory中的registerBeanDefinition方法  
+        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());        // Register aliases for bean name, if any.        String[] aliases = definitionHolder.getAliases();        if (aliases != null) {            for (String aliase : aliases) {                registry.registerAlias(beanName, aliase);            }        }    }  
+```  
+
+解释一下**其实调用的是DefaultListableBeanFactory中的registerBeanDefinition方法**这句话，因为DefaultListableBeanFactory实现BeanDefinitionRegistry接口，BeanDefinitionRegistry接口中定义了registerBeanDefinition()方法  
+看下DefaultListableBeanFactory中registerBeanDefinition()实例方法的具体实现：
+
+```  
+public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)  
+            throws BeanDefinitionStoreException {        Assert.hasText(beanName, "Bean name must not be empty");        Assert.notNull(beanDefinition, "BeanDefinition must not be null");        if (beanDefinition instanceof AbstractBeanDefinition) {            try {                ((AbstractBeanDefinition) beanDefinition).validate();            }            catch (BeanDefinitionValidationException ex) {                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,                        "Validation of bean definition failed", ex);            }        }        synchronized (this.beanDefinitionMap) {            Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);            if (oldBeanDefinition != null) {                if (!this.allowBeanDefinitionOverriding) {                    throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,                            "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +                            "': There is already [" + oldBeanDefinition + "] bound.");                }                else {                    if (this.logger.isInfoEnabled()) {                        this.logger.info("Overriding bean definition for bean '" + beanName +                                "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");                    }                }            }            else {                this.beanDefinitionNames.add(beanName);                this.frozenBeanDefinitionNames = null;            }            this.beanDefinitionMap.put(beanName, beanDefinition);            resetBeanDefinition(beanName);        }    }  
+```  
+
+代码追溯之后发现这个方法里，最关键的是以下2行：
+
+```  
+this.beanDefinitionNames.add(beanName);  
+this.beanDefinitionMap.put(beanName, beanDefinition);  
+  
+```  
+
+前者是把beanName放到队列里，后者是把BeanDefinition放到map中，到此注册就完成了。在后面实例化的时候，就是把beanDefinitionMap中的BeanDefinition取出来，逐一实例化  
+BeanFactory准备完毕之后，代码又回到了ClassPathXmlApplicationContext里
+
+```  
+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) {                // Destroy already created singletons to avoid dangling resources.                destroyBeans();                // Reset 'active' flag.                cancelRefresh(ex);                // Propagate exception to caller.                throw ex;            }        }    }  
+```  
+
+也就是obtainFreshBeanFactory()方法执行之后，再进行下面的步骤。  
+总结来说，ApplicationContext将解析配置文件的工作委托给BeanDefinitionReader，然后BeanDefinitionReader将配置文件读取为xml的Document文档之后，又委托给BeanDefinitionDocumentReader  
+BeanDefinitionDocumentReader这个组件是根据xml元素的命名空间和元素名，起到一个路由的作用，实际的解析工作，是委托给BeanDefinitionParserDelegate来完成的。
+
+
+BeanDefinitionParserDelegate的解析工作完成以后，会返回BeanDefinitionHolder给BeanDefinitionDocumentReader，在这里，会委托给DefaultListableBeanFactory完成bean的注册  
+XmlBeanDefinitionReader（计数、解析XML文档），BeanDefinitionDocumentReader（依赖xml文档，进行解析和注册），BeanDefinitionParserDelegate（实际的解析工作）。
+
+
+可以看出，在解析bean的过程中，这3个组件的分工是比较清晰的，各司其职，这种设计思想值得学习  
+到此为止，bean的解析、注册、spring ioc 容器的实例化过程就基本分析结束了。
+
+
+## 微信公众号
+
+### 个人公众号：黄小斜
+
+黄小斜是跨考软件工程的 985 硕士，自学 Java 两年，拿到了 BAT 等近十家大厂 offer，从技术小白成长为阿里工程师。
+
+作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得和程序人生，目前黄小斜的CSDN博客有百万+访问量，知乎粉丝2W+，全网已有10W+读者。
+
+黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
+
+**原创电子书:**  
+关注公众号【黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》
+
+**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。
+
+**考研复习资料：**  
+计算机考研大礼包，都是我自己考研复习时用的一些复习资料,包括公共课和专业的复习视频，这里也推荐给大家，关注公众号后，后台回复关键字 **“考研”** 即可免费获取。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20190829222750556.jpg)
+
+
+### 技术公众号：Java技术江湖
+
+如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
+
+**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
+
+![我的公众号](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20190805090108984.jpg)
\ No newline at end of file
diff --git "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2208\357\274\232Spring\344\272\213\345\212\241\346\246\202\350\277\260.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232Spring\344\272\213\345\212\241\346\246\202\350\277\260.md"
similarity index 91%
rename from "docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2208\357\274\232Spring\344\272\213\345\212\241\346\246\202\350\277\260.md"
rename to "docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232Spring\344\272\213\345\212\241\346\246\202\350\277\260.md"
index bbf94f7..8659a0d 100644
--- "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2208\357\274\232Spring\344\272\213\345\212\241\346\246\202\350\277\260.md"
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232Spring\344\272\213\345\212\241\346\246\202\350\277\260.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [数据库事务概述](#数据库事务概述)
     * [事务类型](#事务类型)
     * [Spring提供的事务管理](#spring提供的事务管理)
@@ -15,8 +14,7 @@
     * [声明式实现事务管理](#声明式实现事务管理)
     * [@Transactional实现事务管理](#transactional实现事务管理)
 
-
-原文出处： [张开涛](http://sishuok.com/forum/blogPost/list/0/2508.html)
+原文出处：[张开涛](http://sishuok.com/forum/blogPost/list/0/2508.html)
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -104,7 +102,7 @@ spring所有的事务管理策略类都继承自org.springframework.transaction.
 
 ## 事务隔离级别
 
-  隔离级别是指若干个并发的事务之间的隔离程度。TransactionDefinition 接口中定义了五个表示隔离级别的常量：
+ 隔离级别是指若干个并发的事务之间的隔离程度。TransactionDefinition 接口中定义了五个表示隔离级别的常量：
 
 *   TransactionDefinition.ISOLATION_DEFAULT：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是TransactionDefinition.ISOLATION_READ_COMMITTED。
 *   TransactionDefinition.ISOLATION_READ_UNCOMMITTED：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读，不可重复读和幻读，因此很少使用该隔离级别。比如PostgreSQL实际上并没有此级别。
@@ -114,7 +112,7 @@ spring所有的事务管理策略类都继承自org.springframework.transaction.
 
 ## 事务传播行为
 
-      所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在TransactionDefinition定义中包括了如下几个表示传播行为的常量：
+   所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在TransactionDefinition定义中包括了如下几个表示传播行为的常量：
 
 *   TransactionDefinition.PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。
 *   TransactionDefinition.PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。
@@ -126,13 +124,13 @@ spring所有的事务管理策略类都继承自org.springframework.transaction.
 
 ### 事务超时
 
-      所谓事务超时，就是指一个事务所允许执行的最长时间，如果超过该时间限制但事务还没有完成，则自动回滚事务。在 TransactionDefinition 中以 int 的值来表示超时时间，其单位是秒。
+  所谓事务超时，就是指一个事务所允许执行的最长时间，如果超过该时间限制但事务还没有完成，则自动回滚事务。在 TransactionDefinition 中以 int 的值来表示超时时间，其单位是秒。
 
-  默认设置为底层事务系统的超时值，如果底层数据库事务系统没有设置超时值，那么就是none，没有超时限制。
+ 默认设置为底层事务系统的超时值，如果底层数据库事务系统没有设置超时值，那么就是none，没有超时限制。
 
 ### 事务只读属性
 
-      只读事务用于客户代码只读但不修改数据的情形，只读事务用于特定情景下的优化，比如使用Hibernate的时候。
+  只读事务用于客户代码只读但不修改数据的情形，只读事务用于特定情景下的优化，比如使用Hibernate的时候。
 
 默认为读写事务。
 
@@ -215,8 +213,7 @@ Spring提供了许多内置事务管理器实现：
 *   WebLogicJtaTransactionManager：位于org.springframework.transaction.jta包中，Spring提供的对WebLogic 8.1+应用服务器事务管理器的适配器，此适配器用于对应用服务器提供的高级事务的支持。
 
 Spring不仅提供这些事务管理器，还提供对如JMS事务管理的管理器等，Spring提供一致的事务抽象如图9-1所示。
-![](https://segmentfault.com/img/remote/1460000020178870?w=816&h=435)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405190404.png)
 图9-1 Spring事务管理器
 
 接下来让我们学习一下如何在Spring配置文件中定义事务管理器：
@@ -614,3 +611,34 @@ Spring提供的@Transactional 注解事务管理内部同样利用环绕通知Tr
 
 在使用Spring代理时，默认只有在public可见度的方法的@Transactional 注解才是有效的，其它可见度（protected、private、包可见）的方法上即使有@Transactional
 注解也不会应用这些事务属性的，Spring也不会报错，如果你非要使用非公共方法注解事务管理的话，可考虑使用AspectJ。
+
+
+## 微信公众号
+
+### 个人公众号：黄小斜
+
+黄小斜是跨考软件工程的 985 硕士，自学 Java 两年，拿到了 BAT 等近十家大厂 offer，从技术小白成长为阿里工程师。
+
+作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得和程序人生，目前黄小斜的CSDN博客有百万+访问量，知乎粉丝2W+，全网已有10W+读者。
+
+黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
+
+**原创电子书:**
+关注公众号【黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》
+
+**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。
+
+**考研复习资料：**
+计算机考研大礼包，都是我自己考研复习时用的一些复习资料,包括公共课和专业的复习视频，这里也推荐给大家，关注公众号后，后台回复关键字 **“考研”** 即可免费获取。
+
+![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
+
+
+### 技术公众号：Java技术江湖
+
+如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
+
+**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
+
+![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
+ 
diff --git "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2209\357\274\232Spring\344\272\213\345\212\241\346\272\220\347\240\201\345\211\226\346\236\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232Spring\344\272\213\345\212\241\346\272\220\347\240\201\345\211\226\346\236\220.md"
similarity index 52%
rename from "docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2209\357\274\232Spring\344\272\213\345\212\241\346\272\220\347\240\201\345\211\226\346\236\220.md"
rename to "docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232Spring\344\272\213\345\212\241\346\272\220\347\240\201\345\211\226\346\236\220.md"
index 829f645..8dd4664 100644
--- "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2209\357\274\232Spring\344\272\213\345\212\241\346\272\220\347\240\201\345\211\226\346\236\220.md"
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232Spring\344\272\213\345\212\241\346\272\220\347\240\201\345\211\226\346\236\220.md"
@@ -1,12 +1,11 @@
-# Table of Contents
-
-  * [声明式事务使用](#声明式事务使用)
-  * [TxNamespaceHandler](#txnamespacehandler)
-  * [注册事务功能bean](#注册事务功能bean)
-  * [使用bean的后处理方法获取增强器](#使用bean的后处理方法获取增强器)
-  * [Spring获取匹配的增强器](#spring获取匹配的增强器)
-  * [Transactional注解](#transactional注解)
-  * [开启事务过程](#开启事务过程)
+# 目录
+* [声明式事务使用](#声明式事务使用)
+* [TxNamespaceHandler](#txnamespacehandler)
+* [注册事务功能bean](#注册事务功能bean)
+* [使用bean的后处理方法获取增强器](#使用bean的后处理方法获取增强器)
+* [Spring获取匹配的增强器](#spring获取匹配的增强器)
+* [Transactional注解](#transactional注解)
+* [开启事务过程](#开启事务过程)
 
 
 转自：http://www.linkedkeeper.com/detail/blog.action?bid=1045
@@ -29,246 +28,271 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 ## 声明式事务使用
 
 Spring事务是我们日常工作中经常使用的一项技术，Spring提供了编程、注解、aop切面三种方式供我们使用Spring事务，其中编程式事务因为对代码入侵较大所以不被推荐使用，注解和aop切面的方式可以基于需求自行选择，我们以注解的方式为例来分析Spring事务的原理和源码实现。
 
 首先我们简单看一下Spring事务的使用方式，配置：
 
+```  
+<tx:annotation-driven transaction-manager="transactionManager"/>  
+ <bean id="transactionManager"         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
+     <property name="dataSource" ref="dataSource"/> </bean>```  
+  
+在需要开启事务的方法上加上@Transactional注解即可，这里需要注意的是，当<tx:annotation-driven>标签在不指定transaction-manager属性的时候，会默认寻找id固定名为transactionManager的bean作为事务管理器，如果没有id为transactionManager的bean并且在使用@Transactional注解时也没有指定value（事务管理器），程序就会报错。当我们在配置两个以上的<tx:annotation-driven>标签时，如下：</tx:annotation-driven></tx:annotation-driven>  
 ```
-<tx:annotation-driven transaction-manager="transactionManager"/>
- <bean id="transactionManager" 
-         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
-     <property name="dataSource" ref="dataSource"/>
- </bean>
-```
-
-在需要开启事务的方法上加上@Transactional注解即可，这里需要注意的是，当<tx:annotation-driven>标签在不指定transaction-manager属性的时候，会默认寻找id固定名为transactionManager的bean作为事务管理器，如果没有id为transactionManager的bean并且在使用@Transactional注解时也没有指定value（事务管理器），程序就会报错。当我们在配置两个以上的<tx:annotation-driven>标签时，如下：</tx:annotation-driven></tx:annotation-driven>
-
 ```
-    <tx:annotation-driven transaction-manager="transactionManager1"/>
-<bean id="transactionManager1" 
-        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
-    <property name="dataSource" ref="dataSource1"/>
-</bean>
-<tx:annotation-driven transaction-manager="transactionManager2"/>
-<bean id="transactionManager2" 
-        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
-    <property name="dataSource" ref="dataSource2"/>
-</bean>
-```
-
-这时第一个<tx:annotation-driven>会生效，也就是当我们使用@Transactional注解时不指定事务管理器，默认使用的事务管理器是transactionManager1，后文分析源码时会具体提到这些注意点。</tx:annotation-driven>
-
-下面我们开始分析Spring的相关源码，首先看一下对<tx:annotation-driven>标签的解析，这里需要读者对Spring自定义标签解析的过程有一定的了解，笔者后续也会出相关的文章。锁定TxNamespaceHandler：</tx:annotation-driven>
-
-## TxNamespaceHandler
-
-(右键可查看大图)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142033158-801757952.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142035853-1216561547.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142050711-1788774364.jpg)
-
-## 注册事务功能bean
-
-这个方法比较长，关键的部分做了标记，最外围的if判断限制了<tx:annotation-driven>标签只能被解析一次，所以只有第一次被解析的标签会生效。蓝色框的部分分别注册了三个BeanDefinition，分别为AnnotationTransactionAttributeSource、TransactionInterceptor和BeanFactoryTransactionAttributeSourceAdvisor，并将前两个BeanDefinition添加到第三个BeanDefinition的属性当中，这三个bean支撑了整个事务功能，后面会详细说明。我们先来看红色框的第个方法：</tx:annotation-driven>
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142052962-1382540518.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142056340-212555152.jpg)
-
-还记得当<tx:annotation-driven>标签在不指定transaction-manager属性的时候，会默认寻找id固定名为transactionManager的bean作为事务管理器这个注意事项么，就是在这里实现的。下面我们来看红色框的第二个方法：</tx:annotation-driven>
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142058845-60551057.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142100099-521338949.jpg)
-
-这两个方法的主要目的是注册InfrastructureAdvisorAutoProxyCreator，注册这个类的目的是什么呢？我们看下这个类的层次：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142103625-1672142980.jpg)
-
-## 使用bean的后处理方法获取增强器
-
-我们发现这个类间接实现了BeanPostProcessor接口，我们知道，Spring会保证所有bean在实例化的时候都会调用其postProcessAfterInitialization方法，我们可以使用这个方法包装和改变bean，而真正实现这个方法是在其父类AbstractAutoProxyCreator类中：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142105124-1636877804.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142112838-373935120.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142114588-713887840.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142118835-2064313605.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142119676-1959254739.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142131238-2064733556.jpg)
-
-上面这个方法相信大家已经看出了它的目的，先找出所有对应Advisor的类的beanName，再通过beanFactory.getBean方法获取这些bean并返回。不知道大家还是否记得在文章开始的时候提到的三个类，其中BeanFactoryTransactionAttributeSourceAdvisor实现了Advisor接口，所以这个bean就会在此被提取出来，而另外两个bean被织入了BeanFactoryTransactionAttributeSourceAdvisor当中，所以也会一起被提取出来，下图为BeanFactoryTransactionAttributeSourceAdvisor类的层次：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142136219-556507874.jpg)
-
-## Spring获取匹配的增强器
-
-下面让我们来看Spring如何在所有候选的增强器中获取匹配的增强器：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142138356-655521572.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142145927-1806310557.jpg)
-
-上面的方法中提到引介增强的概念，在此做简要说明，引介增强是一种比较特殊的增强类型，它不是在目标方法周围织入增强，而是为目标类创建新的方法和属性，所以引介增强的连接点是类级别的，而非方法级别的。通过引介增强，我们可以为目标类添加一个接口的实现，即原来目标类未实现某个接口，通过引介增强可以为目标类创建实现该接口的代理，使用方法可以参考文末的引用链接。另外这个方法用两个重载的canApply方法为目标类寻找匹配的增强器，其中第一个canApply方法会调用第二个canApply方法并将第三个参数传为false：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142150013-1860771847.jpg)
-
-在上面BeanFactoryTransactionAttributeSourceAdvisor类的层次中我们看到它实现了PointcutAdvisor接口，所以会调用红框中的canApply方法进行判断，第一个参数pca.getPointcut()也就是调用BeanFactoryTransactionAttributeSourceAdvisor的getPointcut方法：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142156819-1296874034.jpg)
-
-这里的transactionAttributeSource也就是我们在文章开始看到的为BeanFactoryTransactionAttributeSourceAdvisor织入的两个bean中的AnnotationTransactionAttributeSource，我们以TransactionAttributeSourcePointcut作为第一个参数继续跟踪canApply方法：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142204505-259300568.jpg)
-
-我们跟踪pc.getMethodMatcher()方法也就是TransactionAttributeSourcePointcut的getMethodMatcher方法是在它的父类中实现：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142208118-661649181.jpg)
-
-发现方法直接返回this，也就是下面methodMatcher.matches方法就是调用TransactionAttributeSourcePointcut的matches方法：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142210658-52846138.jpg)
-
-在上面我们看到其实这个tas就是AnnotationTransactionAttributeSource，这里的目的其实也就是判断我们的业务方法或者类上是否有@Transactional注解，跟踪AnnotationTransactionAttributeSource的getTransactionAttribute方法：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142219647-1040649746.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142229849-1651021110.jpg)
-
-方法中的事务声明优先级最高，如果方法上没有声明则在类上寻找：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142231850-1851923561.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142233762-127153561.jpg)
-
-this.annotationParsers是在AnnotationTransactionAttributeSource类初始化的时候初始化的：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142238658-1305833682.jpg)
-
-所以annotationParser.parseTransactionAnnotation就是调用SpringTransactionAnnotationParser的parseTransactionAnnotation方法：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142241626-1898573511.jpg)
-
-至此，我们终于看到的Transactional注解，下面无疑就是解析注解当中声明的属性了：
-
-## Transactional注解
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142250086-1593469718.jpg)
-
-在这个方法中我们看到了在Transactional注解中声明的各种常用或者不常用的属性的解析，至此，事务的初始化工作算是完成了，下面开始真正的进入执行阶段。
-
-在上文AbstractAutoProxyCreator类的wrapIfNecessary方法中，获取到目标bean匹配的增强器之后，会为bean创建代理，这部分内容我们会在Spring AOP的文章中进行详细说明，在此简要说明方便大家理解，在执行代理类的目标方法时，会调用Advisor的getAdvice获取MethodInterceptor并执行其invoke方法，而我们本文的主角BeanFactoryTransactionAttributeSourceAdvisor的getAdvice方法会返回我们在文章开始看到的为其织入的另外一个bean，也就是TransactionInterceptor，它实现了MethodInterceptor，所以我们分析其invoke方法：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142251964-1897702955.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142253742-81370531.jpg)
-
-这个方法很长，但是整体逻辑还是非常清晰的，首选获取事务属性，这里的getTransactionAttrubuteSource()方法的返回值同样是在文章开始我们看到的被织入到TransactionInterceptor中的AnnotationTransactionAttributeSource，在事务准备阶段已经解析过事务属性并保存到缓存中，所以这里会直接从缓存中获取，接下来获取配置的TransactionManager，也就是determineTransactionManager方法，这里如果配置没有指定transaction-manager并且也没有默认id名为transactionManager的bean，就会报错，然后是针对声明式事务和编程式事务的不同处理，创建事务信息，执行目标方法，最后根据执行结果进行回滚或提交操作，我们先分析创建事务的过程。在分析之前希望大家能先去了解一下Spring的事务传播行为，有助于理解下面的源码，这里做一个简要的介绍，更详细的信息请大家自行查阅Spring官方文档，里面有更新详细的介绍。
-
-Spring的事务传播行为定义在Propagation这个枚举类中，一共有七种，分别为：
-
-REQUIRED：业务方法需要在一个容器里运行。如果方法运行时，已经处在一个事务中，那么加入到这个事务，否则自己新建一个新的事务，是默认的事务传播行为。
-
-NOT_SUPPORTED：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为他开启事务，如果方法在一个事务中被调用，该事务会被挂起，调用结束后，原先的事务会恢复执行。
-
-REQUIRESNEW：不管是否存在事务，该方法总汇为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有事务挂起，新的事务被创建。
-
-MANDATORY：该方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果在没有事务的环境下被调用，容器抛出例外。
-
-SUPPORTS：该方法在某个事务范围内被调用，则方法成为该事务的一部分。如果方法在该事务范围外被调用，该方法就在没有事务的环境下执行。
-
-NEVER：该方法绝对不能在事务范围内执行。如果在就抛例外。只有该方法没有关联到任何事务，才正常执行。
-
-NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中。如果没有活动事务，则按REQUIRED属性执行。它使用了一个单独的事务，这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效。
-
-## 开启事务过程
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142254272-1473500584.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142256723-2146158353.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142257278-1878221643.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142257769-599399453.jpg)
-
-判断当前线程是否存在事务就是判断记录的数据库连接是否为空并且transactionActive状态为true。
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142259232-1015967872.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142301922-198146239.jpg)
-
-REQUIRESNEW会开启一个新事务并挂起原事务，当然开启一个新事务就需要一个新的数据库连接：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142303284-1121880076.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142303540-922946646.jpg)
-
-suspend挂起操作主要目的是将当前connectionHolder置为null，保存原有事务信息，以便于后续恢复原有事务，并将当前正在进行的事务信息进行重置。下面我们看Spring如何开启一个新事务：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142304817-1631199195.jpg)
-
-这里我们看到了数据库连接的获取，如果是新事务需要获取新一个新的数据库连接，并为其设置了隔离级别、是否只读等属性，下面就是将事务信息记录到当前线程中：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142305129-2058808100.jpg)
-
-接下来就是记录事务状态并返回事务信息：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142306070-647878384.jpg)
-
-然后就是我们目标业务方法的执行了，根据执行结果的不同做提交或回滚操作，我们先看一下回滚操作：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142307229-1348831577.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142307451-1327327647.jpg)
-
-其中回滚条件默认为RuntimeException或Error，我们也可以自行配置。
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142307619-1218769460.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142309139-1058770763.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142310021-1140102079.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142310191-1124633997.jpg)
-
-保存点一般用于嵌入式事务，内嵌事务的回滚不会引起外部事务的回滚。下面我们来看新事务的回滚：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142310897-1920299450.jpg)
-
-很简单，就是获取当前线程的数据库连接并调用其rollback方法进行回滚，使用的是底层数据库连接提供的API。最后还有一个清理和恢复挂起事务的操作：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142311558-94141948.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142312884-396652627.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142313851-102126465.jpg)
-
-如果事务执行前有事务挂起，那么当前事务执行结束后需要将挂起的事务恢复，挂起事务时保存了原事务信息，重置了当前事务信息，所以恢复操作就是将当前的事务信息设置为之前保存的原事务信息。到这里事务的回滚操作就结束了，下面让我们来看事务的提交操作：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142314316-220782134.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142315709-533683607.jpg)
-
-在上文分析回滚流程中我们提到了如果当前事务不是独立的事务，也没有保存点，在回滚的时候只是设置一个回滚标记，由外部事务提交时统一进行整体事务的回滚。
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142316748-2061067152.jpg)
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825142317597-660647393.jpg)
-
-提交操作也是很简单的调用数据库连接底层API的commit方法。
-
-参考链接：
-
-http://blog.163.com/asd_wll/blog/static/2103104020124801348674/
-
-https://docs.spring.io/spring/docs/current/spring-framework-reference/data-access.html#spring-data-tier
+    <tx:annotation-driven transaction-manager="transactionManager1"/><bean id="transactionManager1"   
+        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
+    <property name="dataSource" ref="dataSource1"/></bean>  
+<tx:annotation-driven transaction-manager="transactionManager2"/>  
+<bean id="transactionManager2"   
+class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
+<property name="dataSource" ref="dataSource2"/></bean>
+```  
+  
+这时第一个<tx:annotation-driven>会生效，也就是当我们使用@Transactional注解时不指定事务管理器，默认使用的事务管理器是transactionManager1，后文分析源码时会具体提到这些注意点。</tx:annotation-driven>  
+  
+下面我们开始分析Spring的相关源码，首先看一下对<tx:annotation-driven>标签的解析，这里需要读者对Spring自定义标签解析的过程有一定的了解，笔者后续也会出相关的文章。锁定TxNamespaceHandler：</tx:annotation-driven>  
+  
+## TxNamespaceHandler  
+  
+(右键可查看大图)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142033158-801757952.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142035853-1216561547.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142050711-1788774364.jpg)  
+  
+## 注册事务功能bean  
+  
+这个方法比较长，关键的部分做了标记，最外围的if判断限制了<tx:annotation-driven>标签只能被解析一次，所以只有第一次被解析的标签会生效。蓝色框的部分分别注册了三个BeanDefinition，分别为AnnotationTransactionAttributeSource、TransactionInterceptor和BeanFactoryTransactionAttributeSourceAdvisor，并将前两个BeanDefinition添加到第三个BeanDefinition的属性当中，这三个bean支撑了整个事务功能，后面会详细说明。我们先来看红色框的第个方法：</tx:annotation-driven>  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142052962-1382540518.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142056340-212555152.jpg)  
+  
+还记得当<tx:annotation-driven>标签在不指定transaction-manager属性的时候，会默认寻找id固定名为transactionManager的bean作为事务管理器这个注意事项么，就是在这里实现的。下面我们来看红色框的第二个方法：</tx:annotation-driven>  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142058845-60551057.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142100099-521338949.jpg)  
+  
+这两个方法的主要目的是注册InfrastructureAdvisorAutoProxyCreator，注册这个类的目的是什么呢？我们看下这个类的层次：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142103625-1672142980.jpg)  
+  
+## 使用bean的后处理方法获取增强器  
+  
+我们发现这个类间接实现了BeanPostProcessor接口，我们知道，Spring会保证所有bean在实例化的时候都会调用其postProcessAfterInitialization方法，我们可以使用这个方法包装和改变bean，而真正实现这个方法是在其父类AbstractAutoProxyCreator类中：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142105124-1636877804.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142112838-373935120.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142114588-713887840.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142118835-2064313605.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142119676-1959254739.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142131238-2064733556.jpg)  
+  
+上面这个方法相信大家已经看出了它的目的，先找出所有对应Advisor的类的beanName，再通过beanFactory.getBean方法获取这些bean并返回。不知道大家还是否记得在文章开始的时候提到的三个类，其中BeanFactoryTransactionAttributeSourceAdvisor实现了Advisor接口，所以这个bean就会在此被提取出来，而另外两个bean被织入了BeanFactoryTransactionAttributeSourceAdvisor当中，所以也会一起被提取出来，下图为BeanFactoryTransactionAttributeSourceAdvisor类的层次：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142136219-556507874.jpg)  
+  
+## Spring获取匹配的增强器  
+  
+下面让我们来看Spring如何在所有候选的增强器中获取匹配的增强器：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142138356-655521572.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142145927-1806310557.jpg)  
+  
+上面的方法中提到引介增强的概念，在此做简要说明，引介增强是一种比较特殊的增强类型，它不是在目标方法周围织入增强，而是为目标类创建新的方法和属性，所以引介增强的连接点是类级别的，而非方法级别的。通过引介增强，我们可以为目标类添加一个接口的实现，即原来目标类未实现某个接口，通过引介增强可以为目标类创建实现该接口的代理，使用方法可以参考文末的引用链接。另外这个方法用两个重载的canApply方法为目标类寻找匹配的增强器，其中第一个canApply方法会调用第二个canApply方法并将第三个参数传为false：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142150013-1860771847.jpg)  
+  
+在上面BeanFactoryTransactionAttributeSourceAdvisor类的层次中我们看到它实现了PointcutAdvisor接口，所以会调用红框中的canApply方法进行判断，第一个参数pca.getPointcut()也就是调用BeanFactoryTransactionAttributeSourceAdvisor的getPointcut方法：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142156819-1296874034.jpg)  
+  
+这里的transactionAttributeSource也就是我们在文章开始看到的为BeanFactoryTransactionAttributeSourceAdvisor织入的两个bean中的AnnotationTransactionAttributeSource，我们以TransactionAttributeSourcePointcut作为第一个参数继续跟踪canApply方法：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142204505-259300568.jpg)  
+  
+我们跟踪pc.getMethodMatcher()方法也就是TransactionAttributeSourcePointcut的getMethodMatcher方法是在它的父类中实现：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142208118-661649181.jpg)  
+  
+发现方法直接返回this，也就是下面methodMatcher.matches方法就是调用TransactionAttributeSourcePointcut的matches方法：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142210658-52846138.jpg)  
+  
+在上面我们看到其实这个tas就是AnnotationTransactionAttributeSource，这里的目的其实也就是判断我们的业务方法或者类上是否有@Transactional注解，跟踪AnnotationTransactionAttributeSource的getTransactionAttribute方法：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142219647-1040649746.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142229849-1651021110.jpg)  
+  
+方法中的事务声明优先级最高，如果方法上没有声明则在类上寻找：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142231850-1851923561.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142233762-127153561.jpg)  
+  
+this.annotationParsers是在AnnotationTransactionAttributeSource类初始化的时候初始化的：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142238658-1305833682.jpg)  
+  
+所以annotationParser.parseTransactionAnnotation就是调用SpringTransactionAnnotationParser的parseTransactionAnnotation方法：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142241626-1898573511.jpg)  
+  
+至此，我们终于看到的Transactional注解，下面无疑就是解析注解当中声明的属性了：  
+  
+## Transactional注解  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142250086-1593469718.jpg)  
+  
+在这个方法中我们看到了在Transactional注解中声明的各种常用或者不常用的属性的解析，至此，事务的初始化工作算是完成了，下面开始真正的进入执行阶段。  
+  
+在上文AbstractAutoProxyCreator类的wrapIfNecessary方法中，获取到目标bean匹配的增强器之后，会为bean创建代理，这部分内容我们会在Spring AOP的文章中进行详细说明，在此简要说明方便大家理解，在执行代理类的目标方法时，会调用Advisor的getAdvice获取MethodInterceptor并执行其invoke方法，而我们本文的主角BeanFactoryTransactionAttributeSourceAdvisor的getAdvice方法会返回我们在文章开始看到的为其织入的另外一个bean，也就是TransactionInterceptor，它实现了MethodInterceptor，所以我们分析其invoke方法：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142251964-1897702955.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142253742-81370531.jpg)  
+  
+这个方法很长，但是整体逻辑还是非常清晰的，首选获取事务属性，这里的getTransactionAttrubuteSource()方法的返回值同样是在文章开始我们看到的被织入到TransactionInterceptor中的AnnotationTransactionAttributeSource，在事务准备阶段已经解析过事务属性并保存到缓存中，所以这里会直接从缓存中获取，接下来获取配置的TransactionManager，也就是determineTransactionManager方法，这里如果配置没有指定transaction-manager并且也没有默认id名为transactionManager的bean，就会报错，然后是针对声明式事务和编程式事务的不同处理，创建事务信息，执行目标方法，最后根据执行结果进行回滚或提交操作，我们先分析创建事务的过程。在分析之前希望大家能先去了解一下Spring的事务传播行为，有助于理解下面的源码，这里做一个简要的介绍，更详细的信息请大家自行查阅Spring官方文档，里面有更新详细的介绍。  
+  
+Spring的事务传播行为定义在Propagation这个枚举类中，一共有七种，分别为：  
+  
+REQUIRED：业务方法需要在一个容器里运行。如果方法运行时，已经处在一个事务中，那么加入到这个事务，否则自己新建一个新的事务，是默认的事务传播行为。  
+  
+NOT_SUPPORTED：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为他开启事务，如果方法在一个事务中被调用，该事务会被挂起，调用结束后，原先的事务会恢复执行。  
+  
+REQUIRESNEW：不管是否存在事务，该方法总汇为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有事务挂起，新的事务被创建。  
+  
+MANDATORY：该方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果在没有事务的环境下被调用，容器抛出例外。  
+  
+SUPPORTS：该方法在某个事务范围内被调用，则方法成为该事务的一部分。如果方法在该事务范围外被调用，该方法就在没有事务的环境下执行。  
+  
+NEVER：该方法绝对不能在事务范围内执行。如果在就抛例外。只有该方法没有关联到任何事务，才正常执行。  
+  
+NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中。如果没有活动事务，则按REQUIRED属性执行。它使用了一个单独的事务，这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效。  
+  
+## 开启事务过程  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142254272-1473500584.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142256723-2146158353.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142257278-1878221643.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142257769-599399453.jpg)  
+  
+判断当前线程是否存在事务就是判断记录的数据库连接是否为空并且transactionActive状态为true。  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142259232-1015967872.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142301922-198146239.jpg)  
+  
+REQUIRESNEW会开启一个新事务并挂起原事务，当然开启一个新事务就需要一个新的数据库连接：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142303284-1121880076.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142303540-922946646.jpg)  
+  
+suspend挂起操作主要目的是将当前connectionHolder置为null，保存原有事务信息，以便于后续恢复原有事务，并将当前正在进行的事务信息进行重置。下面我们看Spring如何开启一个新事务：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142304817-1631199195.jpg)  
+  
+这里我们看到了数据库连接的获取，如果是新事务需要获取新一个新的数据库连接，并为其设置了隔离级别、是否只读等属性，下面就是将事务信息记录到当前线程中：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142305129-2058808100.jpg)  
+  
+接下来就是记录事务状态并返回事务信息：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142306070-647878384.jpg)  
+  
+然后就是我们目标业务方法的执行了，根据执行结果的不同做提交或回滚操作，我们先看一下回滚操作：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142307229-1348831577.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142307451-1327327647.jpg)  
+  
+其中回滚条件默认为RuntimeException或Error，我们也可以自行配置。  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142307619-1218769460.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142309139-1058770763.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142310021-1140102079.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142310191-1124633997.jpg)  
+  
+保存点一般用于嵌入式事务，内嵌事务的回滚不会引起外部事务的回滚。下面我们来看新事务的回滚：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142310897-1920299450.jpg)  
+  
+很简单，就是获取当前线程的数据库连接并调用其rollback方法进行回滚，使用的是底层数据库连接提供的API。最后还有一个清理和恢复挂起事务的操作：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142311558-94141948.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142312884-396652627.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142313851-102126465.jpg)  
+  
+如果事务执行前有事务挂起，那么当前事务执行结束后需要将挂起的事务恢复，挂起事务时保存了原事务信息，重置了当前事务信息，所以恢复操作就是将当前的事务信息设置为之前保存的原事务信息。到这里事务的回滚操作就结束了，下面让我们来看事务的提交操作：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142314316-220782134.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142315709-533683607.jpg)  
+  
+在上文分析回滚流程中我们提到了如果当前事务不是独立的事务，也没有保存点，在回滚的时候只是设置一个回滚标记，由外部事务提交时统一进行整体事务的回滚。  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142316748-2061067152.jpg)  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190825142317597-660647393.jpg)  
+  
+提交操作也是很简单的调用数据库连接底层API的commit方法。  
+  
+参考链接：  
+  
+http://blog.163.com/asd_wll/blog/static/2103104020124801348674/  
+  
+https://docs.spring.io/spring/docs/current/spring-framework-reference/data-access.html#spring-data-tier  
+  
+  
+  
+## 微信公众号  
+  
+### 个人公众号：黄小斜  
+  
+黄小斜是跨考软件工程的 985 硕士，自学 Java 两年，拿到了 BAT 等近十家大厂 offer，从技术小白成长为阿里工程师。  
+  
+作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得和程序人生，目前黄小斜的CSDN博客有百万+访问量，知乎粉丝2W+，全网已有10W+读者。  
+  
+黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！  
+  
+**原创电子书:**  
+关注公众号【黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》  
+  
+**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。  
+  
+**考研复习资料：**  
+计算机考研大礼包，都是我自己考研复习时用的一些复习资料,包括公共课和专业的复习视频，这里也推荐给大家，关注公众号后，后台回复关键字 **“考研”** 即可免费获取。  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20190829222750556.jpg)  
+  
+  
+### 技术公众号：Java技术江湖  
+  
+如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！  
+  
+**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。  
+  
+![我的公众号](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20190805090108984.jpg)
\ No newline at end of file
diff --git "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2202\357\274\232\345\210\235\346\216\242Spring IOC\346\240\270\345\277\203\346\265\201\347\250\213.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232\345\210\235\346\216\242SpringIOC\346\240\270\345\277\203\346\265\201\347\250\213.md"
similarity index 82%
rename from "docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2202\357\274\232\345\210\235\346\216\242Spring IOC\346\240\270\345\277\203\346\265\201\347\250\213.md"
rename to "docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232\345\210\235\346\216\242SpringIOC\346\240\270\345\277\203\346\265\201\347\250\213.md"
index 50490ce..ba4415e 100644
--- "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2202\357\274\232\345\210\235\346\216\242Spring IOC\346\240\270\345\277\203\346\265\201\347\250\213.md"	
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232\345\210\235\346\216\242SpringIOC\346\240\270\345\277\203\346\265\201\347\250\213.md"
@@ -1,21 +1,21 @@
-# Table of Contents
-
-  * [前言](#前言)
-  * [准备](#准备)
-  * [读取](#读取)
-  * [解析](#解析)
-  * [注册](#注册)
-    * [注入依赖](#注入依赖)
+# 目录
+* [前言](#前言)
+* [准备](#准备)
+* [读取](#读取)
+* [解析](#解析)
+* [注册](#注册)
 
 
 本文转载自互联网，侵删
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 文章将同步到我的个人博客：
+
 > www.how2playlife.com
 
 本文是微信公众号【Java技术江湖】的《Spring和SpringMVC源码分析》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
@@ -42,7 +42,7 @@
 
 大致单步跟了下Spring IOC的初始化过程，整个脉络很庞大，初始化的过程主要就是读取XML资源，并解析，最终注册到Bean Factory中：
 
-[![](https://cloud.githubusercontent.com/assets/1736354/7897341/032179be-070b-11e5-9ecf-d7befc804e9d.png "flow")](https://cloud.githubusercontent.com/assets/1736354/7897341/032179be-070b-11e5-9ecf-d7befc804e9d.png "flow")
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/032179be-070b-11e5-9ecf-d7befc804e9d.png "flow")](https://cloud.githubusercontent.com/assets/1736354/7897341/032179be-070b-11e5-9ecf-d7befc804e9d.png "flow")
 
 在完成初始化的过程后，Bean们就在BeanFactory中蓄势以待地等调用了。下面通过一个具体的例子，来详细地学习一下初始化过程，例如当加载下面一个bean：
 
@@ -58,7 +58,7 @@
 ```
 
 加载时需要读取、解析、注册bean，这个过程具体的调用栈如下所示：
-[![](https://cloud.githubusercontent.com/assets/1736354/7896285/8a488060-06e6-11e5-9ad9-4ddd3375984f.png "load")](https://cloud.githubusercontent.com/assets/1736354/7896285/8a488060-06e6-11e5-9ad9-4ddd3375984f.png "load")
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/8a488060-06e6-11e5-9ad9-4ddd3375984f.png "load")](https://cloud.githubusercontent.com/assets/1736354/7896285/8a488060-06e6-11e5-9ad9-4ddd3375984f.png "load")
 
 下面对每一步的关键的代码进行详细分析：
 
@@ -222,7 +222,7 @@ protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate d
 
 ## 解析
 
-[![](https://cloud.githubusercontent.com/assets/1736354/7896302/eae02bc6-06e6-11e5-941a-d1f59e3b363f.png "process")](https://cloud.githubusercontent.com/assets/1736354/7896302/eae02bc6-06e6-11e5-941a-d1f59e3b363f.png "process")
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/eae02bc6-06e6-11e5-941a-d1f59e3b363f.png "process")](https://cloud.githubusercontent.com/assets/1736354/7896302/eae02bc6-06e6-11e5-941a-d1f59e3b363f.png "process")
 
 处理每个Bean的元素
 
@@ -352,7 +352,7 @@ public void registerBeanDefinition(String beanName, BeanDefinition beanDefinitio
 
 理解了以上两个过程，我们就可以自己实现一个简单的Spring框架了。于是，我根据自己的理解实现了一个简单的IOC框架Simple Spring，有兴趣可以看看。
 
-​
+
 
 注册过程中，最核心的一句就是：`this.beanDefinitionMap.put(beanName, beanDefinition)`，也就是说注册的实质就是以beanName为key，以beanDefinition为value，将其put到HashMap中。
 
@@ -363,11 +363,11 @@ public void registerBeanDefinition(String beanName, BeanDefinition beanDefinitio
 
 创建bean的实例
 创建bean的实例过程函数调用栈如下所示：
-[![](https://cloud.githubusercontent.com/assets/1736354/7929379/cec01bcc-092f-11e5-81ad-88c285f33845.png "create_bean")](https://cloud.githubusercontent.com/assets/1736354/7929379/cec01bcc-092f-11e5-81ad-88c285f33845.png "create_bean")
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/cec01bcc-092f-11e5-81ad-88c285f33845.png "create_bean")](https://cloud.githubusercontent.com/assets/1736354/7929379/cec01bcc-092f-11e5-81ad-88c285f33845.png "create_bean")
 
 注入bean的属性
 注入bean的属性过程函数调用栈如下所示：
-[![](https://cloud.githubusercontent.com/assets/1736354/7929381/db58350e-092f-11e5-82a4-caaf349291ea.png "inject_property")](https://cloud.githubusercontent.com/assets/1736354/7929381/db58350e-092f-11e5-82a4-caaf349291ea.png "inject_property")
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/db58350e-092f-11e5-82a4-caaf349291ea.png "inject_property")](https://cloud.githubusercontent.com/assets/1736354/7929381/db58350e-092f-11e5-82a4-caaf349291ea.png "inject_property")
 
 在创建bean和注入bean的属性时，都是在doCreateBean函数中进行的，我们重点看下：
 
@@ -405,3 +405,34 @@ protected Object doCreateBean(final String beanName, final RootBeanDefinition mb
 
 
 
+## 微信公众号
+
+### 个人公众号：黄小斜
+
+黄小斜是跨考软件工程的 985 硕士，自学 Java 两年，拿到了 BAT 等近十家大厂 offer，从技术小白成长为阿里工程师。
+
+作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得和程序人生，目前黄小斜的CSDN博客有百万+访问量，知乎粉丝2W+，全网已有10W+读者。
+
+黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
+
+**原创电子书:**
+关注公众号【黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》
+
+**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。
+
+**考研复习资料：**
+计算机考研大礼包，都是我自己考研复习时用的一些复习资料,包括公共课和专业的复习视频，这里也推荐给大家，关注公众号后，后台回复关键字 **“考研”** 即可免费获取。
+
+![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
+
+
+### 技术公众号：Java技术江湖
+
+如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
+
+**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
+
+![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
+ 
+
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232\346\207\222\345\212\240\350\275\275\347\232\204\345\215\225\344\276\213Bean\350\216\267\345\217\226\350\277\207\347\250\213\345\210\206\346\236\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232\346\207\222\345\212\240\350\275\275\347\232\204\345\215\225\344\276\213Bean\350\216\267\345\217\226\350\277\207\347\250\213\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..c04c1fd
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\346\272\220\347\240\201\345\211\226\346\236\220\357\274\232\346\207\222\345\212\240\350\275\275\347\232\204\345\215\225\344\276\213Bean\350\216\267\345\217\226\350\277\207\347\250\213\345\210\206\346\236\220.md"
@@ -0,0 +1,187 @@
+# 目录
+
+* [前言](#前言)
+* [step1:](#step1)
+* [step2:](#step2)
+* [step3:](#step3)
+
+
+本文转自五月的仓颉 https://www.cnblogs.com/xrq730
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+文章将同步到我的个人博客：
+
+> www.how2playlife.com
+
+本文是微信公众号【Java技术江湖】的《Spring和SpringMVC源码分析》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+
+该系列博文会告诉你如何从spring基础入手，一步步地学习spring基础和springmvc的框架知识，并上手进行项目实战，spring框架是每一个Java工程师必须要学习和理解的知识点，进一步来说，你还需要掌握spring甚至是springmvc的源码以及实现原理，才能更完整地了解整个spring技术体系，形成自己的知识框架。
+
+后续还会有springboot和springcloud的技术专题，陆续为大家带来，敬请期待。
+
+为了更好地总结和检验你的学习成果，本系列文章也会提供部分知识点对应的面试题以及参考答案。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+<!-- more -->
+
+## 前言
+
+xml的读取应该是Spring的重要功能，因为Spring的大部分功能都是以配置做为切入点的。
+
+我们在静态代码块中读取配置文件可以这样做：
+
+```
+   //这样来加载配置文件    
+   XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml")); 
+```
+
+（1）XmlBeanFactory 继承 AbstractBeanDefinitionReader ，使用ResourceLoader 将资源文件路径转换为对应的Resource文件。
+
+（2）通过DocumentLoader 对 Resource 文件进行转换，将 Resource 文件转换为 Document 文件。
+
+（3）通过实现接口 BeanDefinitionDocumentReader 的 DefaultBeanDefinitionDocumentReader 类对Document 进行解析，并且使用 BeanDefinitionParserDelegate对Element进行解析。
+
+## step1:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/bb0bf7543226c4ada238d93363f864d39da8e3e8.png)
+
+在平常开发中，我们也可以使用Resource 获取 资源文件：
+
+```
+  Resource resource = new ClassPathResource("application.xml");
+  InputStream in = resource.getInputStream();
+```
+
+## step2:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/13bd511377c0957e4ef8daebdf457585a9acabea.png)
+
+在资源实现加载之前，调用了 super(parentBeanFactory) -- /**Ignore the given dependency interface for autowiring.(忽略接口的自动装配功能)*/
+
+调用XmlBeanDefinitionReader 的 loadBeanDefinitions（）方法进行加载资源：
+
+（1） 对Resource资源进行编码
+
+（2） 通过SAX读取XML文件来创建InputSource对象
+
+（3） 核心处理
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405185226.png)
+
+可以很直观的看出来是这个function是在解析xml文件从而获得对应的Document对象。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405185240.png)
+
+在doLoadDocument方法里面还存一个方法getValidationModeForResource（）用来读取xml的验证模式。（和我关心的没什么关系，暂时不看了~）
+
+转换成document也是最常用的方法：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405185253.png)
+
+## step3
+
+/**Register the bean definitions contained in the given DOM document*/
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405185301.png)
+
+参数doc是doLoadBeanDefinitions（）方法传进来的 loadDocument 加载过来的。这边就很好的体现出了面向对象的单一全责原则，将逻辑处理委托給单一的类去处理。
+
+在这边单一逻辑处理类是： BeanDefinitionDocumentReader
+
+核心方法：<font color="#FF0000">documentReader.registerBeanDefinitions(doc, createReaderContext(resource));</font>
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405185308.png)
+
+<font color="#FF0000">开始解析：</font>
+
+![image-20230405185319712](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230405185319712.png)
+
+-------------
+
+在Spring的xml配置中有两种方式来声明bean:
+
+一种是默认的： <bean id = " " class = " " />
+
+还有一种是自定义的： < tx : annotation-driven / >
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405185328.png)
+
+通过xml配置文件的默认配置空间来判断：http://www.springframework.org/schema/beans
+
+对于默认标签的解析：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405185340.png)
+
+对Bean 配置的解析：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405185347.png)
+
+**BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); 返回BeanDefinitionHolder**
+
+![image-20230405185356720](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230405185356720.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405185402.png)
+
+这边代码大致看下来：
+
+1.  提取元素中的id和name属性
+2.  进一步解析将其他属性封装到 BeanDefinition 的实现类中
+3.  如果没有指定beanName 变使用默认规则生成beanName
+4.  封装类BeanDefinitionHolder
+
+可以先了解一下 BeanDefinition 这个类的作用。
+
+BeanDefinition是一个接口，对应着配置文件中<bean>里面的所有配置，在Spring中存在着三个实现类：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405185457.png)
+
+在配置文件中，可以定义父<bean>和子<bean>，父<bean>是用RootDefinition来表示，子<bean>是用ChildBeanDefinition来表示。
+
+Spring 通过BeanDefiniton将配置文件中的<bean>配置信息转换为容器内部表示，并且将这些BeanDefinition注册到BeanDefinitonRegistry中。
+
+Spring容器的BeanDefinitonRegistry就像是Spring配置信息的内存数据库，主要是以map的形式保存的。
+
+因此解析属性首先要创建用于承载属性的实例：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405185505.png)
+
+然后就是各种对属性的解析的具体方法：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405185520.png)
+
+
+## 微信公众号
+
+### 个人公众号：黄小斜
+
+黄小斜是跨考软件工程的 985 硕士，自学 Java 两年，拿到了 BAT 等近十家大厂 offer，从技术小白成长为阿里工程师。
+
+作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得和程序人生，目前黄小斜的CSDN博客有百万+访问量，知乎粉丝2W+，全网已有10W+读者。
+
+黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
+
+**原创电子书:**
+关注公众号【黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》
+
+**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。
+
+**考研复习资料：**
+计算机考研大礼包，都是我自己考研复习时用的一些复习资料,包括公共课和专业的复习视频，这里也推荐给大家，关注公众号后，后台回复关键字 **“考研”** 即可免费获取。
+
+![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
+
+
+### 技术公众号：Java技术江湖
+
+如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
+
+**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
+
+![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
+
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213ApplicationContext.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213ApplicationContext.md"
new file mode 100644
index 0000000..ff74cca
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213ApplicationContext.md"
@@ -0,0 +1,802 @@
+### 1. `ApplicationContext` ���
+
+���������� spring ����ʱ��һ��������������
+
+```
+ApplicationContext context = new AnnotationConfigApplicationContext(Main.class);
+
+```
+
+��������
+
+```
+ApplicationContext context = new AnnotationConfigWebApplicationContext();
+context.register(MvcConfig.class);
+context.refresh();
+
+```
+
+����� `AnnotationConfigApplicationContext` �� `AnnotationConfigWebApplicationContext` ���� `ApplicationContext`�����ս��л���� `AbstractApplicationContext#refresh` �������� spring ������
+
+`ApplicationContext` ����Ϊ **spring Ӧ��������**�������������Ի�ȡ spring �����ڼ�ĸ�����Ϣ���� `BeanFactory`��`Environment` �ȣ��� spring ��������Ҫ��һ���ࡣ
+
+`ApplicationContext` �̳еĽӿ����£�
+
+```
+public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, 
+        HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, 
+        ResourcePatternResolver {
+    ...
+}
+
+```
+
+��������Կ�����`ApplicationContext` ����Ҳ�������ӿڵ��ӽӿڣ���Щ�ӿڵĹ������£�
+
+*   `EnvironmentCapable`���ṩ�˻������ù��ܣ�`applicationContext` ʵ���л���һ�� `Environment` ���͵ij�Ա����������ͨ�� `EnvironmentCapable#getEnvironment()` ����ȡ��
+*   `ListableBeanFactory`��`BeanFactory` ���ӽӿڣ��ṩ���о� `BeanFactory` ������ `bean` �ķ���
+*   `HierarchicalBeanFactory`��`BeanFactory` ���ӽӿڣ��ṩ�� `BeanFactory` ���Ƽ̳е����������Ի�ȡ�� `BeanFactory`��
+*   `MessageSource`��ָ����Ϣ��Դ����������ʵ�ֹ��ʻ�����
+*   `ApplicationEventPublisher`���¼��������������ṩ�� `publishEvent(...)` �����������¼�
+*   `ResourcePatternResolver`����Դ���������ṩ�˻�ȡ��Դ��`Resource`���ķ�����`getResources(...)`
+
+���������� `ApplicationContext` �����ṩ�ķ�����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-82de66bd51d650aa8a1fda29bdda3efd6b4.png)
+
+���Կ������������ķ��������ࡣ
+
+### 2. `ApplicationContext` �̳нṹ
+
+�� `ApplicationContext` �����У�`ApplicationContext` ��Ҫ��Ϊ������ϵ�����Ǽ���������£�
+
+*   �� web ���͵� `ApplicationContext`��������ͨ java Ӧ�õ� `ApplicationContext`��������Ϊ `AnnotationConfigApplicationContext`
+*   web ���͵� `ApplicationContext`������ web Ӧ�õ� `ApplicationContext`��������Ϊ `AnnotationConfigWebApplicationContext`������ֻ���� `servlet` ���͵� web�������� `reactive` �� web��
+
+������������ `AnnotationConfigApplicationContext` �ļ̳нṹ��
+
+![ͼƬ��������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-6e20477e8f5948894a5f241cd41038cfa15.png)
+
+������������ `AnnotationConfigWebApplicationContext` �ļ̳нṹ��
+
+![ͼƬ��������](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-23a6c84d82370afe39245a568cbcf918209.png)
+
+### 3\. �� bean �л�ȡ `ApplicationContext`
+
+�� spring bean �л�ȡ `ApplicationContext`������ͨ�� `ApplicationContextAware` �ӿ���������
+
+```
+@Component
+public class TestBean implements ApplicationContextAware {
+
+    private ApplicationContext applicationContext;
+
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) 
+            throws BeansException {
+        this.applicationContext = applicationContext;
+    }
+
+    // ��������
+
+}
+
+```
+
+�̳� `ApplicationContextAware` ��`ApplicationContextAwareProcessor` ���ڳ�ʼ����ɺ���� `setApplicationContext(xxx)` ��������������ֻ��Ҫ�� `TestBean` ��ά��һ����Ա�������� `applicationContext` ���漴�ɡ�
+
+### 4. `ApplicationContextAwareProcessor`
+
+`ApplicationContextAwareProcessor` ��һ�� `BeanPostProcessor`��������Ҫ��ע `ApplicationContextAwareProcessor#postProcessBeforeInitialization` �������������£�
+
+```
+@Override
+@Nullable
+public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+    /**
+     * applicationContext �� Environment��ResourceLoader��
+     * ApplicationEventPublisher��MessageSource �ȵ����࣬��Щ���aware�ӿڵĵ��ã�������
+     * ͨ�� applicationContext ��������
+     */
+    if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
+            bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
+            bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
+        return bean;
+    }
+    AccessControlContext acc = null;
+    if (System.getSecurityManager() != null) {
+        acc = this.applicationContext.getBeanFactory().getAccessControlContext();
+    }
+    if (acc != null) {
+        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
+            invokeAwareInterfaces(bean);
+            return null;
+        }, acc);
+    }
+    else {
+        invokeAwareInterfaces(bean);
+    }
+    return bean;
+}
+
+/**
+ * ���� Aware �ӿڵķ���
+ * ����EmbeddedValueResolverAware�⣬����Ĵ���������� this.applicationContext
+ */
+private void invokeAwareInterfaces(Object bean) {
+    if (bean instanceof EnvironmentAware) {
+        ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
+    }
+    if (bean instanceof EmbeddedValueResolverAware) {
+        // ע��embeddedValueResolver�Ļ�ȡ�������£�
+        // new EmbeddedValueResolver(applicationContext.getBeanFactory());
+        ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
+    }
+    if (bean instanceof ResourceLoaderAware) {
+        ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
+    }
+    if (bean instanceof ApplicationEventPublisherAware) {
+        ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(
+                this.applicationContext);
+    }
+    if (bean instanceof MessageSourceAware) {
+        ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
+    }
+    // װ�� ʵ����ApplicationContextAware����� applicationContext
+    if (bean instanceof ApplicationContextAware) {
+        ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
+    }
+}
+
+```
+
+����������DZȽϼ򵥵ģ������ж� bean ���ͣ�Ȼ��ת�������÷�����
+
+### 5. `ApplicationContext` �� `BeanFactory` �Ĺ�ϵ
+
+����������������� `ApplicationContext` �� `BeanFactory` ���ߵĹ�ϵ������һ��ʼ��˵���� `ApplicationContext` �̳��� `BeanFactory` �Ľӿڣ���Ϊ�������Ǽ̳й�ϵ�����������˼̳й�ϵ�⣬���ǻ�����Ϲ�ϵ��`ApplicationContext` ���� `BeanFactory` �Ķ���ֱ�ӿ����룺
+
+���� `AnnotationConfigApplicationContext`��`beanFactory` ��ֵ�������£�
+
+```
+public class GenericApplicationContext extends AbstractApplicationContext 
+        implements BeanDefinitionRegistry {
+
+    // ����dz��е� beanFactory ����
+    private final DefaultListableBeanFactory beanFactory;
+
+    public GenericApplicationContext() {
+        this.beanFactory = new DefaultListableBeanFactory();
+    }
+
+    @Override
+    public final ConfigurableListableBeanFactory getBeanFactory() {
+        return this.beanFactory;
+    }
+
+    ...
+
+}
+
+```
+
+���� `AnnotationConfigWebApplicationContext`��`beanFactory` ��ֵ�������£�
+
+```
+public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
+
+    // ����dz��е� beanFactory ����
+    @Nullable
+    private DefaultListableBeanFactory beanFactory;
+
+    @Override
+    protected final void refreshBeanFactory() throws BeansException {
+        // �жϵ�ǰApplicationContext�Ƿ����BeanFactory��������ڵĻ����������� Bean���ر� BeanFactory
+        if (hasBeanFactory()) {
+            destroyBeans();
+            closeBeanFactory();
+        }
+        try {
+            // ��ʼ��DefaultListableBeanFactory��������Ĵ�������
+            DefaultListableBeanFactory beanFactory = createBeanFactory();
+            beanFactory.setSerializationId(getId());
+
+            // ���� BeanFactory �������������ԣ��Ƿ����� Bean ���ǡ��Ƿ�����ѭ������
+            customizeBeanFactory(beanFactory);
+
+            // ���� Bean �� BeanFactory ��
+            loadBeanDefinitions(beanFactory);
+            synchronized (this.beanFactoryMonitor) {
+                this.beanFactory = beanFactory;
+            }
+        }
+        catch (IOException ex) {
+            ...
+        }
+    }
+
+    // ���� beanFactory
+    protected DefaultListableBeanFactory createBeanFactory() {
+        // ָ����beanFactory
+        return new DefaultListableBeanFactory(getInternalParentBeanFactory());
+    }
+
+    // ��ȡ beanFactory
+    @Override
+    public final ConfigurableListableBeanFactory getBeanFactory() {
+        synchronized (this.beanFactoryMonitor) {
+            if (this.beanFactory == null) {
+                ...
+            }
+            return this.beanFactory;
+        }
+    }
+
+    ...
+
+}
+
+```
+
+`BeanFactory` ����ط���ʵ�����£�
+
+```
+public abstract class AbstractApplicationContext extends DefaultResourceLoader
+        implements ConfigurableApplicationContext {### 1\. ʲô�� `BeanDefinition`
+
+`BeanDefinition` ������������������ `bean����`���������� spring bean ����Ϣ��
+
+�� java �У�����һ�����Ԫ��Ϣ�����췽������Ա��������Ա�����ȣ���ʹ�õ��� `Class` �࣬һ��`.class` �ļ����ص� jvm �󣬶�������һ�� `Class` �����ڶ���ʵ����ʱ���͸������ `Class` �������Ϣ�����ɡ�
+
+�� spring �У�Ҳ����ôһ���������� bean ����Ϣ���������� `BeanDefinition`���������� spring bean ������ɣ���γ�ʼ����������ٵȣ�������������֧�ֵIJ��ַ�����
+
+```
+public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
+
+    /**
+     * ���ø� BeanDefinition
+     * BeanDefinition �и����Ƽ̳еĸ������ָ���˸�BeanDefinition
+     * ʵ����beanʱ����ϲ���BeanDefinition
+     */
+    void setParentName(@Nullable String parentName);
+
+    /**
+     * ��ȡ��Bean
+     */
+    @Nullable
+    String getParentName();
+
+    /**
+     * ����beanClass����
+     * ʵ����ʱ����ʵ��������� Class �Ķ���
+     */
+    void setBeanClassName(@Nullable String beanClassName);
+
+    /**
+     * ��ȡbeanClass����
+     */
+    @Nullable
+    String getBeanClassName();
+
+    /**
+     * ����bean�����÷�Χ��������ԭ��
+     */
+    void setScope(@Nullable String scope);
+
+    /**
+     * ��ȡbean�����÷�Χ��������ԭ��
+     */
+    @Nullable
+    String getScope();
+
+    /**
+     * ����������
+     */
+    void setLazyInit(boolean lazyInit);
+
+    /**
+     * �Ƿ�Ϊ������
+     */
+    boolean isLazyInit();
+
+    /**
+     * ���ø�Bean����������Bean
+     * �� @DependsOn ָ����bean
+     */
+    void setDependsOn(@Nullable String... dependsOn);
+
+    /**
+     * ���ظ�Bean������������
+     */
+    @Nullable
+    String[] getDependsOn();
+
+    /**
+     * �����Ƿ���Ϊ�Զ�ע��ĺ�ѡ����
+     */
+    void setAutowireCandidate(boolean autowireCandidate);
+
+    /**
+     * �Ƿ���Ϊ�Զ�ע��ĺ�ѡ����
+     */
+    boolean isAutowireCandidate();
+
+    /**
+     * �����Ƿ�Ϊ��Ҫ�ģ��������д��ڶ��ͬ���͵�beanʱ������ֻ������Ҫ��
+     * ���� @Primary ������
+     */
+    void setPrimary(boolean primary);
+
+    /**
+     * �Ƿ�Ϊ��Ҫ��bean
+     */
+    boolean isPrimary();
+
+    /**
+     * ���factoryBean
+     * ָ��factoryBean������
+     */
+    void setFactoryBeanName(@Nullable String factoryBeanName);
+
+    /**
+     * ���factoryBean
+     * ��ȡfactoryBean������
+     */
+    @Nullable
+    String getFactoryBeanName();
+
+    /**
+     * ���ù�������������
+     * ���� @Bean ��ǵķ���
+     */
+    void setFactoryMethodName(@Nullable String factoryMethodName);
+
+    /**
+     * ���ع�������������
+     * ���� @Bean ��ǵķ���
+     */
+    @Nullable
+    String getFactoryMethodName();
+
+    /**
+     * ��ȡ�����ȥ�IJ���ֵ
+     */
+    ConstructorArgumentValues getConstructorArgumentValues();
+
+    /**
+     * ���췽���Ƿ��в���
+     */
+    default boolean hasConstructorArgumentValues() {
+        return !getConstructorArgumentValues().isEmpty();
+    }
+
+    /**
+     * ��ȡ����ֵ
+     * ���������������ֵ��Ϊ���췽�������������IJ���
+     */
+    MutablePropertyValues getPropertyValues();
+
+    /**
+     * �Ƿ�������ֵ
+     */
+    default boolean hasPropertyValues() {
+        return !getPropertyValues().isEmpty();
+    }
+
+    /**
+     * ���ó�ʼ����������
+     */
+    void setInitMethodName(@Nullable String initMethodName);
+
+    /**
+     * ��ȡ��ʼ����������
+     */
+    @Nullable
+    String getInitMethodName();
+
+    /**
+     * �������ٷ�������
+     */
+    void setDestroyMethodName(@Nullable String destroyMethodName);
+
+    /**
+     * ��ȡ���ٷ�������
+     */
+    @Nullable
+    String getDestroyMethodName();
+
+    /**
+     * �Ƿ�Ϊ����bean
+     */
+    boolean isSingleton();
+
+    /**
+     * �Ƿ�Ϊԭ��bean
+     */
+    boolean isPrototype();
+
+    /**
+     * ������ Bean �DZ�����Ϊ abstract����ô����ʵ��������������Ϊ ��bean ���ڼ̳�
+     */
+    boolean isAbstract();
+
+    ...
+
+}
+
+```
+
+���Կ�����`BeanDefinition` ֧�ֵķ����dz��࣬�кܶ�������ƽʱʹ��ʱָ���ģ�
+
+*   `setScope(...)`������ bean �����÷�Χ���� `@Scope` ָ��
+*   `setLazyInit(...)`�����������أ��� `@Lazy` ָ��
+*   `setDependsOn(...)`������ bean �������� `@DependsOn` ָ��
+*   `setPrimary(...)`������Ϊ��Ҫ bean���� `@Primary` ָ��
+*   `setFactoryMethodName(...)`�����ù����������ƣ������� `@Bean` ��ǵķ���
+
+��������ע��ʱ������ָ���ģ�����Щ���� `xml` ʱ��ָ���ģ��磺
+
+*   `setInitMethodName(...)`�����ó�ʼ������ ���� `init-method` ָ��
+*   `setDestroyMethodName(...)`���������ٷ������� `destroy-method` ָ��
+
+### 2\. spring �ṩ����Щ `BeanDefinition`
+
+`BeanDefinition` ��һ���ӿڣ����ǵ�Ȼ����ֱ��ʹ�ã����������������� Spring �ṩ����Щ `BeanDefinition`��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-49cbc9cb32badc1db52717cd19a9447eca7.png)
+
+spring �ṩ�� `BeanDefinition` ����������ͼ��ʾ�ļ����ˣ�����������Ҫ�������֣�
+
+*   `RootBeanDefinition`
+*   `ChildBeanDefinition`
+*   `GenericBeanDefinition`
+*   `ScannedGenericBeanDefinition`
+*   `AnnotatedGenericBeanDefinition`
+
+#### 2.1 `RootBeanDefinition` �� `ChildBeanDefinition`
+
+��ǰ���ᵽ�� `BeanDefinition` ���ӵĸ������������������̳еģ�һ����˵�����ǿ����� `RootBeanDefinition` ���幫��������Ȼ���� `ChildBeanDefinition` �ж�����Ե����ݣ�ʾ�����£�
+
+```
+public static void main(String[] args) {
+AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
+// RootBeanDefinition
+RootBeanDefinition root = new RootBeanDefinition();
+root.setBeanClass(User.class);
+root.getPropertyValues().add("name", "123");
+// ����ע�᷽������չʾ��ʵ����Ŀ�в�����ʹ��
+// ʹ����Ŀ����ʹ�õ� BeanDefinitionRegistryPostProcessor �ṩ�ķ���
+context.registerBeanDefinition("root", root);
+
+    // ChildBeanDefinition
+    ChildBeanDefinition child1 = new ChildBeanDefinition("root");
+    child1.getPropertyValues().add("age", "11");
+    // ����ע�᷽������չʾ��ʵ����Ŀ�в�����ʹ��
+    // ʹ����Ŀ����ʹ�õ� BeanDefinitionRegistryPostProcessor �ṩ�ķ���
+    context.registerBeanDefinition("child1", child1);
+
+    // ChildBeanDefinition
+    ChildBeanDefinition child2 = new ChildBeanDefinition("root");
+    child2.getPropertyValues().add("age", "12");
+    // ����ע�᷽������չʾ��ʵ����Ŀ�в�����ʹ��
+    // ʹ����Ŀ����ʹ�õ� BeanDefinitionRegistryPostProcessor �ṩ�ķ���
+    context.registerBeanDefinition("child2", child2);
+    // ��������
+    context.refresh();
+
+    User rootUser = (User) context.getBean("root");
+    User child1User = (User) context.getBean("child1");
+    User child2User = (User) context.getBean("child2");
+    System.out.println(rootUser);
+    System.out.println(child1User);
+    System.out.println(child2User);
+}
+
+```
+
+������
+
+```
+User{name='123', age=null}
+User{name='123', age=11}
+User{name='123', age=12}
+
+```
+
+���Կ�����`child1` �� `child1` ���гɹ��ش� `RootBeanDefinition` �̳е������ԡ�
+
+#### 2.2 `GenericBeanDefinition`
+
+���Ǹ�ͨ�õ� `BeanDefinition`��ֱ�Ӽ̳��� `AbstractBeanDefinition`���������ṩ�ķ������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-5ed980070b301dc84926fac2494093d4fc6.png)
+
+���Կ������������ṩ�ķ��������࣬����������̳� `AbstractBeanDefinition`��һ������£�����Ҫ�����Լ��� `BeanDefinition` ʱ��ֻ��Ҫʹ�������Ϳ����ˣ�����Ҳ�ṩһ��ʾ����
+
+```
+public static void main(String[] args) {
+AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
+
+    GenericBeanDefinition userBeanDefinition = new GenericBeanDefinition();
+    userBeanDefinition.setBeanClass(User.class);
+    userBeanDefinition.getPropertyValues().add("name", "123");
+    userBeanDefinition.getPropertyValues().add("age", "11");
+    // ����ע�᷽������չʾ��ʵ����Ŀ�в�����ʹ��
+    // ʹ����Ŀ����ʹ�õ� BeanDefinitionRegistryPostProcessor �ṩ�ķ���
+    context.registerBeanDefinition("user", userBeanDefinition);
+
+    // ��������
+    context.refresh();
+
+    User user = (User) context.getBean("user");
+    System.out.println(user);
+}
+
+```
+
+### 2.3 `ScannedGenericBeanDefinition`
+
+`ScannedGenericBeanDefinition` �̳��� `GenericBeanDefinition`��ͬʱҲʵ���� `AnnotatedBeanDefinition` �ӿڣ������ṩ�ķ��������ࣺ
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-9ed3925090a9ae5fc1d4218ed5a59c2ea19.png)
+
+������������� `GenericBeanDefinition`������Ͳ��ṩʾ���ˡ�
+
+### 2.4 `AnnotatedGenericBeanDefinition`
+
+`AnnotatedGenericBeanDefinition` �̳��� `GenericBeanDefinition`��ͬʱҲʵ���� `AnnotatedBeanDefinition` �ӿڣ������ṩ�ķ��������ࣺ
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-b2e7f49fcdcae4f7272e2670b4fbb92766a.png)
+
+������������� `GenericBeanDefinition`������Ͳ��ṩʾ���ˡ�
+
+### 3\. ���� spring ���������е� `BeanDefinition`
+
+��������Ӷ����� spring ���������� `BeanDefinition`������Ҫ��β��� spring ���������е� `BeanDefinition` �أ�
+
+#### 3.1 demo ׼��
+
+��������׼��һ�� demo��
+
+����׼������ `service`��
+
+```
+@Service
+public class Service01 {
+
+    private String name;
+
+    public void hello() {
+        System.out.println("hello " + name + ", from service01");
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}
+
+@Service
+public class Service02 {
+
+    private String name;
+
+    public void hello() {
+        System.out.println("hello " + name + ", from service02");
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}
+
+```
+
+��������Ҫ�ࣺ
+
+```
+@ComponentScan
+public class Demo02Main {
+
+    public static void main(String[] args) {
+        AnnotationConfigApplicationContext context
+                = new AnnotationConfigApplicationContext();
+        context.register(Demo02Main.class);
+        context.refresh();
+
+        Service01 service01 = (Service01) context.getBean("service01");
+        Service02 service02 = (Service02) context.getBean("service02");
+        service01.hello();
+        service02.hello();
+
+    }
+}
+
+```
+
+���� ��������£�
+
+```
+hello null, from service01
+hello null, from service02
+
+```
+
+��˵�����ǵ������Ѿ������ɹ��ˣ�`service01` �� `service02` Ҳ��ʼ���ɹ��ˡ�
+
+#### 3.2 ���ɹ��ij���
+
+�������Ƿ����£�`service01` �� `service02` �Ѿ���ʼ���ɹ��ˣ���˵�������б�Ȼ `service01` �� `service02` ��Ӧ�� `beanDefifnition`�������������� `beanDefifnition`���ͱ���Ҫ�Ȼ�ȡ��� `beanDefifnition`��
+
+��λ�ȡ spring ���Ѿ����ڵ� `beanDefifnition` �أ��ο��� 2 �ڵ�ʾ�����������Ϊ�� `context.refresh()` ǰ��ȡ����������
+
+```
+public static void main(String[] args) {
+AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
+context.register(Demo02Main.class);
+// �������ȡ beanDefinition���ᱨ��
+BeanDefinition service01Bd = context.getBeanDefinition("service01");
+service01Bd.getPropertyValues().addPropertyValue("name", "123");
+
+    context.refresh();
+
+    Service01 service01 = (Service01) context.getBean("service01");
+    Service02 service02 = (Service02) context.getBean("service02");
+    service01.hello();
+    service02.hello();
+}
+
+```
+
+���У����ֻᱨ����
+
+```
+Exception in thread "main" org.springframework.beans.factory
+.NoSuchBeanDefinitionException: No bean named 'service01' available
+
+```
+
+�������㣬һ�����뵽���� `context.refresh()` ǰ��ȡ�ᱨ��������֮���أ�������������
+
+```
+public static void main(String[] args) {
+AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
+context.register(Demo02Main.class);
+context.refresh();
+
+    // ��ȡ beanDefinition���޸IJ�������
+    BeanDefinition service01Bd = context.getBeanDefinition("service01");
+    service01Bd.getPropertyValues().addPropertyValue("name", "123");
+
+    Service01 service01 = (Service01) context.getBean("service01");
+    Service02 service02 = (Service02) context.getBean("service02");
+    service01.hello();
+    service02.hello();
+
+}
+
+```
+
+���У�������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-268bb546197c4eb9d1686118a12fabb0009.png)
+
+ȷʵû�б������������ǵ��޸�Ҳû�����á��ڴ�������Ǹ� `service01` �� `name` ����ָ��ֵΪ `123`�����н������ `null`��û�����õ�ԭ���� `service01` ���� `context.refresh()` ���г�ʼ�� �ģ���������ô������ `BeanDefinition` �޸ģ�Ҳ���ֲ��������ϡ�
+
+��ô����Ҫ��ô���أ�
+
+#### 3.2 `BeanDefinitionRegistryPostProcessor`�����ƻ� `beanDefinition`
+
+����������Ҫ�ų������ˣ�������о��ǣ�`BeanFactoryPostProcessor`����������Ľ��ܣ��������Ľ��ܣ����Բο� [spring ���֮ BeanFactoryPostProcessor](https://my.oschina.net/funcy/blog/4597545)������ֱ�Ӹ��½��ۣ�
+
+> `BeanFactoryPostProcessor` �������� `spring beanFactory �ĺ��ô�����`�������������ƻ� `beanFactory` ��һЩ��Ϊ��spring Ϊ�����ṩ������ `BeanFactoryPostProcessor`��
+>
+> *   `BeanFactoryPostProcessor`�����ƻ� `beanFactory` ����Ϊ
+> *   `BeanDefinitionRegistryPostProcessor`�����ƻ� `beanDefinition` ����Ϊ
+
+�����ԣ�����Ӧ��ʹ�� `BeanDefinitionRegistryPostProcessor`��ֱ��ʵ������ӿڣ�
+
+```
+@Component
+public class MyBeanDefinitionRegistryPostProcessor
+implements BeanDefinitionRegistryPostProcessor {
+
+    @Override
+    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) 
+            throws BeansException {
+        BeanDefinition service01Bd = registry.getBeanDefinition("service01");
+        service01Bd.getPropertyValues().addPropertyValue("name", "123");
+    }
+
+    @Override
+    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 
+            throws BeansException {
+        // BeanDefinitionRegistryPostProcessor �� BeanFactoryPostProcessor ���ӽӿ�
+        // postProcessBeanFactory(...) ���� BeanFactoryPostProcessor���������ﲻ����
+    }
+}
+
+```
+
+`main` �������������һ�£�
+
+```
+public static void main(String[] args) {
+AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
+context.register(Demo02Main.class);
+context.refresh();
+
+    Service01 service01 = (Service01) context.getBean("service01");
+    Service02 service02 = (Service02) context.getBean("service02");
+    service01.hello();
+    service02.hello();
+
+}
+
+```
+
+���У�������£�
+
+```
+hello 123, from service01
+hello null, from service02
+
+```
+
+���Կ��� `service01` �� `name` ȷʵ��� `123` �ˡ�
+
+ʵ���ϣ�`BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry` ��Ҫ����ʹ�� `BeanDefinitionRegistry` ����� `BeanDefinition` �IJ�������֧�ֵķ������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-5812a2cac994c5940d57c7e6ab55c23a63e.png)
+
+��Ҫ�������£�
+
+*   `getBeanDefinition(...)`����ȡ `BeanDefinition`�������򷵻أ��������򱨴����õ� `BeanDefinition` �󣬾Ϳ��Զ�����и��ֲ�����
+*   `registerBeanDefinition(...)`��ע�� `BeanDefinition`�������Զ��� `BeanDefinition` ����Ȼ����ø÷���ע�ᵽ�����У�ǰ��������У��������� `context.refresh()` ǰ���� `context.registerBeanDefinition`��������Ҫ˵��������ǰ��ķ����ɣ����������е�����£������õ� `context.refresh()` �� `context`������ `springboot` �У�������Ƽ�ʹ�� `BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry` ����ע�� `BeanDefinition`
+*   `removeBeanDefinition(...)`���Ƴ� `BeanDefinition`��һ�������Ӧ�ò����õ�
+*   `containsBeanDefinition(...)`���ж��Ƿ����ij�� `BeanDefinition`
+
+### 4\. �ܽ�
+
+������Ҫ������ `BeanDefinition` �����ã�
+
+1.  `BeanDefinition` �ķ���
+2.  �������͵� `BeanDefinition` ��ʹ��
+3.  ʹ�� `BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry` ���� `BeanDefinition`����Ҫ��ע�ᡢ�޸� `BeanDefinition`
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4597536](https://my.oschina.net/funcy/blog/4597536) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
+
+    ...
+    @Override
+    public <T> T getBean(Class<T> requiredType) throws BeansException {
+        assertBeanFactoryActive();
+        return getBeanFactory().getBean(requiredType);
+    }
+
+    @Override
+    public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException {
+        assertBeanFactoryActive();
+        return getBeanFactory().getBean(requiredType, args);
+    }
+
+    ...
+}
+
+```
+
+��Щ������ʵ��ʱ�����ǵ��� `getBeanFactory()` ��ȡ�� `BeanFactory` ����Ȼ��ֱ�ӵ��� `BeanFactory` �ķ�����`getBeanFactory()` ���õľ��� `GenericApplicationContext` �� `AnnotationConfigWebApplicationContext` �� `getBeanFactory()` ������
+
+���� `ApplicationContext` �����ݾͽ��ܵ������ˡ�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4597456](https://my.oschina.net/funcy/blog/4597456) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/\345\205\254\344\274\227\345\217\267\345\216\206\345\217\262\346\226\207\347\253\240\346\261\207\346\200\273.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213BeanDefinition.md"
similarity index 100%
rename from "docs/\345\205\254\344\274\227\345\217\267\345\216\206\345\217\262\346\226\207\347\253\240\346\261\207\346\200\273.md"
rename to "docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213BeanDefinition.md"
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213BeanFactory.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213BeanFactory.md"
new file mode 100644
index 0000000..7700641
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213BeanFactory.md"
@@ -0,0 +1,88 @@
+public interface BeanFactory {
+
+    /**
+     * factoryBeanʹ��
+     */
+    String FACTORY_BEAN_PREFIX = "&";
+
+    /**
+     * �������ƻ�ȡbean
+     */
+    Object getBean(String name) throws BeansException;
+
+    /**
+     * �������ƻ�ȡbean
+     */
+    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
+
+    /**
+     * �������ƻ�ȡbean
+     */
+    Object getBean(String name, Object... args) throws BeansException;
+
+    /**
+     * �������ͻ�ȡbean
+     */
+    <T> T getBean(Class<T> requiredType) throws BeansException;
+
+    /**
+     * �������ͻ�ȡbean
+     */
+    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
+
+    /**
+     * ��ȡBeanProvider
+     */
+    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
+
+    /**
+     * ��ȡBeanProvider
+     */
+    <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
+
+    /**
+     * �Ƿ����bean
+     */
+    boolean containsBean(String name);
+
+    /**
+     * �Ƿ�Ϊ����bean
+     */
+    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
+
+    /**
+     * �Ƿ�Ϊԭ��bean
+     */
+    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
+
+    /**
+     * �ж������Ƿ�ƥ��
+     */
+    boolean isTypeMatch(String name, ResolvableType typeToMatch) 
+            throws NoSuchBeanDefinitionException;
+
+    /**
+     * �ж������Ƿ�ƥ��
+     */
+    boolean isTypeMatch(String name, Class<?> typeToMatch) 
+            throws NoSuchBeanDefinitionException;
+
+    /**
+     * �������ƻ�ȡbean������
+     */
+    @Nullable
+    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
+
+    /**
+     * �������ƻ�ȡbean������
+     */
+    @Nullable
+    Class<?> getType(String name, boolean allowFactoryBeanInit) 
+            throws NoSuchBeanDefinitionException;
+
+    /**
+     * ����bean���ƻ�ȡbean�ı���
+     */
+    String[] getAliases(String name);
+
+}
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213BeanFactoryPostProcessor.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213BeanFactoryPostProcessor.md"
new file mode 100644
index 0000000..121dfeb
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213BeanFactoryPostProcessor.md"
@@ -0,0 +1,129 @@
+### 1\. ʲô�� `BeanFactoryPostProcessor`
+
+`BeanFactoryPostProcessor` �������� spring beanFactory �ĺ��ô������������������ƻ� beanFactory ��һЩ��Ϊ��
+
+spring Ϊ�����ṩ������ `BeanFactoryPostProcessor`��
+
+* `org.springframework.beans.factory.config.BeanFactoryPostProcessor`
+
+  ```
+  /**
+   * beanFactory �ĺ��ô����������Ըı� beanFactory ��һЩ��Ϊ
+   */
+  public interface BeanFactoryPostProcessor {
+  
+      /**
+       * ���� beanFactory �ķ���������Ϊ beanFactory��ʵ�������� DefaultListableBeanFactory
+       */
+      void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 
+              throws BeansException;
+  
+  }
+  
+  ```
+
+* `org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor`
+
+  ```
+  /**
+   * BeanDefinition ע��������������������������ע�� beanDefinition ��
+   * �̳��� BeanFactoryPostProcessor �ӿڣ�
+   * Ҳ������д BeanFactoryPostProcessor#postProcessBeanFactory ����
+   * 
+   */
+  public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
+  
+      /**
+       * 1\. �÷������� BeanDefinitionRegistryPostProcessor#postProcessBeanFactory ִ��
+       * 2\. �������Ϊ registry��ʵ������ DefaultListableBeanFactory��Ҳ����ʹ�� beanFactory �IJ���
+       */
+      void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) 
+              throws BeansException;
+  
+  }
+  
+  ```
+
+`BeanFactoryPostProcessor` �� `AbstractApplicationContext#invokeBeanFactoryPostProcessors` �����б�ִ�У�ִ��ʱ��ִ�� `BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry`����ִ�� `BeanFactoryPostProcessor#postProcessBeanFactory`���������ķ��������Բο� [spring ��������ִ֮�� BeanFactoryPostProcessor](https://my.oschina.net/funcy/blog/4641114) һ�ġ�
+
+### 2. `BeanFactoryPostProcessor` �ṩ�Ĺ���
+
+�������������� `BeanFactoryPostProcessor` �ṩ�Ĺ��ܡ�
+
+#### 2.1 `BeanFactoryPostProcessor` ������
+
+̽��ǰ�����������˽��� `BeanFactoryPostProcessor` �ṩ������
+
+```
+void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 
+        throws BeansException;
+
+```
+
+�÷�����ֻ��һ��������`ConfigurableListableBeanFactory`���������˽� `BeanFactoryPostProcessor` ��Ϊ������ʲô����Ҫ֪����������ṩ����Щ���ܣ�
+
+���������������� `set` ������ ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-63b39c81bcae0b10c60a2f847c6b47af932.png)
+
+����֮�⣬���� `register` ������ ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-50c48da9b50dcf18abcd99db09142644c6c.png)
+
+������Щ���������ǾͿ��Զ��ƻ� `beanFactory` ��һЩ��Ϊ�ˡ�
+
+#### 2.2 `BeanDefinitionRegistryPostProcessor` ������
+
+����Ҳ���˽��� `BeanDefinitionRegistryPostProcessor` �ṩ�ķ�����
+
+```
+void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) 
+        throws BeansException;
+
+```
+
+��������IJ����� `BeanDefinitionRegistry`���������������������Ǹ� `BeanDefinition ע����`�����ṩ�����·�����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-5812a2cac994c5940d57c7e6ab55c23a63e.png)
+
+���Կ��������������Ҫ����Χ�� `BeanDefinition` ���������Ƚ���Ҫ�ķ����о����£�
+
+*   `BeanDefinitionRegistry#containsBeanDefinition`���Ƿ����ָ�����Ƶ� `BeanDefinition`
+*   `BeanDefinitionRegistry#getBeanDefinition`����ȡָ�����Ƶ� `BeanDefinition`
+*   `BeanDefinitionRegistry#registerBeanDefinition`��ע��һ�� `BeanDefinition`
+*   `BeanDefinitionRegistry#removeBeanDefinition`���Ƴ� `BeanDefinition`
+
+### 3\. spring �ṩ�� `BeanFactoryPostProcessor`
+
+spring ��һ�������� `BeanFactoryPostProcessor` ��ʵ���࣬�����Ϣ���������£�
+
+*   `EventListenerMethodProcessor`��
+
+    *   ʵ���� `BeanFactoryPostProcessor`��`SmartInitializingSingleton` �ӿ�
+    *   �� `BeanDefinitionRegistryPostProcessor#postProcessBeanFactory` �����л�ȡ�� `EventListenerFactory`
+    *   �� `SmartInitializingSingleton#afterSingletonsInstantiated` �����д��� `@EventListener` ע��
+*   `ConfigurationClassPostProcessor`��
+
+    *   �� `AnnotationConfigUtils#registerAnnotationConfigProcessors(BeanDefinitionRegistry, Object)` ������ע��
+    *   ʵ���� `BeanDefinitionRegistryPostProcessor` �ӿ�
+    *   ���� `@Conditional` ע��
+    *   ���� `@Component` ע��
+    *   ���� `@PropertySource/@PropertySources` ע��
+    *   ���� `@ComponentScan/@ComponentScans` ע��
+    *   ���� `@Import` ע��
+    *   ���� `@ImportResource` ע��
+    *   ���� `@Bean` ע��
+    *   ���� `@Configuration` ע��
+
+���� `EventListenerMethodProcessor` ���� `@EventListener` �ķ��������Բο�[��spring Դ�������spring ̽��֮������ע�� @EventListener](https://my.oschina.net/funcy/blog/4926344).
+
+���� `ConfigurationClassPostProcessor` ������ע������̣����Բο���
+
+*   [ConfigurationClassPostProcessor��һ�������� @ComponentScan ע��](https://my.oschina.net/funcy/blog/4836178)
+*   [ConfigurationClassPostProcessor������������ @Bean ע��](https://my.oschina.net/funcy/blog/4492878)
+*   [ConfigurationClassPostProcessor������������ @Import ע��](https://my.oschina.net/funcy/blog/4678152)
+*   [ConfigurationClassPostProcessor���ģ������� @Conditional ע��](https://my.oschina.net/funcy/blog/4873444)
+
+### 4\. �ܽ�
+
+���Ľ����� `BeanFactoryPostProcessor` �ĸ������˵���� `BeanFactoryPostProcessor` ��ʹ�ã��Լ������� spring �ṩ������ `BeanFactoryPostProcessor` ʵ���ࣺ`EventListenerMethodProcessor` �� `ConfigurationClassPostProcessor`��
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4597545](https://my.oschina.net/funcy/blog/4597545) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213BeanPostProcessor.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213BeanPostProcessor.md"
new file mode 100644
index 0000000..8bed1ab
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\347\273\204\344\273\266\345\210\206\346\236\220/Spring\347\273\204\344\273\266\344\271\213BeanPostProcessor.md"
@@ -0,0 +1,132 @@
+`BeanPostProcessor` ������Ϊ spring bean �ĺ��ô������������� `BeanFactoryPostProcessor`��`BeanPostProcessor` ���Զ� bean ���в�����
+
+spring `BeanPostProcessor` �� bean �Ĵ���������ִ�У�ִ��ʱ������:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-b7a4d4bc1bfbd76537e40cf843b0d18df93.png)
+
+�� bean �Ĵ��������У�`BeanPostProcessor` һ��ִ�й� 8 �Σ�
+
+1.  �������ɴ�������
+2.  �ƶϹ��췽��
+3.  ��ȡע�������
+4.  ������������
+5.  �Ƿ���Ҫע������
+6.  �������
+7.  ��ʼ��ǰ
+8.  ��ʼ����
+
+����������һ������Щ������ִ�е� `BeanPostProcessor`��
+
+### 1\. ʲô�� `BeanPostProcessor`
+
+���� `BeanPostProcessor` ǰ��������������ʲô�� `BeanPostProcessor`���������£�
+
+```
+public interface BeanPostProcessor {
+
+    /**
+     * ��ʼ��ǰִ��
+     */
+    @Nullable
+    default Object postProcessBeforeInitialization(Object bean, String beanName) 
+            throws BeansException {
+        return bean;
+    }
+
+    /**
+     * ��ʼ����ִ��
+     */
+    @Nullable
+    default Object postProcessAfterInitialization(Object bean, String beanName) 
+            throws BeansException {
+        return bean;
+    }
+
+}
+
+```
+
+`BeanPostProcessor` ��һ���ӿڣ������� bean ��ʼǰ���һЩ���������ǿ���ʵ������ӿڣ���д���������������Ϳ����� bean ��ʼ��ǰ����һЩ���������ˡ�
+
+`BeanPostProcessor` �� `AbstractApplicationContext#registerBeanPostProcessors` ��ע�ᡣ
+
+ʵ���ϣ�`BeanPostProcessor` �����ڶ���ӽӿڣ���Щ���Ƕ�ͳ��Ϊ `BeanPostProcessor`�����ĵ���ҪĿ�ľ���������Щ `BeanPostProcessor`��
+
+### 2. `BeanPostProcessor` ����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-102ca0d1e4db82a28871661241b05bc3956.png)
+
+#### 2.1 �������ɴ�������
+
+*   ����λ�ã�`AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation`
+*   ִ�з�����`InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation`
+*   `AbstractAutoProxyCreator#postProcessBeforeInstantiation`�����ɴ�������
+
+#### 2.2 �ƶϹ��췽��
+
+*   ����λ�ã�`AbstractAutowireCapableBeanFactory#determineConstructorsFromBeanPostProcessors`
+*   ִ�з�����`SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors`
+*   `AutowiredAnnotationBeanPostProcessor#determineCandidateConstructors`���ƶϹ��췽��
+
+#### 2.3 ��ȡע�������
+
+*   ����λ�ã�`AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors`
+*   ִ�з�����`MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition`
+*   `ApplicationListenerDetector#postProcessMergedBeanDefinition`���ռ������� `ApplicationListener`
+*   `AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition`�����ұ� `@Autowired`��`@Value`��`@Inject` ��ǵ������뷽��
+*   `CommonAnnotationBeanPostProcessor#postProcessMergedBeanDefinition`�����ұ� `@Resource` ��ǵ������뷽��
+*   `InitDestroyAnnotationBeanPostProcessor#postProcessMergedBeanDefinition`�����ұ� `@PostConstruct`��`@PreDestroy` ��ǵķ���
+
+#### 2.4 ������������
+
+*   ����λ�ã�������û��ִ�У���`AbstractAutowireCapableBeanFactory#doCreateBean`
+*   ִ�з�����`SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference`
+*   `AbstractAutoProxyCreator#getEarlyBeanReference`����ǰ���ɴ�������
+
+#### 2.5 �Ƿ���Ҫע������
+
+*   ����λ�ã�`AbstractAutowireCapableBeanFactory#populateBean`
+*   ִ�з�����`InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation`
+
+#### 2.6 �������
+
+*   ����λ�ã�`AbstractAutowireCapableBeanFactory#populateBean`
+*   ִ�з�����`InstantiationAwareBeanPostProcessor#postProcessProperties`
+*   `AutowiredAnnotationBeanPostProcessor#postProcessProperties`����䱻 `@Autowired`��`@Value`��`@Inject` ��ǵ������뷽��
+*   `CommonAnnotationBeanPostProcessor#postProcessProperties`����䱻 `@Resource` ��ǵ������뷽��
+*   `ImportAwareBeanPostProcessor#postProcessProperties`��Ϊ `EnhancedConfiguration` ʵ������ `beanFactory`
+
+#### 2.7 ��ʼ��ǰ
+
+*   ����λ�ã�`AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization`
+*   ִ�з�����`BeanPostProcessor#postProcessBeforeInitialization`
+*   `ApplicationContextAwareProcessor#postProcessBeforeInitialization`������ `XxxAware` �ӿڵķ���
+*   `BeanValidationPostProcessor#postProcessBeforeInitialization`������ `JSR-303` ��
+*   `ImportAwareBeanPostProcessor#postProcessBeforeInitialization`������ `ImportAware` �ӿڵķ���
+*   `InitDestroyAnnotationBeanPostProcessor#postProcessBeforeInitialization`�����ñ� `@PostConstruct` ��ǵķ���
+*   `LoadTimeWeaverAwareProcessor#postProcessBeforeInitialization`������ `LoadTimeWeaverAware` �ӿڵķ���
+*   `ServletContextAwareProcessor#postProcessBeforeInitialization`������ `ServletContextAware` �ӿڵķ��������� `servletContext` �� `servletConfig`
+
+#### 2.8 ��ʼ����
+
+*   ����λ�ã�`AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization`
+*   ִ�з�����`BeanPostProcessor#postProcessAfterInitialization`
+*   `AbstractAdvisingBeanPostProcessor#postProcessAfterInitialization`������ `AopInfrastructureBean`
+*   `AbstractAutoProxyCreator#postProcessAfterInitialization`�����ɴ�������
+*   `AdvisorAdapterRegistrationManager#postProcessAfterInitialization`�������ǰ bean �� `AdvisorAdapter`����ע��
+*   `ApplicationListenerDetector#postProcessAfterInitialization`�������ǰ bean �� `ApplicationListener`�������ӵ��¼���������
+*   `BeanPostProcessorChecker#postProcessAfterInitialization`�������������˸� log
+*   `BeanValidationPostProcessor#postProcessAfterInitialization`������ `JSR-303` ��
+*   `JmsListenerAnnotationBeanPostProcessor#postProcessAfterInitialization`������ `@JmsListener` ע��
+*   `ScheduledAnnotationBeanPostProcessor#postProcessAfterInitialization`������ `@Scheduled` ע��
+*   `SimpleServletPostProcessor#postProcessAfterInitialization`���� `Servlet` ʵ�������÷��� `Servlet#init(ServletConfig)`
+
+### 3\. �ܽ�
+
+�����һ���������ܽ���Щ `BeanPostProcessor`:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-b1117b66c4881f366669dab69b332164d8f.png)
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4597551](https://my.oschina.net/funcy/blog/4597551) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/ConfigurationClassPostProcessor\357\274\210\344\270\200\357\274\211\357\274\232\345\244\204\347\220\206@ComponentScan\346\263\250\350\247\243.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/ConfigurationClassPostProcessor\357\274\210\344\270\200\357\274\211\357\274\232\345\244\204\347\220\206@ComponentScan\346\263\250\350\247\243.md"
new file mode 100644
index 0000000..f8eb270
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/ConfigurationClassPostProcessor\357\274\210\344\270\200\357\274\211\357\274\232\345\244\204\347\220\206@ComponentScan\346\263\250\350\247\243.md"
@@ -0,0 +1,622 @@
+�� [spring ��������ִ֮�� BeanFactoryPostProcessor](https://my.oschina.net/funcy/blog/4641114) һ���У���ִ�� `BeanFactoryPostProcessor` �����У���һ����Ҫ����ᱻִ�е��������� `ConfigurationClassPostProcessor`�������dz���Ҫ�����ᴦ�� spring �������࣬�� `@Component`��`@PropertySources`��`@ComponentScans`��`@ImportResource` ��ע�⣬��ϵ�����½�ͨ������ʵ������Դ��ĽǶȷ��� spring ���⼸��ע��Ĵ�����
+
+## 1\. �ع� `BeanFactoryPostProcessor` ��ִ��
+
+������ `BeanFactoryPostProcessor` ��ִ�У�����������:
+
+```
+AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.String...)
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#invokeBeanFactoryPostProcessors
+   |-PostProcessorRegistrationDelegate
+     #invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory, List)
+
+```
+
+�� `PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory, List)` �У������ε��� `ConfigurationClassPostProcessor` �ķ�����
+
+*   `invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry)`�����õ��� `BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry` ������
+*   `invokeBeanFactoryPostProcessors(registryProcessors, beanFactory)`�����õ��� `BeanFactoryPostProcessor#postProcessBeanFactory` ������
+
+`ConfigurationClassPostProcessor` ͬʱʵ���� `BeanDefinitionRegistryPostProcessor` �� `BeanFactoryPostProcessor`���������������������ִ�е����������������� `ConfigurationClassPostProcessor` ��������������
+
+```
+/**
+ * ��ִ�� postProcessBeanDefinitionRegistry(...)
+ */
+@Override
+public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
+    int registryId = System.identityHashCode(registry);
+    if (this.registriesPostProcessed.contains(registryId)) {
+        throw new IllegalStateException(...);
+    }
+    if (this.factoriesPostProcessed.contains(registryId)) {
+        throw new IllegalStateException(...);
+    }
+    this.registriesPostProcessed.add(registryId);
+    // �ֵ�����һ������
+    processConfigBeanDefinitions(registry);
+}
+
+/**
+ * ִ���� postProcessBeanDefinitionRegistry(...) ����ִ�� postProcessBeanFactory(...)
+ */
+@Override
+public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
+    int factoryId = System.identityHashCode(beanFactory);
+    if (this.factoriesPostProcessed.contains(factoryId)) {
+        throw new IllegalStateException(
+                "postProcessBeanFactory already called on this post-processor against " + beanFactory);
+    }
+    this.factoriesPostProcessed.add(factoryId);
+    if (!this.registriesPostProcessed.contains(factoryId)) {
+        // ��� beanFactory û�б�����������ִ��һ�� processConfigBeanDefinitions ����
+        // һ������£����ﲻ�ᱻִ�е�
+        processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
+    }
+    // ��ǿ������
+    enhanceConfigurationClasses(beanFactory);
+    // ���Ӵ��� ImportAware �ص��� BeanPostProcessor���뱾�������ϵ���󣬲�����
+    beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
+}
+
+```
+
+����������������˵�����£�
+
+*   ���� `PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory, List)` ��ִ���߼�������ִ�� `postProcessBeanDefinitionRegistry(...)`����ִ�� `postProcessBeanDefinitionRegistry(...)`
+*   `postProcessBeanDefinitionRegistry(...)` ��Ҫ�ǵ��� `processConfigBeanDefinitions(...)` ������
+*   `postProcessBeanFactory(...)` �����жϵ�ǰ beanFactory �Ƿ�ִ�й� `processConfigBeanDefinitions(...)` ���������û�У����ִ�� `processConfigBeanDefinitions(...)` ������֮��� `enhanceConfigurationClasses(...)` �����������������ǿ��
+
+�����Ϸ������������������������յ��õ��� `processConfigBeanDefinitions(...)` �� `enhanceConfigurationClasses(...)`��������������������ǽ������������ص㡣
+
+## 2\. spring ����δ��� `@ComponentScan` ע��ģ�
+
+### 2.1 demo ׼��
+
+�ڷ�������ǰ��������׼������ demo:
+
+����׼��һ���࣬������� `@ComponentScan` ע�⣺
+
+```
+@ComponentScan("org.springframework.learn.explore.demo02")
+public class BeanConfigs {
+
+}
+
+```
+
+��׼������ `Bean`��
+
+```
+@Component
+public class BeanObj1 {
+
+    public BeanObj1() {
+        System.out.println("����beanObj1�Ĺ��췽��");
+    }
+
+    @Override
+    public String toString() {
+        return "BeanObj1{}";
+    }
+}
+
+@Component
+public class BeanObj2 {
+
+    public BeanObj2() {
+        System.out.println("����beanObj2�Ĺ��췽��");
+    }
+
+    @Override
+    public String toString() {
+        return "BeanObj2{}";
+    }
+}
+
+```
+
+��������ࣺ
+
+```
+public class Demo05Main {
+    public static void main(String[] args) {
+        ApplicationContext context = new AnnotationConfigApplicationContext(BeanConfigs.class);
+        Object obj1 = context.getBean("beanObj1");
+        Object obj2 = context.getBean("beanObj2");
+        System.out.println("obj1:" + obj1);
+        System.out.println("obj2:" + obj2);
+        System.out.println(context.getBean("beanConfigs"));
+    }
+}
+
+```
+
+����ֻ�� demo ����Ҫ���֣������� demo �� [gitee/funcy](https://gitee.com/funcy/spring-framework/tree/v5.2.2.RELEASE_learn/spring-learn/src/main/java/org/springframework/learn/explore/demo05).
+
+���У�������£�
+
+```
+����beanObj1�Ĺ��췽��
+����beanObj2�Ĺ��췽��
+obj1:BeanObj1{}
+obj2:BeanObj2{}
+org.springframework.learn.explore.demo05.BeanConfigs@13eb8acf
+
+```
+
+��������������� demo Ϊ����һ�������з�����
+
+### 2.2 `ApplicationContext` �Ĺ��췽����`AnnotationConfigApplicationContext(Class)`
+
+���ǽ��� `AnnotationConfigApplicationContext` �Ĺ��췽��:
+
+```
+public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
+    this();
+    register(componentClasses);
+    // spring ����������
+    refresh();
+}
+
+/**
+ * this() �����ĵ�������
+ */
+public AnnotationConfigApplicationContext() {
+    // ��������Ա���и�ֵ
+    // ������õ���`AnnotationConfigApplicationContext(Class)`���� �����������Բ����õ�
+    // ������õ���`AnnotationConfigApplicationContext(String)`���� �����������ԲŻ��õ�
+    this.reader = new AnnotatedBeanDefinitionReader(this);
+    this.scanner = new ClassPathBeanDefinitionScanner(this);
+}
+
+/**
+ * register(...) ����������
+ */
+@Override
+public void register(Class<?>... componentClasses) {
+    Assert.notEmpty(componentClasses, "At least one component class must be specified");
+    this.reader.register(componentClasses);
+}
+
+```
+
+`AnnotationConfigApplicationContext` �Ĺ��췽���������£�
+
+*   `this()`�������޲ι��췽���������������Ҫ�Ǹ� `reader` �� `scanner` ��Ա������ֵ��
+*   `register(componentClasses)`��ע�� `component` �ൽ `beanFactory` �У����õ��� `reader.register(...)` ������
+*   `refresh()`��spring �����������������Ͳ�������
+
+ִ���� `register(componentClasses);` ǰ��`beanFactory` �ڵ� `BeanDefinitionMap` �������£�
+
+ִ��ǰ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-c317168bfde886f7817e6e9a11301c84b52.png)
+
+ִ�к�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-cc2f7bcdb4b56f67893ac29774bb8119892.png)
+
+���Կ�����`beanConfigs` �Ѿ�ע�ᵽ `beanDefinitionNames` �ˡ�
+
+�����spring ����ֻ�ǰ� `beanConfigs` ע�ᵽ�� `beanDefinitionNames`��`BeanConfigs` �� `new AnnotationConfigApplicationContext(BeanConfigs.class)` ����ģ�����û��ɨ�� `@ComponentSacn` ע��ָ���İ�����Ҳ���� `org.springframework.learn.explore.demo05`����ô����ɨ������������е��أ���Ӧ���� `ConfigurationClassPostProcessor` �У����Ǽ������¿���
+
+### 2.3 ���������ࣺ`ConfigurationClassPostProcessor#processConfigBeanDefinitions`
+
+���ݿ�ƪ�ķ���������ֱ�ӽ��� `ConfigurationClassPostProcessor#processConfigBeanDefinitions` ���������������£�
+
+```
+AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(Class)
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#invokeBeanFactoryPostProcessors
+   |-PostProcessorRegistrationDelegate
+      #invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory, List)
+    |-PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors
+     |-ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry
+      |-ConfigurationClassPostProcessor#processConfigBeanDefinitions
+
+```
+
+�����������£�
+
+```
+public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
+    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
+    // 1\. ��ȡ����BeanDefinition����
+    String[] candidateNames = registry.getBeanDefinitionNames();
+    // 2\. ѭ��candidateNames���飬��ʶFull��Lite
+    for (String beanName : candidateNames) {
+        BeanDefinition beanDef = registry.getBeanDefinition(beanName);
+        // �жϵ�ǰBeanDefinition���Ѿ��������ˣ��������˾Ͳ��ٴ�����
+        if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
+            // ����ֻ�Ǵ��˸�log��ʡ��
+            ...
+        }
+        // �ж��Ƿ�Ϊ�����࣬��������������
+        //  1\. ���� @Configuration ע���� proxyBeanMethods != false ���࣬spring ����Ϊ Full ������
+        //  2\. ���� @Configuration ע���� proxyBeanMethods == false, ����� @Component��@ComponentScan��
+        //     @Import��@ImportResource��@Bean ����֮һע����࣬spring ����Ϊ Lite ������
+        // ������Full��Lite�����б�ʶ
+        else if (ConfigurationClassUtils
+                 .checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
+            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
+        }
+    }
+    // ���û�������ֱ࣬�ӷ���
+    if (configCandidates.isEmpty()) {
+        return;
+    }
+
+    // ʡ���޹صĴ���
+    ...
+
+    // ������������������dz���Ҫ������������������� ��@Component��@Import��ע���
+    ConfigurationClassParser parser = new ConfigurationClassParser(
+            this.metadataReaderFactory, this.problemReporter, this.environment,
+            this.resourceLoader, this.componentScanBeanNameGenerator, registry);
+    // �����ṹ��candidates����Ҫ�����������࣬alreadyParsed����ɽ�����������
+    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
+    Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
+    do {
+        // 3\. ���������࣬����������˺ܶ��£�
+        // �磺����@Component��@PropertySources��@ComponentScans��@ImportResource��ע��
+        // ע��������һ���Խ������е�candidates
+        parser.parse(candidates);
+        parser.validate();
+        Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
+        configClasses.removeAll(alreadyParsed);
+        // ���� reader�����reader��ǰ��ApplicationContext�е�reader����ͬһ��
+        if (this.reader == null) {
+            this.reader = new ConfigurationClassBeanDefinitionReader(
+                    registry, this.sourceExtractor, this.resourceLoader, this.environment,
+                    this.importBeanNameGenerator, parser.getImportRegistry());
+        }
+        // 4\. �������������
+        // ���ǰ�@Import������ࡢ�������д�@Bean�ķ�����@ImportResource�������Դ��ת����BeanDefinition
+        this.reader.loadBeanDefinitions(configClasses);
+        // ��configClasses���뵽alreadyParsed
+        alreadyParsed.addAll(configClasses);
+
+        // ������ɺ󣬻��candidates����գ���������������ӵġ�δ��������Full���������ӵ�candidates��
+        candidates.clear();
+        // 5\. �������ؽ������������ӵ���Ϊ Full ��������δ���������Ͱ������ӵ�candidates�У����´�ѭ��ʱ�ٽ���
+        // ���ע��������BeanDefinition������ �� candidateNames���бȽ�
+        // ������ڵĻ���˵�����µ�BeanDefinitionע�������
+        if (registry.getBeanDefinitionCount() > candidateNames.length) {
+            String[] newCandidateNames = registry.getBeanDefinitionNames();
+            Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
+            Set<String> alreadyParsedClasses = new HashSet<>();
+            // ѭ��alreadyParsed�����������뵽alreadyParsedClasses
+            for (ConfigurationClass configurationClass : alreadyParsed) {
+                alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
+            }
+            for (String candidateName : newCandidateNames) {
+                if (!oldCandidateNames.contains(candidateName)) {
+                    BeanDefinition bd = registry.getBeanDefinition(candidateName);
+                    // ����¼ӵ���Ϊ�����࣬��δ���������Ͱ������ӵ�candidates�У��ȴ��´�ѭ������
+                    if (ConfigurationClassUtils
+                            .checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
+                            !alreadyParsedClasses.contains(bd.getBeanClassName())) {
+                        candidates.add(new BeanDefinitionHolder(bd, candidateName));
+                    }
+                }
+            }
+            candidateNames = newCandidateNames;
+        }
+    }
+
+    // ʡ���뱾�������޹صĴ���
+    ...
+}
+
+```
+
+��ʽ�������Ϸ���ǰ������ȷ spring ����������ļ��������
+
+*   �����ࣺ���� `@Configuration`��`@Component`��`@ComponentScan`��`@Import`��`@ImportResource` ������֮һע����ࣻ
+*   `Full` �����ࣺ���� `@Configuration` ע���� `proxyBeanMethods != false` ���࣬`spring` ����Ϊ `Full` �����ࣻ
+*   `Lite` �����ࣺ���� `@Configuration` ע���� `proxyBeanMethods == false`, ����� `@Component`��`@ComponentScan`��`@Import`��`@ImportResource` ������֮һע����࣬`spring` ����Ϊ `Lite` �����ࡣ
+
+���Ϸ����е㳤���ܽ���������������¼����£�
+
+1. ��ȡ���� `BeanDefinition` �������ⲽִ����ɺ󣬽�����£�
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-df320c2911c4222a6867a0f0a4fe7d9987d.png)
+
+2. ѭ�� `candidateNames` ���飬��ʶ�����������Ϊ `Full` ���� `Lite`����һ�������Ĺ������Ƕ��������Ӧ�� `BeanDefinition` ���б�ʶ�����ڱ�ʶ����ʲô���ã��ں������ `@Configuration` ע��ʱ���ٷ�������`beanConfigs` û�� `@Configuration` ע�⣬����� `Lite` �����ࡣ��һ���õ��� `configCandidates` ���£�
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-81a68ec905807d77153158af4c86d48a1d3.png)
+
+3. ���������࣬������ `@Component`��`@PropertySources`��`@ComponentScans`��`@ImportResource` ��ע���ע���࣬��������dz���Ҫ��������ص������
+
+4. �������ν������࣬�� @Import ������ࡢ�������д� @Bean �ķ�����@ImportResource �������Դ��ת���� BeanDefinition�����ص� `BeanDefinitionMap` �У�
+
+5. �������ؽ������������ӵ���Ϊ `Full` �����࣬��δ���������Ͱ������ӵ� `candidates` �У����´�ѭ��ʱ�ٽ�����
+
+���Ϸ��������̾������ˣ����������Ǿ�������������Ľ�����Ҳ���������ĵ� 3 ����
+
+### 2.4 ������`ConfigurationClassParser#parse(Set<BeanDefinitionHolder>)`
+
+```
+public void parse(Set<BeanDefinitionHolder> configCandidates) {
+    // ѭ����������������
+    for (BeanDefinitionHolder holder : configCandidates) {
+        BeanDefinition bd = holder.getBeanDefinition();
+        try {
+            // ������BeanDefinition��AnnotatedBeanDefinition��ʵ��
+            // ǰ��õ��� beanConfigs����AnnotatedBeanDefinition��ʵ����if��ķ�����ִ��
+            if (bd instanceof AnnotatedBeanDefinition) {
+                parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
+            }
+            else if (bd instanceof AbstractBeanDefinition 
+                    && ((AbstractBeanDefinition) bd).hasBeanClass()) {
+                parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
+            }
+            else {
+                parse(bd.getBeanClassName(), holder.getBeanName());
+            }
+        }
+        catch (...) {
+            ...
+        }
+    }
+    this.deferredImportSelectorHandler.process();
+}
+
+/**
+ * ����parse�����
+ */
+protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
+    // ConfigurationClass��metadata��beanName�İ�װ��
+    processConfigurationClass(new ConfigurationClass(metadata, beanName));
+}
+
+```
+
+ǰ�洫��� `BeanConfigs` �ᱻ��װ�� `AnnotatedGenericBeanDefinition`������ `AnnotatedBeanDefinition` ��ʵ����Ȼ��ͻ���� `ConfigurationClassParser#parse(String, String)`��������ʵ��û��ʲôʵ���ԵĹ������������� `processConfigurationClass(...)` ������
+
+```
+/**
+ * ������������ж���������֤�����಻�ظ�����
+ * ʵ�ʸɻ���� doProcessConfigurationClass(...)
+ */
+protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
+    // �ж��Ƿ���Ҫ��������������� @Conditional ע�⣬�ж��Ƿ���������
+    if (this.conditionEvaluator.shouldSkip(configClass.getMetadata() ,
+             ConfigurationPhase.PARSE_CONFIGURATION)) {
+        return;
+    }
+    ConfigurationClass existingClass = this.configurationClasses.get(configClass);
+    // �ж��Ƿ���������������Ͳ������ˣ���������ݹ�ϵ����ʡ��
+    if (existingClass != null) {
+        ...
+    }
+    // SourceClass ͬǰ��� ConfigurationClass һ����Ҳ�Ƕ�metadata��beanName�İ�װ
+    SourceClass sourceClass = asSourceClass(configClass);
+    do {
+        // doXxx(...) �������������ɻ��
+        // ������ص����ݲ�Ϊ�գ�������ٴ�ѭ��
+        sourceClass = doProcessConfigurationClass(configClass, sourceClass);
+    }
+    while (sourceClass != null);
+    this.configurationClasses.put(configClass, configClass);
+}
+
+```
+
+����������ж��������Ƿ�����ִ��������Ȼ���� `do-while` ѭ����ִ�� `doProcessConfigurationClass(...)`��ѭ�������� `doProcessConfigurationClass(...)` ���ص����ݲ�Ϊ�գ����Ǽ������¿���
+
+### 2.5 ���������ࣺ`ConfigurationClassParser#doProcessConfigurationClass`
+
+```
+/**
+ * ������������������������ķ���
+ */
+protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, 
+        SourceClass sourceClass) throws IOException {
+    // 1\. ����� @Component ע�⣬�ݹ鴦���ڲ��࣬���IJ���ע
+    ...
+
+    // 2\. ����@PropertySourceע�⣬���IJ���ע
+    ...
+
+    // 3\. ���� @ComponentScan/@ComponentScans ע��
+    // 3.1 ��ȡ�������ϵ� @ComponentScan/@ComponentScans ע��
+    Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
+            sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
+    // ���û�д���ComponentScan�����߱�@Condition�����������Ͳ��ٽ������if
+    if (!componentScans.isEmpty() && !this.conditionEvaluator
+            .shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
+        // ѭ������componentScans��Ҳ�����������ϵ�����@ComponentScanע�������
+        for (AnnotationAttributes componentScan : componentScans) {
+            // 3.2 componentScanParser.parse(...)���������componentScan�IJ���
+            // componentScan����@ComponentScan�ϵľ������ݣ�
+            // sourceClass.getMetadata().getClassName()���������������
+            Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser
+                    .parse(componentScan, sourceClass.getMetadata().getClassName());
+            // 3.3 ѭ���õ��� BeanDefinition�������Ӧ�����������࣬�ݹ����parse(...)����
+            // componentScan�����������б�@Bean��ǵķ�����������@ComponentScanע��
+            for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
+                BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
+                if (bdCand == null) {
+                    bdCand = holder.getBeanDefinition();
+                }
+                // �ж�BeanDefinition��Ӧ�����Ƿ�Ϊ������
+                if (ConfigurationClassUtils
+                        .checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
+                    // �Եõ����࣬����parse(...)�������ٴν��н���
+                    parse(bdCand.getBeanClassName(), holder.getBeanName());
+                }
+            }
+        }
+    }
+    // 4\. ����@Importע�⣬���IJ���ע
+    ...
+
+    // 5\. ����@ImportResourceע�⣬���IJ���ע
+    ...
+
+    // 6\. ����@Bean��ע�⣬�����IJ���ע
+    ...
+
+    // 7\. ����������ĸ��࣬���� processConfigurationClass(...) ��������һ��ѭ��ʱ����
+    // sourceClass.getMetadata()����������
+    if (sourceClass.getMetadata().hasSuperClass()) {
+        String superclass = sourceClass.getMetadata().getSuperClassName();
+        if (superclass != null && !superclass.startsWith("java") &&
+                !this.knownSuperclasses.containsKey(superclass)) {
+            this.knownSuperclasses.put(superclass, configClass);
+            return sourceClass.getSuperClass();
+        }
+    }
+    return null;
+}
+
+/**
+ * ����������ٴε���processConfigurationClass(...)�������н���
+ * Ŀ���ǣ����������Ҳ�п����б�@Bean��ǵķ�����������ComponentScan��ע��
+ */
+protected final void parse(@Nullable String className, String beanName) throws IOException {
+    Assert.notNull(className, "No bean class name for configuration class bean definition");
+    MetadataReader reader = this.metadataReaderFactory.getMetadataReader(className);
+    // �ֵ��� processConfigurationClass(...) ������
+    processConfigurationClass(new ConfigurationClass(reader, beanName));
+}
+
+```
+
+`ConfigurationClassParser#doProcessConfigurationClass` ����������Ƕ� `@PropertySource`��`@ComponentScan`��`@Import`��`@ImportResource`��`@Bean` ��ע�⣬�������ǽ���ע `@ComponentScan` ע��Ĵ������������£�
+
+1.  ��ȡ�������ϵ� `@ComponentScan/@ComponentScans` ע�⣻
+2.  `componentScanParser.parse(...)`��������� `componentScan` �IJ�����������ص������
+3.  ѭ���õ��� `BeanDefinition`�������Ӧ�����������࣬�ݹ���� `parse(...)` ���������ɨ�赽������� `@Import`��`@Bean`��`@ComponentScan` ��ע�⣬�ݹ���� `parse(...)` ����ʱ�ᱻ��������
+
+����IJ��������ڴ������Ѿ�ע�͵ú�����ˣ��Ͳ���˵�ˣ�����ֱ������ `@ComponentScan` �Ľ�������.
+
+### 2.6 ���������ĵط���`ComponentScanAnnotationParser#parse`
+
+`@ComponentScan` �Ľ����� `ComponentScanAnnotationParser#parse` �����У��������£�
+
+```
+public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
+    // 1\. ����һ��ɨ����������ɨ���
+    ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
+            componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
+    // 2\. �ж��Ƿ���д��Ĭ�ϵ���������
+    Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
+    boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
+    scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
+            BeanUtils.instantiateClass(generatorClass));
+    // 3\. ���� @ComponentScan ע�������
+    // 3.1 ���� @ComponentScan �� scopedProxy ����
+    ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
+    if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
+        scanner.setScopedProxyMode(scopedProxyMode);
+    }
+    else {
+        Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
+        scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
+    }
+    // 3.2 ���� @ComponentScan �� resourcePattern ����
+    scanner.setResourcePattern(componentScan.getString("resourcePattern"));
+
+    // 3.3 ���� @ComponentScan �� includeFilters ����
+    // addIncludeFilter addExcludeFilter,��������List<TypeFilter>�����������
+    for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
+        for (TypeFilter typeFilter : typeFiltersFor(filter)) {
+            scanner.addIncludeFilter(typeFilter);
+        }
+    }
+    // 3.4 ���� @ComponentScan �� excludeFilters ����
+    for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
+        for (TypeFilter typeFilter : typeFiltersFor(filter)) {
+            scanner.addExcludeFilter(typeFilter);
+        }
+    }
+    boolean lazyInit = componentScan.getBoolean("lazyInit");
+    if (lazyInit) {
+        scanner.getBeanDefinitionDefaults().setLazyInit(true);
+    }
+    Set<String> basePackages = new LinkedHashSet<>();
+    // 3.5\. @ComponentScan ָ���� basePackages ���ԣ�������Ե�������String
+    String[] basePackagesArray = componentScan.getStringArray("basePackages");
+    for (String pkg : basePackagesArray) {
+        String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
+                ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
+        Collections.addAll(basePackages, tokenized);
+    }
+    // 3.6\. @ComponentScan ָ���� basePackageClasses�� ������Ե�������Class��
+    //    ��ֻҪ�����⼸����ͬ���ģ��������⼸�����¼��Ķ����Ա�ɨ�赽
+    for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
+        basePackages.add(ClassUtils.getPackageName(clazz));
+    }
+    // 3.7 ���϶�û��ָ����Ĭ�ϻ�����������ڵİ�����Ϊɨ��·��
+    if (basePackages.isEmpty()) {
+        basePackages.add(ClassUtils.getPackageName(declaringClass));
+    }
+    // 3.8 �����ų���������Ͱ�ע�������������ų���������ִ��ƥ���ʱ�򣬻���������ų�
+    scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
+        @Override
+        protected boolean matchClassName(String className) {
+            return declaringClass.equals(className);
+        }
+    });
+    // 4\. ������ſ�ʼɨ�� @ComponentScan ָ���İ�
+    // ɨ����ɺ󣬶Է����������࣬spring�Ὣ�����ӵ�beanFactory��BeanDefinitionMap��
+    return scanner.doScan(StringUtils.toStringArray(basePackages));
+}
+
+```
+
+���Ϸ���ִ���������£�
+
+1.  ����һ��ɨ����������ɨ���
+2.  �ж��Ƿ���д��Ĭ�ϵ���������
+3.  ���� `@ComponentScan` ע������ԣ�����ɨ����
+    1.  ���� `@ComponentScan` �� `scopedProxy` ����
+    2.  ���� `@ComponentScan` �� `resourcePattern` ����
+    3.  ���� `@ComponentScan` �� `includeFilters` ����
+    4.  ���� `@ComponentScan` �� `excludeFilters` ����
+    5.  ���� `@ComponentScan` �� `basePackages` ���ԣ�������Ե������� `String`
+    6.  ���� `@ComponentScan` �� `basePackageClasses` ���ԣ� ������Ե������� `Class`
+    7.  ���û��ָ��ɨ������Ĭ�ϻ�����������ڵİ�����Ϊɨ��·��
+    8.  �����ų���������Ͱ�ע�������������ų���������ִ��ƥ���ʱ�򣬻���������ų�
+4.  ���� `ClassPathBeanDefinitionScanner#doScan` ���ɨ��
+
+���գ������� `ClassPathBeanDefinitionScanner#doScan` ��������ɰ���������������������� [spring ��������֮����ɨ������](https://my.oschina.net/funcy/blog/4614071)�Ѿ���ϸ�������ˣ�����Ͳ��ٷ����ˡ�
+
+�����ǻص� `ConfigurationClassPostProcessor#processConfigBeanDefinitions` ������
+
+```
+public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
+    ...
+    parser.parse(candidates);
+    ....
+}
+
+```
+
+ִ��ǰ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-85e400f7d45b4fe5e2353e359f034b1a726.png)
+
+ִ�к�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-a6d02c305f562414326ca7836c281ebf472.png)
+
+���Կ�����`BeanObj1`��`BeanObj2` �Ѿ������� `BeanFactory` �� `BeanDefinitionMap` ���� ��
+
+### 2.7 �ܽ�
+
+spring ���� `@ComponentScan` �����̵�����ͽ����ˣ���������λ�� `ConfigurationClassParser#doProcessConfigurationClass` ����������������˽��� `@ComponentScan`��������� `@Bean`��`@Import` ��ע�⣬����ֻ���� `@ComponentScan` �Ĵ������̣������������ܽ����£�
+
+1.  ��ȡ�������ϵ� `@ComponentScan/@ComponentScans` ע��
+2.  ���н��� `@ComponentScan` �IJ���������ʱ���ȶ�����һ����������Ȼ����� `@ComponentScan` �����ԣ���������������������䣬��������Щ֮�󣬾Ϳ�ʼ���а�ɨ�������
+3.  ����ɨ��õ����࣬�����Ϊ�����࣬��ͨ������ `parse(...)` ������һ�ε��� `ConfigurationClassParser#doProcessConfigurationClass` ���н�������һ��dz���Ҫ����ͱ�֤��ɨ��õ������е� `@Bean`��`@Import`��`@ComponentScan` ��ע��õ�������
+
+���ˣ����ľ��ȵ������ˣ���������ƪ���»�������� `ConfigurationClassPostProcessor` ������ע��Ĵ�����
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4836178](https://my.oschina.net/funcy/blog/4836178) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/ConfigurationClassPostProcessor\357\274\210\344\270\211\357\274\211\357\274\232\345\244\204\347\220\206@Import\346\263\250\350\247\243.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/ConfigurationClassPostProcessor\357\274\210\344\270\211\357\274\211\357\274\232\345\244\204\347\220\206@Import\346\263\250\350\247\243.md"
new file mode 100644
index 0000000..ad1a70a
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/ConfigurationClassPostProcessor\357\274\210\344\270\211\357\274\211\357\274\232\345\244\204\347\220\206@Import\346\263\250\350\247\243.md"
@@ -0,0 +1,849 @@
+������ `ConfigurationClassPostProcessor` �����ĵ���ƪ����Ҫ�Ƿ��� spring �� `@Import` ע��Ĵ������̡�
+
+## 4. spring ����δ��� @Import ע��ģ�
+
+�н����ģ����Ǽ������� spring �� `@Import` ע��Ĵ������̡�
+
+### 4.1 �˽� `@Import` ע��
+
+���������� `@Import` ע��Ķ��壺
+
+```
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface Import {
+    /**
+     * {@link Configuration @Configuration}, {@link ImportSelector},
+     * {@link ImportBeanDefinitionRegistrar}, or regular component classes to import.
+     */
+    Class<?>[] value();
+}
+```
+
+`@Import` ����һ��������`value()`��֧�ֵ������� `Class`����������ĵ�����������֧�������� 4 �֣�
+
+- �� `@Configuration` ע���ǵ���
+- ʵ���� `ImportSelector` ����
+- ʵ���� `ImportBeanDefinitionRegistrar` ����
+- ��ͨ��
+
+������������ͨ��һ�� demo ��չʾʹ�� `@Import` ��ν��������ർ�뵽 spring �С�
+
+### 4.2 demo ׼��
+
+1. ����׼�� 4 �� bean��
+
+```
+/**
+ * Element01
+ */
+public class Element01 {
+    public String desc() {
+        return "this is element 01";
+    }
+}
+
+/**
+ * Element02
+ */
+public class Element02 {
+    public String desc() {
+        return "this is element 02";
+    }
+}
+
+/**
+ * Element03
+ */
+public class Element03 {
+    public String desc() {
+        return "this is element 03";
+    }
+}
+
+/**
+ * Element04
+ */
+public class Element04 {
+    public String desc() {
+        return "this is element 04";
+    }
+}
+```
+
+1. ׼��ʵ�� `ImportBeanDefinitionRegistrar` ���࣬�� `element02` ע������
+
+```
+public class Element02ImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
+
+    /**
+     * �� registerBeanDefinitions ��ע��element02��Ӧ��BeanDefinition
+     * Ҳ���ǰ� Element02 ��Ӧ�� beanDefinition �ֶ�ע�ᵽbeanFactory 
+     * �� beanDefinitionMap ��
+     */
+    @Override
+    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, 
+            BeanDefinitionRegistry registry) {
+        registry.registerBeanDefinition("element02", new RootBeanDefinition(Element02.class));
+    }
+}
+```
+
+1. ׼��ʵ�� `ImportSelector` ���࣬�� `selectImports(...)` �����У����� `Element03` �� "����������"
+
+```
+public class Element03Selector implements ImportSelector {
+    /**
+     * ����String Ϊ ����.����
+     * ���ں���Ҫ�õ����䣬��˱�����"����.����"
+     * @param importingClassMetadata
+     * @return
+     */
+    @Override
+    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
+        return new String[] {Element03.class.getName()};
+    }
+}
+```
+
+1. ׼��һ���� `@Configuration` ע�����࣬ͨ�����б� `@Bean` ��ǵķ������� `Element04`
+
+```
+@Configuration
+public class Element04Configuration {
+    @Bean
+    public Element04 element04() {
+        return new Element04();
+    }
+
+}
+```
+
+1. ���� `@EnableElement` ע�⣬���е� `@Import` ע���������� `Element01.class`��`Element02ImportBeanDefinitionRegistrar.class`��`Element03Selector.class`��`Element04Configuration.class`
+
+```
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Import({
+        // ��ͨ�� 
+        Element01.class,
+        // ʵ���� ImportBeanDefinitionRegistrar ����
+        Element02ImportBeanDefinitionRegistrar.class,
+        // ʵ���� ImportSelector ����
+        Element03Selector.class,
+        // �� @Configuration ��ǵ���
+        Element04Configuration.class
+})
+public @interface EnableElement {
+
+}
+```
+
+1. ���ࣺ
+
+```
+// ֻ��Ҫ @EnableElement ע��
+@EnableElement
+public class Demo04Main {
+
+    public static void main(String[] args) {
+        // ������� Demo04Main.class
+        ApplicationContext context = new AnnotationConfigApplicationContext(Demo04Main.class);
+
+        Element01 element01 = context.getBean(Element01.class);
+        System.out.println(element01.desc());
+
+        Element02 element02 = context.getBean(Element02.class);
+        System.out.println(element02.desc());
+
+        Element03 element03 = context.getBean(Element03.class);
+        System.out.println(element03.desc());
+
+        Element04 element04 = context.getBean(Element04.class);
+        System.out.println(element04.desc());
+    }
+}
+```
+
+��������� [gitee/funcy](https://gitee.com/funcy/spring-framework/tree/v5.2.2.RELEASE_learn/spring-learn/src/main/java/org/springframework/learn/explore/demo04).
+
+���У�������£�
+
+```
+this is element 01
+this is element 02
+this is element 03
+this is element 04
+```
+
+���Կ�����4 �� bean ���ɹ������� spring ������������������ͨ������������ spring ����δ����ġ�
+
+ע�������� `ConfigurationClassPostProcessor` �����ĵ���ƪ������ǰ����ƪ���£�[���� @ComponentScan ע��](https://my.oschina.net/funcy/blog/4836178)��[���� @Bean ע��](https://my.oschina.net/funcy/blog/4492878)����ͬ�Ĵ��룬���Ļ�һ�ʴ����������������ˡ�
+
+### 4.3 ���������ࣺ`ConfigurationClassPostProcessor#processConfigBeanDefinitions`
+
+����������Ľ����̣�ǰ��ƪ�Ѿ�����ᵽ���ˣ���������ֱ�ӿ��ؼ����룺
+
+```
+public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
+    ...
+    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
+    Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
+    do {
+        // 1. ����������, ��@Component��@PropertySources��@ComponentScans��
+        // @ImportResource�ȵĽ���
+        parser.parse(candidates);
+        parser.validate();
+        // ������ɺ󣬵õ��������࣬�����ౣ���� parser �� configurationClasses ������
+        Set<ConfigurationClass> configClasses 
+                = new LinkedHashSet<>(parser.getConfigurationClasses());
+        ...
+
+        // 2. �� @Import ������ࡢ�������д�@Bean�ķ�����
+        // @ImportResource �������Դ��ת����BeanDefinition
+        this.reader.loadBeanDefinitions(configClasses);
+        ...
+        // ���ע��������BeanDefinition������ �� candidateNames���бȽ�
+        // ������ڵĻ���˵�����µ�BeanDefinitionע�������
+        if (registry.getBeanDefinitionCount() > candidateNames.length) {
+            ...
+            for (String candidateName : newCandidateNames) {
+                // ���˱���������BeanDefinition
+                if (!oldCandidateNames.contains(candidateName)) {
+                    BeanDefinition bd = registry.getBeanDefinition(candidateName);
+                    // 3. �������ӵ��࣬����������࣬��δ���������ӵ�candidates�У��ȴ��´�ѭ������
+                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(
+                            bd, this.metadataReaderFactory) 
+                            &&!alreadyParsedClasses.contains(bd.getBeanClassName())) {
+                        candidates.add(new BeanDefinitionHolder(bd, candidateName));
+                    }
+                }
+            }
+            candidateNames = newCandidateNames;
+        }
+    }
+    while (!candidates.isEmpty());
+    ...
+}
+```
+
+���ϴ��뾭����һЩ����ֻ�����˴��� `@Import` �ؼ����裬�ܽ����£�
+
+1. ���������࣬�� `@Component`��`@PropertySources`��`@ComponentScans`��`@ImportResource` �ȵĽ�������� ����ǰ��ƪ����Ҳ�����ˣ�������Ǿۼ��� `@Import` ���ٴη���������һ����Ҫ������������ֻ��һ�������������� `main()` ������ע��� `Demo04.class`��
+
+   ![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-840c14685be569012b54d94aad67ee48825.png)
+
+2. �� `@Import` ������ࡢ�������д� `@Bean` �ķ�����`@ImportResource` �������Դ��ת���� `BeanDefinition`�����������ǰ����� `@Bean` ��ʱ��Ҳ�������ˣ��������Ҳ���������
+
+3. �������ӵ��࣬����������࣬��δ���������ӵ� `candidates` �У��ȴ��´�ѭ��������
+
+### 4.4 ���������ࣺ`ConfigurationClassParser#doProcessConfigurationClass`
+
+���������� `@Import` ����ν����ģ����� `ConfigurationClassParser#doProcessConfigurationClass`��
+
+```
+/**
+ * ������������������������ķ���
+ */
+protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, 
+        SourceClass sourceClass) throws IOException {
+    // 1. ����� @Component ע�⣬�ݹ鴦���ڲ��࣬���IJ���ע
+    ...
+
+    // 2. ����@PropertySourceע�⣬���IJ���ע
+    ...
+
+    // 3. ���� @ComponentScan/@ComponentScans ע�⣬���IJ���ע
+    ...
+
+    // 4. ����@Importע��
+    processImports(configClass, sourceClass, getImports(sourceClass), true);
+
+    // 5. ����@ImportResourceע�⣬���IJ���ע
+    ...
+
+    // 6. ����@Bean��ע�⣬���IJ���ע
+    ...
+
+    // 7. ����������ĸ��࣬���� processConfigurationClass(...) ��������һ��ѭ��ʱ����
+    ...
+    return null;
+}
+```
+
+���� `@Import` ע����õ��� `processImports(...)` ���������Ǽ�����
+
+#### 1. ��ȡ `@Import` �������
+
+�����ǰ�Ŀ��ŵ� `processImports(...)` ������
+
+```
+processImports(configClass, sourceClass, getImports(sourceClass), true);
+```
+
+��������������� 4 ��������
+
+- `configClass`�������࣬���� `demo04Main` ��Ӧ�������ࣻ
+- `sourceClass`���� `demo04Main` �����ϵ�ע��İ�װ��
+- `getImports(sourceClass)`��`getImports(...)` ������ȡ���� `sourceClass` ������ `@Import` ע��������ࣻ
+- `true`������ֵ���Ƿ���ѭ�����롣
+
+���У���ȡ `@Import` ע����������� `getImports(...)` �Ĺ��ܣ������������������������λ�ȡ�ģ�
+
+```
+private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException {
+    Set<SourceClass> imports = new LinkedHashSet<>();
+    Set<SourceClass> visited = new LinkedHashSet<>();
+    // �������ȡ
+    collectImports(sourceClass, imports, visited);
+    return imports;
+}
+
+/**
+ * ����Ļ�ȡ����
+ */
+private void collectImports(SourceClass sourceClass, Set<SourceClass> imports, 
+        Set<SourceClass> visited) throws IOException {
+    if (visited.add(sourceClass)) {
+        for (SourceClass annotation : sourceClass.getAnnotations()) {
+            String annName = annotation.getMetadata().getClassName();
+            if (!annName.equals(Import.class.getName())) {
+                // ���annotation�����Ʋ���import����ݹ���� collectImports(...) ����
+                collectImports(annotation, imports, visited);
+            }
+        }
+        // ��ȡ��ǰ��� @Import ע��
+        imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
+    }
+}
+```
+
+��ȡ `@Import` �ķ����� `ConfigurationClassParser#collectImports`�������������ȡ��ȡ��������ʽ���£�
+
+1. ��ȡ�����������ע�⣻
+2. ������Щע�⣬����� `@Import` ע�⣬���ȡ `@Import` �� `value` ֵ�����򣬻ص���һ��������������
+
+����֮���������� `demo04Main` �ϵ� `@EnableElement` ע��ᱻ��ȡ�����������ע�ⲻ�� `@Import` ע�⣬�ͼ�����ȡ `@EnableElement` ���ϵ�ע�⣬��ʱ���� `@EnableElement` �� `@Import` ע�⣬��ʱ�ͻ��ȡ `@Import` �� `value()` ֵ��Ҳ���� `@Import` ע��������ࡣ
+
+����������к� ���õ��Ľ�����£�
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-05c7fb442b4bb84d13ff6688e5fbf31cfa5.png)
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-4e7153f9cbb922496e7c303cc3c35e7eceb.png)
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-b238838641af43b783fc9b14c4226f5c1eb.png)
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-d7e2063676e6e19850c35893b62f4ab76a9.png)
+
+�õ��Ľ��Ϊ `LinkedHashSet`��һ�ν�ͼ�����㣬��˷�Ϊ�� 4 ��ͼ�����Կ�����`@Import` ע������� 4 ���඼��ȡ���ˣ�
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-d615198a8f6dbef1ac6a800526311f36078.png)
+
+#### 2. ���� `@Import` �������
+
+��ȡ�� `@Import` ע�⵼���������������� `processImports(...)` ������
+
+```
+private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
+        Collection<SourceClass> importCandidates, boolean checkForCircularImports) {
+    ...
+    for (SourceClass candidate : importCandidates) {
+        // 1. ������������� ImportSelector
+        if (candidate.isAssignable(ImportSelector.class)) {
+            Class<?> candidateClass = candidate.loadClass();
+            // ʵ��������� ImportSelector�����һ�ִ�� Aware �ӿڷ���
+            // ֧�ֵ�Aware��BeanClassLoaderAware��BeanFactoryAware��EnvironmentAware��ResourceLoaderAware
+            ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, 
+                    ImportSelector.class, this.environment, this.resourceLoader, this.registry);
+            if (selector instanceof DeferredImportSelector) {
+                this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
+            }
+            else {
+                // ִ�� selectImports ��������ȡ������࣬������Ϊ�������"����.����"
+                String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
+                Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
+                // �ݹ���� processImports(...) ��������һ�δ����������
+                processImports(configClass, currentSourceClass, importSourceClasses, false);
+            }
+        }
+        // 2. ������������� ImportBeanDefinitionRegistrar
+        else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
+            Class<?> candidateClass = candidate.loadClass();
+            // ʵ���� ImportBeanDefinitionRegistrar������ִ�� Aware �ӿڵķ���
+            // ֧�ֵ�Aware��BeanClassLoaderAware��BeanFactoryAware��EnvironmentAware��ResourceLoaderAware
+            ImportBeanDefinitionRegistrar registrar = ParserStrategyUtils
+                    .instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class, 
+                    this.environment, this.resourceLoader, this.registry);
+            // �� ImportBeanDefinitionRegistrar ��������
+            configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
+        }
+        // 3. �����������ߣ����� processConfigurationClass(...) ֱ�ӽ���
+        // �����������������ࣨ���� @Component��@Configuration��@Import ��ע�⣩������������н���
+        else {
+            this.importStack.registerImport(
+                    currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
+            processConfigurationClass(candidate.asConfigClass(configClass));
+        }
+    }
+
+    ...
+}
+```
+
+�����Ǿ��������Ĵ��룬����ֻ������ `@Import` �Ĺؼ����裺
+
+1. ���������������� `ImportSelector`�������������£�
+
+    1. ʹ�÷���ʵ���� `ImportSelector`��֮����ִ�� `Aware` �ӿڷ��������������ڴ��� `ImportSelector` ʱ��������ʵ�� `Aware` �ӿڣ�֧�ֵ� `Aware` �� `BeanClassLoaderAware`��`BeanFactoryAware`��`EnvironmentAware`��`ResourceLoaderAware`��
+    2. ִ�� `ImportSelector` ʵ���� `selectImports` ��������һ����Ϊ�˻�ȡ������࣬���Ϊ `Class[]`��������� "����������"��`Element03Selector` �и÷����������£�
+
+   ```
+   @Override
+   public String[] selectImports(AnnotationMetadata importingClassMetadata) {
+       return new String[] {Element03.class.getName()};
+   }
+   ```
+
+   ��һ�����ȡ�� `Element03.class`; 3. ����ȡ���� `Class` ���飬ת���� `SourceClass` ���ϣ���һ�ε��� `processImports(...)`���ڵڶ��ε���ʱ�������������� `Element03`��
+
+2. ���������������� `ImportBeanDefinitionRegistrar`�������������£�
+
+    1. ʵ���� `ImportBeanDefinitionRegistrar`������ִ�� `Aware` �ӿڵķ�������һ��ͬ `ImportSelector` ��ʵ��������һ��������׸����
+    2. ����һ���õ��� `ImportBeanDefinitionRegistrar` ʵ�����浽 `configClass` �У����������ٷ�������������ʵ������δ����ģ�
+
+3. �������������Ͳ����������ߣ����� `processConfigurationClass(...)` ֱ�ӽ������������ǰ��ƪ�����Ѿ�����ἰ�ˣ������������� `@Component`��`@Import`��`@ComponentScan`��`@Configuration`��`@Bean` ��ע��ģ���һ����Ϊ�˽����������е���Щע�⣬����� `Element01`��`Element02`��`Element03`(����� 1 �����ᵽ�ģ��� `Element03Selector` �л�ȡ�� `Element03.class` �󣬽���ת���� `SourceClass`���ٴε��� `processImports(...)` �Ĺ���) ��������һ�������ġ�
+
+����������Ƿ��֣����� `ImportBeanDefinitionRegistrar` �ķ�ʽ�⣬�����������뷽ʽ����ͨ�ࡢ�����ࡢ`ImportSelector` ��ʵ���ࣩ����һ���Ĵ�����ʽ�����ǰ�**������Ľ�����ʽ������**�����յ��õ��� `processConfigurationClass(...)` ��������һ ������ǰ��ƪ�����Ѿ���η����ˣ�����Ͳ��ٷ����ˣ��������������������� `ImportBeanDefinitionRegistrar` �Ĵ�����
+
+### 4.5 ���� `BeanDefinitions`��`ConfigurationClassBeanDefinitionReader#loadBeanDefinitions`
+
+�ڷ��� `@Bean` ����ʱ�����Ƿ����� `ConfigurationClassBeanDefinitionReader#loadBeanDefinitions` ���� `@Bean` ���������̣����������������� `@Import` �����̣�����ֱ�ӽ���ؼ����� `ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForConfigurationClass`��
+
+```
+private void loadBeanDefinitionsForConfigurationClass(
+        ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
+    ...
+
+    // ���� @Import �����������
+    if (configClass.isImported()) {
+        registerBeanDefinitionForImportedConfigurationClass(configClass);
+    }
+    // ���� @Bean ����
+    for (BeanMethod beanMethod : configClass.getBeanMethods()) {
+        loadBeanDefinitionsForBeanMethod(beanMethod);
+    }
+    // ���� @ImportResource �������Դ
+    loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
+    // ���� @Import ����� ImportBeanDefinitionRegistrar
+    // ǰ�汣����configClass�е�ImportBeanDefinitionRegistrars��������ʹ����
+    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
+}
+```
+
+���� `@Import` �ĵط���������
+
+1. ���� `@Import` �����������
+2. ���� `@Import` ����� `ImportBeanDefinitionRegistrar`
+
+���Ƿֱ�����������������δ����ġ�
+
+#### 1. ���� `@Import` �����������
+
+���� `@Import` ��������������ش���Ϊ��
+
+```
+    // ���� @Import �����������
+    if (configClass.isImported()) {
+        registerBeanDefinitionForImportedConfigurationClass(configClass);
+    }
+```
+
+���ǽ�������һ̽������
+
+```
+private void registerBeanDefinitionForImportedConfigurationClass(ConfigurationClass configClass) {
+    AnnotationMetadata metadata = configClass.getMetadata();
+    // ���� BeanDefinition������Ϊ AnnotatedGenericBeanDefinition
+    AnnotatedGenericBeanDefinition configBeanDef = new AnnotatedGenericBeanDefinition(metadata);
+    // ����һϵ�е�����
+    ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(configBeanDef);
+    configBeanDef.setScope(scopeMetadata.getScopeName());
+    String configBeanName = this.importBeanNameGenerator.generateBeanName(configBeanDef, this.registry);
+    AnnotationConfigUtils.processCommonDefinitionAnnotations(configBeanDef, metadata);
+    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(configBeanDef, configBeanName);
+    definitionHolder = AnnotationConfigUtils
+            .applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
+    // ע��
+    this.registry.registerBeanDefinition(definitionHolder.getBeanName(), 
+            definitionHolder.getBeanDefinition());
+    configClass.setBeanName(configBeanName);
+}
+```
+
+�����һ������ע�ᵽ `BeanDefinition` �еĹ��̣�ʹ�õ� `BeanDefinition` �� `AnnotatedGenericBeanDefinition`��
+
+#### 2. ���� `@Import` ����� `ImportBeanDefinitionRegistrar`
+
+�����ù��̵ķ���Ϊ `loadBeanDefinitionsFromRegistrars(...)`���������£�
+
+```
+private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, 
+        AnnotationMetadata> registrars) {
+    registrars.forEach((registrar, metadata) ->
+            registrar.registerBeanDefinitions(metadata, this.registry, 
+                    this.importBeanNameGenerator));
+}
+```
+
+�÷������DZ�������� `ImportBeanDefinitionRegistrar` ���ϣ�Ȼ����һ�������е� `ImportBeanDefinitionRegistrar#registerBeanDefinitions(AnnotationMetadata, BeanDefinitionRegistry, BeanNameGenerator)` �������÷���λ�� `ImportBeanDefinitionRegistrar` �ӿڣ��������£�
+
+```
+public interface ImportBeanDefinitionRegistrar {
+
+    /**
+     * Ĭ�Ϸ�����Ĭ��ʵ�ֽ�������һ������
+     */
+    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, 
+            BeanDefinitionRegistry registry,BeanNameGenerator importBeanNameGenerator) {
+        registerBeanDefinitions(importingClassMetadata, registry);
+    }
+
+    /**
+     * �� Element02ImportBeanDefinitionRegistrar ��ʵ�ֵķ���
+     */
+    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, 
+            BeanDefinitionRegistry registry) {
+    }
+
+}
+```
+
+`ImportBeanDefinitionRegistrar#registerBeanDefinitions(AnnotationMetadata, BeanDefinitionRegistry, BeanNameGenerator)` ��������һ�����ã����յ��õ��� `ImportBeanDefinitionRegistrar#registerBeanDefinitions(AnnotationMetadata, BeanDefinitionRegistry)`�������ǵ� `Element02ImportBeanDefinitionRegistrar` ����ʵ���˸÷�����
+
+```
+public class Element02ImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
+    @Override
+    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, 
+            BeanDefinitionRegistry registry) {
+        registry.registerBeanDefinition("element02", new RootBeanDefinition(Element02.class));
+    }
+}
+```
+
+���˴���죬���շ��� `ImportBeanDefinitionRegistrar` ע�ᵽ `beanDefinitionMap` ���߼��������Լ�д�ģ�
+
+#### 3. �������л�ȡ `ElementXx`
+
+�������`Element01`��`Element02`��`Element03`��`Element04` �͵�ע�ᵽ `beanDefinitionMap` ���ˣ������ǿ�һ�� `beanDefinitionNames` �е����ݣ�
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-68171a4af503b3e80b23d10a91834e231aa.png)
+
+���Է��֣�`Element01` �� `Element03` beanName ��ͬѰ���������� bean �����뷽ʽΪ
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-0e07154a732c2a884803531e54aa10a0ef9.png)
+
+�����ʹ�� `beanFactory.get(��beanName��)` ʱ��Ҫע�⣺
+
+```
+// ��ȡ�������ᱨ��
+beanFactory.get("element01");
+// �ܻ�ȡ��
+beanFactory.get("element02");
+// ��ȡ�������ᱨ��
+beanFactory.get("element03");
+// �ܻ�ȡ��
+beanFactory.get("element04");
+```
+
+ʹ�� `beanFactory.get(��beanName��)` ��ȡ `element01` �� `element03` ��Ҫ������ȡ��
+
+```
+// �ܻ�ȡ��
+beanFactory.get("org.springframework.learn.explore.demo04.element.Element01");
+// �ܻ�ȡ��
+beanFactory.get("org.springframework.learn.explore.demo04.element.Element03");
+```
+
+��Ȼ������Ҳ����ʹ�� `beanFactory.get(Class)` �ķ�ʽ��ȡ��
+
+```
+// �ܻ�ȡ��
+beanFactory.get(Element01.class);
+// �ܻ�ȡ��
+beanFactory.get(Element02.class);
+// �ܻ�ȡ��
+beanFactory.get(Element03.class);
+// �ܻ�ȡ��
+beanFactory.get(Element04.class);
+```
+
+### 4.6 ���䣺`DeferredImportSelector` �Ĵ���
+
+�ڷ��� `ConfigurationClassParser#processImports` ����ʱ������ `ImportSelector` ������ʱ������ôһ�δ��룺
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-4fb0dddcbf45d84ad5260c43a5b55e85a0a.png)
+
+��δ�������ж� `selector` �Ƿ�Ϊ `DeferredImportSelector` ��ʵ��������ǾͰ� `DeferredImportSelector` ���͵�ʵ�����д���������Ͱ���ͨ�� `ImportSelector` �������������������������� `DeferredImportSelector` ����ͨ�� `ImportSelector` �кβ�ͬ��
+
+`DeferredImportSelector` �Ĵ������£�
+
+```
+/**
+ * DeferredImportSelector �� ImportSelector���ӽӿ�
+ */
+public interface DeferredImportSelector extends ImportSelector {
+
+    /**
+     * ���ص������
+     */
+    @Nullable
+    default Class<? extends Group> getImportGroup() {
+        return null;
+    }
+
+
+    /**
+     * ����Ķ���
+     */
+    interface Group {
+
+        /**
+         * �÷���Ĵ�������
+         */
+        void process(AnnotationMetadata metadata, DeferredImportSelector selector);
+
+        /**
+         * ���ظ÷��������
+         */
+        Iterable<Entry> selectImports();
+
+
+        /**
+         * �����Ԫ�ض���
+         */
+        class Entry {
+
+            /**
+             * ע������
+             */
+            private final AnnotationMetadata metadata;
+
+            /**
+             * ���������
+             */
+            private final String importClassName;
+
+            public Entry(AnnotationMetadata metadata, String importClassName) {
+                this.metadata = metadata;
+                this.importClassName = importClassName;
+            }
+
+            // ʡ�� get/set ������ʡ�� equals/toString/hashCode ����
+            ...
+
+        }
+    }
+}
+```
+
+������Ĵ�����Կ�����
+
+- `DeferredImportSelector` �� `ImportSelector` ���ӽӿڣ��߱� `ImportSelector` �Ĺ���
+- `DeferredImportSelector` �ṩ��һ��������`Class<? extends Group> getImportGroup()`���÷������ص��ǵ�ǰ `DeferredImportSelector` ʵ�����ڵķ��顣
+
+��������������ע���д��룺
+
+```
+this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
+```
+
+���������д���������ʲô������ `ConfigurationClassParser#handler����`��
+
+```
+class ConfigurationClassParser {
+
+    ...
+
+    private class DeferredImportSelectorHandler {
+
+        @Nullable
+        private List<DeferredImportSelectorHolder> deferredImportSelectors = new ArrayList<>();
+
+        public void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
+            // �� configClass �� importSelector ��װ�� DeferredImportSelectorHolder
+            DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(
+                    configClass, importSelector);
+            if (this.deferredImportSelectors == null) {
+                DeferredImportSelectorGroupingHandler handler 
+                    = new DeferredImportSelectorGroupingHandler();
+                handler.register(holder);
+                handler.processGroupImports();
+            }
+            else {
+                // ���ӵ� deferredImportSelectors ��
+                this.deferredImportSelectors.add(holder);
+            }
+        }
+        ...
+    }
+    ...
+}
+```
+
+���Կ����������ϴ�Ƚ� `configClass` �� `importSelector` ��װ�� `DeferredImportSelector`��Ȼ�������ӵ� `deferredImportSelectors`��
+
+��ĿǰΪֹ��`DeferredImportSelector` ������ಢû�н��д�������ô `DeferredImportSelector` ��������������ﴦ�����أ������ǻص� `ConfigurationClassParser#parse(Set<BeanDefinitionHolder>)` ������
+
+```
+public class  ConfigurationClassParser {
+    public void parse(Set<BeanDefinitionHolder> configCandidates) {
+        // ѭ����������������
+        for (BeanDefinitionHolder holder : configCandidates) {
+            BeanDefinition bd = holder.getBeanDefinition();
+            try {
+                // ������BeanDefinition��AnnotatedBeanDefinition��ʵ��
+                if (bd instanceof AnnotatedBeanDefinition) {
+                    parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
+                }
+                ...
+            }
+            catch (BeanDefinitionStoreException ex) {
+                throw ex;
+            }
+            catch (Throwable ex) {
+                ...
+            }
+        }
+        // �����ﴦ�� DeferredImportSelector
+        this.deferredImportSelectorHandler.process();
+    }
+    ...
+}
+```
+
+���Կ������ڴ�����������Ľ���������������� `DeferredImportSelector`��Ҳ�����������ӵ� `deferredImportSelectors` �����ݣ����õ��� `deferredImportSelectorHandler.process()`.
+
+���Ǽ�����
+
+```
+class ConfigurationClassParser {
+
+    private class DeferredImportSelectorHandler {
+        ...
+        public void process() {
+            List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
+            this.deferredImportSelectors = null;
+            try {
+                if (deferredImports != null) {
+                    DeferredImportSelectorGroupingHandler handler 
+                        = new DeferredImportSelectorGroupingHandler();
+                    // ����DeferredImportSelector ����ָ������˳��@Order/Orderd
+                    deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
+                    // �������� DeferredImportSelectorGroupingHandler#register ����
+                    deferredImports.forEach(handler::register);
+                    // ��������
+                    handler.processGroupImports();
+                }
+            }
+            finally {
+                this.deferredImportSelectors = new ArrayList<>();
+            }
+        }
+        ...
+    }
+    ...
+}
+```
+
+`process()` �����������£�
+
+1. ���������Ҫ�Ǹ��� `@Order` ע�⣬����ʵ���� `Orderd` �ӿ�������
+2. �������� `DeferredImportSelectorGroupingHandler#register` ��������ʵ���ǽ� `deferredImports` �е�Ԫ��ע�ᵽ `handler` �У�
+3. ���� `handler.processGroupImports()` �������������롣
+
+������������ `handler.processGroupImports()` ������
+
+```
+class ConfigurationClassParser {
+
+    ...
+
+    private class DeferredImportSelectorGroupingHandler {
+        ...
+        /**
+         * ���յĴ�����
+         * �����ﴦ�����鵼��
+         */
+        public void processGroupImports() {
+            for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
+                // �������飬 grouping.getImports()�ǹؼ�
+                grouping.getImports().forEach(entry -> {
+                    ConfigurationClass configurationClass = this.configurationClasses.get(
+                            entry.getMetadata());
+                    try {
+                        // ͬImportSelector��ʵ����һ��������Ҳ�ǵ��� processImports(...) ��������
+                        // ע�� entry.getImportClassName()����һ�ε��� processImports(...) �IJ�
+                        // ����ImportSelector�������
+                        processImports(configurationClass, asSourceClass(configurationClass),
+                                asSourceClasses(entry.getImportClassName()), false);
+                    }
+                    catch (...) {
+                        ...
+                    }
+                });
+            }
+        }
+        ...
+    }
+    ...
+
+}
+```
+
+`processGroupImports(...)` ��Ҫ�߼����£�
+
+1. ��������
+2. ���� `grouping.getImports()` ��ȡ�������
+3. ���� `processImports` ����������ĵ��룬���ͬ���� `ImportSelector` �ӿ�������һ����
+
+���������� `grouping.getImports()` �������÷���Ϊ `ConfigurationClassParser.DeferredImportSelectorGrouping#getImports`���������£�
+
+```
+public Iterable<Group.Entry> getImports() {
+    for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
+        // ִ�� Group#process
+        this.group.process(deferredImport.getConfigurationClass().getMetadata(),
+                deferredImport.getImportSelector());
+    }
+    // ִ�� Group#selectImports
+    return this.group.selectImports();
+}
+```
+
+��������������� `DeferredImportSelector.Group` ������������
+
+- `DeferredImportSelector.Group#process`
+- `DeferredImportSelector.Group#selectImports`
+
+������������������С�ڵ�һ��ʼ������������뼰��ע�ͣ��������������� `DeferredImportSelector.Group#selectImports` �������ص�.
+
+�������ϰ��죬�ܽ��� `DeferredImportSelector` �� `ImportSelector` ���ߵ�����
+
+- `DeferredImportSelector` ����ָ�����飺�ڴ���ʱ�����Ը��ݷ���ͳһ������
+- `DeferredImportSelector` ����ʱ�����������������������֮���ٴ�����
+- `DeferredImportSelector` ������ķ��أ���ͬ�� `ImportSelector`������������ `ImportSelector#selectImports` �������أ��������������� `DeferredImportSelector.Group#selectImports` �������ء�
+
+### 4.7 �ܽ�
+
+������Ҫ������ `ConfigurationClassPostProcessor` �� `@Import` ע��Ĵ������ܽ�����:
+
+1. `@Import` �ɵ�������� 4 �֣��ֱ�����ͨ�ࡢ�����ࡢʵ���� `ImportSelector` �����Լ�ʵ���� `ImportBeanDefinitionRegistrar` ���ࣻ
+2. ��ȡ `@Import` ע�⣺spring �ڻ�ȡ���ϵ� `@Import` ʱ���Ȼ�ȡ���ϵ�����ע�⣬Ȼ����һ�жϣ������ǰע���� `@Import`�����ȡ `@Import` ��������� (����Ϊ `Import#value`)�������ȡ��ǰע���ϵ�����ע�⣬�ظ����ϴ�����
+3. ���� `@Import` ������ࣺ��ͨ�ࡢ������ͳһ����������������ʵ���� `ImportSelector` ���࣬��� `selectImports(...)` �������ص� �������������� ���õ� class��Ȼ��Ҳ�ǰ������������ʵ�� `ImportBeanDefinitionRegistrar` ���࣬��Ѷ�Ӧ���ʵ�����浽��ǰ�������У�����ע�ᵽ `beanDefinitionMap` ʱ�����Ǵ������ȡ�ģ�
+4. ��������ע�ᵽ `beanDefinitionMap`��ʵ���� `ImportSelector` �������յõ�����һ����ͨ��������࣬ͬ�������ͨ����������һ����ֱ��ע�᣻ʵ�� `ImportBeanDefinitionRegistrar` ���࣬������ `ImportBeanDefinitionRegistrar#registerBeanDefinitions(AnnotationMetadata, BeanDefinitionRegistry)` ��������ע�ᣬע���߼���ʵ�������ж��塣
+
+------
+
+*����ԭ�����ӣ�https://my.oschina.net/funcy/blog/4678152 ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������*
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/ConfigurationClassPostProcessor\357\274\210\344\272\214\357\274\211\357\274\232\345\244\204\347\220\206@Bean\346\263\250\350\247\243.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/ConfigurationClassPostProcessor\357\274\210\344\272\214\357\274\211\357\274\232\345\244\204\347\220\206@Bean\346\263\250\350\247\243.md"
new file mode 100644
index 0000000..84b7b0f
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/ConfigurationClassPostProcessor\357\274\210\344\272\214\357\274\211\357\274\232\345\244\204\347\220\206@Bean\346\263\250\350\247\243.md"
@@ -0,0 +1,946 @@
+������ `ConfigurationClassPostProcessor` �����ĵڶ�ƪ����Ҫ�Ƿ��� spring �� `@Bean` ע��Ĵ������̡�
+
+## 3\. spring ����δ��� `@Bean` ע��ģ�
+
+�н����ģ����Ǽ������� spring �� `@Bean` ע��Ĵ������̡�
+
+### 3.1 demo ׼��
+
+Ϊ��˵�����⣬����ֱ���ϴ��룺
+
+����׼������ Bean:
+
+```
+public class BeanObj1 {
+    public BeanObj1() {
+        System.out.println("����beanObj1�Ĺ��췽��");
+    }
+
+    @Override
+    public String toString() {
+        return "BeanObj1{}";
+    }
+}
+
+public class BeanObj2 {
+    public BeanObj2() {
+        System.out.println("����beanObj2�Ĺ��췽��");
+    }
+
+    @Override
+    public String toString() {
+        return "BeanObj2{}";
+    }
+}
+
+```
+
+ע�⣺���������඼û�� `Component`��`@Service` ��ע�⡣
+
+��׼��һ�������࣬ͨ�� `@Bean` ע��ķ����������� bean��
+
+```
+@Component
+public class BeanConfigs {
+
+    @Bean
+    public BeanObj1 beanObj1() {
+        return new BeanObj1();
+    }
+
+    @Bean
+    public BeanObj2 beanObj2() {
+        // ��������� beanObj1() ����
+        beanObj1();
+        return new BeanObj2();
+    }
+
+}
+
+```
+
+����������ࣺ
+
+```
+@ComponentScan
+public class Demo02Main {
+
+    public static void main(String[] args) {
+        ApplicationContext context 
+                = new AnnotationConfigApplicationContext(Demo02Main.class);
+        Object obj1 = context.getBean("beanObj1");
+        Object obj2 = context.getBean("beanObj2");
+        System.out.println("obj1:" + obj1);
+        System.out.println("obj2:" + obj2);
+        System.out.println(context.getBean("beanConfigs"));
+    }
+}
+
+```
+
+������ ���룬�����¼�����Ҫ˵����
+
+*   `BeanConfigs` ��ʹ�õ�ע����� `@Component`������[��һƪ����](https://my.oschina.net/funcy/blog/4836178)�ķ�����`@Component` Ҳ���������࣬��������ͬ `@Configuration` ע�⣻
+*   �� `Demo02Main` �У����� `AnnotationConfigApplicationContext` ��Ϊ `Demo02Main`��������һ��ע�� `@ComponentScan`�����ע��ûָ����ɨ��·��������[��һƪ����](https://my.oschina.net/funcy/blog/4836178)�ķ�������ָ����ɨ��·����spring ��Ĭ��ɨ�����������ڰ���
+*   ���Dz�û��ֱ�Ӱ� `BeanConfigs` ע�ᵽ�����У��� `new AnnotationConfigApplicationContext(BeanConfigs.class)` ����������[��һƪ����](https://my.oschina.net/funcy/blog/4836178)�ķ�����֪��spring ���Ƚ��� `Demo02Main` �࣬�������ϵ� `@Component` ע�⣬�Ӷ�ɨ�赽 `BeanConfigs` �࣬Ȼ������ `BeanConfigs`�������ڲ��� `@Bean` ����������������ǽ�����Ҳ��ͨ�����Եķ�ʽ������֤��
+
+�������ϴ��룬������£�
+
+```
+����beanObj1�Ĺ��췽��
+����beanObj1�Ĺ��췽��
+����beanObj2�Ĺ��췽��
+obj1:BeanObj1{}
+obj2:BeanObj2{}
+org.springframework.learn.explore.demo05.BeanConfigs@2b71e916
+
+```
+
+��������������� demo �������
+
+**ע��**�������� `ConfigurationClassPostProcessor` �����ĵڶ�ƪ������[��һƪ](https://my.oschina.net/funcy/blog/4836178)��ͬ�Ĵ��룬����ֻһ�ʴ����������ٽ�����ϸ������
+
+### 3.2 ���������ࣺConfigurationClassPostProcessor#processConfigBeanDefinitions
+
+����ֱ�ӽ��� `ConfigurationClassPostProcessor#processConfigBeanDefinitions` ���������������£�
+
+```
+AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(Class)
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#invokeBeanFactoryPostProcessors
+   |-PostProcessorRegistrationDelegate
+      #invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory, List)
+    |-PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors
+     |-ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry
+      |-ConfigurationClassPostProcessor#processConfigBeanDefinitions
+
+```
+
+��ʱ�� `candidates` ֻ��һ�� Ԫ�أ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-0d50f32d5ea1d2b79b8e17612d30693f753.png)
+
+### 3.2 ���� `demo02Main`��ConfigurationClassParser#doProcessConfigurationClass
+
+��һ����ǽ��� `@ComponentScan` ע��Ĺ��̣�[��һƪ](https://my.oschina.net/funcy/blog/4836178)����ϸ������������ֻ��������ջ��
+
+```
+AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(Class)
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#invokeBeanFactoryPostProcessors
+   |-PostProcessorRegistrationDelegate
+      #invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory, List)
+    |-PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors
+     |-ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry
+      |-ConfigurationClassPostProcessor#processConfigBeanDefinitions
+       |-ConfigurationClassParser#parse(Set<BeanDefinitionHolder>)
+        |-ConfigurationClassParser#parse(AnnotationMetadata, String)
+          |-ConfigurationClassParser#processConfigurationClass
+           |-ConfigurationClassParser#doProcessConfigurationClass
+
+```
+
+���� `Demo02Main` �� `@ComponentScan` ֮�󣬿��Կ��� `beanConfigs` �Ѿ�ɨ�赽�ˣ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-7fef6007424562f63dda7f2a0b25e9c293b.png)
+
+���� `beanConfigs` �������࣬��˻������н�����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-fba3821df9cf2926b16bd064cf164e83471.png)
+
+���ջ��ǻ�ص� `ConfigurationClassParser#doProcessConfigurationClass`�����еĵ��������£�
+
+```
+AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(Class)
+ |-AbstractApplicationContext#refresh
+  |-AbstractApplicationContext#invokeBeanFactoryPostProcessors
+   |-PostProcessorRegistrationDelegate
+      #invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory, List)
+    |-PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors
+     |-ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry
+      |-ConfigurationClassPostProcessor#processConfigBeanDefinitions
+       |-ConfigurationClassParser#parse(Set<BeanDefinitionHolder>)
+        |-ConfigurationClassParser#parse(AnnotationMetadata, String)
+          |-ConfigurationClassParser#processConfigurationClass
+           |-ConfigurationClassParser#doProcessConfigurationClass
+            |-ConfigurationClassParser#parse(String, String)
+             |-ConfigurationClassParser#processConfigurationClass
+              |-ConfigurationClassParser#doProcessConfigurationClass
+
+```
+
+��ʱ�� `ConfigurationClassParser#doProcessConfigurationClass`�����ǾͲ����� `demo02Main`������ `beanConfigs` �ˡ�
+
+### 3.3 ���� `beanConfigs`��ConfigurationClassParser#doProcessConfigurationClass
+
+���������������� `ConfigurationClassParser#doProcessConfigurationClass` �� `@Bean` ע��Ĵ������������£�
+
+```
+/**
+ * ������������������������ķ���
+ */
+protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, 
+        SourceClass sourceClass) throws IOException {
+    // 1\. ����� @Component ע�⣬�ݹ鴦���ڲ��࣬���IJ���ע
+    ...
+
+    // 2\. ����@PropertySourceע�⣬���IJ���ע
+    ...
+
+    // 3\. ���� @ComponentScan/@ComponentScans ע�⣬���IJ���ע
+    ...
+
+    // 4\. ����@Importע�⣬���IJ���ע
+    ...
+
+    // 5\. ����@ImportResourceע�⣬���IJ���ע
+    ...
+
+    // 6\. ����@Bean��ע��
+    // ����Ľ�������
+    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
+    for (MethodMetadata methodMetadata : beanMethods) {
+        // ���ӵ� configClass �У������ٴ���
+        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
+    }
+
+    // 7\. ����������ĸ��࣬���� processConfigurationClass(...) ��������һ��ѭ��ʱ����
+    ...
+    return null;
+}
+
+```
+
+��ȡ `@Bean` �ķ������õ��� `retrieveBeanMethodMetadata(...)`�����Ǹ���ȥ��
+
+```
+private Set<MethodMetadata> retrieveBeanMethodMetadata(SourceClass sourceClass) {
+    AnnotationMetadata original = sourceClass.getMetadata();
+    // ��ȡ���� @Bean ע��ķ���
+    Set<MethodMetadata> beanMethods = original.getAnnotatedMethods(Bean.class.getName());
+    ...
+    return beanMethods;
+}
+
+```
+
+�ٸ���ȥ�����յ��õ��� `StandardAnnotationMetadata#getAnnotatedMethods`:
+
+```
+public Set<MethodMetadata> getAnnotatedMethods(String annotationName) {
+    Set<MethodMetadata> annotatedMethods = null;
+    if (AnnotationUtils.isCandidateClass(getIntrospectedClass(), annotationName)) {
+        try {
+            // 1\. ͨ��������Ļ�ȡ���еķ���
+            Method[] methods = ReflectionUtils.getDeclaredMethods(getIntrospectedClass());
+            for (Method method : methods) {
+                // 2\. �ж��Ƿ��� @Bean ע��
+                if (isAnnotatedMethod(method, annotationName)) {
+                    if (annotatedMethods == null) {
+                        annotatedMethods = new LinkedHashSet<>(4);
+                    }
+                    annotatedMethods.add(new StandardMethodMetadata(
+                        method, this.nestedAnnotationsAsMap));
+                }
+            }
+        }
+        catch (Throwable ex) {
+            throw new IllegalStateException(������);
+        }
+    }
+    return annotatedMethods != null ? annotatedMethods : Collections.emptySet();
+}
+
+```
+
+��������ܺ����⣬�ؼ���������
+
+1.  ͨ�������ȡ�������з�����
+2.  �����õ��ķ�������һ�жϸ÷����Ƿ��� `@Bean` ע�⣻
+
+�������`beanConfigs` �е������������ڻ�ȡ���ˣ������� `ConfigurationClass` ����� `beanMethods` ���ԣ���
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-121f4d518fa57c8932e6b7fd3e7def8704b.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-a4d91c1f52703b8c911bdb9d9afaf697d92.png)
+
+### 3.4 ���� `@Bean` ��ǵķ������ص� `BeanDefinitionMap`
+
+�����ȡ���� `beanMethod` ��ʱ��ֻ���� `ConfigurationClass` ����� `beanMethods` �����У���û�м��ص� `beanFactory` �� `BeanDefinitionMap` �У���С����̽���������Ǻ�ʱ���뵽 `BeanDefinitionMap` �С�
+
+���ǵ� `ConfigurationClassPostProcessor#processConfigBeanDefinition` ����������ôһ�д��룺
+
+```
+public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
+    ...
+    // �������������
+    // �� @Import ������ࡢ�������д�@Bean�ķ�����@ImportResource �������Դ��ת����BeanDefinition
+    this.reader.loadBeanDefinitions(configClasses);
+    ...
+}
+
+```
+
+����Ǽ�������� `BeanDefinition` �ĵط������� `@Import` ������ࡢ�������д� `@Bean` �ķ�����`@ImportResource` �������Դ��ת���� `BeanDefinition`�������ص��ע `@Bean` �����Ĵ������������£�
+
+> ConfigurationClassBeanDefinitionReader
+
+```
+    public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
+        TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
+        // ������������� configurationModel
+        for (ConfigurationClass configClass : configurationModel) {
+            loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
+        }
+    }
+
+    /**
+     * �����������ظ��� ConfigurationClass ����� BeanDefinition
+     * 1\. @Import �������
+     * 2\. �������е� @Bean ����
+     * 3\. @ImportResource �������Դ
+     * 4\. @Import ����� ImportBeanDefinitionRegistrar
+     */
+    private void loadBeanDefinitionsForConfigurationClass(
+            ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
+
+        if (trackedConditionEvaluator.shouldSkip(configClass)) {
+            ...
+        }
+
+        // ���� @Import �����������
+        if (configClass.isImported()) {
+            registerBeanDefinitionForImportedConfigurationClass(configClass);
+        }
+        // ���� @Bean ����
+        for (BeanMethod beanMethod : configClass.getBeanMethods()) {
+            loadBeanDefinitionsForBeanMethod(beanMethod);
+        }
+        // ���� @ImportResource �������Դ
+        loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
+        // ���� @Import ����� ImportBeanDefinitionRegistrar
+        loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
+    }
+
+    /**
+     * ���� @Bean ����
+     * 1\. ����BeanDefinition��beanMethod ʹ�õ��� ConfigurationClassBeanDefinition
+     * 2\. ���� @Bean �ĸ������ԣ����õ� BeanDefinition ��
+     * 3\. �� BeanDefinition ע�ᵽ beanFactory ��
+     */
+    private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
+        ConfigurationClass configClass = beanMethod.getConfigurationClass();
+        MethodMetadata metadata = beanMethod.getMetadata();
+        String methodName = metadata.getMethodName();
+
+        ...
+
+        // 1\. beanMethodʹ�õ���ConfigurationClassBeanDefinition
+        ConfigurationClassBeanDefinition beanDef = 
+                new ConfigurationClassBeanDefinition(configClass, metadata);
+        beanDef.setResource(configClass.getResource());
+        beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));
+
+        // 2\. ���� @Bean �ĸ�������
+        if (metadata.isStatic()) {
+            // ��̬ @Bean ����
+            if (configClass.getMetadata() instanceof StandardAnnotationMetadata) {
+                beanDef.setBeanClass(
+                    ((StandardAnnotationMetadata) configClass.getMetadata()).getIntrospectedClass());
+            }
+            else {
+                beanDef.setBeanClassName(configClass.getMetadata().getClassName());
+            }
+            beanDef.setUniqueFactoryMethodName(methodName);
+        }
+        else {
+            // ��ͨ�� @Bean ����
+            beanDef.setFactoryBeanName(configClass.getBeanName());
+            beanDef.setUniqueFactoryMethodName(methodName);
+        }
+
+        if (metadata instanceof StandardMethodMetadata) {
+            beanDef.setResolvedFactoryMethod(
+                ((StandardMethodMetadata) metadata).getIntrospectedMethod());
+        }
+
+        beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
+        beanDef.setAttribute(
+                org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.
+                SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);
+
+        AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);
+
+        Autowire autowire = bean.getEnum("autowire");
+        if (autowire.isAutowire()) {
+            beanDef.setAutowireMode(autowire.value());
+        }
+
+        boolean autowireCandidate = bean.getBoolean("autowireCandidate");
+        if (!autowireCandidate) {
+            beanDef.setAutowireCandidate(false);
+        }
+
+        String initMethodName = bean.getString("initMethod");
+        if (StringUtils.hasText(initMethodName)) {
+            beanDef.setInitMethodName(initMethodName);
+        }
+
+        String destroyMethodName = bean.getString("destroyMethod");
+        beanDef.setDestroyMethodName(destroyMethodName);
+
+        ...
+
+        // 3\. ��BeanDefinitionע�ᵽbeanFactory��
+        this.registry.registerBeanDefinition(beanName, beanDefToRegister);
+    }
+
+```
+
+`ConfigurationClassBeanDefinitionReader#loadBeanDefinitions` �ֵ������������������մ������� `ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForBeanMethod`���ⲿ���߼����£�
+
+1.  ��������� `configClass` ���ϣ���ÿ�� `configClass` ���� `Definitions` ���ش�����
+2.  �� `configClass` ���� `Definitions` ���ش���ʱ������һ���� `@Import`/`@Bean`/`@ImportResource` ��ע�⣬��С�����ǽ���ע `@Bean` �Ĵ�����
+3.  ���� `@Bean` ����ʱ���ȴ��� `BeanDefinition`(`@Bean` ������Ӧ�� `BeanDefinition` �� `ConfigurationClassBeanDefinition`)��Ȼ����� `@Bean` �����ԣ����õ� `BeanDefinition` �У������ǰ� `BeanDefinition` ע�ᵽ `beanFactory` ��.
+
+�� �ˣ�ִ���� `ConfigurationClassBeanDefinitionReader#loadBeanDefinitions` ��`BeanDefinition` �ͼ��ص� `beanFactory` �ˣ���Ӧ�� `BeanDefinition` ������ `ConfigurationClassBeanDefinition`.
+
+### 3.5 `@Bean` ����ʵ��
+
+ʵ���Ĵ�������ͬ��ͨ�� `@Component` ��һ�£���ͬ������ͨ�� `@Component` ����õ��ǹ��췽������ `@Bean` ʹ�õ��� `factoryMethod`���������£�
+
+> AbstractAutowireCapableBeanFactory#createBeanInstance
+
+```
+/**
+ * ʵ���Ĵ�����ʽ
+ * 1\. ʹ�� instanceSupplier��Supplier��java8�ṩ���࣬���Դ���һ��lambda����ʽ
+ * 2\. ʹ�ù����������� @Bean ע���Ӧ�ķ���
+ * 3\. ʹ�õ��ǹ��췽��ע�룬�����췽������ @Autowired ע��
+ * 4\. ���췽��ע�룬�������޲ι��죬Ҳ�������вι���
+ *
+ */
+protected BeanWrapper createBeanInstance(String beanName, 
+        RootBeanDefinition mbd, @Nullable Object[] args) {
+    // ȷ���Ѿ������˴� class
+    Class<?> beanClass = resolveBeanClass(mbd, beanName);
+    ...
+
+    // �Ƿ�������bean������Supplier��Supplier��java8�ṩ���࣬���Դ���һ��lambda����ʽ
+    // ���� AbstractBeanDefinition#setInstanceSupplier ָ��
+    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
+    if (instanceSupplier != null) {
+        return obtainFromSupplier(instanceSupplier, beanName);
+    }
+    if (mbd.getFactoryMethodName() != null) {
+        // ���ù�������ʵ����
+        return instantiateUsingFactoryMethod(beanName, mbd, args);
+    }
+    // �Ƿ��һ��
+    boolean resolved = false;
+    // �Ƿ���ù��캯��ע��
+    boolean autowireNecessary = false;
+    ...
+    if (resolved) {
+        if (autowireNecessary) {
+            return autowireConstructor(beanName, mbd, null, null);
+        }
+        else {
+            // �޲ι��캯��
+            return instantiateBean(beanName, mbd);
+        }
+    }
+    // Candidate constructors for autowiring?
+    // �ж��Ƿ�����вι��캯��
+    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(
+            beanClass, beanName);
+    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
+            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
+        return autowireConstructor(beanName, mbd, ctors, args);
+    }
+    ctors = mbd.getPreferredConstructors();
+    if (ctors != null) {
+        // ���캯������ע��
+        return autowireConstructor(beanName, mbd, ctors, null);
+    }
+    // �����޲ι��캯��
+    return instantiateBean(beanName, mbd);
+}
+
+```
+
+�Ӵ�����������spring ʵ������ķ�ʽ�� 4 �֣�
+
+1.  ʹ�� `instanceSupplier`��`Supplier` �� `java8` �ṩ���࣬���Դ���һ�� `lambda` ����ʽ
+2.  ʹ�ù����������� `@Bean` ע���Ӧ�ķ���
+3.  ʹ�õ��ǹ��췽��ע�룬�����췽������ `@Autowired` ע��
+4.  ���췽��ע�룬�������޲ι��죬Ҳ�������вι���
+
+����������Ҫ��ע `@Bean` ��ʵ����ʽ��Ҳ���ǹ�������ʵ������ʽ�����ǽ�ȥ���£�
+
+```
+public BeanWrapper instantiateUsingFactoryMethod(String beanName, 
+             RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
+    BeanWrapperImpl bw = new BeanWrapperImpl();
+    this.beanFactory.initBeanWrapper(bw);
+    Object factoryBean;
+    Class<?> factoryClass;
+    boolean isStatic;
+    String factoryBeanName = mbd.getFactoryBeanName();
+    if (factoryBeanName != null) {
+        factoryBean = this.beanFactory.getBean(factoryBeanName);
+        factoryClass = factoryBean.getClass();
+        isStatic = false;
+    }
+    ...
+
+    Method factoryMethodToUse = null;
+    ArgumentsHolder argsHolderToUse = null;
+    Object[] argsToUse = null;
+    // ���� factoryMethod �IJ���
+    if (explicitArgs != null) {
+        argsToUse = explicitArgs;
+    }
+    else {
+        ...
+    }
+
+    if (factoryMethodToUse == null || argsToUse == null) {
+        factoryClass = ClassUtils.getUserClass(factoryClass);
+        List<Method> candidates = null;
+        if (mbd.isFactoryMethodUnique) {
+            if (factoryMethodToUse == null) {
+                factoryMethodToUse = mbd.getResolvedFactoryMethod();
+            }
+            if (factoryMethodToUse != null) {
+                candidates = Collections.singletonList(factoryMethodToUse);
+            }
+        }
+        // ʡ���˺ö����
+        ...
+    }
+    bw.setBeanInstance(instantiate(beanName, mbd, 
+            factoryBean, factoryMethodToUse, argsToUse));
+    return bw;
+}
+
+```
+
+���Ϸ����Ǿ������Ĵ��룬ԭ����������Ƚ϶࣬�󲿷ִ��������ڴ��� `argsToUse` �� `factoryMethodToUse` ������ϸ�ڷdz��࣬�Ͳ�չ�������ˣ�����������Ҫ��ע���¼���������
+
+1.  `factoryBean`�� `@Bean` �����������ʵ���������� `beanConfig`;
+2.  `factoryMethodToUse`: ʵ�������õķ�����Ҳ���DZ� `@Bean` ע��ķ����������� `BeanConfigs#beanObj1`;
+3.  `argsToUse`���� `@Bean` ע��ķ���Ҫ�õIJ��������� `BeanConfigs#beanObj1` û��ָ�������������� null;
+
+��������������������ʵ�����ı�����ʵ������ʽ����Ҳ���뵽�ˣ�ʵ�����������������������ˣ����������ǵ��÷������ʵ�����ˣ�
+
+> ConstructorResolver#instantiate(...)
+
+```
+private Object instantiate(String beanName, RootBeanDefinition mbd,
+        @Nullable Object factoryBean, Method factoryMethod, Object[] args) {
+    try {
+
+        return this.beanFactory.getInstantiationStrategy().instantiate(
+                mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args);
+    }
+    catch (Throwable ex) {
+        ...
+    }
+}
+
+```
+
+> SimpleInstantiationStrategy#instantiate(...)
+
+```
+@Override
+public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
+        @Nullable Object factoryBean, final Method factoryMethod, Object... args) {
+    try {
+        ...
+        try {
+            currentlyInvokedFactoryMethod.set(factoryMethod);
+            // ������൱�ڵ��� beanConfigs.beanObj1()
+            Object result = factoryMethod.invoke(factoryBean, args);
+            if (result == null) {
+                result = new NullBean();
+            }
+            return result;
+        }
+        finally {
+            ...
+        }
+    }
+    catch (...) {
+        ...
+    }
+}
+
+```
+
+�������� `SimpleInstantiationStrategy#instantiate(...)` �����н��з���ʵ�����ˣ�
+
+ʵ������ɺ󣬺�������ע�롢��ʼ���ȶ�����ͨ�� spring bean һ�£�����Ͳ��ٷ����ˡ�
+
+### 3.6 `@Configuration` �� `@Bean` ���ʹ��
+
+��������� `@Component` �� `@Bean` ʹ��ʱ�Ĵ����������
+
+```
+@Component
+public class BeanConfigs {
+    @Bean
+    public Xxx xxx() {
+        ...
+    }
+}
+
+```
+
+ʵ���ϣ���������������ʹ�õ��� `@Configuration` �� `@Bean` ����ϣ�
+
+```
+@Configuration
+public class BeanConfigs {
+    @Bean
+    public Xxx xxx() {
+        ...
+    }
+}
+
+```
+
+��������ǰ��ʹ�õ� `@Component` �кβ���أ��������Ǿ��������¡�
+
+#### 1\. demo ׼��
+
+demo ׼����
+
+```
+//@Component
+@Configuration
+public class BeanConfigs {
+
+    @Bean
+    public BeanObj1 beanObj1() {
+        return new BeanObj1();
+    }
+
+    @Bean
+    public BeanObj2 beanObj2() {
+        // ��������� beanObj1() ����
+        beanObj1();
+        return new BeanObj2();
+    }
+
+}
+
+```
+
+��� demo ����ֻ�ǽ� `@Component` �滻Ϊ `@Configuration`��ִ���£�������£�
+
+```
+����beanObj1�Ĺ��췽��
+����beanObj2�Ĺ��췽��
+obj1:BeanObj1{}
+obj2:BeanObj2{}
+org.springframework.learn.explore.demo02.BeanConfigs$$EnhancerBySpringCGLIB$$dca1c55b@75c072cb
+
+```
+
+���������������ǽ�֮ǰ��ִ��Ҳ�������
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-88e5047479e4f30e70d09397d2631c0c6a5.png)
+
+�����Ƚϣ�������������ͬ��
+
+1.  `beanObj1` �Ĺ��췽����������һ�Σ�
+2.  `beanConfigs` ��Ӧ������ `BeanConfigs$$EnhancerBySpringCGLIB$$dca1c55b@75c072cb`��˵������һ����������ʹ���� cglib ������
+
+ʵ���ϣ�����������ͬ�㶼���Թ��Ϊһ��ԭ��spring �� `beanConfigs` �����˴��������� `BeanConfigs#beanObj1` ʵ�ʵ��õ��Ǵ����������� **spring ��Ա� `@Configuration` ��ǵ������ cglib ����**��
+
+��ô��������ô���������е��أ����Ǽ���̽����
+
+#### 2\. ������Ĵ�����`ConfigurationClassPostProcessor#enhanceConfigurationClasses`
+
+��[��һƪ����](https://my.oschina.net/funcy/blog/4836178)�Ŀ�ƪ�����Ǿ��ᵽ�� `ConfigurationClassPostProcessor` ��ִ��ʱ����õ�����������`processConfigBeanDefinitions(...)` �� `enhanceConfigurationClasses(...)`��`processConfigBeanDefinitions(...)` ������ spring �� `@Import`��`@Configuration` ��ע��Ľ�����ǰ���Ѿ��������ˣ��� `enhanceConfigurationClasses(...)` ���DZ� `@Configuration` ��ǵ�����������Ĺؼ����ڣ�
+
+`enhanceConfigurationClasses(...)` �����������£�
+
+> ConfigurationClassPostProcessor#enhanceConfigurationClasses
+
+```
+public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
+    Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
+    for (String beanName : beanFactory.getBeanDefinitionNames()) {
+        BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
+        Object configClassAttr = beanDef.getAttribute(
+            ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE);
+        ...
+        // 1\. �ж��Ƿ�Ϊһ��ȫ������
+        if (ConfigurationClassUtils.CONFIGURATION_CLASS_FULL.equals(configClassAttr)) {
+            ...
+            configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
+        }
+    }
+    // ȫ�����ࣺ��������
+    ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
+    for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
+        AbstractBeanDefinition beanDef = entry.getValue();
+        beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
+        // ���� BeanClass
+        Class<?> configClass = beanDef.getBeanClass();
+        // 2\. ���� enhancedClass
+        Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
+        if (configClass != enhancedClass) {
+            // 3\. ���� BeanClass��ֵΪenhancedClass
+            beanDef.setBeanClass(enhancedClass);
+        }
+    }
+}
+
+```
+
+��������Ƚϼ򵥣��������£�
+
+1.  �ж��������Ƿ�Ϊȫ�����࣬����[��һƪ����](https://my.oschina.net/funcy/blog/4836178)�����У������ᵽ spring ��Ѵ��� `@Configuration` ע���� `proxyBeanMethods != false` ������Ϊ `Full` �����࣬�������Ǹ���ǰ��ı�����жϷ�Ϊȫ�����࣬�����ԣ���ʱ�� `beanConfigs` ����һ��ȫ�����ࣻ
+2.  ��ȫ�����࣬������� `configClass` ���ɶ�Ӧ�� `enhancedClass`��
+3.  �����ɵ� `enhancedClass` ���õ� `beanDefinition` �� `beanClass` �С�
+
+ִ����˷�����`beanConfigs` ��Ӧ�� `beanDefinition` �� `beanClass` ���Ǵ������ˣ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-f617fc93f72b13b8f785ccf5a12624dec0b.png)
+
+���洴���� `beanConfigs` ��������������ʵ���ˡ�
+
+#### 3\. ִ�д�������ķ���
+
+���ɴ�������󣬴������������ִ�е��أ��� spring �����ִ�� `beanConfigs.beanObj1()` ���أ�˵�����������Ҫ̸�� cglib ��������ķ���ִ���ˡ�����ֱ���������������ɣ����� `enhancer.enhance(configClass, this.beanClassLoader)`��
+
+```
+public Class<?> enhance(Class<?> configClass, @Nullable ClassLoader classLoader) {
+    if (EnhancedConfiguration.class.isAssignableFrom(configClass)) {
+        return configClass;
+    }
+    // newEnhancer(...) �������ǹؼ�
+    Class<?> enhancedClass = createClass(newEnhancer(configClass, classLoader));
+    return enhancedClass;
+}
+
+```
+
+�������룺
+
+```
+private static final Callback[] CALLBACKS = new Callback[] {
+        // �����������֤ @Bean �����ĵ���
+        new BeanMethodInterceptor(),
+        new BeanFactoryAwareMethodInterceptor(),
+        NoOp.INSTANCE
+};
+
+// ���� CallbackFilter������Ķ���ΪCallback
+private static final ConditionalCallbackFilter CALLBACK_FILTER 
+        = new ConditionalCallbackFilter(CALLBACKS);
+
+// ����cglib��ǿ
+private Enhancer newEnhancer(Class<?> configSuperClass, @Nullable ClassLoader classLoader) {
+    Enhancer enhancer = new Enhancer();
+    enhancer.setSuperclass(configSuperClass);
+    enhancer.setInterfaces(new Class<?>[] {EnhancedConfiguration.class});
+    enhancer.setUseFactory(false);
+    enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
+    enhancer.setStrategy(new BeanFactoryAwareGeneratorStrategy(classLoader));
+    // ����������callbackFilter
+    enhancer.setCallbackFilter(CALLBACK_FILTER);
+    enhancer.setCallbackTypes(CALLBACK_FILTER.getCallbackTypes());
+    return enhancer;
+}
+
+```
+
+���� cglib ���������ݣ��� [spring aop ֮ cglib ����](https://my.oschina.net/funcy/blog/4696655)һ��������ϸ�������ˣ��ⲻ�ٷ���������ֱ��˵���ۣ�cglib ִ�д�������ʱ��ִ�е��� `Enhancer` �� `callbackFilter` ���Ե� `MethodInterceptor#intercept` �������� `CALLBACKS` �����е� `BeanMethodInterceptor`���������Ǿ��������������ݣ�
+
+> ConfigurationClassEnhancer.BeanMethodInterceptor
+
+```
+private static class BeanMethodInterceptor implements MethodInterceptor, ConditionalCallback {
+    @Override
+    @Nullable
+    public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs,
+                MethodProxy cglibMethodProxy) throws Throwable {
+        ConfigurableBeanFactory beanFactory = getBeanFactory(enhancedConfigInstance);
+        String beanName = BeanAnnotationHelper.determineBeanNameFor(beanMethod);
+        ...
+        // ����ǵ��õ�ǰ�� factoryMethod ������ֱ�ӵ��ø���ķ���
+        if (isCurrentlyInvokedFactoryMethod(beanMethod)) {
+            // ���ø���ķ�����Ҳ����Ŀ�귽��
+            return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
+        }
+        // ����ֱ�ӻ�ȡ beanFactory�����еĶ���
+        return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);
+    }
+
+    private Object resolveBeanReference(Method beanMethod, Object[] beanMethodArgs,
+            ConfigurableBeanFactory beanFactory, String beanName) {
+        try {
+            ...
+            // ���õĵ��� beanFactory.getBean(...) ������������������Ѿ��dz���Ϥ��
+            Object beanInstance = (useArgs ? beanFactory.getBean(beanName, beanMethodArgs) :
+                    beanFactory.getBean(beanName));
+            ...
+            return beanInstance;
+        }
+        finally {
+            ...
+        }
+    }
+
+    /**
+     * �ж��ܷ�ִ�е�ǰ MethodInterceptor
+     */
+    @Override
+    public boolean isMatch(Method candidateMethod) {
+        return (candidateMethod.getDeclaringClass() != Object.class &&
+                !BeanFactoryAwareMethodInterceptor.isSetBeanFactory(candidateMethod) &&
+                BeanAnnotationHelper.isBeanAnnotated(candidateMethod));
+    }
+}
+
+```
+
+`BeanMethodInterceptor` ʵ���� `MethodInterceptor` �� `ConditionalCallback`��`ConditionalCallback#isMatch` �����жϵ�ǰ `MethodInterceptor` �ܷ�ִ�У�`MethodInterceptor#intercept` ����ִ�еķ������ݣ�ִ���߼�Ϊ��
+
+1.  �����ֱ�ӵ��õ�ǰ�� `factoryMethod` ������ֱ�ӵ��ø���ķ�����Ҳ���� `beanConfigs.beanObj1()`��������̻�ʵ���� `beanObj1` ʱ�����ã�
+2.  �������ֱ�ӵ��õ�ǰ�� `factoryMethod` �����������ڱ�ķ����е��ã�������� `beanFactory.getBean(...)` ��ȡ bean��������̻���ʵ���� `beanObj1` ʱ�� �����á�
+
+���Ͼ���Ϊʲô `beanObj1` �Ĺ��췽��ֻ������һ�Σ��Լ�Ϊʲô `beanConfigs` �Ǵ������ԭ�������ˡ�
+
+�������һ�䣬`@Configuration` �ṩ�� `proxyBeanMethods()` ������������ѡ���Ƿ���������Ĵ�����Ĭ��ֵ�� true��������������ã�
+
+```
+@Configuration(proxyBeanMethods=false)
+public class BeanConfigs {
+    ...
+}
+
+```
+
+`BeanConfigs` �Ͳ�����д����ˣ����н��ͬ `@Component` ע��һ��������Ͳ�չʾ�ˡ�
+
+#### 4\. ��������
+
+##### 1\. �ڲ���������Ҳ�ܱ�������
+
+��ʾ���У��������������õģ�
+
+```
+    @Bean
+    public BeanObj2 beanObj2() {
+        // ��������� beanObj1() ����
+        beanObj1();
+        return new BeanObj2();
+    }
+
+```
+
+���� `beanObj2()` �е����� `beanObj1()`�����������ڲ��������ã�`beanObj1()` Ҳ�ܱ�������
+
+**�ش�**��cglib �����ĵ��÷��������֣�
+
+```
+@Override
+public Object intercept(Object proxyObj, Method method, Object[] objects, 
+            MethodProxy proxy) throws Throwable {
+    // ����1�� ʹ��Ŀ�����ֱ�ӵ���Ŀ�����ķ���
+    // return proxy.invoke(target, objects);
+    // ����2�� ʹ�ô������󣬵����丸��ķ���
+    return proxy.invokeSuper(proxyObj, objects);
+}
+
+```
+
+`beanObj2()` �ĵ���ʹ����`����2`��Ҳ����ʹ�ô���������� `beanObj2()`��`beanObj2()` �� `this` Ϊ��������
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-7ef891450ace815d22a5bf5c8e78e65c2db.png)
+
+����� `beanObj2()` ��ֱ�ӵ��� `beanObj1()`�����൱��ʹ�ô���������� `beanObj1()`����Ȼ�ܱ������ˡ�
+
+������ӡ���У��������ڲ����ò��ܱ�������������Ϊ spring �ڴ��� Aop ʱ��ʹ�õ��Ƿ��� 1 �ĵ��÷�ʽ����ʱ�� `this` Ϊԭʼ���󣬵�Ȼ���ܱ������ˡ�
+
+##### 2\. ˽���������ע�룿
+
+���磬����������һ�� `BeanObj3`:
+
+```
+@Component
+public class BeanObj3 {
+
+    public BeanObj3() {
+        System.out.println("����beanObj3�Ĺ��췽��");
+    }
+
+    @Override
+    public String toString() {
+        return "BeanObj3{}";
+    }
+}
+
+```
+
+Ȼ���� `BeanConfigs` ��ע�룺
+
+```
+@Configuration
+public class BeanConfigs {
+
+    @Autowired
+    private BeanObj3 beanObj3;
+
+    @Bean
+    public BeanObj1 beanObj1() {
+        return new BeanObj1();
+    }
+
+    @Bean
+    public BeanObj2 beanObj2() {
+        // ��������� beanObj1() ����
+        beanObj1();
+        System.out.println("beanObj3��" + this.beanObj3);
+        return new BeanObj2();
+    }
+
+}
+
+```
+
+�� `BeanConfigs` ���Զ�ע���� `beanObj3` ���ԣ�Ȼ���� `beanObj2()` ���ִ�ӡ�� `beanObj3` ���ԡ����У�������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-e21bf76da41fcf12e674fa155de4b636253.png)
+
+���Կ�����ע��� `beanObj3` Ҳ�ܻ�ȡ���ˡ�������и������ˣ�`beanObj3` ������Ŀ�����ģ��� `this` �Ǵ��������Ѳ��ɴ����������õ�Ŀ������˽�����ԣ�
+
+���ȣ����ӵ� `beanFactory` �� `beanDefinitionMap` �е����� `BeanConfigs$$EnhancerBySpringCGLIB$$Xxx` �ࣨ�����ࣩ�������� `BeanConfigs`��spring �ڽ�������ע��ʱ������ҵ�ǰ�༰�丸������е�ע�����Խ���ע�룬��ˣ���Ȼ���ӵ� spring �����е� �� `BeanConfigs$$EnhancerBySpringCGLIB$$Xxx` �࣬�� `BeanConfigs` �е� `beanObj3` һ���ᱻע�룬����ԭ������� cglib �Ĵ�����ϵ��`BeanConfigs` �� `BeanConfigs$$EnhancerBySpringCGLIB$$Xxx` �ĸ��ࡣ
+
+�� `BeanConfigs$$EnhancerBySpringCGLIB$$Xxx` ��̳� `beanObj3` ����������ֱ�ӿ����н���ɣ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-27ebdebfd8c958f1de362ca1b30f2d0fc7c.png)
+
+�������յõ��� `beanConfigs` ���󣬿��Կ��������������һ�� `beanObj3` ���ԣ����һ���ֵ��
+
+### 3.7 �ܽ�
+
+������Ҫ������ `ConfigurationClassPostProcessor` ���� `@Bean` ע��Ĺ��̣��ܽ����£�
+
+1.  ���������࣬ͨ�������ȡ�����������б� `@Bean` ��ǵķ�����
+2.  ������Щ�����������װ��һ���� `BeanDefinition` ע�ᵽ `beanFactory` �У���Ӧ `BeanDefinition` ��������Ϊ `ConfigurationClassBeanDefinition`��
+3.  �����������ȫ�����࣬������������ cglib ������
+4.  ʵ����ʱ��ʹ�÷�����ö�Ӧ�ķ�������ʵ�����õ�ʵ����spring ���ٶ����������ע�롢��ʼ���ȣ���
+5.  �ڱ�� `@Bean` �����е��õ�ǰ `@Bean` ����ʱ�������ǰ `@Bean` �������ڵ�����ȫ�����࣬���ȥ `beanFactory` �в��Ҷ�Ӧ�� `bean`(���ҵĹ����ǣ��ҵ��򷵻أ��Ҳ����򴴽��ٷ��أ�**���ص� bean �������� spring bean ����������**)������������� cglib ������ɣ������ǰ `@Bean` �������ڵ��಻��ȫ�����࣬��ᰴ����ͨ�ķ������ã����� bean ��ʵ�����أ�**���ص� bean û�������� spring bean ����������**����
+
+���ĵķ����͵������ˣ����������Ǽ������� `ConfigurationClassPostProcessor` ��������ע������̡�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4492878](https://my.oschina.net/funcy/blog/4492878) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/ConfigurationClassPostProcessor\357\274\210\345\233\233\357\274\211\357\274\232\345\244\204\347\220\206@Conditional\346\263\250\350\247\243.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/ConfigurationClassPostProcessor\357\274\210\345\233\233\357\274\211\357\274\232\345\244\204\347\220\206@Conditional\346\263\250\350\247\243.md"
new file mode 100644
index 0000000..5d11cae
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/ConfigurationClassPostProcessor\357\274\210\345\233\233\357\274\211\357\274\232\345\244\204\347\220\206@Conditional\346\263\250\350\247\243.md"
@@ -0,0 +1,385 @@
+������ `ConfigurationClassPostProcessor` �����ĵ���ƪ����Ҫ�Ƿ��� spring �� `@Conditional` ע��Ĵ������̡�
+
+## 5\. spring ����δ��� @Conditional ע��ģ�
+
+### 5.1 `@Conditional` �Ĵ�������
+
+��ǰ����� `ConfigurationClassParser#processConfigurationClass` ����ʱ������ôһ�У�
+
+```
+class ConfigurationClassParser {
+    protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
+        // �ж��Ƿ���Ҫ��������������� @Conditional ע�⣬�ж��Ƿ���������
+        if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), 
+                ConfigurationPhase.PARSE_CONFIGURATION)) {
+            return;
+        }
+        ...
+    }
+    ...
+}
+
+```
+
+`conditionEvaluator.shouldSkip(...)` ���������������� `@Conditional` ע��ģ�������������Ĵ������̣����������ٷ�����������������ʲô�� `@Conditional` ע�⣺
+
+```
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface Conditional {
+
+    /**
+     * ������
+     */
+    Class<? extends Condition>[] value();
+
+}
+
+```
+
+`@Conditional` ע��dz��򵥣�����һ�����ԣ�����ֵ�� `Class[]`���ұ����� `Condition` �����ࡣ������������ `Condition`��
+
+```
+public interface Condition {
+
+    /**
+     * ������ָ��ƥ���߼�
+     */
+    boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
+
+}
+
+```
+
+`Condition` �ӿڽ���һ�� `matches` ���������ǿ���������ָ��ƥ���߼���
+
+�������������� `conditionEvaluator.shouldSkip(...)` �Ĵ������̣�
+
+```
+class ConditionEvaluator {
+    public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, 
+            @Nullable ConfigurationPhase phase) {
+        // �Ƿ��� @Conditional
+        if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
+            return false;
+        }
+        // �жϴ���� phase
+        if (phase == null) {
+            if (metadata instanceof AnnotationMetadata &&
+                    ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
+                return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
+            }
+            return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
+        }
+
+        // ʵ���� condition������� conditions ��
+        List<Condition> conditions = new ArrayList<>();
+        // 1\. getConditionClasses(metadata)����ȡ @Conditional ��ָ�����ж���
+        for (String[] conditionClasses : getConditionClasses(metadata)) {
+            for (String conditionClass : conditionClasses) {
+                // 2\. ʵ�����������õ��Ļ��Ƿ��䣩��ͳһ�ŵ� conditions ��
+                Condition condition = getCondition(conditionClass, this.context.getClassLoader());
+                conditions.add(condition);
+            }
+        }
+        // 3\. ��������õ��� condition ʵ��
+        AnnotationAwareOrderComparator.sort(conditions);
+        // ��������õ��� conditions
+        for (Condition condition : conditions) {
+            ConfigurationPhase requiredPhase = null;
+            if (condition instanceof ConfigurationCondition) {
+                requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
+            }
+            // 4\. ���� Condition#matches ���������ж�
+            if ((requiredPhase == null || requiredPhase == phase) && 
+                    !condition.matches(this.context, metadata)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    ...
+}
+
+```
+
+�÷����Ĵ����������£�
+
+1.  ��ȡ `@Conditional` ��ָ�����ж��࣬���� `@Conditional` �� `value` ����ֵ��
+2.  ʹ�� ����ʵ������ 1 ���� �õ����ж��࣬�� ���浽 `conditions`�����Ǹ� `List`�� �У�
+3.  �Ե� 2 ���õ��� `conditions` ��������
+4.  ������ 3 ���õ��� `conditions`������ `Condition#matches` ��������ƥ�䡣
+
+`@Conditional` �Ĵ������Ƿdz��򵥵ģ���������������������ʹ��ʾ����
+
+### 5.2 `@Conditional` ʹ��ʾ��
+
+#### ʾ�� 1����ָ���������ʱ���Ŵ��� spring bean
+
+��������ʵ�ָ����ܣ���ָ���������ʱ���Ž��� spring bean �Ĵ�������ʼ�����������£�
+
+1. ׼��һ���򵥵� bean:
+
+   ```
+   public class BeanObj {
+   
+   }
+   
+   ```
+
+2. ʵ�� `Condition` �ӿڣ������ﴦ���ж��߼�
+
+   ```
+   public class MyCondition implements Condition {
+       @Override
+       public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
+           String className = "java.lang.Object";
+           try {
+               // �ж����Ƿ����
+               Class.forName(className);
+               return true;
+           } catch (ClassNotFoundException e) {
+               return false;
+           }
+       }
+   }
+   
+   ```
+
+   �� `matches(...)` ������ ������ָ�� `className` Ϊ `java.lang.Object`��Ȼ���ж����Ƿ���ڣ��жϷ�ʽҲ ʮ�ּ� ������ʹ�� java �ķ�����ƣ�`Class.forName(...)`�����಻����ʱ�����׳� `ClassNotFoundException`�����ǿ��Բ�����쳣���Ӷ���֪������ڲ������ˡ�
+
+3. ׼��������
+
+   ```
+   @ComponentScan
+   public class BeanConfigs {
+       @Bean
+       @Conditional(MyCondition.class)
+       public BeanObj beanObj() {
+           return new BeanObj();
+       }
+   }
+   
+   ```
+
+   ������Ƚϼ򵥣���Ҫע����� `beanObj()` �ϵ� `@Conditional` ע�⣬ָ����������ƥ������ `MyCondition`��ƥ�����������������н��еġ�
+
+4. ����
+
+   ```
+   public class Demo06Main {
+       public static void main(String[] args) {
+           ApplicationContext context 
+                   = new AnnotationConfigApplicationContext(BeanConfigs.class);
+           try {
+               Object obj = context.getBean("beanObj");
+               System.out.println("beanObj ���ڣ�");
+           } catch (Exception e) {
+               System.out.println("beanObj �����ڣ�");
+           }
+       }
+   }
+   
+   ```
+
+���У�������£�
+
+```
+beanObj ���ڣ�
+
+```
+
+�� `MyCondition#matches` �У������жϵ��ǵ�ǰ��Ŀ���Ƿ���� `java.lang.Object`����Ȼ���Ǵ��ڵģ���� `beanObj` ���� spring �����У��������ǻ��� `className`:
+
+```
+public class MyCondition implements Condition {
+    @Override
+    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
+        // ��������
+        String className = "java.lang.Object111";
+        ...
+    }
+}
+
+```
+
+��Ȼ��`java.lang.Object111` �Dz������ڵ�ǰ��Ŀ�еģ����У�������£�
+
+```
+beanObj �����ڣ�
+
+```
+
+#### ʾ�� 2���Ľ�ʾ�� 1 ����
+
+��ʾ�� 1 �У�����ͨ���� `MyCondition#matches` �޸� `className` ���ı� `beanObj` �������еĴ���������������Ŀ���зdz��������Ҫ����Ĵ��������м��أ�������ʵ�ֶ�� `MyCondition` ��
+
+���磬�� `A` ��Ҫ������ `A1` �Ĵ���������ж��Ƿ���г�ʼ������ `B` ��Ҫ������ `B1` �Ĵ���������ж��Ƿ���г�ʼ������ `C` ��Ҫ������ `C1` �Ĵ���������ж��Ƿ���г�ʼ��... �����Ƿ���Ҫ�ֱ�Ϊ`��A`��`��B`��`��C` ʵ�� `Condition`���ڸ��Ե� `match(...)` �����н����ж���
+
+ʵ���ϣ����Dz�����Ҫ��ô��������ͨ�� spring ���ע��ķ�����������Ϲ��ܡ�
+
+1. ׼��һ�� bean������ʾ�� 1 ��������
+
+   ```
+   public class BeanObj {
+   
+   }
+   
+   ```
+
+2. ׼��ע�� `@ConditionalForClass`����ע������� `@Conditional` �Ĺ��ܣ���������ƥ�����Ϊ `MyCondition`��`className` ���Ծ��DZ�����ڵ��ࣺ
+
+```
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+// ����� @Conditional �Ĺ��ܣ���������ƥ�����Ϊ MyCondition
+@Conditional(MyCondition.class)
+public @interface ConditionalForClass {
+
+    /**
+     * ����ָ��������ڵ���
+     */
+    String className();
+
+}
+
+```
+
+1. ׼�� `MyCondition`��ע����ʾ���IJ�����ڣ�`className` �����ڸ÷����ж��壬������ `@ConditionalForClass` ���룺
+
+   ```
+   public class MyCondition implements Condition {
+       /**
+        * ���ﴦ��ƥ��������ע����ʾ��1�е�����
+        */
+       @Override
+       public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
+           // ��ȡ @ConditionalForClass ע�����������ֵ
+           Map<String, Object> annotationAttributes = metadata.getAnnotationAttributes(
+                   ConditionalForClass.class.getName());
+           // ��ȡclassName������ֵ������ @ConditionalForClass �� className ����
+           String className = (String)annotationAttributes.get("className");
+           if(null == className || className.length() <= 0) {
+               return true;
+           }
+           try {
+               // �ж����Ƿ����
+               Class.forName(className);
+               return true;
+           } catch (ClassNotFoundException e) {
+               return false;
+           }
+       }
+   }
+   
+   ```
+
+2. ׼�������࣬��ʱ������ע��Ϊ `@ConditionalForClass`��
+
+   ```
+   @ComponentScan
+   public class BeanConfigs {
+       @Bean
+       /**
+        * �� @ConditionalForClass ��ָ������������
+        */
+       @ConditionalForClass(className = "java.lang.Object")
+       public BeanObj beanObj() {
+           return new BeanObj();
+       }
+   }
+   
+   ```
+
+3. ��������࣬��ʾ�� 1 ��������
+
+   ```
+   public class Demo07Main {
+   
+       public static void main(String[] args) {
+           ApplicationContext context 
+                   = new AnnotationConfigApplicationContext(BeanConfigs.class);
+           try {
+               Object obj = context.getBean("beanObj");
+               System.out.println("beanObj ���ڣ�");
+           } catch (Exception e) {
+               System.out.println("beanObj �����ڣ�");
+           }
+       }
+   }
+   
+   ```
+
+������ͨ���Զ���ע�� `@ConditionalForClass` ��ָ�������� `java.lang.Object` ����ʱ��`beanObj` �Żᱻ���ӵ� spring �����У����������Ȼ���������У�������£�
+
+```
+beanObj ���ڣ�
+
+```
+
+�������������� `@ConditionalForClass` �� `className` ֵ��
+
+```
+@ComponentScan
+public class BeanConfigs {
+    @Bean
+    // ���޸���@ConditionalForClass��classNameֵ��������������
+    @ConditionalForClass(className = "java.lang.Object1111")
+    public BeanObj beanObj() {
+        return new BeanObj();
+    }
+}
+
+```
+
+���ｫ `@ConditionalForClass` �� `className` ֵ����Ϊ `java.lang.Object1111`����Ȼ����ಢ���ڵ�ǰ��Ŀ�У����н�����£�
+
+```
+beanObj �����ڣ�
+
+```
+
+���Ҳ�����ǵ�����һ�¡�
+
+�����ǻص����ڿ�ͷ�����⣺���磬�� `A` ��Ҫ������ `A1` �Ĵ���������ж��Ƿ���г�ʼ������ `B` ��Ҫ������ `B1` �Ĵ���������ж��Ƿ���г�ʼ������ `C` ��Ҫ������ `C1` �Ĵ���������ж��Ƿ���г�ʼ��... �����Ƿ���Ҫ�ֱ�Ϊ`��A`��`��B`��`��C` ʵ�� `Condition`���ڸ��Ե� `match(...)` �����н����ж���
+
+���� `@ConditionalForClass` ע������Dz�����Ҫ��ô�鷳��ֻ��Ҫ�ڸ��Ե� `@Bean` ���������� `@ConditionalForClass` �����ˣ���������
+
+```
+@Bean
+@ConditionalForClass(className = "A1")
+public A a() {
+    return new A();
+}
+
+@Bean
+@ConditionalForClass(className = "B1")
+public B b() {
+    return new B();
+}
+
+@Bean
+@ConditionalForClass(className = "B1")
+public C c() {
+    return new C();
+}
+
+...
+
+```
+
+ע����� `@ConditionalForClass` ��ʵ�֣�springboot �е� `@ConditionalOnClass` ���ǰ�����˼·ʵ�ֵġ�
+
+### 5.3 �ܽ�
+
+������Ҫ������ spring ���� `@Conditional` �����̣��߼��Ƚϼ򵥣����յ��õ��� `Condition#matches` ��������ƥ������ģ���ƥ������� `Condition` ��ʵ��������ָ����
+
+Ϊ�˸��õ�˵�� `@Conditional` ��ʹ�ã�����׼��������ʹ��ʾ�����ر���ʾ�� 2����Ҫ�ر���ᣬspringboot �е� `@ConditionalOnClass` ���ǻ���ʾ�� 2 ��˼·����ʵ�ֵģ����⣬springboot �еĶ������ע��Ҳ�Ƕ� `@Conditional` ����չ��
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4873444](https://my.oschina.net/funcy/blog/4873444) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213AOP\347\232\204\346\211\247\350\241\214\351\241\272\345\272\217.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213AOP\347\232\204\346\211\247\350\241\214\351\241\272\345\272\217.md"
new file mode 100644
index 0000000..89b3927
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213AOP\347\232\204\346\211\247\350\241\214\351\241\272\345\272\217.md"
@@ -0,0 +1,671 @@
+spring aop ִ��ʱ��˳���������ģ���θı�ִ�е����ȼ������Ľ���Դ������̽�� aop ִ��˳������ܡ�
+
+�� [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������ϣ�](https://my.oschina.net/funcy/blog/4678817) �� [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������£�](https://my.oschina.net/funcy/blog/4687961)�У��ݹ� spring aop ������ִ�й��̣�����һ���������ι��� aop �����������
+
+*   `ReflectiveAspectJAdvisorFactory#getAdvisorMethods`���� `aspect` �е� `@Around/@Before/@After` �ȷ�����������
+*   `AspectJAwareAdvisorAutoProxyCreator#sortAdvisors`���� `advisor` ��������
+
+�����������ص�������������������
+
+#### 1 `ReflectiveAspectJAdvisorFactory#getAdvisorMethods`
+
+��һ�������� `ReflectiveAspectJAdvisorFactory#getAdvisorMethods`�����ýṹ���£�
+
+```
+|-AbstractAutoProxyCreator#postProcessBeforeInstantiation
+  |-AspectJAwareAdvisorAutoProxyCreator#shouldSkip
+   |-AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors
+    |-BeanFactoryAspectJAdvisorsBuilder#buildAspectJAdvisors
+     |-ReflectiveAspectJAdvisorFactory#getAdvisors
+      |-ReflectiveAspectJAdvisorFactory#getAdvisorMethods
+
+```
+
+�������£�
+
+> ReflectiveAspectJAdvisorFactory
+
+```
+// ��ȡ @Aspect ���еķ���
+private List<Method> getAdvisorMethods(Class<?> aspectClass) {
+    final List<Method> methods = new ArrayList<>();
+    // ʡ�Ի�ȡ�����IJ���
+    ...
+
+    //�Եõ������з�������
+    methods.sort(METHOD_COMPARATOR);
+    return methods;
+}
+
+```
+
+��������IJ����� [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������ϣ�](https://my.oschina.net/funcy/blog/4678817) һ����������ϸ�������������ǽ���ע�������
+
+> ReflectiveAspectJAdvisorFactory
+
+```
+/**
+ * METHOD_COMPARATOR ���
+ */
+private static final Comparator<Method> METHOD_COMPARATOR;
+static {
+    Comparator<Method> adviceKindComparator = new ConvertingComparator<>(
+            // �Ƚ�����������˳����бȽ�
+            new InstanceComparator<>(
+                    Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class),
+            // ת������������ת��Ϊ @Around, @Before, @After, @AfterReturning, @AfterThrowing ��ע��
+            (Converter<Method, Annotation>) method -> {
+                AspectJAnnotation<?> annotation =
+                    AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(method);
+                return (annotation != null ? annotation.getAnnotation() : null);
+            });
+    // ת���Ƚ�����
+    // 1\. ת����������ķ���(Method)ת��Ϊ������(String)
+    // 2\. �Ƚϣ����������ͽ��бȽϣ����ﴫ��ĵ�����ΪString��ԭ����ת�����������Methodת����String��
+    Comparator<Method> methodNameComparator = new ConvertingComparator<>(Method::getName);
+    /*
+     * METHOD_COMPARATOR �ȽϹ���
+     * 1\. ���������ʶ������ע��, �� @Around, @Before, @After, @AfterReturning,
+     *       @AfterThrowing ˳������ (`adviceKindComparator`)
+     * 2\. ���û�б�ʶ��Щע�⣬�򰴷������Ƶ��ַ�������(`methodNameComparator`)
+     */
+    METHOD_COMPARATOR = adviceKindComparator.thenComparing(methodNameComparator);
+}
+
+```
+
+����������������������ܽ����£�
+
+1.  �����������Ķ�����ͬһ�� `@Aspect` �еķ�����
+2.  �������淽�����������£�`@Around`, `@Before`, `@After`, `@AfterReturning`, `@AfterThrowing`��
+3.  ���ڷ����淽��������������String �������������
+
+�÷�������ǰ��ı仯���£�
+
+����ǰ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-23df6d6a46f37badb1017ceee8dcfa6533e.png)
+
+�����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-85bdb16953c1c6348d39578de6b6144c1cc.png)
+
+����������Ƿ����� `@Around, @Before, @After, @AfterReturning,@AfterThrowing` ��˳��һ�¡�
+
+�õ� `List<Method>` �󣬽��Ż������Щ `method`�������װΪһ���� `advisor`��
+
+> ReflectiveAspectJAdvisorFactory
+
+```
+public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
+    // ʡ����һЩ����
+    ...
+
+    List<Advisor> advisors = new ArrayList<>();
+    //��ȡ��������е���ǿ����
+    for (Method method : getAdvisorMethods(aspectClass)) {
+        // ������ǿʵ����advisors.size() ����Ϊ 0��1��2��... ����
+        // declarationOrderInAspect ��ֵ������������õ�
+        Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 
+                advisors.size(), aspectName);
+        if (advisor != null) {
+            advisors.add(advisor);
+        }
+    }
+
+    // ʡ����һЩ����
+    ...
+}
+
+```
+
+��װ�� `Advisor` ʱ���ᴫ�� `declarationOrderInAspect` ֵ����ֵΪ `advisors.size()`������Ϊ `0��1��2��...`�����ֵ�ں���������л��õ���
+
+### 2\. advisor ������`AspectJAwareAdvisorAutoProxyCreator#sortAdvisors`
+
+`@Aspect` ���е����淽����װ�� `advisor` �󣬻��߻�ȡ���Զ��� `advisor` �󣬽��žͽ����˵ڶ�������`AspectJAwareAdvisorAutoProxyCreator#sortAdvisors`�������ĵ��������£�
+
+```
+|-AbstractAutoProxyCreator#postProcessAfterInitialization
+ |-AbstractAutoProxyCreator#wrapIfNecessary
+  |-AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean
+   |-AbstractAdvisorAutoProxyCreator#findEligibleAdvisors
+    |-AspectJAwareAdvisorAutoProxyCreator#sortAdvisors
+
+```
+
+> AspectJAwareAdvisorAutoProxyCreator
+
+```
+protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
+    List<PartiallyComparableAdvisorHolder> partiallyComparableAdvisors 
+            = new ArrayList<>(advisors.size());
+    for (Advisor element : advisors) {
+        partiallyComparableAdvisors.add(
+            // �ȽϹ���Ϊ DEFAULT_PRECEDENCE_COMPARATOR,��ʵ��AspectJPrecedenceComparator
+            new PartiallyComparableAdvisorHolder(element, DEFAULT_PRECEDENCE_COMPARATOR));
+    }
+    // ����ıȽϲ������ȽϹ����� AspectJPrecedenceComparator �ṩ
+    List<PartiallyComparableAdvisorHolder> sorted 
+            = PartialOrder.sort(partiallyComparableAdvisors);
+    if (sorted != null) {
+        List<Advisor> result = new ArrayList<>(advisors.size());
+        for (PartiallyComparableAdvisorHolder pcAdvisor : sorted) {
+            result.add(pcAdvisor.getAdvisor());
+        }
+        return result;
+    }
+    else {
+        return super.sortAdvisors(advisors);
+    }
+}
+
+```
+
+�����������������һ���� `PartialOrder.sort(...)`��һ���� `super.sortAdvisors(...)`�������������� `PartialOrder.sort(...)`��
+
+#### 2.1 `PartialOrder.sort(...)` �ıȽ�����`AspectJPrecedenceComparator`
+
+ʵ���ϣ�`PartialOrder.sort(...)` ֻҪ����һ��������ѣ��������ûɶ�����ģ���������Ҫ������Ӧ���Ǵ�����������Ҳ���� `DEFAULT_PRECEDENCE_COMPARATOR`��
+
+```
+private static final Comparator<Advisor> DEFAULT_PRECEDENCE_COMPARATOR 
+        = new AspectJPrecedenceComparator();
+
+```
+
+`DEFAULT_PRECEDENCE_COMPARATOR` �������� `AspectJPrecedenceComparator`������ֱ�Ӳ鿴�� `compare(xxx)` ������
+
+> AspectJPrecedenceComparator
+
+```
+@Override
+public int compare(Advisor o1, Advisor o2) {
+    // �ȽϹ���AnnotationAwareOrderComparator
+    int advisorPrecedence = this.advisorComparator.compare(o1, o2);
+    // ˳����ͬ������Դ��ͬһ aspect������ comparePrecedenceWithinAspect �ٴαȽ�
+    if (advisorPrecedence == SAME_PRECEDENCE && declaredInSameAspect(o1, o2)) {
+        // �Ƚ�����˳�����������һ����after֪ͨ��������������ȼ��ߣ����������������ȼ���
+        advisorPrecedence = comparePrecedenceWithinAspect(o1, o2);
+    }
+    return advisorPrecedence;
+}
+
+```
+
+`AspectJPrecedenceComparator#compare` �Ƚϼ򵥣��������£�
+
+1.  ���� `advisorComparator.compare` ���бȽϣ�����ȽϹ������ǽ������������
+2.  ����������ȽϹ���õ������ȼ���ͬ�������� `advisor` ����ͬһ aspect �ж���ģ������ `comparePrecedenceWithinAspect` �����Ƚ�.
+
+##### `this.advisorComparator.compare`
+
+���������� `this.advisorComparator.compare` �ıȽϹ���
+
+```
+private final Comparator<? super Advisor> advisorComparator;
+
+public AspectJPrecedenceComparator() {
+    this.advisorComparator = AnnotationAwareOrderComparator.INSTANCE;
+}
+
+public int compare(Advisor o1, Advisor o2) {
+    // �ȽϹ���AnnotationAwareOrderComparator
+    int advisorPrecedence = this.advisorComparator.compare(o1, o2);
+    ...
+}
+
+```
+
+`this.advisorComparator.compare` �ıȽϹ����� `AnnotationAwareOrderComparator` �ṩ��
+
+```
+public int compare(@Nullable Object o1, @Nullable Object o2) {
+    return doCompare(o1, o2, null);
+}
+
+/**
+ * ����ıȽϲ������ȱȽ� PriorityOrdered���ٱȽ� Ordered
+ */
+private int doCompare(@Nullable Object o1, @Nullable Object o2, 
+        @Nullable OrderSourceProvider sourceProvider) {
+    // ����֮һΪ PriorityOrdered��˭��PriorityOrdered��˭�����ȼ���
+    boolean p1 = (o1 instanceof PriorityOrdered);
+    boolean p2 = (o2 instanceof PriorityOrdered);
+    if (p1 && !p2) {
+        return -1;
+    }
+    else if (p2 && !p1) {
+        return 1;
+    }
+    // ����order��ֵ���Ȳ���Ordered�ӿڣ����û�ҵ����ٲ��� @Order ע��
+    int i1 = getOrder(o1, sourceProvider);
+    int i2 = getOrder(o2, sourceProvider);
+    // ��Integer������бȽ�
+    return Integer.compare(i1, i2);
+}
+
+```
+
+������Ĵ����֪���ȱȽ� `PriorityOrdered`���ٱȽ� `Ordered`���ȽϹ������£�
+
+1.  `PriorityOrdered` �Ƚϣ�����֮�У�ֻ����һʵ���� `PriorityOrdered` �ӿڣ���ô����Ϊ `PriorityOrdered` ���ȼ��ߣ� ��������� `Ordered` �Ĺ���Ƚϣ�
+2.  `Ordered` �ȽϹ���
+    1.  ���ʵ���� `Ordered` �� `PriorityOrdered` �ӿڣ������ `getOrder()` ����ֵ���бȽϣ�ֵԽС���ȼ�Խ�ߣ�
+    2.  �����ע�� `@Order/@Priority` ע�⣬������� `value()` ����ֵ���бȽϣ�ֵԽС���ȼ�Խ�ߣ�
+    3.  ���û��ʵ�� `Ordered/PriorityOrdered`��Ҳû�б�ע `@Order/@Priority` ע�⣬��Ϊ������ȼ� (`Integer.MAX_VALUE`).
+
+##### `comparePrecedenceWithinAspect`
+
+���� `@Aspect` ��ע���࣬���ͬһ `aspect` �ﶨ����ͬ���� `advice`��spring aop Ҳ�ṩ��һ�ױȽϹ���
+
+```
+/**
+ * ��� @Aspect�� ͬһaspect�ﶨ����ͬ���� advice���ٴαȽ�
+ */
+private int comparePrecedenceWithinAspect(Advisor advisor1, Advisor advisor2) {
+    boolean oneOrOtherIsAfterAdvice = (AspectJAopUtils.isAfterAdvice(advisor1) 
+            || AspectJAopUtils.isAfterAdvice(advisor2));
+    int adviceDeclarationOrderDelta = getAspectDeclarationOrder(advisor1) 
+            - getAspectDeclarationOrder(advisor2);
+    // ������һ����after֪ͨ��declarationOrderInAspect������ȼ���
+    if (oneOrOtherIsAfterAdvice) {
+        if (adviceDeclarationOrderDelta < 0) {
+            return LOWER_PRECEDENCE;
+        }
+        else if (adviceDeclarationOrderDelta == 0) {
+            return SAME_PRECEDENCE;
+        }
+        else {
+            return HIGHER_PRECEDENCE;
+        }
+    }
+    // ���߶�����after֪ͨ��declarationOrderInAspectС�����ȼ���
+    else {
+        if (adviceDeclarationOrderDelta < 0) {
+            return HIGHER_PRECEDENCE;
+        }
+        else if (adviceDeclarationOrderDelta == 0) {
+            return SAME_PRECEDENCE;
+        }
+        else {
+            return LOWER_PRECEDENCE;
+        }
+    }
+}
+
+```
+
+�ȽϹ������£��Ƚ����ߵ� `declarationOrderInAspect` ֵ���������֮һΪ `after` ֪ͨ��`declarationOrderInAspect` ������ȼ��ߣ�������߶����� `after` ֪ͨ��`declarationOrderInAspect` С�����ȼ��ߡ�
+
+����� `declarationOrderInAspect` ��ʲô�أ�������һС���ᵽ�� `advisor.size()`���������£�
+
+> ReflectiveAspectJAdvisorFactory
+
+```
+public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
+    // ʡ����һЩ����
+    ...
+
+    List<Advisor> advisors = new ArrayList<>();
+    //��ȡ��������е���ǿ����
+    for (Method method : getAdvisorMethods(aspectClass)) {
+        // ������ǿʵ����advisors.size() ����Ϊ 0��1��2��... ����
+        // declarationOrderInAspect ��ֵ������������õ�
+        Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 
+                advisors.size(), aspectName);
+        if (advisor != null) {
+            advisors.add(advisor);
+        }
+    }
+
+    // ʡ����һЩ����
+    ...
+}
+
+```
+
+�ر�ǿ�����ǣ��������ֻ������ͬһ `@Aspect` �ඨ��ġ�ͬ����֪ͨ�������磺
+
+```
+@Aspect
+public class AspectTest {
+    @Before
+    public void before1() {
+        ...
+    }
+
+    @Before
+    public void before2() {
+        ...
+    }
+
+}
+
+```
+
+����� `before1()` �� `before2()` ��Ӧ�� `advisor` ������ `comparePrecedenceWithinAspect` ���򣬶����´���Ͳ������ˣ�ԭ�����ڲ�ͬ�� `@Aspect` ���ж���ģ�
+
+```
+@Aspect
+public class AspectTest1 {
+    @Before
+    public void before() {
+        ...
+    }
+
+}
+
+@Aspect
+public class AspectTest2 {
+    @Before
+    public void before() {
+        ...
+    }
+
+}
+
+```
+
+#### 2. `super.sortAdvisors`
+
+�����ٻع�ͷ���� `super.sortAdvisors(advisors)`:
+
+> AspectJAwareAdvisorAutoProxyCreator
+
+```
+protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
+    ...
+    else {
+        return super.sortAdvisors(advisors);
+    }
+}
+
+```
+
+���Ǹ���ȥ��
+
+> AbstractAdvisorAutoProxyCreator
+
+```
+ protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
+     AnnotationAwareOrderComparator.sort(advisors);
+     return advisors;
+ }
+
+```
+
+�������ʹ�õ��� `AnnotationAwareOrderComparator.sort(advisors)`��ʵ���ϣ����������������� `this.advisorComparator.compare` �ıȽϹ�������Ͳ��ٷ����ˡ�
+
+### 3. `getOrder()` ֵ������
+
+#### `BeanFactoryTransactionAttributeSourceAdvisor#getOrder()`
+
+`BeanFactoryTransactionAttributeSourceAdvisor` û�� `@Order/@Priority`������ʵ���� `Ordered` �ӿڣ��������ִ��˳���� `getOrder()` �����ķ���ֵ��������Ӧ�� `getOrder()` �������£�
+
+```
+    /**
+     * ��ȡ order���������£�
+     * 1\. �����ָ���� order��ֱ�ӷ��أ�
+     * 2\. ��ȡ advisor �� advice����� advice ʵ���� Ordered �ӿڣ����� getOrder()��
+     * 3\. ������϶������㣬�򷵻� Ordered.LOWEST_PRECEDENCE (������ȼ�)��
+     * @return
+     */
+    @Override
+    public int getOrder() {
+        if (this.order != null) {
+            return this.order;
+        }
+        Advice advice = getAdvice();
+        if (advice instanceof Ordered) {
+            return ((Ordered) advice).getOrder();
+        }
+        return Ordered.LOWEST_PRECEDENCE;
+    }
+
+```
+
+`Ordered.LOWEST_PRECEDENCE` Ϊ `Integer.MAX_VALUE`���� `2147483647`�������ٿ��� `BeanFactoryTransactionAttributeSourceAdvisor` �� `getOrder()` �������ص�ֵ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-d05044b7dcd41855ab6e59727c4be74bdb9.png)
+
+�ɼ���`BeanFactoryTransactionAttributeSourceAdvisor` ��ִ��˳����Ĭ�ϵ� `Integer.MAX_VALUE`��������ȵĻ����������ֵ���� `return this.order` ���صģ�
+
+```
+public int getOrder() {
+    // ͨ�����ȷ��֣�this.order ����Ϊnull
+    if (this.order != null) {
+        return this.order;
+    }
+    // ʡ��һЩ����
+    ...
+}
+
+```
+
+��ô��ֵ�Ǵ����������أ��������ط������������ڴ��� `BeanFactoryTransactionAttributeSourceAdvisor` ����ʱ������ `BeanFactoryTransactionAttributeSourceAdvisor#setOrder` ���õģ�
+
+> ProxyTransactionManagementConfiguration
+
+```
+@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
+@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
+    BeanFactoryTransactionAttributeSourceAdvisor advisor 
+            = new BeanFactoryTransactionAttributeSourceAdvisor();
+    advisor.setTransactionAttributeSource(transactionAttributeSource());
+    advisor.setAdvice(transactionInterceptor());
+    if (this.enableTx != null) {
+        // �����ȡ���� @EnableTransactionManagement ע��� order() ֵ
+        advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
+    }
+    return advisor;
+}
+
+```
+
+���������Ǿ������ˣ����� advisor ��ִ��˳������� `@EnableTransactionManagement` ��ָ����
+
+```
+public @interface EnableTransactionManagement {
+
+    boolean proxyTargetClass() default false;
+
+    AdviceMode mode() default AdviceMode.PROXY;
+
+    /**
+     * ����ָ��advisorִ��˳��Ĭ����������ȼ�
+     */
+    int order() default Ordered.LOWEST_PRECEDENCE;
+
+}
+
+```
+
+���ۣ�`@EnableTransactionManagement` ע��� `order()` ��������ָ�� `advisor` ��ִ��˳��
+
+#### `InstantiationModelAwarePointcutAdvisorImpl#getOrder()`
+
+��ǰ��ķ�����֪��`@Aspect` ���е�ÿһ���������ն���ת��Ϊ `advisor`������Ϊ `InstantiationModelAwarePointcutAdvisorImpl`����Ҳʵ���� `Ordered` �ӿڣ����ִ��˳��Ҳ���� `InstantiationModelAwarePointcutAdvisorImpl#getOrder()` �������������� `getOrder()` �������£�
+
+> InstantiationModelAwarePointcutAdvisorImpl
+
+```
+@Override
+public int getOrder() {
+    return this.aspectInstanceFactory.getOrder();
+}
+
+```
+
+�� [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������ϣ�](https://my.oschina.net/funcy/blog/4678817)�����Ѿ���ϸ������ `method` �� `advisor` ��ת����̣��ܴӴ����������ҵ� `aspectInstanceFactory` �����ͣ��������ǾͲ���һ��������Դ���ˣ�ֱ��ͨ�����Եķ�����ȡ `aspectInstanceFactory` �����ͣ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-e2784fc573474f56e8555ef60d57a07bcbf.png)
+
+�ӵ��ԵĽ��������`aspectInstanceFactory` ����Ϊ `LazySingletonAspectInstanceFactoryDecorator`�����Ǹ����� `getOrder()` ������
+
+> LazySingletonAspectInstanceFactoryDecorator
+
+```
+@Override
+public int getOrder() {
+    return this.maaif.getOrder();
+}
+
+```
+
+������Ȼʹ�õ��Եķ�ʽ��ȡ `maaif` �����ͣ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-2a4b87b6c8c824c55c4a3d86d736796def0.png)
+
+`maaif` ����Ϊ `BeanFactoryAspectInstanceFactory`�����Ǽ���������
+
+> BeanFactoryAspectInstanceFactory
+
+```
+public int getOrder() {
+    // this.name ָ���DZ�ע�� @Aspect ע�����
+    Class<?> type = this.beanFactory.getType(this.name);
+    if (type != null) {
+        // ���ʵ���� Ordered �ӿڣ��͵��� getOrder() ������ȡ
+        // PriorityOrdered �� Ordered ���ӽӿڣ�Ҳ�� getOrder() �������������Ҳ���ȡ��
+        if (Ordered.class.isAssignableFrom(type) && this.beanFactory.isSingleton(this.name)) {
+            return ((Ordered) this.beanFactory.getBean(this.name)).getOrder();
+        }
+        // 1\. ���������Ƿ��� @Order ע�⣬����У��򷵻� @Order ע��ָ����ֵ��
+        // 2\. �����ѯ���Ƿ��� @Priority ע�⣬����У��򷵻� @Priority ע��ָ����ֵ��
+        // 3\. ������϶������㣬���� Ordered.LOWEST_PRECEDENCE��ֵΪ Integer.MAX_VALUE
+        return OrderUtils.getOrder(type, Ordered.LOWEST_PRECEDENCE);
+    }
+    return Ordered.LOWEST_PRECEDENCE;
+}
+
+```
+
+�Ӵ�����������`getOrder()` �߼����£�
+
+1.  ͨ�����ƻ�ȡ�����࣬Ҳ���DZ�ע�� `@Aspect` ���ࣻ
+2.  ���������ʵ���� `Ordered` �ӿڣ��͵��� `getOrder()` ������ȡ�����أ�ֵ��һ����ǣ�`PriorityOrdered` �� `Ordered` ���ӽӿڣ�Ҳ�� `getOrder()` ����������Ҳ���ȡ������
+3.  �������û�л�ȡ������������������Ƿ��� `@Order` ע�⣬����У��򷵻� `@Order` ע��ָ����ֵ�����û�У������������Ƿ��� `@Priority` ע�⣬����У��򷵻� `@Priority` ע��ָ����ֵ��
+4.  �������û�л�ȡ��ֵ���ͷ���Ĭ��ֵ��`Ordered.LOWEST_PRECEDENCE`��
+
+������������ˣ�`@Aspect` �����ͨ��ʵ�� `Ordered/PriorityOrdered` �ӿ���ָ��ִ�����ȼ���Ҳ����ͨ�� `@Order/@Priority` ע����ָ��ִ�����ȼ���
+
+**��Ҫ�ر�ָ������**���� `getOrder()` �����������ⲿ�� ����ֻ �ǰ� `PriorityOrdered/@Priority` ���� `Order` �����������ȼ������� `Ordered/@Order` �ߡ�Ҳ����˵����� `AspectA` ��ע�˵��� `@Priority`��`AspectB` ��ע�˵��� `@Order`��`AspectA` �����ȼ�����һ���� `AspectB` �ߣ������������ȼ�����ע�� ��� `value()` ֵ��
+
+### 4\. ����Զ������ȼ�
+
+�������Լ�д����ʱ�����ָ�����ȼ��أ�
+
+1. ���������ʵ�� `advisor`����ʵ�� `Ordered` �ӿڣ�Ҳ������ `advisor` ���ϱ�ע `@Order` ע�⣺
+
+   ```
+   public class MyAdvisor extends AbstractBeanFactoryPointcutAdvisor implements Ordered {
+   
+       @Override
+       public int getOrder() {
+           return xxx;
+       }
+   
+   }
+   
+   @Order(xxx)
+   public class MyAdvisor extends AbstractBeanFactoryPointcutAdvisor {
+   
+       @Override
+       public int getOrder() {
+           return xxx;
+       }
+   
+   }
+   
+   ```
+
+2. ����ǵ��������� (`@Aspect` ��ע����)�������ظ��� `@Around/@Before/@After` ��
+
+   ```
+   @Aspect
+   public class MyAspectj {
+   
+       @Around("xxx")
+       public Object around(ProceedingJoinPoint p){
+           ...
+       }
+   
+       @Before("xxx")
+       public void before(JoinPoint p) {
+           ...
+       }
+   
+       @After("xxx")
+       public void after(JoinPoint p) {
+           ...
+       }
+   
+       @AfterReturning("xxx")
+       public void afterReturning(JoinPoint p) {
+           ...
+       }
+   
+       @AfterThrowing("xxx")
+       public void afterThrowing(JoinPoint p) {
+           ...
+       }
+   }
+   
+   ```
+
+   ����ͬһ����IJ�֪ͬͨ��spring �Ѿ����������ú���ִ��˳�������޴Ӹ��ģ�ִ��˳������Ϊ `Around, Before, After, AfterReturning, AfterThrowing`.
+
+3. ���������� (`@Aspect` ��ע����) �����ظ��� `@Around/@Before/@After` �ȣ�������£�
+
+   ```
+   @Aspect
+   public class MyAspectj {
+   
+       @Around("xxx")
+       public Object around(ProceedingJoinPoint p){
+           ...
+       }
+   
+       @Before("xxx")
+       public void before(JoinPoint p) {
+           ...
+       }
+   
+       @Around("xxx")
+       public Object around(ProceedingJoinPoint p){
+           ...
+       }
+   
+       @Before("xxx")
+       public void before(JoinPoint p) {
+           ...
+       }
+   
+   }
+   
+   ```
+
+   ������������� `AspectJPrecedenceComparator#comparePrecedenceWithinAspect` ����ʱ�з��������õ��Ľ����ǣ��Ƚ����ߵ� `declarationOrderInAspect` ֵ���������֮һΪ `after` ֪ͨ��`declarationOrderInAspect` ������ȼ��ߣ�������߶����� `after` ֪ͨ��`declarationOrderInAspect` С�����ȼ��ߡ���� `declarationOrderInAspect` ��ȫ������ jdk �ķ�����ƣ��Ȼ�ȡ�������ĸ��������ĸ������� `declarationOrderInAspect` ��С����ͬ jdK �汾֮�䣬���Ա�֤��õ�˳��һ�¡�
+
+4. ��������� (`@Aspect` ��ע����) ��ִ��˳�����ͨ�� `@Order` ע�⣬��ʵ�� `Ordered` �ӿ���ָ����
+
+   ```
+   @Order(xxx)
+   public class MyAspectj1 {
+       ...
+   }
+   
+   @Order(xxx)
+   public class MyAspectj2 {
+       ...
+   }
+   
+   ```
+
+���⣬`getOrder()` ���ص�ֵ�� `@Order(xxx)` ָ����ֵԽС���������ȼ�Խ�ߡ�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4784828](https://my.oschina.net/funcy/blog/4784828) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213Spring\344\272\213\344\273\266\346\234\272\345\210\266.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213Spring\344\272\213\344\273\266\346\234\272\345\210\266.md"
new file mode 100644
index 0000000..5d4fa2c
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213Spring\344\272\213\344\273\266\346\234\272\345\210\266.md"
@@ -0,0 +1,918 @@
+### 1\. demo ׼��
+
+����ʽ�����¼�����ǰ����������׼��һ�� demo��
+
+1.  ׼��һ���¼��� `MyApplicationEvent`��
+
+```
+public class MyApplicationEvent extends ApplicationEvent {
+
+    private static final long serialVersionUID = -1L;
+
+    public MyApplicationEvent(Object source) {
+        super(source);
+    }
+}
+
+```
+
+1.  ׼��һ�������� `MyApplicationEventListener`�����¼� `MyApplicationEvent` ���м�����
+
+```
+@Component
+public class MyApplicationEventListener 
+        implements ApplicationListener<MyApplicationEvent> {
+
+    @Override
+    public void onApplicationEvent(MyApplicationEvent event) {
+        System.out.println(Thread.currentThread().getName() + " | " + event.getSource());
+    }
+}
+
+```
+
+׼��һ�������࣬�Ȳ�ָ�����ݣ�
+
+```
+@Configuration
+@ComponentScan
+public class Demo08Config {
+
+}
+
+```
+
+��������ࣺ
+
+```
+@ComponentScan
+public class Demo08Main {
+
+    public static void main(String[] args) {
+        AnnotationConfigApplicationContext context 
+            = new AnnotationConfigApplicationContext(Demo08Config.class);
+        // �����¼�
+        context.publishEvent(
+            new MyApplicationEvent(Thread.currentThread().getName() + " | �Զ����¼� ..."));
+    }
+
+}
+
+```
+
+���ϴ��붨����һ���¼� `MyApplicationEvent`��Ȼ������һ�������� `MyApplicationEventListener`���������� `MyApplicationEvent` �¼���Ȼ���� `main()` �����У����� `context.publishEvent(...)` �������������¼���
+
+���У�������£�
+
+```
+main | main | �Զ����¼� ...
+
+```
+
+���Կ������¼��ɹ��������ˡ�
+
+�����п�֪���¼��ķ����߳�Ϊ `main`���¼��ļ��������߳�Ҳ�� `main`��
+
+### 2\. �¼��������
+
+��ʽ����ǰ�����������������¼���ص�������¼���ص������ 4 ����
+
+1.  �¼�������������
+2.  �����������������¼������
+3.  �㲥�������շ������������¼����������յ����¼��㲥��������
+4.  �������������¼�
+
+��������һһ��������
+
+#### 2.1 �¼�
+
+spring �ṩ���¼�Ϊ `ApplicationEvent`������һ�������࣬�̳��� jdk �ṩ�� `EventObject` �࣬�����Զ����¼�ʱ���ɼ̳� `ApplicationEvent`��
+
+```
+public abstract class ApplicationEvent extends EventObject {
+
+    private static final long serialVersionUID = 7099057708183571937L;
+
+    /** ���� timestamp ����*/
+    private final long timestamp;
+
+    public ApplicationEvent(Object source) {
+        super(source);
+        this.timestamp = System.currentTimeMillis();
+    }
+
+    public final long getTimestamp() {
+        return this.timestamp;
+    }
+}
+
+```
+
+`ApplicationEvent` �� `EventObject`�����Ǽ�����
+
+```
+/**
+ * EventObject ��jdk�ṩ��λ�� java.util ����
+ */
+public class EventObject implements java.io.Serializable {
+
+    private static final long serialVersionUID = 5516075349620653480L;
+
+    // �¼�����
+    protected transient Object  source;
+
+    public EventObject(Object source) {
+        if (source == null)
+            throw new IllegalArgumentException("null source");
+
+        this.source = source;
+    }
+
+    /**
+     * ��ȡ�¼�����
+     */
+    public Object getSource() {
+        return source;
+    }
+
+    public String toString() {
+        return getClass().getName() + "[source=" + source + "]";
+    }
+}
+
+```
+
+��� `ApplicationEvent` �� `EventObject` ������`ApplicationEvent` �ṩ���������ԣ�
+
+*   `source`������ `EventObject` �����ԣ��������¼������ݣ�
+*   `timestamp`: ʱ�����������¼���¼�������ʱ�䡣
+
+ʵ���ϣ�spring �����ܷ��� `ApplicationEvent` ���͵��¼��⣬�����Է��� `Object` ���͵��¼���������鿴�������Ϳ��Է� ����һ�㡣
+
+#### 2.2 ������
+
+spring �ṩ�ķ�����Ϊ `ApplicationEventPublisher`���������£�
+
+```
+public interface ApplicationEventPublisher {
+
+    /**
+     * ����ApplicationEvent���͵��¼�
+     */
+    default void publishEvent(ApplicationEvent event) {
+        publishEvent((Object) event);
+    }
+
+    /**
+     * ����Object���͵��¼�
+     */
+    void publishEvent(Object event);
+
+}
+
+```
+
+���Ǹ��ӿڣ����ڶ���������������
+
+*   `void publishEvent(ApplicationEvent event)`: �������� `ApplicationEvent` ���͵��¼�
+*   `void publishEvent(Object event)`: �������� `Object` ���͵��¼�
+
+`AbstractApplicationContext` �� `ApplicationEventPublisher` �����࣬������ǿ���ֱ�ӵ��� `AbstractApplicationContext#publishEvent` �������¼���
+
+���� `AbstractApplicationContext` ��������������ʵ�֣����Ǻ��������������ʱ�پ��������
+
+#### 2.3 �㲥��
+
+�㲥���������ǽ��շ������¼���Ȼ���¼��㲥�����������������£�
+
+```
+public interface ApplicationEventMulticaster {
+
+    /**
+     * ���Ӽ�����
+     */
+    void addApplicationListener(ApplicationListener<?> listener);
+
+    /**
+     * ���Ӽ������� beanName
+     */
+    void addApplicationListenerBean(String listenerBeanName);
+
+    /**
+     * �Ƴ�������
+     */
+    void removeApplicationListener(ApplicationListener<?> listener);
+
+    /**
+     * �Ƴ��������� beanName
+     */
+    void removeApplicationListenerBean(String listenerBeanName);
+
+    /**
+     * �Ƴ����еļ�����
+     */
+    void removeAllListeners();
+
+    /**
+     * �㲥�¼�
+     */
+    void multicastEvent(ApplicationEvent event);
+
+    /**
+     * �㲥�¼�
+     */
+    void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType);
+
+}
+
+```
+
+�Ӵ������������㲥����Ҫ������������
+
+1.  ά�������������ԶԼ�����������ɾ����
+2.  �㲥�¼�
+
+spring Ĭ�ϵĹ㲥��Ϊ `SimpleApplicationEventMulticaster`��������Ǻ�����ٷ�����
+
+#### 2.4 ������
+
+���������������������¼���Ȼ����һЩ�����������������£�
+
+```
+@FunctionalInterface
+public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
+
+    /**
+     * �����¼�
+     */
+    void onApplicationEvent(E event);
+
+}
+
+```
+
+�ڴ����¼�����ʱ��������Ҫʵ�� `ApplicationListener`��Ȼ���� `onApplicationEvent(...)` �����б�д���ǵ��¼������߼���
+
+### 3\. �عˣ�`�㲥���ij�ʼ��`��`��������ע��`
+
+�����������ع���`�¼��㲥���ij�ʼ��`��`��������ע��`�����̡�
+
+�ڴ��� spring ���������� `AbstractApplicationContext#refresh` �����У�`�¼��㲥���ij�ʼ��`��`��������ע��`�ֱ����ڵ� 8 ����� 10 ����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-c4d4ac83c23e41a706b7ba545fd8d0f7681.png)
+
+��ش������£�
+
+```
+public abstract class AbstractApplicationContext extends DefaultResourceLoader
+        implements ConfigurableApplicationContext {
+
+    /**
+     * ��ʼ���㲥��
+     * ������������¼��㲥������ʹ�������õģ������ʹ��Ĭ�ϵ��¼��㲥��
+     */
+    protected void initApplicationEventMulticaster() {
+        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
+        // ����û��������Զ����¼��㲥������ʹ���û���
+        if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
+            this.applicationEventMulticaster =
+                    beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, 
+                            ApplicationEventMulticaster.class);
+        }
+        else {
+            // �û�û�����ù㲥������ʹ��Ĭ�ϵ��¼��㲥��
+            this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
+            beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, 
+                    this.applicationEventMulticaster);
+        }
+    }
+
+    /**
+     * ע�������
+     */
+    protected void registerListeners() {
+        // 1\. �Ƚ��ֶ����ӵļ������ŵ��㲥����
+        // ����AbstractApplicationContext#addApplicationListener��������
+        for (ApplicationListener<?> listener : getApplicationListeners()) {
+            getApplicationEventMulticaster().addApplicationListener(listener);
+        }
+
+        // 2\. ��beanFactory�л�ȡȡ�����������ƣ����ӵ��㲥����
+        String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
+        for (String listenerBeanName : listenerBeanNames) {
+            getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
+        }
+
+        // 3\. �����������Ӧ���¼�������
+        Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
+        // �� earlyApplicationEvents ����Ϊ null���ٷ��������¼�
+        this.earlyApplicationEvents = null;
+        if (earlyEventsToProcess != null) {
+            for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
+                getApplicationEventMulticaster().multicastEvent(earlyEvent);
+            }
+        }
+    }
+
+    ...
+
+}
+
+```
+
+�㲥���ij�ʼ���߼��ܼ򵥣���������������¼��㲥������ʹ�������õģ������ʹ��Ĭ�ϵ��¼��㲥����Ĭ�ϵ��¼��㲥���� `SimpleApplicationEventMulticaster`��
+
+ע����������������£�
+
+1.  �Ƚ��ֶ����ӵļ������ŵ��㲥���У����ǿ��Ե��� `AbstractApplicationContext#addApplicationListener` ���Ӽ�������
+2.  �� `beanFactory` �л�ȡȡ�����������ƣ����ӵ��㲥���У�ע�⣺��ʱ `beanFactory` �е� bean ��û�г�ʼ�������ֻ������ `beanName`;
+3.  ������������¼����ͷ��������¼���
+
+�ع������������̺����Ǵ�������Ҫ����������������㣺
+
+1.  �㲥�����������ʼ����
+2.  ��������������ע�ᵽ�㲥���е�
+
+### 4\. �¼���������
+
+����ǰ�����ڵ��̵棬���Ƕ��¼�������Ѿ����˸���ŵĸ��Ҳ�������¼��㲥���ij�ʼ�����������ע�����̣������� ���Ǿ���ʽ�����¼��ķ��������ˡ�
+
+�� demo �У����ǵ��� `context.publishEvent(...)` �������¼������Ǹ������������
+
+```
+public abstract class AbstractApplicationContext extends DefaultResourceLoader
+        implements ConfigurableApplicationContext {
+
+    @Override
+    public void publishEvent(ApplicationEvent event) {
+        publishEvent(event, null);
+    }
+
+    protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
+        Assert.notNull(event, "Event must not be null");
+        // �����¼�����
+        ApplicationEvent applicationEvent;
+        if (event instanceof ApplicationEvent) {
+            applicationEvent = (ApplicationEvent) event;
+        }
+        else {
+            applicationEvent = new PayloadApplicationEvent<>(this, event);
+            if (eventType == null) {
+                eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
+            }
+        }
+
+        // earlyApplicationEvents ��Ϊ null����applicationEvent���ӵ� earlyApplicationEvents
+        // ��ע��������󣬻�� earlyApplicationEvents ����Ϊ null
+        if (this.earlyApplicationEvents != null) {
+            this.earlyApplicationEvents.add(applicationEvent);
+        }
+        else {
+            // �����Ƿ����¼��IJ���
+            getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
+        }
+
+        // ���ڸ�������һ������
+        if (this.parent != null) {
+            if (this.parent instanceof AbstractApplicationContext) {
+                ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
+            }
+            else {
+                this.parent.publishEvent(event);
+            }
+        }
+    }
+
+}
+
+```
+
+��������ܼ򵥣��ؼ�����Ϊ
+
+```
+// �����Ƿ����¼��IJ���
+getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
+
+```
+
+���д����Ȼ�ȡ���¼��㲥����Ȼ��㲥�¼���
+
+ǰ���ᵽ��spring �ṩ��Ĭ�ϵ��¼��㲥���� `SimpleApplicationEventMulticaster`�����ǽ��� `SimpleApplicationEventMulticaster#multicastEvent(ApplicationEvent, ResolvableType)` �������¼��Ĺ㲥���̣�
+
+```
+/**
+ * �㲥�¼�
+ */
+public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
+    ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
+    // 1\. ��ȡ TaskExecutor
+    Executor executor = getTaskExecutor();
+    // 2\. getApplicationListeners(...) ��ȡ�ܼ������¼��ļ�����
+    for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
+        // 3\. ��������������һ���� invokeListener(...) ����
+        if (executor != null) {
+            executor.execute(() -> invokeListener(listener, event));
+        }
+        else {
+            invokeListener(listener, event);
+        }
+    }
+}
+
+```
+
+���Ϸ������� 3 ��������
+
+1.  ��ȡִ������`getTaskExecutor()`
+2.  ��ȡ�¼��ļ�������`getApplicationListeners(...)`
+3.  ���ü������ļ���������`invokeListener(...)`
+
+���ϲ����������¼��㲥���������̣������������ú÷����¡�
+
+#### 1\. ��ȡִ������`getTaskExecutor()`
+
+`taskExecutor` �� `SimpleApplicationEventMulticaster` ��һ�����ԣ�`getTaskExecutor()` �� `taskExecutor` �� `getter` ������
+
+```
+    private Executor taskExecutor;
+
+    public void setTaskExecutor(@Nullable Executor taskExecutor) {
+        this.taskExecutor = taskExecutor;
+    }
+
+    @Nullable
+    protected Executor getTaskExecutor() {
+        return this.taskExecutor;
+    }
+
+```
+
+spring Ϊ�����ṩ���������͵� `taskExecutor`��
+
+1. `SyncTaskExecutor`��ͬ���� `taskExecutor`���� `execute(...)` ����Ϊ��
+
+   ```
+    @Override
+    public void execute(Runnable task) {
+        Assert.notNull(task, "Runnable must not be null");
+        task.run();
+    }
+   
+   ```
+
+   ���Կ�������ȷʵ�Ǹ�ͬ��������ֱ�ӵ��� `Runnable#run` ��������û�������µ��߳�
+
+2. `SimpleAsyncTaskExecutor`���첽�� `taskExecutor`���� `execute(...)` ����Ϊ��
+
+   ```
+   @Override
+    public void execute(Runnable task, long startTimeout) {
+        Assert.notNull(task, "Runnable must not be null");
+        Runnable taskToUse = (this.taskDecorator != null 
+                ? this.taskDecorator.decorate(task) : task);
+        // doExecute(...) ���������ɻ�ķ���
+        if (isThrottleActive() && startTimeout > TIMEOUT_IMMEDIATE) {
+            this.concurrencyThrottle.beforeAccess();
+            doExecute(new ConcurrencyThrottlingRunnable(taskToUse));
+        }
+        else {
+            doExecute(taskToUse);
+        }
+    }
+   
+    /**
+     * �����ɻ�ķ���
+     * �Ӵ�����������������ᴴ���´�����ִ�����񣬵���û��ʹ���̳߳�
+     */
+    protected void doExecute(Runnable task) {
+        // ���Կ��������ﴴ�����̣߳������������߳�
+        Thread thread = (this.threadFactory != null 
+                ? this.threadFactory.newThread(task) : createThread(task));
+        thread.start();
+    }
+   
+   ```
+
+   ���Կ����� `SimpleAsyncTaskExecutor` �У��ᴴ���µ��߳���ִ������
+
+�����ܲ��ܻ�ȡ��ִ�����أ�ͨ�����Է��֣�ִ�����Ļ�ȡ���Ϊ `null`��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-2e6ba6389e603a6373287dac26a89a24109.png)
+
+���������ִ�� `invokeListener(...)` ����ʱ����ֱ�ӵ��õģ�
+
+```
+...
+        else {
+            invokeListener(listener, event);
+        }
+...
+
+```
+
+#### 2\. ��ȡ�¼��ļ�������`getApplicationListeners(...)`
+
+׼����˵�������ȡ�����ܼ��������¼��ļ�����������Ϊ `AbstractApplicationEventMulticaster#getApplicationListeners(ApplicationEvent, ResolvableType)`��
+
+```
+/**
+ * ����������������裺
+ * 1\. �ӻ����л�ȡ���ܻ�ȡ����ֱ�ӷ���
+ * 2\. ���ܴӻ����л�ȡ������ retrieveApplicationListeners(...) ������ȡ
+ */
+protected Collection<ApplicationListener<?>> getApplicationListeners(
+        ApplicationEvent event, ResolvableType eventType) {
+    Object source = event.getSource();
+    Class<?> sourceType = (source != null ? source.getClass() : null);
+    ListenerCacheKey cacheKey = new ListenerCacheKey(eventType, sourceType);
+    // 1\. �ӻ����л�ȡ
+    ListenerRetriever retriever = this.retrieverCache.get(cacheKey);
+    if (retriever != null) {
+        return retriever.getApplicationListeners();
+    }
+    if (this.beanClassLoader == null ||
+            (ClassUtils.isCacheSafe(event.getClass(), this.beanClassLoader) &&
+            (sourceType == null || ClassUtils.isCacheSafe(sourceType, this.beanClassLoader)))) {
+        synchronized (this.retrievalMutex) {
+            retriever = this.retrieverCache.get(cacheKey);
+            if (retriever != null) {
+                return retriever.getApplicationListeners();
+            }
+            retriever = new ListenerRetriever(true);
+            // 2\. ��ȡ������������ǹؼ�
+            Collection<ApplicationListener<?>> listeners =
+                    retrieveApplicationListeners(eventType, sourceType, retriever);
+            this.retrieverCache.put(cacheKey, retriever);
+            return listeners;
+        }
+    }
+    else {
+        return retrieveApplicationListeners(eventType, sourceType, null);
+    }
+}
+
+```
+
+����������ų������ؼ�������������
+
+1.  �ӻ����л�ȡ���ܻ�ȡ����ֱ�ӷ���
+2.  ���ܴӻ����л�ȡ������ `retrieveApplicationListeners(...)` ������ȡ
+
+���Ǽ������� `retrieveApplicationListeners(...)`��
+
+```
+/**
+ * ������������ȡ������
+ *
+ */
+private Collection<ApplicationListener<?>> retrieveApplicationListeners(
+        ResolvableType eventType, @Nullable Class<?> sourceType, 
+        @Nullable ListenerRetriever retriever) {
+    List<ApplicationListener<?>> allListeners = new ArrayList<>();
+    Set<ApplicationListener<?>> listeners;
+    Set<String> listenerBeans;
+    synchronized (this.retrievalMutex) {
+        listeners = new LinkedHashSet<>(this.defaultRetriever.applicationListeners);
+        listenerBeans = new LinkedHashSet<>(this.defaultRetriever.applicationListenerBeans);
+    }
+    // �� listeners �л�ȡ�ܴ�����ǰ�¼��� lister
+    for (ApplicationListener<?> listener : listeners) {
+        // �������жϵ�ǰlistener�Ƿ�֧�ִ���event
+        if (supportsEvent(listener, eventType, sourceType)) {
+            if (retriever != null) {
+                retriever.applicationListeners.add(listener);
+            }
+            allListeners.add(listener);
+        }
+    }
+    // �� listenerBeans �л�ȡ�ܴ�����ǰ�¼��� lister
+    if (!listenerBeans.isEmpty()) {
+        ConfigurableBeanFactory beanFactory = getBeanFactory();
+        for (String listenerBeanName : listenerBeans) {
+            try {
+                // �����жϵ�ǰ listenerBeanName �Ƿ��ܼ��������¼�
+                if (supportsEvent(beanFactory, listenerBeanName, eventType)) {
+                    // �������л�ȡ��Ӧ��bean�����������¼����������������ǰ��ʼ��
+                    ApplicationListener<?> listener = beanFactory.getBean(
+                            listenerBeanName, ApplicationListener.class);
+                    if (!allListeners.contains(listener) 
+                            && supportsEvent(listener, eventType, sourceType)) {
+                        if (retriever != null) {
+                            // ע�ⵥ����ǵ���������
+                            if (beanFactory.isSingleton(listenerBeanName)) {
+                                retriever.applicationListeners.add(listener);
+                            }
+                            else {
+                                retriever.applicationListenerBeans.add(listenerBeanName);
+                            }
+                        }
+                        allListeners.add(listener);
+                    }
+                }
+                else {
+                    Object listener = beanFactory.getSingleton(listenerBeanName);
+                    if (retriever != null) {
+                        retriever.applicationListeners.remove(listener);
+                    }
+                    allListeners.remove(listener);
+                }
+            }
+            catch (NoSuchBeanDefinitionException ex) {
+            }
+        }
+    }
+    // ����
+    AnnotationAwareOrderComparator.sort(allListeners);
+    if (retriever != null && retriever.applicationListenerBeans.isEmpty()) {
+        retriever.applicationListeners.clear();
+        retriever.applicationListeners.addAll(allListeners);
+    }
+    return allListeners;
+}
+...
+
+}
+
+```
+
+�� `AbstractApplicationContext#registerListeners` �����У�������ע�������ʱ ��ע�����������������
+
+1.  ע���ֶ����ӵļ�������������һ����ʵ����
+2.  �������л�ȡ�������� beanName������ע�᣻
+
+`retrieveApplicationListeners()` �г��ֵ� `listeners` �� `listenerBeans` ���Ǵ������������͵ļ������ġ�
+
+���Ϸ�����Ȼ�е㳤�����߼��dz�������
+
+1.  ���� `listeners`����һ���� `supportsEvent(listener, eventType, sourceType)` ���жϵ�ǰ listener �ܷ���������¼���
+2.  ���� `listenerBeans`����һ���� `supportsEvent(beanFactory, listenerBeanName, eventType)` ���жϵ�ǰ listener �ܷ���������¼���
+
+���������������Ĵ����Ƚϸ��ӣ�����Ͳ�һһ���з����ˣ�������������Ĵ���˼·��
+
+1. �Ӵ���� `listener` �� `listenerBeanName` ��ȡ `listener` �� Class��`listener` ֻ�� `listener.getClass()` ���ɣ�`listenerBeanName` ��ͨ�� `beanFactory.getType(listenerBeanName)` ��ȡ��
+
+2. ��ȡ `listener` �������¼����ͣ�һ������������������ģ�
+
+   ```
+   public class MyApplicationEventListener 
+           implements ApplicationListener<MyApplicationEvent> {
+   
+       @Override
+       public void onApplicationEvent(MyApplicationEvent event) {
+           ...
+       }
+   }
+   
+   ```
+
+   ���ǿ���������ȡ�� `MyApplicationEvent`��
+
+   ```
+   // ��Щ�඼��jdk�ṩ��
+   ParameterizedType parameterizedType = (ParameterizedType) 
+           MyApplicationEventListener.class.getGenericInterfaces()[0];
+       Class<?> type = (Class)parameterizedType.getActualTypeArguments()[0];
+   
+   ```
+
+   ��Ȼ��spring �ڴ����ⲿ���߼�ʱ�ر��ӣ��Ͼ���� `MyApplicationEventListener` ͬʱʵ���˶���ӿڣ����� `MyApplicationEventListener` �ĸ� - �� - �� -... �ӿڲ��� `ApplicationListener`����Щ�����Ҫ���ǵ���
+
+3. ��ȡ���������ܼ������¼��ˣ������жϵ�ǰ�жϼ����Ƿ��ܼ��������¼��ˣ�spring ����ƥ��ķ���Ϊ `ResolvableType#isAssignableFrom(ResolvableType)`����ע������������ʵ�������� `Class.isAssignableFrom` �����Ĺ��ܣ�ͬʱ���Դ������ϵķ���Ҳʵ�������� `Class.isAssignableFrom` �Ĺ��ܡ�
+
+#### 3\. ���ü���������`invokeListener(...)`
+
+���ڵ����ü��������ˣ��������£�
+
+```
+/**
+ * ִ�м�����
+ */
+protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
+    ErrorHandler errorHandler = getErrorHandler();
+    // ���յ��õ��� doInvokeListener(...)
+    if (errorHandler != null) {
+        try {
+            doInvokeListener(listener, event);
+        }
+        catch (Throwable err) {
+            errorHandler.handleError(err);
+        }
+    }
+    else {
+        doInvokeListener(listener, event);
+    }
+}
+
+/**
+ * �����ִ�в��������յ��õ��� ApplicationListener#onApplicationEvent ����
+ */
+private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
+    try {
+        listener.onApplicationEvent(event);
+    }
+    catch (ClassCastException ex) {
+        String msg = ex.getMessage();
+        if (msg == null || matchesClassCastMessage(msg, event.getClass())) {
+            // ʡ����־��ӡ
+        }
+        else {
+            throw ex;
+        }
+    }
+}
+
+```
+
+��һ��ܼ򵥣����DZ�����һ����ȡ�ļ���������һ������ `onApplicationEvent(...)` ������
+
+������Ҫע����ǣ���ǰ��`��ȡִ����`�ķ����У������ᵽ `getTaskExecutor()` �Ľ��Ϊ `null`������� `invokeListener(...)` ��ֱ��ִ�еģ���û������һ���߳���ִ�У������Ҫ����ע�⡣
+
+### 5\. �¼���Ӧ��
+
+#### 5.1 ����������������¼�
+
+�� spring ���������У�����������ɻᷢ�� `ContextRefreshed` �¼���
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-f60ea2710c59e2ce9e1401f1b54cbd9d700.png)
+
+����Ҫ���������¼�Ҳʮ�ּ򵥣���Ӧ�� `Listener` ���£�
+
+```
+@Component
+public class ContextRefreshedListener 
+        implements ApplicationListener<ContextRefreshedEvent> {
+
+    @Override
+    public void onApplicationEvent(ContextRefreshedEvent event) {
+        System.out.println("�����������");
+    }
+
+}
+
+```
+
+#### 5.2 ���������¼�
+
+һ��ʼ������Ϊ�����¼�������������
+
+```
+AnnotationConfigApplicationContext context 
+        = new AnnotationConfigApplicationContext();
+context.register(Demo08Config.class);
+// �����¼�������������ǰ����
+context.publishEvent(new MyApplicationEvent(
+        Thread.currentThread().getName() + " | �Զ����¼� ..."));
+context.refresh();
+
+```
+
+���к󣬻ᱨ���� ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-4fc18c95f69d8c3d65be2a0f603d42e19ce.png)
+
+�Ӵ�����Ϣ��������˵�㲥��δ��ʼ����
+
+��ô�㲥�����������ʼ�����أ�������ǰ��ķ������������֪������ `refresh()` ���̵ĵ� 8 �����������¼��ķ������ڵ� 10 ��������һ���������¼���ֻ���ڵ� 9 ���ˣ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-1fecd516c6d58d628937b20ebd806065891.png)
+
+��������Կ����������¼�����Ϊ `onRefresh()` �����չ��׼���ģ�
+
+�����¼��ķ���Ҳ�ͼ��ˣ�
+
+```
+ApplicationContext context = 
+        new AnnotationConfigApplicationContext(Demo08Config.class) {
+    @Override
+    public void onRefresh() {
+        // ���﷢�����������¼�
+        publishEvent(new MyApplicationEvent(
+                Thread.currentThread().getName() + " | �Զ����¼� ..."));
+    }
+};
+
+```
+
+#### 5.3 �첽�㲥�¼�
+
+��ǰ���Դ������������¼���ִ������ͬһ���߳��н��еģ������ demo �����н����Ҳ�ܿ�������
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-afed97c136df717ba3d9397ff142ae0675f.png)
+
+ǰ���Ѿ����������㲥�¼�ʱ�����Ȼ�ȡ `executor`����� `executor` ���ڣ��� `executor` ִ�У������ֱ��ִ�У����㲥���е� `executor` Ϊ `null`����˺����׽��ۣ�Ҫ��ʵ���첽ִ�У���Ҫ�ڹ㲥�������� `executor` ���ԡ�
+
+ǰ��ͬ��Ҳ��������spring �ڳ�ʼ���㲥��ʱ�������ж��������Ƿ���ڹ㲥����`beanName` Ϊ `applicationEventMulticaster`������������ʹ�� `SimpleApplicationEventMulticaster` ����Ĭ�ϵĹ㲥����
+
+���һ��������ֻ��Ҫ�Զ��� `beanName` Ϊ `applicationEventMulticaster` �� bean �����У���������
+
+```
+@Configuration
+@ComponentScan
+public class Demo08Config {
+
+    /**
+     * �����Զ���㲥��
+     * ע�⣺���Ʊ���Ϊ applicationEventMulticaster
+     */
+    @Bean
+    public ApplicationEventMulticaster applicationEventMulticaster() {
+        SimpleApplicationEventMulticaster applicationEventMulticaster
+                = new SimpleApplicationEventMulticaster();
+        // SimpleAsyncTaskExecutor ��spring���ṩ���첽����ִ����
+        applicationEventMulticaster.setTaskExecutor(new SimpleAsyncTaskExecutor());
+        return applicationEventMulticaster;
+    }
+}
+
+```
+
+`SimpleApplicationEventMulticaster` ʹ���� spring �ṩ���첽����ִ������`SimpleAsyncTaskExecutor`�����У�������£�
+
+```
+SimpleAsyncTaskExecutor-2 | main | �Զ����¼� ...
+
+```
+
+���Կ����������߳�������̲߳�����ͬһ���ˡ�
+
+�����鵽�⻹���꣬ǰ���Ѿ������� `SimpleAsyncTaskExecutor` ������ִ�й��̣���ִ��ʱ���᲻�ϴ������̣߳�
+
+```
+   protected void doExecute(Runnable task) {
+        // ���Կ��������ﴴ�����̣߳������������߳�
+        Thread thread = (this.threadFactory != null 
+                ? this.threadFactory.newThread(task) : createThread(task));
+        thread.start();
+    }
+
+```
+
+��������������� 100 ���¼���
+
+```
+for(int i = 0; i < 100; i++) {
+    context.publishEvent(new MyApplicationEvent(
+            Thread.currentThread().getName() + " | �Զ����¼� ..."));
+}
+
+```
+
+������������
+
+```
+SimpleAsyncTaskExecutor-2 | main | �Զ����¼� ...
+SimpleAsyncTaskExecutor-3 | main | �Զ����¼� ...
+SimpleAsyncTaskExecutor-4 | main | �Զ����¼� ...
+...
+SimpleAsyncTaskExecutor-99 | main | �Զ����¼� ...
+SimpleAsyncTaskExecutor-100 | main | �Զ����¼� ...
+SimpleAsyncTaskExecutor-101 | main | �Զ����¼� ...
+
+```
+
+���Կ���������ÿһ���¼������ᴴ��һ�����߳���ִ�У��̱߳�������˱������Դ������Ƶ���ش�������һ��������˷ѣ�����������߳��أ������̳߳ء�
+
+���ǿ��� `SimpleApplicationEventMulticaster#setTaskExecutor` �����IJ������������� `java.util.concurrent.Executor`������������ͱ�ü��ˣ�����ֱ��ʹ�� jdk �ṩ���̳߳أ�
+
+```
+@Bean
+public ApplicationEventMulticaster applicationEventMulticaster() {
+    SimpleApplicationEventMulticaster applicationEventMulticaster
+            = new SimpleApplicationEventMulticaster();
+    // ʹ��jdk�ṩ���̳߳�
+    applicationEventMulticaster.setTaskExecutor(Executors.newFixedThreadPool(4));
+    return applicationEventMulticaster;
+}
+
+```
+
+����ʹ�õ��� jdK �ṩ�� `newFixedThreadPool`�������� 4 ���̣߳����У�������£�
+
+```
+pool-1-thread-2 | main | �Զ����¼� ...
+pool-1-thread-3 | main | �Զ����¼� ...
+pool-1-thread-4 | main | �Զ����¼� ...
+pool-1-thread-4 | main | �Զ����¼� ...
+pool-1-thread-1 | main | �Զ����¼� ...
+pool-1-thread-3 | main | �Զ����¼� ...
+pool-1-thread-3 | main | �Զ����¼� ...
+pool-1-thread-2 | main | �Զ����¼� ...
+pool-1-thread-1 | main | �Զ����¼� ...
+pool-1-thread-3 | main | �Զ����¼� ...
+...
+
+```
+
+���Կ�������ʼ����ֻ�� 4 ���߳��ڹ㲥�¼���
+
+����Щ����淶�У��ǽ�ֱֹ��ʹ�� jdk �ṩ���̵߳ijأ����Ǹ��ᳫ�Զ����̳߳أ�������㣬���ڱ��IJ����������̳߳ؼ����ģ���˾ͼ򵥵�ʹ�� jdk �ṩ���߳�ʾ���¡�
+
+#### 5.4 �Զ����¼�
+
+ʵ���ϣ�ǰ���ṩ��ʾ�� demo �����Զ����¼�������Ͳ��ظ��ˡ�
+
+### 6\. �ܽ�
+
+���ķ����� spring �¼����ƣ��������¼����Ĵ����������¼������������㲥���������������Ҵ�Դ�����������ij�ʼ�����¼��ķ������̡�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4713339](https://my.oschina.net/funcy/blog/4713339) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213\345\276\252\347\216\257\344\276\235\350\265\226\347\232\204\350\247\243\345\206\263\357\274\210\344\270\200\357\274\211\357\274\232\347\220\206\350\256\272\345\237\272\347\237\263.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213\345\276\252\347\216\257\344\276\235\350\265\226\347\232\204\350\247\243\345\206\263\357\274\210\344\270\200\357\274\211\357\274\232\347\220\206\350\256\272\345\237\272\347\237\263.md"
new file mode 100644
index 0000000..faddf44
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213\345\276\252\347\216\257\344\276\235\350\265\226\347\232\204\350\247\243\345\206\263\357\274\210\344\270\200\357\274\211\357\274\232\347\220\206\350\256\272\345\237\272\347\237\263.md"
@@ -0,0 +1,1091 @@
+### 1\. ʲô��ѭ��������
+
+spring ������ע��ʱ�����ܻ�����໥ע��������
+
+```
+@Service
+public class Service1 {
+    @Autowired
+    private Service2 service2;
+
+}
+
+@Service
+public class Service2 {
+    @Autowired
+    private Service1 service1;
+
+}
+
+```
+
+�����ϴ��룬�� `Service1` ��ͨ�� `@Autowird` ע���� `Service2`���� `Service2` ��ͨ�� `@Autowird` ע���� `Service1`�������໥ע���������ͽ���ѭ��������
+
+### 2\. ѭ����������ʲô����
+
+ʵ���ϣ����� `A����B����BҲ����A����`�������java ��������ȫ֧�ֵģ�
+
+```
+/**
+ * ׼��service1
+ */
+public class Service1 {
+    private Service2 service2;
+
+    public void setService2(Service2 service2) {
+        this.service2 = service2;
+    }
+
+    public Service2 getService2() {
+        return this.service2;
+    }
+}
+
+/**
+ * ׼��service2
+ */
+public class Service2 {
+    private Service1 service1;
+
+    public void setService1(Service1 service1) {
+        this.service1 = service1;
+    }
+
+    public Service1 getService1() {
+        return this.service1;
+    }
+}
+
+/**
+ * ���������
+ */
+public class Main {
+    public void main(String[] args) {
+        // ׼����������
+        Service1 service1 = new Service1();
+        Service2 service2 = new Service2();
+        // �໥����
+        service1.setService2(service2);
+        service2.setService1(service1);
+    }
+}
+
+```
+
+��ô���� spring �У��������໥ע��Է�ʵ�������������ʲô�����أ��������� `spring bean` �Ĵ������̣�**ע�⣺�������ǽ����� `bean` �� `scope` Ϊ `singleton` �������Ҳ���� `scope` Ϊ`����`�����**����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-ca36e17077b1b191834645b3c8e588ff6c4.png)
+
+����������м�����Ҫ˵���£�
+
+1.  �������������ʵ����ʹ�� jdk �ṩ�ķ�����ƴ��� java �����Ե� 1 ���ᵽ�� `Service1` Ϊ�����ɼ�����Ϊ `Service1 service = new Service1()`��
+2.  ע���������󣺻����Ե� 1 ���ᵽ�� `Service1` Ϊ����`Service1` ��ͨ�� `@Autowired` �Զ�ע�� `Service2`����һ�����Ǹ� `Service2` ��ֵ�Ĺ��̣��ɼ�����Ϊ `service1.setService2(service2)`��
+3.  `singletonObjects`����������������һ�� java ����ͱ����һ�� spring bean��Ȼ�󱣴浽 `singletonObjects` �ˣ����Ǹ� `map`��`key` �� bean �����ƣ�`value` �� bean����ֻ���� `spring bean`������ֻ�� java ʵ����
+
+ʵ���ϣ�`java` ������ `spring bean`��������ֻ������ע�룬���г�ʼ����ִ�� `beanPorcessor` �����ȣ�**���ڱ����Ƿ��� `spring bean` ��ѭ�������ģ���������ص��ע��ѭ��������صIJ��衣**
+
+#### 2.1 ѭ����������������
+
+�˽��� spring bean �IJ�������֮�󣬽��������Ǿ���������ѭ���������������⣬����ʽ����ǰ������������ȷ�������
+
+*   `java����`��ʵ���ϣ�java ��һ�ж��󶼿��Գ�֮Ϊ `java` ����Ϊ��˵�����㣬�����ᵽ�� `java����`��ָʵ������ɡ���δ���� spring bean ���������ڶ���
+*   `spring bean`����һ�� java ���󣬲��ҽ����������� spring bean ���������ڶ���
+
+spring bean �Ĵ����������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-b55a211447b5fabeaa0c3ef0bfee0920c82.png)
+
+����ͼ˵�����£�
+
+1.  �� `service1` ���󴴽���ɺ�`spring` ���� `service1` ��Ҫע�� `service2`��Ȼ���ȥ `singletonObjects` �в��� `service2`����ʱ���Ҳ��� `service2`��Ȼ��Ϳ�ʼ�� `service2` �Ĵ������̣�
+2.  �� `service2` ���󴴽���ɺ�`spring` ���� `service2` ��Ҫע�� `service1`��Ȼ���ȥ `singletonObjects` �в��� `service1`����ʱ���Ҳ��� `service1`����Ϊ��һ���� `service1` ��û�д����ɹ� ��Ȼ��Ϳ�ʼ�� `service1` �Ĵ������̣�
+3.  �������ص� `1`���ٴο�ʼ�� `service1` �Ĵ���������ע����̡�
+
+��������Ǿ�ϲ�ط��֣�ѭ�������ˣ�
+
+#### 2.2 ���� `earlySingletonObjects` ���ѭ������
+
+���Ƿ����£�ѭ�����ֵ�ԭ�����ڣ��� `service2` ��ȡ `service1` ʱ������ `singletonObjects` �д�ʱ�������� `service1`����˻����� `service1` �Ĵ������̣����´��� `service1`����ˣ������и��󵨵��뷨������� `service1` ʵ������Ͱ����������������������� `service1` ʱ���ͷ������δ��������ע��� `service1`��������������
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-c0eaecbe82b144a6fcd9fd048f2cca53497.png)
+
+��ͼ�У������� `earlySingletonObjects`����Ҳ�Ǹ� map��ͬ `singletonObjects` һ����`key` �� bean �����ƣ�`value` ��һ��δ�������ע��Ķ���
+
+����ͼ˵�����£�
+
+1.  �� `service1` ���󴴽���ɺ��Ƚ� `service1` ���� `earlySingletonObjects`��Ȼ���������ע�룻
+2.  �� `service1` ��������ע��ʱ��`spring` ���� `service1` ��Ҫע�� `service2`��Ȼ����ȥ `earlySingletonObjects` ���� `service2`��δ�ҵ�����ȥ `singletonObjects` �в��� `service2`������δ�ҵ������ǾͿ�ʼ�� `service2` �Ĵ������̣�
+3.  �� `service2` ���󴴽���ɺ��Ƚ� `service2` ���� `earlySingletonObjects`��Ȼ���������ע�룻
+4.  �� `service2` ��������ע��ʱ��`spring` ���� `service2` ��Ҫע�� `service1`��Ȼ���ȥ `earlySingletonObjects` ���� `service1`���ҵ��ˣ��ͽ� `service1` ע�뵽 `service2` �У���ʱ `service2` ����һ�� `spring bean` �ˣ����䱣�浽 `singletonObjects` �У�
+5.  ������ 4 �������ǵõ��� `service2`��Ȼ����ע�뵽 `service1` �У���ʱ `service1` Ҳ����һ�� `spring bean`�����䱣�浽 `singletonObjects` �С�
+
+�������ϲ��裬���Ƿ��֣�ѭ�������õ��˽����
+
+#### 2.2 aop �µ�ѭ������
+
+��������ķ��������Ƿ���ֻҪ��������һ�� `earlySingletonObjects` ��ѭ���������ܵõ���������ǣ�ѭ��������ĵõ��˽����spring ���� ioc �⣬������һ���ش��ܣ�aop������������ aop ����³���ѭ��������������
+
+##### 1\. aop ����Ĵ�������
+
+����ʽ���� aop �µ�ѭ������ǰ������������ȷ���������
+
+*   `ԭʼ����`�������ڴ�������ָδ���й� aop �Ķ��󣬿����� java ����Ҳ������δ���� aop �� spring bean��
+*   `��������`�����й� aop �Ķ��󣬿����� java ��������й� aop �õ��Ķ��� (�����й� aop��δ��������ע�룬Ҳδ���г�ʼ��)��Ҳ�����ǽ��й� aop �� `spring bean`.
+
+������������ aop ����δ�������ģ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-e92991c1c173bbd5579be3001a977555be7.png)
+
+����� `2.1` �е����̣�aop ���� "���ɴ�������" �IJ������������ձ��浽 `singletonObjects` �еĶ���Ҳ�Ǵ�������
+
+ԭʼ�������������֮����ʲô��ϵ�أ��ô���ʾ���£��������£�
+
+```
+public class ProxyObj extends Obj {
+
+    // ԭʼ����
+    private Obj obj;
+
+    ...
+}
+
+```
+
+ʵ���ϣ�����֮��Ĺ�ϵ��û����ô�򵥣���Ϊ��˵�����⣬��������߹�ϵ���˼򻯣�С�����ֻ��Ҫ���ף�**�����������ԭʼ���������**���ɡ�
+
+����ԭʼ������α�ɴ�������ģ����Բο� [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������£�](https://my.oschina.net/funcy/blog/4687961)��
+
+�����ϴ������̣��� java ����ģ�����£�
+
+```
+/**
+ * ׼��һ����
+ */
+public class Obj1 {
+
+}
+
+/**
+ * ׼��һ���࣬�ڲ���һ������ Obj1
+ */
+public class Obj2 {
+
+    private Obj1 obj1;
+
+    // ʡ����������
+    ...
+
+}
+
+/**
+ * ׼��Obj2�Ĵ����࣬�ڲ�����obj2�Ķ���
+ */
+public class ProxyObj2 extends Obj2 {
+
+    private Obj2 obj2;
+
+    public ProxyObj2(Obj2 obj2) {
+        this.obj2 = obj2;
+    }
+
+    // ʡ����������
+    ...
+
+}
+
+```
+
+���ţ�����ģ�� ������ --> ����ע�� --> ���ɴ������� --> ���浽�����С� �� �����ˣ�
+
+```
+public static main(String[] args) {
+     // ׼��һ�����������ﱣ�������������������ڵĶ���
+     // 1\. ���Ԫ����ԭʼ������ö����Ѿ����������ע�� 
+     // 2\. ���Ԫ���Ǵ���������ö�����е�ԭ�ж����Ѿ����������ע�� 
+     Collection<?> collection = new ArrayList();
+
+     // ��ʼ Obj2 �Ĵ�������
+     // 1\. ���� Obj2 ����
+     Obj2 obj2 = new Obj2();
+
+     // 2\. �� Obj2 ��ע�� obj1������ʱ��û��obj1�������Ҫ����obj1���ٽ���ע�뵽Obj2��
+     Obj1 obj1 = new Obj1();
+     obj2.setObj1(obj1);
+
+     // 3\. ����Obj2�Ĵ������󣬴��������г��� Obj2��ԭʼ����
+     ProxyObj2 proxyObj2 = new ProxyObj2(obj2);
+
+     // 4\. proxyObj2�Ѿ��������������������ڣ���˽������������ӵ�����ʱ
+     collection.add(proxyObj2); 
+
+}
+
+```
+
+����������
+
+*   �� `new Obj2()` ģ�����Ĵ���
+*   �� `obj2.setObj1(xxx)` ģ������ע��
+*   �� `new ProxyObj2(xxx)` ģ��������������
+*   �� `collection.add(xxx)` ģ��������ӵ������еĹ���
+
+ģ����������£�
+
+1.  ���� `obj2` ����
+2.  �� `Obj2` ��ע�� `obj1`������ʱ��û�� `obj1`�������Ҫ���� `obj1`���ٽ���ע�뵽 `Obj2` ��
+3.  ���� `Obj2` �Ĵ������� `proxyObj2`��`proxyObj2` �г��� `Obj2` ��ԭʼ����
+4.  `proxyObj2` �Ѿ��������������������ڣ���˽������������ӵ�����ʱ
+
+��ϸ��������IJ��裬�ͻᷢ�֣�����ĵ� 2 ����� 3 ����ȫ����˳��Ҳû���⣬����ģ�����£�
+
+```
+public static main(String[] args) {
+     // ׼��һ�����������ﱣ�������������������ڵĶ���
+     // 1\. ���Ԫ����ԭʼ������ö����Ѿ����������ע�� 
+     // 2\. ���Ԫ���Ǵ���������ö�����е�ԭ�ж����Ѿ����������ע�� 
+     Collection<?> collection = new ArrayList();
+
+     // ��ʼ Obj2 �Ĵ�������
+     // 1\. ���� Obj2 ����
+     Obj2 obj2 = new Obj2();
+
+     // 2\. ����Obj2�Ĵ������󣬴��������г��� Obj2��ԭʼ����
+     ProxyObj2 proxyObj2 = new ProxyObj2(obj2);
+
+     // 3\. �� obj2 ��ע�� obj1������ʱ��û��obj1�������Ҫ����obj1���ٽ���ע�뵽Obj2��
+     Obj1 obj1 = new Obj1();
+     // ������ע�뵽ԭʼ������
+     obj2.setObj1(obj1);
+
+     // 4\. proxyObj2�Ѿ��������������������ڣ���˽������������ӵ�����ʱ
+     collection.add(proxyObj2); 
+
+}
+
+```
+
+����������������£�
+
+1.  ���� obj2 ����
+2.  ���� Obj2 �Ĵ������󣬴��������г��� Obj2 ��ԭʼ����
+3.  �� Obj2 ��ע�� obj1������ʱ��û�� obj1�������Ҫ���� obj1���ٽ���ע�뵽 Obj2
+4.  proxyObj2 �Ѿ��������������������ڣ���˽������������ӵ�����ʱ
+
+�Ӵ����Ͽ���`proxyObj2(��������)` �г��� `ob2(ԭʼ����)`�����ɴ�������󣬼�����ԭʼ�����������ע�룬��Ȼ��Ӱ������������մ���������е�ԭʼ����Ҳ���������ע�룬����������ͼ��ʾ�����£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-8ff5579425f73dd5c2d321a86d0303390ac.png)
+
+���������ٴ��������� java ���� spring bean �IJ����кö࣬�������ǽ���ע��ѭ��������صIJ��裬������˽� spring bean ��ϸ�ij�ʼ�����̣��ɲ鿴 [spring ��������֮�������̸���](https://my.oschina.net/funcy/blog/4597493)��
+
+���������̽��������������������ڿ��������֣�
+
+*   ���� --> ����ע�� --> ���ɴ������� --> ���������󱣴浽������
+*   ���� (ԭʼ����)--> ���ɴ������� (��ǰ���� aop)--> ��ԭʼ�����������ע�� --> ���������󱣴浽������
+
+�����ֶ��ܴﵽ����Ŀ�ģ���**���浽�����е��Ǵ��������Ҵ��������Ӧ��ԭʼ�������������ע��**�����μ��������������̣����Ǻ����� aop ��ѭ����������ĺ��ģ�˵���ˣ�**aop �µ�ѭ����������֮�����ܽ����������Ϊ���������ǰ���� aop ����**��
+
+##### 2\. Ϊʲô�� `earlySingletonObjects` �޷����ѭ��������
+
+ǰ��������Ҫ˵���˴�������Ĵ������̣������������������� aop �£�ʹ�� `earlySingletonObjects` �����ѭ��������ʲô���⣺
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-d3d00d76ab0c72339faccb7ccd853723d6c.png)
+
+������������ͼ�����̣�
+
+1.  �� `service1` ���󴴽���ɺ��Ƚ� `service1` ���� `earlySingletonObjects`��Ȼ���������ע�룻
+2.  �� `service1` ��������ע��ʱ��`spring` ���� `service1` ��Ҫע�� `service2`��Ȼ����ȥ `earlySingletonObjects` ���� `service2`��δ�ҵ�����ȥ `singletonObjects` �в��� `service2`������δ�ҵ������ǾͿ�ʼ�� `service2` �Ĵ������̣�
+3.  �� `service2` ���󴴽���ɺ��Ƚ� `service2` ���� `earlySingletonObjects`��Ȼ���������ע�룻
+4.  �� `service2` ��������ע��ʱ��`spring` ���� `service2` ��Ҫע�� `service1`��Ȼ���ȥ `earlySingletonObjects` ���� `service1`���ҵ��ˣ��ͽ� `service1` ע�뵽 `service2` �У�Ȼ���ٽ��� aop����ʱ `service2` ��һ���������󣬽��䱣�浽 `singletonObjects` �У�
+5.  ������ 4 �������ǵõ��� `service2` �Ĵ�������Ȼ����ע�뵽 `service1` �У������ٶ� `service1` ���� aop����ʱ `service1` Ҳ����һ�� `spring bean`�����䱣�浽 `singletonObjects` �С�
+
+����������ʲô�����أ���ϸ���� 4 �����ͻᷢ�֣�**ע�뵽 `service2` �� `service1` �����Ǵ�������**���ݹ�ȫ�֣����յõ��� `service1` �� `service2` ���Ǵ�������ע�뵽 `service2` �� `service1` Ӧ��Ҳ�Ǵ�������Ŷԡ���ˣ��� aop �£�ѭ�������������ֳ����ˣ�
+
+#### 2.3 spring �Ľ������
+
+ǰ�������ᵽ���� aop �£����� `earlySingletonObjects` �����ܽ��ѭ�����������⣬�� spring ����ô������أ�spring �ٴ�������һ�� `map` �����������⣬��Ҳ�����dz�˵�� **spring ��������**���������� `map` ˵�����£�
+
+*   һ������ `singletonObjects`������Ϊ `ConcurrentHashMap<String, Object>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` �������� `spring bean`�����������ע�롢��ʼ���� bean����� bean ��Ҫ aop���洢�ľ��Ǵ�������
+*   �������� `earlySingletonObjects`������Ϊ `HashMap<String, Object>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` ��ʵ������ɣ���δ��������ע��� `bean`����� `bean` ��Ҫ `aop`������洢�ľ��Ǵ�������ֻ�����������������е�ԭʼ����δ��������ע�룻
+*   �������� `singletonFactories`������Ϊ `HashMap<String, ObjectFactory>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` �洢����һ�� `lambda` ����ʽ��`() -> getEarlyBeanReference(beanName, mbd, bean)`�� `getEarlyBeanReference` �е� `bean` �Ǹմ�����ɵ� `java bean`��û�н��� spring ����ע�룬Ҳû���� aop (������� `lambda` ����ʽ��������������)��
+
+Ϊ��˵�����㣬����� `singletonObjects`��`earlySingletonObjects` �� `singletonFactories` �ֱ��Ϊ**һ������**��**��������**��**��������**��
+
+spring ��� aop �µ�ѭ�������������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-dc325a87b321e4c246a1b2f14169821a75a.png)
+
+���ͼ���űȽϸ��ӣ���ʵ�ֿ������ͱȽϼ��ˣ����������У�`1~8` �ǻ�ȡ `service1` �����̣�`5.1~5.8` �ǻ�ȡ `service2` �����̣�`5.5.1` ���ٴλ�ȡ `service1` �����̣�ֻ�����ڴ��� `service1` �ij�ʼ�������У��ᴥ�� `service2` �ij�ʼ�����̣��� `service2` �ij�ʼ��ʱ���ֻ������� `service1`����˲ſ�����������һ�𣬱Ƚϸ��ӡ�
+
+����ͼ�Ĺ��̣�����˵�����£����飺����������̱Ƚϸ��ӣ������ȿ� `1~8` �IJ������ٿ� `5.1~5.8` �IJ�����������������������������������ࣩܶ��
+
+*   1.  `service1`����ȡ `service1`����һ�������л�ȡ����ʱ�ǻ�ȡ�����ģ�
+*   1.  `service1`������ `service1` ��ʵ����
+*   1.  `service1`����ȡ��Ҫע��������뷽������ԭʼ�����Ͻ��л�ȡ����
+*   1.  `service1`�����������֧��ѭ�����������ã��ͽ� `service1` �ŵ����������У��Ƿ�֧��ѭ���������ǿ������õģ���
+*   1.  `service1`���� `service1` ��������ע�룬��Ҫ `service2`��Ȼ��Ϳ�ʼ�� `service2` �Ļ�ȡ���̣�
+*   5.1 `service2`����ȡ `service2`����һ�������л�ȡ����ʱ�ǻ�ȡ�����ģ�
+*   5.2 `service2`������ `service2` ��ʵ����
+*   5.3 `service2`����ȡ��Ҫע��������뷽������ԭʼ�����Ͻ��л�ȡ����
+*   5.4 `service2`�����������֧��ѭ�����������ã��ͽ� `service2` �ŵ����������У��Ƿ�֧��ѭ���������ǿ������õģ���
+*   5.5 `service2`���� `service2` ��������ע�룬��Ҫ `service1`��Ȼ��Ϳ�ʼ�� `service1` �Ļ�ȡ���̣�
+*   5.5.1 `service1`: ��ȡ `service1`����һ�������л�ȡ����ȡ��������ʱ���� `service1` ���ڴ����У����Ǽ����Ӷ������������л�ȡ�����մ����������л�ȡ���ˣ��������������档�����������ȡ�Ĺ����У�**���ж� `service1` �Ƿ���Ҫ���� aop��Ȼ��ʼ aop ����**����˷�����������е��� `service1` ������������ǰ���� aop �ǽ��ѭ�������Ĺؼ���
+*   5.6 `service2`���õ��� `service1` ������� `service1` �Ǵ������󣩣�����ע�뵽 `service2` �У����Ŷ� `service2` ���� aop���õ� `service2` �Ĵ�������
+*   5.7 `service2`�����֧��ѭ���������ȴ�һ�������������ٴλ�ȡ `service2`����δ��ȡ������ʹ�õ�ǰ `service2`����ǰ `service2` �Ǵ�������)��
+*   5.8 `service2`���� service2 �Ĵ����������һ�������У�ɾ�������������棬���ˣ�`service2` ��ʼ����ɣ�ע��� `service1` �Ǵ�������һ�������е� `service2` Ҳ�Ǵ�������
+*   1.  `service1`���ص� `service1` ���������ڣ��õ� `service2`������� `service2` �Ǵ������󣩺󣬽���ע�뵽 `service1`��`service1` ������ע����ɣ����г�ʼ����������ж� `service1` �Ƿ���Ҫ���� aop����Ȼ `service1` ����Ҫ���� aop �ģ��������� `5.5.1` �Ѿ����й� aop �ˣ���ˣ�����ֱ�ӷ��أ�����һ����`service1` ����ԭʼ���󣩣�
+*   1.  `service1`�����֧��ѭ���������ȴ�һ�������л�ȡ `service1`����ȡ�������ٴӶ������л�ȡ `service1`�����Ի�ȡ������ `5.5.1` ��֪�������������� `service1` �������󣩣����أ�
+*   1.  `service1`�������������л�ȡ�Ķ���ע�ᵽһ�������У�ɾ�������������棬���ˣ�`service1` ��ʼ����ɣ�ע��� `service2` �Ǵ�������һ�������е� `service1` Ҳ�Ǵ�������
+
+�������̣���Ȼ����϶࣬�� `service1` �� `service2` �Ļ�ȡ��������ͬ�ģ�ֻҪŪ��������֮һ�Ļ�ȡ���̣���һ�� bean �Ļ�ȡ���̾ͺ���ͬ�ˡ�
+
+�����������У������������ݽṹ��Ҫ˵���£�
+
+*   `singletonsCurrentlyInCreation`������Ϊ `SetFromMap<String>`��λ�� `DefaultSingletonBeanRegistry`��������ʽΪ `Collections.newSetFromMap(new ConcurrentHashMap<>(16))`���������Ǹ��� `ConcurrentHashMap` ʵ�ֵ� set���洢�������ڴ����еĶ���**�жϵ�ǰ�����Ƿ��ڴ����о���ͨ�����ҵ�ǰ�����Ƿ������ set ��**�����ģ�
+*   `earlyProxyReferences`������Ϊ `ConcurrentHashMap<Object, Object>`��λ�� `AbstractAutoProxyCreator`���洢������ǰ���� aop �Ķ���**���һ��������ǰ������ aop���ں����ٴ� aop ʱ����ͨ���ж϶����Ƿ��� `earlyProxyReferences` �ж�ȷ��Ҫ��Ҫ���� aop���Դ�����֤ÿ������ֻ����һ�� aop**��
+
+���ˣ�spring һ���ṩ�� 5 �����ݽṹ���������ѭ���������⣬�ܽ����£�
+
+| �ṹ                            | ˵��                                                         |
+| ------------------------------- | ------------------------------------------------------------ |
+| `singletonObjects`              | **һ������**������Ϊ `ConcurrentHashMap<String, Object>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` �������� `spring bean`�����������ע�롢��ʼ���� bean����� bean ��Ҫ aop���洢�ľ��Ǵ������� |
+| `earlySingletonObjects`         | **��������**������Ϊ `HashMap<String, Object>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` ��ʵ������ɣ���δ��������ע��� `bean`��**��� `bean` ��Ҫ `aop`������洢�ľ��Ǵ�������ֻ�����������������е�ԭʼ����δ��������ע��** |
+| `singletonFactories`            | **��������**������Ϊ `HashMap<String, ObjectFactory>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` �洢����һ�� `lambda` ����ʽ��`() -> getEarlyBeanReference(beanName, mbd, bean)`��`getEarlyBeanReference(xxx)` �е� `bean` �Ǹմ�����ɵ� `java bean`��û�н��� spring ����ע�룬Ҳû���� aop |
+| `singletonsCurrentlyInCreation` | ����Ϊ `SetFromMap<String>`��λ�� `DefaultSingletonBeanRegistry`��������ʽΪ `Collections.newSetFromMap(new ConcurrentHashMap<>(16))`���������Ǹ��� `ConcurrentHashMap` ʵ�ֵ� set���洢�������ڴ����еĶ��󣬿���**�����жϵ�ǰ�����Ƿ��ڴ�����** |
+| `earlyProxyReferences`          | ����Ϊ `ConcurrentHashMap<Object, Object>`��λ�� `AbstractAutoProxyCreator`���洢������ǰ���� aop �Ķ��󣬿���**�����ж� bean �Ƿ���й� aop����֤ÿ������ֻ����һ�� aop** |
+
+���Ͼ��� spring ���ѭ�����������������ˡ�
+
+### 3\. ����ģ��
+
+����ʽ����Դ��ǰ����������ģ��ѭ������������Ĺ��̣��������£�
+
+```
+/**
+ * ׼��һ���࣬�ڲ���һ������ Obj2
+ */
+public class Obj1 {
+    // ��Ҫע�� obj2
+    private Obj2 obj2;
+
+    // ʡ����������
+    ...
+}
+
+/**
+ * ׼��һ���࣬�ڲ���һ������ Obj1
+ */
+public class Obj2 {
+    // ��Ҫע�� ob1
+    private Obj1 obj1;
+
+    // ʡ����������
+    ...
+
+}
+
+/**
+ * ׼��Obj2�Ĵ����࣬�ڲ�����obj2�Ķ���
+ */
+public class ProxyObj2 extends Obj2 {
+    // obj2�������ڲ�����obj2��ԭʼ����
+    private Obj2 obj2;
+
+    public ProxyObj2(Obj2 obj2) {
+        this.obj2 = obj2;
+    }
+
+    // ʡ����������
+    ...
+
+}
+
+/**
+ * ׼��Obj1�Ĵ����࣬�ڲ�����obj1�Ķ���
+ */
+public class ProxyObj1 extends Obj1 {
+    // obj2�������ڲ�����obj1��ԭʼ����
+    private Obj1 obj1;
+
+    public ProxyObj1(Obj1 obj1) {
+        this.obj1 = obj1;
+    }
+
+    // ʡ����������
+    ...
+
+}
+
+```
+
+*   ����׼���������ࣺ`Obj1` �� `Obj2`�� ���� `Obj1` �и�����Ϊ `Obj2`��`Obj2` ���и�����Ϊ `Obj1`��
+*   ����׼���� `Obj1` �� `Obj2` �Ĵ����� `ProxyObj1`��`ProxyObj2`������ `ProxyObj1`��`ProxyObj2` �ֱ���һ�����ԣ�`Obj1` �� `Obj2`��
+*   ���������� `new ObjX()` ģ�����Ĵ�����
+*   ���������� `objX.setObjX(xxx)` ģ������ע�룻
+*   ���������� `new ProxyObjX(xxx)` ģ�������������ɣ�
+*   ���������� `collection.add(xxx)` ģ��������ӵ������еĹ��̣�
+
+����ģ�����յõ��Ľ��Ϊ��
+
+*   ���շ��������Ķ���ֱ��� `proxyObj1`��`proxyObj2`
+*   ע�뵽 `obj1` �е��� `proxyObj2`��ע�뵽 `obj2` �е��� `proxyObj2`
+
+׼�������Ѿ�����ˣ����������ǾͿ�ʼ����ģ���ˡ�
+
+#### 3.1 ģ�� 1
+
+Ҫ��
+
+*   Obj1 �� Obj2 �����ϸ��� ������ --> ����ע�� --> ���ɴ������� --> ���浽�����С� �����̴���
+*   ��������Ĵ������̿��Խ������
+
+Ŀ�꣺
+
+*   ���շ��������Ķ���ֱ��� `proxyObj1`��`proxyObj2`
+*   ע�뵽 `obj1` �е��� `proxyObj2`��ע�뵽 `obj2` �е��� `proxyObj2`
+
+�������£�
+
+```
+public static main(String[] args) {
+     // ׼��һ�����������ﱣ�������������������ڵĶ���
+     // 1\. ���Ԫ����ԭʼ������ö����Ѿ����������ע�� 
+     // 2\. ���Ԫ���Ǵ���������ö�����е�ԭ�ж����Ѿ����������ע�� 
+     Collection<?> collection = new ArrayList();
+
+     // 1\. ���� Obj1 ����
+     Obj1 obj1 = new Obj1();
+
+     // ��������Ҫ��obj2�Ĵ�������ע�뵽obj1�У�����ʱ�����в�û��obj2�Ĵ������������л���obj2�Ĵ�������
+     // һ. ���� Obj2 ����
+     Obj2 obj2 = new Obj2();
+
+     // �����obj2��Ҫע��obj1�Ĵ������󣬵���ʱ�����в�û��obj2�Ĵ�������������Ҫ�е�obj1�Ĵ�������
+
+}
+
+```
+
+��ִ������������ �����ִ��� Obj2 ��������̾ͽ��в���ȥ�ˣ�
+
+*   `obj1` ��Ҫע�� `obj2` �Ĵ������󣬵��Ҳ����������л��� `obj2` �Ĵ������̣�
+*   `obj2` ��Ҫע�� `obj1` �Ĵ������󣬵��Ҳ����������л��� `obj1` �Ĵ������̣�
+*   `obj1` ��Ҫע�� `obj2` �Ĵ������󣬵��Ҳ����������л��� `obj2` �Ĵ������̣�
+*   ...
+
+���ѭ��������
+
+ģ������δ�ﵽԤ��Ŀ�꣬����ģ������ʧ�ܡ�
+
+#### 3.1 ģ�� 2
+
+Ҫ��
+
+*   Obj1 �� Obj2 ����������������֮һ������
+    *   ������ --> ����ע�� --> ���ɴ������� --> ���浽�����С� �����̴���
+    *   ������ (ԭʼ����)--> ���ɴ������� --> ��ԭʼ�����������ע�� --> ���������󱣴浽�����С� �����̴���
+*   ��������Ĵ������̿��Խ������
+
+Ŀ�꣺
+
+*   ���շ��������Ķ���ֱ��� `proxyObj1`��`proxyObj2`
+*   ע�뵽 `obj1` �е��� `proxyObj2`��ע�뵽 `obj2` �е��� `proxyObj2`### 1\. ʲô��ѭ��������
+
+spring ������ע��ʱ�����ܻ�����໥ע��������
+
+```
+@Service
+public class Service1 {
+    @Autowired
+    private Service2 service2;
+
+}
+
+@Service
+public class Service2 {
+    @Autowired
+    private Service1 service1;
+
+}
+
+```
+
+�����ϴ��룬�� `Service1` ��ͨ�� `@Autowird` ע���� `Service2`���� `Service2` ��ͨ�� `@Autowird` ע���� `Service1`�������໥ע���������ͽ���ѭ��������
+
+### 2\. ѭ����������ʲô����
+
+ʵ���ϣ����� `A����B����BҲ����A����`�������java ��������ȫ֧�ֵģ�
+
+```
+/**
+ * ׼��service1
+ */
+public class Service1 {
+    private Service2 service2;
+
+    public void setService2(Service2 service2) {
+        this.service2 = service2;
+    }
+
+    public Service2 getService2() {
+        return this.service2;
+    }
+}
+
+/**
+ * ׼��service2
+ */
+public class Service2 {
+    private Service1 service1;
+
+    public void setService1(Service1 service1) {
+        this.service1 = service1;
+    }
+
+    public Service1 getService1() {
+        return this.service1;
+    }
+}
+
+/**
+ * ���������
+ */
+public class Main {
+    public void main(String[] args) {
+        // ׼����������
+        Service1 service1 = new Service1();
+        Service2 service2 = new Service2();
+        // �໥����
+        service1.setService2(service2);
+        service2.setService1(service1);
+    }
+}
+
+```
+
+��ô���� spring �У��������໥ע��Է�ʵ�������������ʲô�����أ��������� `spring bean` �Ĵ������̣�**ע�⣺�������ǽ����� `bean` �� `scope` Ϊ `singleton` �������Ҳ���� `scope` Ϊ`����`�����**����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-ca36e17077b1b191834645b3c8e588ff6c4.png)
+
+����������м�����Ҫ˵���£�
+
+1.  �������������ʵ����ʹ�� jdk �ṩ�ķ�����ƴ��� java �����Ե� 1 ���ᵽ�� `Service1` Ϊ�����ɼ�����Ϊ `Service1 service = new Service1()`��
+2.  ע���������󣺻����Ե� 1 ���ᵽ�� `Service1` Ϊ����`Service1` ��ͨ�� `@Autowired` �Զ�ע�� `Service2`����һ�����Ǹ� `Service2` ��ֵ�Ĺ��̣��ɼ�����Ϊ `service1.setService2(service2)`��
+3.  `singletonObjects`����������������һ�� java ����ͱ����һ�� spring bean��Ȼ�󱣴浽 `singletonObjects` �ˣ����Ǹ� `map`��`key` �� bean �����ƣ�`value` �� bean����ֻ���� `spring bean`������ֻ�� java ʵ����
+
+ʵ���ϣ�`java` ������ `spring bean`��������ֻ������ע�룬���г�ʼ����ִ�� `beanPorcessor` �����ȣ�**���ڱ����Ƿ��� `spring bean` ��ѭ�������ģ���������ص��ע��ѭ��������صIJ��衣**
+
+#### 2.1 ѭ����������������
+
+�˽��� spring bean �IJ�������֮�󣬽��������Ǿ���������ѭ���������������⣬����ʽ����ǰ������������ȷ�������
+
+*   `java����`��ʵ���ϣ�java ��һ�ж��󶼿��Գ�֮Ϊ `java` ����Ϊ��˵�����㣬�����ᵽ�� `java����`��ָʵ������ɡ���δ���� spring bean ���������ڶ���
+*   `spring bean`����һ�� java ���󣬲��ҽ����������� spring bean ���������ڶ���
+
+spring bean �Ĵ����������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-b55a211447b5fabeaa0c3ef0bfee0920c82.png)
+
+����ͼ˵�����£�
+
+1.  �� `service1` ���󴴽���ɺ�`spring` ���� `service1` ��Ҫע�� `service2`��Ȼ���ȥ `singletonObjects` �в��� `service2`����ʱ���Ҳ��� `service2`��Ȼ��Ϳ�ʼ�� `service2` �Ĵ������̣�
+2.  �� `service2` ���󴴽���ɺ�`spring` ���� `service2` ��Ҫע�� `service1`��Ȼ���ȥ `singletonObjects` �в��� `service1`����ʱ���Ҳ��� `service1`����Ϊ��һ���� `service1` ��û�д����ɹ� ��Ȼ��Ϳ�ʼ�� `service1` �Ĵ������̣�
+3.  �������ص� `1`���ٴο�ʼ�� `service1` �Ĵ���������ע����̡�
+
+��������Ǿ�ϲ�ط��֣�ѭ�������ˣ�
+
+#### 2.2 ���� `earlySingletonObjects` ���ѭ������
+
+���Ƿ����£�ѭ�����ֵ�ԭ�����ڣ��� `service2` ��ȡ `service1` ʱ������ `singletonObjects` �д�ʱ�������� `service1`����˻����� `service1` �Ĵ������̣����´��� `service1`����ˣ������и��󵨵��뷨������� `service1` ʵ������Ͱ����������������������� `service1` ʱ���ͷ������δ��������ע��� `service1`��������������
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-c0eaecbe82b144a6fcd9fd048f2cca53497.png)
+
+��ͼ�У������� `earlySingletonObjects`����Ҳ�Ǹ� map��ͬ `singletonObjects` һ����`key` �� bean �����ƣ�`value` ��һ��δ�������ע��Ķ���
+
+����ͼ˵�����£�
+
+1.  �� `service1` ���󴴽���ɺ��Ƚ� `service1` ���� `earlySingletonObjects`��Ȼ���������ע�룻
+2.  �� `service1` ��������ע��ʱ��`spring` ���� `service1` ��Ҫע�� `service2`��Ȼ����ȥ `earlySingletonObjects` ���� `service2`��δ�ҵ�����ȥ `singletonObjects` �в��� `service2`������δ�ҵ������ǾͿ�ʼ�� `service2` �Ĵ������̣�
+3.  �� `service2` ���󴴽���ɺ��Ƚ� `service2` ���� `earlySingletonObjects`��Ȼ���������ע�룻
+4.  �� `service2` ��������ע��ʱ��`spring` ���� `service2` ��Ҫע�� `service1`��Ȼ���ȥ `earlySingletonObjects` ���� `service1`���ҵ��ˣ��ͽ� `service1` ע�뵽 `service2` �У���ʱ `service2` ����һ�� `spring bean` �ˣ����䱣�浽 `singletonObjects` �У�
+5.  ������ 4 �������ǵõ��� `service2`��Ȼ����ע�뵽 `service1` �У���ʱ `service1` Ҳ����һ�� `spring bean`�����䱣�浽 `singletonObjects` �С�
+
+�������ϲ��裬���Ƿ��֣�ѭ�������õ��˽����
+
+#### 2.2 aop �µ�ѭ������
+
+��������ķ��������Ƿ���ֻҪ��������һ�� `earlySingletonObjects` ��ѭ���������ܵõ���������ǣ�ѭ��������ĵõ��˽����spring ���� ioc �⣬������һ���ش��ܣ�aop������������ aop ����³���ѭ��������������
+
+##### 1\. aop ����Ĵ�������
+
+����ʽ���� aop �µ�ѭ������ǰ������������ȷ���������
+
+*   `ԭʼ����`�������ڴ�������ָδ���й� aop �Ķ��󣬿����� java ����Ҳ������δ���� aop �� spring bean��
+*   `��������`�����й� aop �Ķ��󣬿����� java ��������й� aop �õ��Ķ��� (�����й� aop��δ��������ע�룬Ҳδ���г�ʼ��)��Ҳ�����ǽ��й� aop �� `spring bean`.
+
+������������ aop ����δ�������ģ�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-e92991c1c173bbd5579be3001a977555be7.png)
+
+����� `2.1` �е����̣�aop ���� "���ɴ�������" �IJ������������ձ��浽 `singletonObjects` �еĶ���Ҳ�Ǵ�������
+
+ԭʼ�������������֮����ʲô��ϵ�أ��ô���ʾ���£��������£�
+
+```
+public class ProxyObj extends Obj {
+
+    // ԭʼ����
+    private Obj obj;
+
+    ...
+}
+
+```
+
+ʵ���ϣ�����֮��Ĺ�ϵ��û����ô�򵥣���Ϊ��˵�����⣬��������߹�ϵ���˼򻯣�С�����ֻ��Ҫ���ף�**�����������ԭʼ���������**���ɡ�
+
+����ԭʼ������α�ɴ�������ģ����Բο� [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������£�](https://my.oschina.net/funcy/blog/4687961)��
+
+�����ϴ������̣��� java ����ģ�����£�
+
+```
+/**
+ * ׼��һ����
+ */
+public class Obj1 {
+
+}
+
+/**
+ * ׼��һ���࣬�ڲ���һ������ Obj1
+ */
+public class Obj2 {
+
+    private Obj1 obj1;
+
+    // ʡ����������
+    ...
+
+}
+
+/**
+ * ׼��Obj2�Ĵ����࣬�ڲ�����obj2�Ķ���
+ */
+public class ProxyObj2 extends Obj2 {
+
+    private Obj2 obj2;
+
+    public ProxyObj2(Obj2 obj2) {
+        this.obj2 = obj2;
+    }
+
+    // ʡ����������
+    ...
+
+}
+
+```
+
+���ţ�����ģ�� ������ --> ����ע�� --> ���ɴ������� --> ���浽�����С� �� �����ˣ�
+
+```
+public static main(String[] args) {
+     // ׼��һ�����������ﱣ�������������������ڵĶ���
+     // 1\. ���Ԫ����ԭʼ������ö����Ѿ����������ע�� 
+     // 2\. ���Ԫ���Ǵ���������ö�����е�ԭ�ж����Ѿ����������ע�� 
+     Collection<?> collection = new ArrayList();
+
+     // ��ʼ Obj2 �Ĵ�������
+     // 1\. ���� Obj2 ����
+     Obj2 obj2 = new Obj2();
+
+     // 2\. �� Obj2 ��ע�� obj1������ʱ��û��obj1�������Ҫ����obj1���ٽ���ע�뵽Obj2��
+     Obj1 obj1 = new Obj1();
+     obj2.setObj1(obj1);
+
+     // 3\. ����Obj2�Ĵ������󣬴��������г��� Obj2��ԭʼ����
+     ProxyObj2 proxyObj2 = new ProxyObj2(obj2);
+
+     // 4\. proxyObj2�Ѿ��������������������ڣ���˽������������ӵ�����ʱ
+     collection.add(proxyObj2); 
+
+}
+
+```
+
+����������
+
+*   �� `new Obj2()` ģ�����Ĵ���
+*   �� `obj2.setObj1(xxx)` ģ������ע��
+*   �� `new ProxyObj2(xxx)` ģ��������������
+*   �� `collection.add(xxx)` ģ��������ӵ������еĹ���
+
+ģ����������£�
+
+1.  ���� `obj2` ����
+2.  �� `Obj2` ��ע�� `obj1`������ʱ��û�� `obj1`�������Ҫ���� `obj1`���ٽ���ע�뵽 `Obj2` ��
+3.  ���� `Obj2` �Ĵ������� `proxyObj2`��`proxyObj2` �г��� `Obj2` ��ԭʼ����
+4.  `proxyObj2` �Ѿ��������������������ڣ���˽������������ӵ�����ʱ
+
+��ϸ��������IJ��裬�ͻᷢ�֣�����ĵ� 2 ����� 3 ����ȫ����˳��Ҳû���⣬����ģ�����£�
+
+```
+public static main(String[] args) {
+     // ׼��һ�����������ﱣ�������������������ڵĶ���
+     // 1\. ���Ԫ����ԭʼ������ö����Ѿ����������ע�� 
+     // 2\. ���Ԫ���Ǵ���������ö�����е�ԭ�ж����Ѿ����������ע�� 
+     Collection<?> collection = new ArrayList();
+
+     // ��ʼ Obj2 �Ĵ�������
+     // 1\. ���� Obj2 ����
+     Obj2 obj2 = new Obj2();
+
+     // 2\. ����Obj2�Ĵ������󣬴��������г��� Obj2��ԭʼ����
+     ProxyObj2 proxyObj2 = new ProxyObj2(obj2);
+
+     // 3\. �� obj2 ��ע�� obj1������ʱ��û��obj1�������Ҫ����obj1���ٽ���ע�뵽Obj2��
+     Obj1 obj1 = new Obj1();
+     // ������ע�뵽ԭʼ������
+     obj2.setObj1(obj1);
+
+     // 4\. proxyObj2�Ѿ��������������������ڣ���˽������������ӵ�����ʱ
+     collection.add(proxyObj2); 
+
+}
+
+```
+
+����������������£�
+
+1.  ���� obj2 ����
+2.  ���� Obj2 �Ĵ������󣬴��������г��� Obj2 ��ԭʼ����
+3.  �� Obj2 ��ע�� obj1������ʱ��û�� obj1�������Ҫ���� obj1���ٽ���ע�뵽 Obj2
+4.  proxyObj2 �Ѿ��������������������ڣ���˽������������ӵ�����ʱ
+
+�Ӵ����Ͽ���`proxyObj2(��������)` �г��� `ob2(ԭʼ����)`�����ɴ�������󣬼�����ԭʼ�����������ע�룬��Ȼ��Ӱ������������մ���������е�ԭʼ����Ҳ���������ע�룬����������ͼ��ʾ�����£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-8ff5579425f73dd5c2d321a86d0303390ac.png)
+
+���������ٴ��������� java ���� spring bean �IJ����кö࣬�������ǽ���ע��ѭ��������صIJ��裬������˽� spring bean ��ϸ�ij�ʼ�����̣��ɲ鿴 [spring ��������֮�������̸���](https://my.oschina.net/funcy/blog/4597493)��
+
+���������̽��������������������ڿ��������֣�
+
+*   ���� --> ����ע�� --> ���ɴ������� --> ���������󱣴浽������
+*   ���� (ԭʼ����)--> ���ɴ������� (��ǰ���� aop)--> ��ԭʼ�����������ע�� --> ���������󱣴浽������
+
+�����ֶ��ܴﵽ����Ŀ�ģ���**���浽�����е��Ǵ��������Ҵ��������Ӧ��ԭʼ�������������ע��**�����μ��������������̣����Ǻ����� aop ��ѭ����������ĺ��ģ�˵���ˣ�**aop �µ�ѭ����������֮�����ܽ����������Ϊ���������ǰ���� aop ����**��
+
+##### 2\. Ϊʲô�� `earlySingletonObjects` �޷����ѭ��������
+
+ǰ��������Ҫ˵���˴�������Ĵ������̣������������������� aop �£�ʹ�� `earlySingletonObjects` �����ѭ��������ʲô���⣺
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-d3d00d76ab0c72339faccb7ccd853723d6c.png)
+
+������������ͼ�����̣�
+
+1.  �� `service1` ���󴴽���ɺ��Ƚ� `service1` ���� `earlySingletonObjects`��Ȼ���������ע�룻
+2.  �� `service1` ��������ע��ʱ��`spring` ���� `service1` ��Ҫע�� `service2`��Ȼ����ȥ `earlySingletonObjects` ���� `service2`��δ�ҵ�����ȥ `singletonObjects` �в��� `service2`������δ�ҵ������ǾͿ�ʼ�� `service2` �Ĵ������̣�
+3.  �� `service2` ���󴴽���ɺ��Ƚ� `service2` ���� `earlySingletonObjects`��Ȼ���������ע�룻
+4.  �� `service2` ��������ע��ʱ��`spring` ���� `service2` ��Ҫע�� `service1`��Ȼ���ȥ `earlySingletonObjects` ���� `service1`���ҵ��ˣ��ͽ� `service1` ע�뵽 `service2` �У�Ȼ���ٽ��� aop����ʱ `service2` ��һ���������󣬽��䱣�浽 `singletonObjects` �У�
+5.  ������ 4 �������ǵõ��� `service2` �Ĵ�������Ȼ����ע�뵽 `service1` �У������ٶ� `service1` ���� aop����ʱ `service1` Ҳ����һ�� `spring bean`�����䱣�浽 `singletonObjects` �С�
+
+����������ʲô�����أ���ϸ���� 4 �����ͻᷢ�֣�**ע�뵽 `service2` �� `service1` �����Ǵ�������**���ݹ�ȫ�֣����յõ��� `service1` �� `service2` ���Ǵ�������ע�뵽 `service2` �� `service1` Ӧ��Ҳ�Ǵ�������Ŷԡ���ˣ��� aop �£�ѭ�������������ֳ����ˣ�
+
+#### 2.3 spring �Ľ������
+
+ǰ�������ᵽ���� aop �£����� `earlySingletonObjects` �����ܽ��ѭ�����������⣬�� spring ����ô������أ�spring �ٴ�������һ�� `map` �����������⣬��Ҳ�����dz�˵�� **spring ��������**���������� `map` ˵�����£�
+
+*   һ������ `singletonObjects`������Ϊ `ConcurrentHashMap<String, Object>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` �������� `spring bean`�����������ע�롢��ʼ���� bean����� bean ��Ҫ aop���洢�ľ��Ǵ�������
+*   �������� `earlySingletonObjects`������Ϊ `HashMap<String, Object>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` ��ʵ������ɣ���δ��������ע��� `bean`����� `bean` ��Ҫ `aop`������洢�ľ��Ǵ�������ֻ�����������������е�ԭʼ����δ��������ע�룻
+*   �������� `singletonFactories`������Ϊ `HashMap<String, ObjectFactory>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` �洢����һ�� `lambda` ����ʽ��`() -> getEarlyBeanReference(beanName, mbd, bean)`�� `getEarlyBeanReference` �е� `bean` �Ǹմ�����ɵ� `java bean`��û�н��� spring ����ע�룬Ҳû���� aop (������� `lambda` ����ʽ��������������)��
+
+Ϊ��˵�����㣬����� `singletonObjects`��`earlySingletonObjects` �� `singletonFactories` �ֱ��Ϊ**һ������**��**��������**��**��������**��
+
+spring ��� aop �µ�ѭ�������������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-dc325a87b321e4c246a1b2f14169821a75a.png)
+
+���ͼ���űȽϸ��ӣ���ʵ�ֿ������ͱȽϼ��ˣ����������У�`1~8` �ǻ�ȡ `service1` �����̣�`5.1~5.8` �ǻ�ȡ `service2` �����̣�`5.5.1` ���ٴλ�ȡ `service1` �����̣�ֻ�����ڴ��� `service1` �ij�ʼ�������У��ᴥ�� `service2` �ij�ʼ�����̣��� `service2` �ij�ʼ��ʱ���ֻ������� `service1`����˲ſ�����������һ�𣬱Ƚϸ��ӡ�
+
+����ͼ�Ĺ��̣�����˵�����£����飺����������̱Ƚϸ��ӣ������ȿ� `1~8` �IJ������ٿ� `5.1~5.8` �IJ�����������������������������������ࣩܶ��
+
+*   1.  `service1`����ȡ `service1`����һ�������л�ȡ����ʱ�ǻ�ȡ�����ģ�
+*   1.  `service1`������ `service1` ��ʵ����
+*   1.  `service1`����ȡ��Ҫע��������뷽������ԭʼ�����Ͻ��л�ȡ����
+*   1.  `service1`�����������֧��ѭ�����������ã��ͽ� `service1` �ŵ����������У��Ƿ�֧��ѭ���������ǿ������õģ���
+*   1.  `service1`���� `service1` ��������ע�룬��Ҫ `service2`��Ȼ��Ϳ�ʼ�� `service2` �Ļ�ȡ���̣�
+*   5.1 `service2`����ȡ `service2`����һ�������л�ȡ����ʱ�ǻ�ȡ�����ģ�
+*   5.2 `service2`������ `service2` ��ʵ����
+*   5.3 `service2`����ȡ��Ҫע��������뷽������ԭʼ�����Ͻ��л�ȡ����
+*   5.4 `service2`�����������֧��ѭ�����������ã��ͽ� `service2` �ŵ����������У��Ƿ�֧��ѭ���������ǿ������õģ���
+*   5.5 `service2`���� `service2` ��������ע�룬��Ҫ `service1`��Ȼ��Ϳ�ʼ�� `service1` �Ļ�ȡ���̣�
+*   5.5.1 `service1`: ��ȡ `service1`����һ�������л�ȡ����ȡ��������ʱ���� `service1` ���ڴ����У����Ǽ����Ӷ������������л�ȡ�����մ����������л�ȡ���ˣ��������������档�����������ȡ�Ĺ����У�**���ж� `service1` �Ƿ���Ҫ���� aop��Ȼ��ʼ aop ����**����˷�����������е��� `service1` ������������ǰ���� aop �ǽ��ѭ�������Ĺؼ���
+*   5.6 `service2`���õ��� `service1` ������� `service1` �Ǵ������󣩣�����ע�뵽 `service2` �У����Ŷ� `service2` ���� aop���õ� `service2` �Ĵ�������
+*   5.7 `service2`�����֧��ѭ���������ȴ�һ�������������ٴλ�ȡ `service2`����δ��ȡ������ʹ�õ�ǰ `service2`����ǰ `service2` �Ǵ�������)��
+*   5.8 `service2`���� service2 �Ĵ����������һ�������У�ɾ�������������棬���ˣ�`service2` ��ʼ����ɣ�ע��� `service1` �Ǵ�������һ�������е� `service2` Ҳ�Ǵ�������
+*   1.  `service1`���ص� `service1` ���������ڣ��õ� `service2`������� `service2` �Ǵ������󣩺󣬽���ע�뵽 `service1`��`service1` ������ע����ɣ����г�ʼ����������ж� `service1` �Ƿ���Ҫ���� aop����Ȼ `service1` ����Ҫ���� aop �ģ��������� `5.5.1` �Ѿ����й� aop �ˣ���ˣ�����ֱ�ӷ��أ�����һ����`service1` ����ԭʼ���󣩣�
+*   1.  `service1`�����֧��ѭ���������ȴ�һ�������л�ȡ `service1`����ȡ�������ٴӶ������л�ȡ `service1`�����Ի�ȡ������ `5.5.1` ��֪�������������� `service1` �������󣩣����أ�
+*   1.  `service1`�������������л�ȡ�Ķ���ע�ᵽһ�������У�ɾ�������������棬���ˣ�`service1` ��ʼ����ɣ�ע��� `service2` �Ǵ�������һ�������е� `service1` Ҳ�Ǵ�������
+
+�������̣���Ȼ����϶࣬�� `service1` �� `service2` �Ļ�ȡ��������ͬ�ģ�ֻҪŪ��������֮һ�Ļ�ȡ���̣���һ�� bean �Ļ�ȡ���̾ͺ���ͬ�ˡ�
+
+�����������У������������ݽṹ��Ҫ˵���£�
+
+*   `singletonsCurrentlyInCreation`������Ϊ `SetFromMap<String>`��λ�� `DefaultSingletonBeanRegistry`��������ʽΪ `Collections.newSetFromMap(new ConcurrentHashMap<>(16))`���������Ǹ��� `ConcurrentHashMap` ʵ�ֵ� set���洢�������ڴ����еĶ���**�жϵ�ǰ�����Ƿ��ڴ����о���ͨ�����ҵ�ǰ�����Ƿ������ set ��**�����ģ�
+*   `earlyProxyReferences`������Ϊ `ConcurrentHashMap<Object, Object>`��λ�� `AbstractAutoProxyCreator`���洢������ǰ���� aop �Ķ���**���һ��������ǰ������ aop���ں����ٴ� aop ʱ����ͨ���ж϶����Ƿ��� `earlyProxyReferences` �ж�ȷ��Ҫ��Ҫ���� aop���Դ�����֤ÿ������ֻ����һ�� aop**��
+
+���ˣ�spring һ���ṩ�� 5 �����ݽṹ���������ѭ���������⣬�ܽ����£�
+
+| �ṹ                            | ˵��                                                         |
+| ------------------------------- | ------------------------------------------------------------ |
+| `singletonObjects`              | **һ������**������Ϊ `ConcurrentHashMap<String, Object>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` �������� `spring bean`�����������ע�롢��ʼ���� bean����� bean ��Ҫ aop���洢�ľ��Ǵ������� |
+| `earlySingletonObjects`         | **��������**������Ϊ `HashMap<String, Object>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` ��ʵ������ɣ���δ��������ע��� `bean`��**��� `bean` ��Ҫ `aop`������洢�ľ��Ǵ�������ֻ�����������������е�ԭʼ����δ��������ע��** |
+| `singletonFactories`            | **��������**������Ϊ `HashMap<String, ObjectFactory>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` �洢����һ�� `lambda` ����ʽ��`() -> getEarlyBeanReference(beanName, mbd, bean)`��`getEarlyBeanReference(xxx)` �е� `bean` �Ǹմ�����ɵ� `java bean`��û�н��� spring ����ע�룬Ҳû���� aop |
+| `singletonsCurrentlyInCreation` | ����Ϊ `SetFromMap<String>`��λ�� `DefaultSingletonBeanRegistry`��������ʽΪ `Collections.newSetFromMap(new ConcurrentHashMap<>(16))`���������Ǹ��� `ConcurrentHashMap` ʵ�ֵ� set���洢�������ڴ����еĶ��󣬿���**�����жϵ�ǰ�����Ƿ��ڴ�����** |
+| `earlyProxyReferences`          | ����Ϊ `ConcurrentHashMap<Object, Object>`��λ�� `AbstractAutoProxyCreator`���洢������ǰ���� aop �Ķ��󣬿���**�����ж� bean �Ƿ���й� aop����֤ÿ������ֻ����һ�� aop** |
+
+���Ͼ��� spring ���ѭ�����������������ˡ�
+
+### 3\. ����ģ��
+
+����ʽ����Դ��ǰ����������ģ��ѭ������������Ĺ��̣��������£�
+
+```
+/**
+ * ׼��һ���࣬�ڲ���һ������ Obj2
+ */
+public class Obj1 {
+    // ��Ҫע�� obj2
+    private Obj2 obj2;
+
+    // ʡ����������
+    ...
+}
+
+/**
+ * ׼��һ���࣬�ڲ���һ������ Obj1
+ */
+public class Obj2 {
+    // ��Ҫע�� ob1
+    private Obj1 obj1;
+
+    // ʡ����������
+    ...
+
+}
+
+/**
+ * ׼��Obj2�Ĵ����࣬�ڲ�����obj2�Ķ���
+ */
+public class ProxyObj2 extends Obj2 {
+    // obj2�������ڲ�����obj2��ԭʼ����
+    private Obj2 obj2;
+
+    public ProxyObj2(Obj2 obj2) {
+        this.obj2 = obj2;
+    }
+
+    // ʡ����������
+    ...
+
+}
+
+/**
+ * ׼��Obj1�Ĵ����࣬�ڲ�����obj1�Ķ���
+ */
+public class ProxyObj1 extends Obj1 {
+    // obj2�������ڲ�����obj1��ԭʼ����
+    private Obj1 obj1;
+
+    public ProxyObj1(Obj1 obj1) {
+        this.obj1 = obj1;
+    }
+
+    // ʡ����������
+    ...
+
+}
+
+```
+
+*   ����׼���������ࣺ`Obj1` �� `Obj2`�� ���� `Obj1` �и�����Ϊ `Obj2`��`Obj2` ���и�����Ϊ `Obj1`��
+*   ����׼���� `Obj1` �� `Obj2` �Ĵ����� `ProxyObj1`��`ProxyObj2`������ `ProxyObj1`��`ProxyObj2` �ֱ���һ�����ԣ�`Obj1` �� `Obj2`��
+*   ���������� `new ObjX()` ģ�����Ĵ�����
+*   ���������� `objX.setObjX(xxx)` ģ������ע�룻
+*   ���������� `new ProxyObjX(xxx)` ģ�������������ɣ�
+*   ���������� `collection.add(xxx)` ģ��������ӵ������еĹ��̣�
+
+����ģ�����յõ��Ľ��Ϊ��
+
+*   ���շ��������Ķ���ֱ��� `proxyObj1`��`proxyObj2`
+*   ע�뵽 `obj1` �е��� `proxyObj2`��ע�뵽 `obj2` �е��� `proxyObj2`
+
+׼�������Ѿ�����ˣ����������ǾͿ�ʼ����ģ���ˡ�
+
+#### 3.1 ģ�� 1
+
+Ҫ��
+
+*   Obj1 �� Obj2 �����ϸ��� ������ --> ����ע�� --> ���ɴ������� --> ���浽�����С� �����̴���
+*   ��������Ĵ������̿��Խ������
+
+Ŀ�꣺
+
+*   ���շ��������Ķ���ֱ��� `proxyObj1`��`proxyObj2`
+*   ע�뵽 `obj1` �е��� `proxyObj2`��ע�뵽 `obj2` �е��� `proxyObj2`
+
+�������£�
+
+```
+public static main(String[] args) {
+     // ׼��һ�����������ﱣ�������������������ڵĶ���
+     // 1\. ���Ԫ����ԭʼ������ö����Ѿ����������ע�� 
+     // 2\. ���Ԫ���Ǵ���������ö�����е�ԭ�ж����Ѿ����������ע�� 
+     Collection<?> collection = new ArrayList();
+
+     // 1\. ���� Obj1 ����
+     Obj1 obj1 = new Obj1();
+
+     // ��������Ҫ��obj2�Ĵ�������ע�뵽obj1�У�����ʱ�����в�û��obj2�Ĵ������������л���obj2�Ĵ�������
+     // һ. ���� Obj2 ����
+     Obj2 obj2 = new Obj2();
+
+     // �����obj2��Ҫע��obj1�Ĵ������󣬵���ʱ�����в�û��obj2�Ĵ�������������Ҫ�е�obj1�Ĵ�������
+
+}
+
+```
+
+��ִ������������ �����ִ��� Obj2 ��������̾ͽ��в���ȥ�ˣ�
+
+*   `obj1` ��Ҫע�� `obj2` �Ĵ������󣬵��Ҳ����������л��� `obj2` �Ĵ������̣�
+*   `obj2` ��Ҫע�� `obj1` �Ĵ������󣬵��Ҳ����������л��� `obj1` �Ĵ������̣�
+*   `obj1` ��Ҫע�� `obj2` �Ĵ������󣬵��Ҳ����������л��� `obj2` �Ĵ������̣�
+*   ...
+
+���ѭ��������
+
+ģ������δ�ﵽԤ��Ŀ�꣬����ģ������ʧ�ܡ�
+
+#### 3.1 ģ�� 2
+
+Ҫ��
+
+*   Obj1 �� Obj2 ����������������֮һ������
+    *   ������ --> ����ע�� --> ���ɴ������� --> ���浽�����С� �����̴���
+    *   ������ (ԭʼ����)--> ���ɴ������� --> ��ԭʼ�����������ע�� --> ���������󱣴浽�����С� �����̴���
+*   ��������Ĵ������̿��Խ������
+
+Ŀ�꣺
+
+*   ���շ��������Ķ���ֱ��� `proxyObj1`��`proxyObj2`
+*   ע�뵽 `obj1` �е��� `proxyObj2`��ע�뵽 `obj2` �е��� `proxyObj2`
+
+ʾ���������£�
+
+```
+ public static main(String[] args) {
+      // ׼��һ�����������ﱣ�������������������ڵĶ���
+      // 1\. ���Ԫ����ԭʼ������ö����Ѿ����������ע�� 
+      // 2\. ���Ԫ���Ǵ���������ö�����е�ԭ�ж����Ѿ����������ע�� 
+      Collection<?> collection = new ArrayList();
+
+      // 1\. ���� Obj1 ����
+      Obj1 obj1 = new Obj1();
+
+      // ��������Ҫ��obj2�Ĵ�������ע�뵽obj1�У�����ʱ�����в�û��obj2�Ĵ������������л���obj2�Ĵ�������
+      // һ. ���� Obj2 ����
+      Obj2 obj2 = new Obj2();
+
+      // 2\. �� Obj1 ��ǰ����
+      ProxyObj1 proxyObj1 = new ProxyObj1(obj1);
+
+      // ��. �� proxyObj1 ע�뵽 obj2 ��
+      obj2.setObj1(proxyObj1);
+
+      // ��. ���� obj2�Ĵ�������
+      ProxyObj2 proxyObj2 = new ProxyObj2(obj2);
+
+      // ��. proxyObj2 �Ѿ��������������������ڣ��������������ӵ�����ʱ
+      collection.add(proxyObj2);
+
+      // ��ʱ�������Ѿ��� obj2 �Ĵ��������ˣ�����obj1����������
+      // 3\. �� proxyObj2 ע�뵽 obj1 ��
+      obj1.setObj2(proxyObj2);
+
+      // 4\. proxyObj1 �Ѿ��������������������ڣ��������������ӵ�����ʱ
+      collection.add(proxyObj1);
+ }
+
+```
+
+����Ĵ����У�obj1 �������� ��1��2��3��4�� ��ʶ��obj2 �������� ��һ�����������ġ� ��ʶ�������������£�
+
+*   obj1�������� (ԭʼ����)--> ���ɴ������� --> ��ԭʼ�����������ע�� --> ���������󱣴浽�����С�
+*   obj2�������� --> ����ע�� --> ���ɴ������� --> ���浽�����С�
+
+�������߶������������У��ﵽ��Ԥ�ڵ�Ŀ�ꡣ
+
+#### 3.3 ��ģ���еõ��Ľ���
+
+�Ա���������ģ����룬����ģ�� 2 ֮ �����ܴﵽԤ��Ŀ�꣬��Ҫ����Ϊ��ע�� `obj2` �� `obj1` ����ʱ����ǰ������ `obj1` �Ĵ������� `proxyObj1`��ʹ�� `obj2` ����������������̡������ٴ�֤�����ṩ���� aop ��ѭ�������Ľ����������Ҫ�����ã�
+
+����ƪ�������ľ��ȵ������ˣ�������Ҫ������ѭ�������IJ����������� spring ���ѭ�������IJ��裬���ͨ�����δ���ģ����ѭ�������Ľ������һƪ�������ǽ��� spring Դ����� spring ����ν��ѭ�������ġ�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4659555](https://my.oschina.net/funcy/blog/4659555) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
+
+ʾ���������£�
+
+```
+ public static main(String[] args) {
+      // ׼��һ�����������ﱣ�������������������ڵĶ���
+      // 1\. ���Ԫ����ԭʼ������ö����Ѿ����������ע�� 
+      // 2\. ���Ԫ���Ǵ���������ö�����е�ԭ�ж����Ѿ����������ע�� 
+      Collection<?> collection = new ArrayList();
+
+      // 1\. ���� Obj1 ����
+      Obj1 obj1 = new Obj1();
+
+      // ��������Ҫ��obj2�Ĵ�������ע�뵽obj1�У�����ʱ�����в�û��obj2�Ĵ������������л���obj2�Ĵ�������
+      // һ. ���� Obj2 ����
+      Obj2 obj2 = new Obj2();
+
+      // 2\. �� Obj1 ��ǰ����
+      ProxyObj1 proxyObj1 = new ProxyObj1(obj1);
+
+      // ��. �� proxyObj1 ע�뵽 obj2 ��
+      obj2.setObj1(proxyObj1);
+
+      // ��. ���� obj2�Ĵ�������
+      ProxyObj2 proxyObj2 = new ProxyObj2(obj2);
+
+      // ��. proxyObj2 �Ѿ��������������������ڣ��������������ӵ�����ʱ
+      collection.add(proxyObj2);
+
+      // ��ʱ�������Ѿ��� obj2 �Ĵ��������ˣ�����obj1����������
+      // 3\. �� proxyObj2 ע�뵽 obj1 ��
+      obj1.setObj2(proxyObj2);
+
+      // 4\. proxyObj1 �Ѿ��������������������ڣ��������������ӵ�����ʱ
+      collection.add(proxyObj1);
+ }
+
+```
+
+����Ĵ����У�obj1 �������� ��1��2��3��4�� ��ʶ��obj2 �������� ��һ�����������ġ� ��ʶ�������������£�
+
+*   obj1�������� (ԭʼ����)--> ���ɴ������� --> ��ԭʼ�����������ע�� --> ���������󱣴浽�����С�
+*   obj2�������� --> ����ע�� --> ���ɴ������� --> ���浽�����С�
+
+�������߶������������У��ﵽ��Ԥ�ڵ�Ŀ�ꡣ
+
+#### 3.3 ��ģ���еõ��Ľ���
+
+�Ա���������ģ����룬����ģ�� 2 ֮ �����ܴﵽԤ��Ŀ�꣬��Ҫ����Ϊ��ע�� `obj2` �� `obj1` ����ʱ����ǰ������ `obj1` �Ĵ������� `proxyObj1`��ʹ�� `obj2` ����������������̡������ٴ�֤�����ṩ���� aop ��ѭ�������Ľ����������Ҫ�����ã�
+
+����ƪ�������ľ��ȵ������ˣ�������Ҫ������ѭ�������IJ����������� spring ���ѭ�������IJ��裬���ͨ�����δ���ģ����ѭ�������Ľ������һƪ�������ǽ��� spring Դ����� spring ����ν��ѭ�������ġ�
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4659555](https://my.oschina.net/funcy/blog/4659555) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213\345\276\252\347\216\257\344\276\235\350\265\226\347\232\204\350\247\243\345\206\263\357\274\210\344\272\214\357\274\211\357\274\232\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213\345\276\252\347\216\257\344\276\235\350\265\226\347\232\204\350\247\243\345\206\263\357\274\210\344\272\214\357\274\211\357\274\232\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..06fe618
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213\345\276\252\347\216\257\344\276\235\350\265\226\347\232\204\350\247\243\345\206\263\357\274\210\344\272\214\357\274\211\357\274\232\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,1123 @@
+�� [spring ̽��֮ѭ��������һ�������ۻ�ʯ](https://my.oschina.net/funcy/blog/4659555 "spring̽��֮ѭ��������һ�������ۻ�ʯ")һ���� �������ᵽ spring ���ѭ����������������:
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-dc325a87b321e4c246a1b2f14169821a75a.png)
+
+Ϊ����������������˳�����У�spring �����ṩ�� 5 �����ݽṹ�����������в����Ĺؼ���Ϣ���� 5 �����ݽṹ���£����Ľ��� 5 �����ݽṹ��Ϊ **5 ��ṹ**����
+
+| �ṹ                            | ˵��                                                         |
+| ------------------------------- | ------------------------------------------------------------ |
+| `singletonObjects`              | **һ������**������Ϊ `ConcurrentHashMap<String, Object>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` �������� `spring bean`�����������ע�롢��ʼ���� bean����� bean ��Ҫ aop���洢�ľ��Ǵ������� |
+| `earlySingletonObjects`         | **��������**������Ϊ `HashMap<String, Object>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` ��ʵ������ɣ���δ��������ע��� `bean`��**��� `bean` ��Ҫ `aop`������洢�ľ��Ǵ�������ֻ�����������������е�ԭʼ����δ��������ע��** |
+| `singletonFactories`            | **��������**������Ϊ `HashMap<String, ObjectFactory>`��λ�� `DefaultSingletonBeanRegistry` ���У�`key` Ϊ `beanName`��`value` �洢����һ�� `lambda` ����ʽ��`() -> getEarlyBeanReference(beanName, mbd, bean)`��`getEarlyBeanReference(xxx)` �е� `bean` �Ǹմ�����ɵ� `java bean`��û�н��� spring ����ע�룬Ҳû���� aop |
+| `singletonsCurrentlyInCreation` | ����Ϊ `SetFromMap<String>`��λ�� `DefaultSingletonBeanRegistry`��������ʽΪ `Collections.newSetFromMap(new ConcurrentHashMap<>(16))`���������Ǹ��� `ConcurrentHashMap` ʵ�ֵ� set���洢�������ڴ����еĶ��󣬿���**�����жϵ�ǰ�����Ƿ��ڴ�����** |
+| `earlyProxyReferences`          | ����Ϊ `ConcurrentHashMap<Object, Object>`��λ�� `AbstractAutoProxyCreator`���洢������ǰ���� aop �Ķ��󣬿���**�����ж� bean �Ƿ���й� aop����֤ÿ������ֻ����һ�� aop** |
+
+�˽�����Щ֮�󣬽��������Ǿ���ʽ��ʼ����Դ������ˡ�
+
+### 1\. ׼�� demo
+
+�����е�ʾ�� demo λ�� [gitee.com/funcy](https://gitee.com/funcy/spring-framework/tree/v5.2.2.RELEASE_learn/spring-learn/src/main/java/org/springframework/learn/explore/demo03 "gitee.com/funcy")������������ؼ����롣
+
+׼������ service��service1��service2�������� service �ﶼ��һ������������
+
+```
+@Service
+public class Service1 {
+
+    @Autowired
+    private Service2 service2;
+
+    public Service1() {
+        System.out.println("����service1�Ĺ��췽��");
+    }
+
+    /**
+     * ��ע @AopAnnotation �ˣ������������Ҫ������
+     */
+    @AopAnnotation
+    public void printAutowired() {
+        System.out.println("Service1 Autowired:" + service2.getClass());
+    }
+
+    @Override
+    public String toString() {
+        return "Service1:" + getClass();
+    }
+}
+
+@Component
+public class Service2 {
+
+    @Autowired
+    private Service1 service1;
+
+    public Service2() {
+        System.out.println("����service2�Ĺ��췽��");
+    }
+
+    /**
+     * ��ע @AopAnnotation �ˣ������������Ҫ������
+     */
+    @AopAnnotation
+    public void printAutowired() {
+        System.out.println("Service2 Autowired:" + service1.getClass());
+    }
+
+    @Override
+    public String toString() {
+        return "Service2:" + this.getClass();
+    }
+}
+
+```
+
+���������ࣺ
+
+```
+public class Demo03Main {
+
+    public static void main(String[] args) {
+        ApplicationContext context = 
+                new AnnotationConfigApplicationContext(AopAnnotationConfig.class);
+        Object obj1 = context.getBean("service1");
+        Object obj2 = context.getBean("service2");
+        ((Service1)obj1).printAutowired();
+        ((Service2)obj2).printAutowired();
+    }
+}
+
+```
+
+�� `Service1` �У���Ҫע������ `service2`������ `Service2` �У���Ҫע������ `service1`���� `Service1`��`Service2` ����Ҫ���д��������� `main()` ����ִ�н�����£�
+
+```
+����service1�Ĺ��췽��
+����service2�Ĺ��췽��
+Disconnected from the target VM, address: 'localhost:55518', transport: 'socket'
+Connected to the target VM, address: '127.0.0.1:55507', transport: 'socket'
+@Around: before execute...
+Service1 Autowired:class org.springframework.learn.explore.demo03.Service2$$EnhancerBySpringCGLIB$$e7e367ab
+@Around: after execute...
+@Around: before execute...
+Service2 Autowired:class org.springframework.learn.explore.demo03.Service1$$EnhancerBySpringCGLIB$$d447df08
+@Around: after execute...
+
+```
+
+�õ��� obj1��obj2 �ֱ�Ϊ
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-201844d13a7b489d1a18a8218d6440d6068.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-3781280ce3f4da91504b0665ebfd3aed05b.png)
+
+�������ݣ����ѵó����½��ۣ�
+
+*   `service1` �� `service2` �� `printAutowired()` ��������������淽�������ݣ��������߶������ɹ��ˣ�
+*   �������л�ȡ�ĵ� `service1` �� `service2` ���Ǵ�������
+*   `service1` �Ĵ���������� `service1` ��ԭʼ����`service2` �Ĵ���������� `service2` ��ԭʼ����
+*   `service1` ��ԭʼ������ע��� `service2` Ϊ��������`service2` ��ԭʼ������ע��� `service1` Ϊ��������
+
+�����������Ǿʹ�Դ��������� spring �����һ�������У����յõ��������ġ�
+
+> `service1` �� `service2` �Ĵ����������� `cglib` ���������ģ��ⲿ�������뱾���޹أ��Ͳ������ˡ�
+
+### 2\. ��һ�ε��� `AbstractBeanFactory#getBean(String)`����ȡ `service1`
+
+spring bean �Ĵ���������ע�������Ǵ� `AbstractBeanFactory#getBean(String)` ������ʼ����һ��ɲο� [spring ��������֮��� BeanFactory �ij�ʼ��](https://my.oschina.net/funcy/blog/4658230)�����ǵ�Դ�����Ҳ������������֡�
+
+����һ��ʼ�����ᵽ�� spring Ϊ���ѭ�������� 5 ��ṹ������չʾ���£�
+
+| �ṹ                            | ���� |
+| ------------------------------- | ---- |
+| `singletonObjects`              |      |
+| `earlySingletonObjects`         |      |
+| `singletonFactories`            |      |
+| `singletonsCurrentlyInCreation` |      |
+| `earlyProxyReferences`          |      |
+
+һ��ʼ��5 ��ṹ�й��� `service1` �� `service2` ��ʲô���ݶ�û�� ��������������һ�߷������룬һ�߹�ע�⼸���ṹ�е����ݡ�
+
+> ��ʵ�ϣ�5 ��ṹ�������ݵģ����� spring �ڲ��ṩ��һЩ bean������������ֻ��ע `service1` �� `service2` ��ص����ݣ�������ﲻչʾ��
+
+### 2.1 `AbstractBeanFactory#doGetBean`
+
+��ȡ `service1` �Ĵ����� `AbstractBeanFactory#getBean(String)`���������Ļ�ȡ����ȴ���� `AbstractBeanFactory#doGetBean` �У����������£�
+
+```
+|-AbstractBeanFactory#getBean(String)
+ |-AbstractBeanFactory#doGetBean
+
+```
+
+�������£�
+
+```
+    protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
+            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
+
+        ...
+        // 1\. ����Ƿ��ѳ�ʼ����������beanName����singletonsCurrentlyInCreation��
+        Object sharedInstance = getSingleton(beanName);
+        ...
+        // ����ǵ�����
+        if (mbd.isSingleton()) {
+            // 2\. getSingleton(): ��������ɾ��������������
+            sharedInstance = getSingleton(beanName, () -> {
+                try {
+                    // ִ�д��� Bean
+                    return createBean(beanName, mbd, args);
+                }
+                catch (BeansException ex) {
+                    destroySingleton(beanName);
+                    throw ex;
+                }
+            });
+            // �����������ͨBean �Ļ���ֱ�ӷ��أ������ FactoryBean �Ļ���
+            // �������������Ǹ�ʵ������
+            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
+        }
+        ...
+    }
+
+```
+
+���ϴ��뾭���˾�������ֻ��������Ҫ���̣����������У�Ҳ�ᾫ����룬ֻ������Ҫ���̣�ʡ���޹ش��룩����������������ط���Ҫ������
+
+1.  `getSingleton(beanName)`����ȡ����ֻ�����������л�ȡ��
+2.  `getSingleton(beanName, () -> { ... })`����ȡ���󣬴����������ﴴ����
+
+#### 2.2 `DefaultSingletonBeanRegistry#getSingleton(String, boolean)`
+
+������������ `getSingleton(beanName)`�����������£�
+
+```
+|-AbstractBeanFactory#getBean(String)
+ |-AbstractBeanFactory#doGetBean
+  |-DefaultSingletonBeanRegistry#getSingleton(String)
+   |-DefaultSingletonBeanRegistry#getSingleton(String, boolean)
+
+```
+
+ֱ�ӿ����룺
+
+```
+/*
+ * beanName: �����ֵΪ service1
+ * allowEarlyReference�������ֵΪ true
+ */
+protected Object getSingleton(String beanName, boolean allowEarlyReference) {
+    // 1\. ��һ�������л�ȡ�������ǻ�ȡ����
+    Object singletonObject = this.singletonObjects.get(beanName);
+    // 2\. isSingletonCurrentlyInCreation(...) �ж�service1�Ƿ��ڴ����У����� false
+    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
+        // ʡ������Ĵ���
+        ...
+    }
+    return singletonObject;
+}
+
+```
+
+����������������£�
+
+1. �����������л�ȡ����ʱ `singletonObjects` �ﲢû�� `service1`����ȡ������
+
+2. �������ж� `service1` �Ƿ��ڴ����У��жϷ�ʽ���£�
+
+   ```
+   public boolean isSingletonCurrentlyInCreation(String beanName) {
+       return this.singletonsCurrentlyInCreation.contains(beanName);
+   }
+   
+   ```
+
+   ��Ȼ��`singletonsCurrentlyInCreation` ��û�� `service1` �ģ�����Ҳ���� false.
+
+`DefaultSingletonBeanRegistry#getSingleton(String, boolean)` ���е�����ͷ����ˣ��������������ķ������Ǿ��Ȳ������ˡ�
+
+#### 2.3 `DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)`
+
+�����ǻص� `AbstractBeanFactory#doGetBean`�����ŷ��� `getSingleton(beanName, () -> { ... })`���������£�
+
+```
+    /**
+     * beanName���������service1
+     * singletonFactory���������lambda����ʽ��ֵΪ
+     *           () -> {
+     *               try {
+     *                   // ������Ǵ���bean������
+     *                   return createBean(beanName, mbd, args);
+     *               }
+     *               catch (BeansException ex) {
+     *                   destroySingleton(beanName);
+     *                   throw ex;
+     *               }
+     *           }
+     */
+    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
+        Assert.notNull(beanName, "Bean name must not be null");
+        synchronized (this.singletonObjects) {
+            // �ٴ��ж�bean�Ƿ��Ѵ���
+            Object singletonObject = this.singletonObjects.get(beanName);
+            if (singletonObject == null) {
+                // 1\. �жϵ�ǰ����ʵ������bean�Ƿ�������ڴ�����
+                // ���������beanName���ӵ� singletonsCurrentlyInCreation ��
+                beforeSingletonCreation(beanName);
+                try {
+                    // 2\. ���������bean�Ĵ���
+                    singletonObject = singletonFactory.getObject();
+                }
+                catch (...) {
+                    ...
+                }
+                ...
+            }
+            return singletonObject;
+        }
+    }
+
+```
+
+���մ����е�ע�����ݣ����Ƿ�����Ҫ���裺
+
+1. �жϵ�ǰ����ʵ������ bean �Ƿ�������ڴ����У������жϵ�ǰ�����Ƿ��� `singletonsCurrentlyInCreation` �У�����������׳��쳣�������������ӵ� `singletonsCurrentlyInCreation` �У�
+
+   ������֮����һ�д����5 ��ṹ�е��������£�
+
+   | �ṹ                            | ����     |
+      | ------------------------------- | -------- |
+   | `singletonObjects`              |          |
+   | `earlySingletonObjects`         |          |
+   | `singletonFactories`            |          |
+   | `singletonsCurrentlyInCreation` | service1 |
+   | `earlyProxyReferences`          |          |
+
+2. ���� bean �Ĵ������̣�`singletonFactory.getObject()` ���е�ʵ�����Ǵ���� lambda ����ʽ��
+
+   ```
+   () -> {
+       try {
+           // ִ�д��� Bean
+           return createBean(beanName, mbd, args);
+       }
+       catch (BeansException ex) {
+           destroySingleton(beanName);
+           throw ex;
+       }
+   }
+   
+   ```
+
+   Ҳ���� `AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])`���� �������ǽ������������ص㣻
+
+#### 2.4 `AbstractAutowireCapableBeanFactory#doCreateBean`
+
+�Ӵ�����������`AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])` ��û����ʲôʵ�������ݣ����Ǿ�ֱ������ `AbstractAutowireCapableBeanFactory#doCreateBean` �ˣ������о�����ǧɽ��ˮ���£�
+
+```
+|-AbstractBeanFactory#getBean(String)
+ |-AbstractBeanFactory#doGetBean
+  |-DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)
+   |-AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])
+    |-AbstractAutowireCapableBeanFactory#doCreateBean
+
+```
+
+`AbstractAutowireCapableBeanFactory#doCreateBean` �������£�
+
+```
+protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, 
+        final @Nullable Object[] args) throws BeanCreationException {
+
+    BeanWrapper instanceWrapper = null;
+    if (instanceWrapper == null) {
+        // 1\. ʵ���� Bean������java�������ʵ����
+        instanceWrapper = createBeanInstance(beanName, mbd, args);
+    }
+    //beanʵ��
+    final Object bean = instanceWrapper.getWrappedInstance();
+    //bean����
+    Class<?> beanType = instanceWrapper.getWrappedClass();
+    if (beanType != NullBean.class) {
+        mbd.resolvedTargetType = beanType;
+    }
+
+    synchronized (mbd.postProcessingLock) {
+        if (!mbd.postProcessed) {
+            try {
+                // ���� AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition ����
+                // 2\. ��ȡ��Ҫע��������뷽������ע @Autowired ע�⣩
+                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
+            }
+            catch (Throwable ex) {
+                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
+                        "Post-processing of merged bean definition failed", ex);
+            }
+            mbd.postProcessed = true;
+        }
+    }
+    // ���ѭ����������, �Ƿ�����ѭ������, allowCircularReferencesĬ��Ϊtrue�����Թر�
+    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
+            isSingletonCurrentlyInCreation(beanName));
+    if (earlySingletonExposure) {
+        // 3\. �� bean ���ӵ� singletonFactories
+        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
+    }
+
+    Object exposedObject = bean;
+    try {
+        // 4\. ����ע�룬������Ҫע�� service2��Ȼ���ٵ��� getBean("service2")
+        populateBean(beanName, mbd, instanceWrapper);
+        ...
+    }
+    catch (Throwable ex) {
+        ...
+    }
+}
+
+```
+
+����������еIJ������£�
+
+1. ʵ���� Bean������ java �������ʵ����������Ͳ���˵�ˣ�ʵ������� `service1` ���£����Կ��� `service2` ���� `null`������δ��������ע�룩��
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-8b2f5fdf0efd6beb7f62d4f35f5c5562b83.png)
+
+2. ��ȡ��Ҫע��������뷽����**������ԭʼ�����в��ܻ�ȡ�������������ǻ�ȡ������**������ `@Autowired` �� `beanPostProcessor` �� `AutowiredAnnotationBeanPostProcessor`��
+
+3. �� bean ���ӵ� `singletonFactories` �У����ӹ������£�
+
+   ```
+   protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
+       Assert.notNull(singletonFactory, "Singleton factory must not be null");
+       synchronized (this.singletonObjects) {
+           // ��������ص��в����ڲŻ�add
+           if (!this.singletonObjects.containsKey(beanName)) {
+               // �ѹ�������put��singletonFactories
+               this.singletonFactories.put(beanName, singletonFactory);
+               // ɾ�����������еĶ���
+               this.earlySingletonObjects.remove(beanName);
+               this.registeredSingletons.add(beanName);
+           }
+       }
+   }
+   
+   ```
+
+   ����Ķ���Ϊ
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-3d9a56a0d655fe1e95d8857095fb46aa71a.png)
+
+   ��ʱ�� 5 ���ṹ�е��������£�
+
+   | �ṹ                            | ����             |
+      | ------------------------------- | ---------------- |
+   | `singletonObjects`              |                  |
+   | `earlySingletonObjects`         |                  |
+   | `singletonFactories`            | lambda(service1) |
+   | `singletonsCurrentlyInCreation` | service1         |
+   | `earlyProxyReferences`          |                  |
+
+   `lambda(service1)` ʵ������Ϊ `() -> getEarlyBeanReference(beanName, mbd, bean)`����� `lambda` ����ʽ�����ľ��ǽ��� aop �������������ݵ����е�ʱ�������ٷ�����
+
+4. ����ע�룬�ڵ� 2 ���У�spring �ҵ� `service1` ��Ҫע������� `service2`��������ٵ��� `beanFactory.getBean("service2")` ���� `service2` ���������ڣ����ֻص��� `AbstractBeanFactory#getBean(String)` ������
+
+   �� `populateBean(xxx)` �� `getBean(xxx)` �IJ����൱�࣬���������£�
+
+   ```
+   |-AbstractBeanFactory#getBean(String)
+    |-AbstractBeanFactory#doGetBean
+     |-DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)
+      |-AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])
+       |-AbstractAutowireCapableBeanFactory#doCreateBean
+        // �����������ע��
+        |-AbstractAutowireCapableBeanFactory#populateBean
+         |-AutowiredAnnotationBeanPostProcessor#postProcessProperties
+          |-InjectionMetadata#inject
+           |-AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
+            |-DefaultListableBeanFactory#resolveDependency
+             |-DefaultListableBeanFactory#doResolveDependency
+              |-DependencyDescriptor#resolveCandidate
+               |-AbstractBeanFactory#getBean(String)
+   
+   ```
+
+   ��һ�� `DependencyDescriptor#resolveCandidate`�����õ����� `beanFactory.getBean(String)` ������
+
+   ```
+   public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
+           throws BeansException {
+       return beanFactory.getBean(beanName);
+   }
+   
+   ```
+
+�������`service1` �Ļ�ȡ���̾���ͣһ�£���Ϊ `service1` Ҫע�� `service2`���������Ϳ�ʼ��ȡ `service2` �����̡�
+
+��С�ڽ���ʱ��5 ��ṹ�е��������£�
+
+| �ṹ                            | ����             |
+| ------------------------------- | ---------------- |
+| `singletonObjects`              |                  |
+| `earlySingletonObjects`         |                  |
+| `singletonFactories`            | lambda(service1) |
+| `singletonsCurrentlyInCreation` | service1         |
+| `earlyProxyReferences`          |                  |
+
+### 3\. �ڶ��ε��� `AbstractBeanFactory#getBean(String)`����ȡ `service2`
+
+#### 3.1 `AbstractBeanFactory#doGetBean`
+
+��һ������ȡ `service1` �����̻���һ�£���ͬ���� `beanName` �� `service2`�����ٷ�����
+
+#### 3.2 `DefaultSingletonBeanRegistry#getSingleton(String, boolean)`
+
+��һ������ȡ `service1` �����̻���һ�£���ͬ���� `beanName` �� `service2`�����ٷ�����
+
+#### 3.3 `DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)`
+
+��һ������ȡ `service1` �����̻���һ�£���ͬ���� `beanName` �� `service2`���������ݲ��ٷ�����
+
+`service2` ������һ������ �� `singletonsCurrentlyInCreation` �ṹ�У���һ��֮��5 ��ṹ�е��������£�
+
+| �ṹ                            | ����               |
+| ------------------------------- | ------------------ |
+| `singletonObjects`              |                    |
+| `earlySingletonObjects`         |                    |
+| `singletonFactories`            | lambda(service1)   |
+| `singletonsCurrentlyInCreation` | service1, service2 |
+| `earlyProxyReferences`          |                    |
+
+#### 3.4 `AbstractAutowireCapableBeanFactory#doCreateBean`
+
+��һ������ȡ `service1` �����̻���һ�£�˵�����£�
+
+1. ���󴴽�������ᴴ�� `service2`��������ɺ�Ķ������£�
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-393811afa91cc1ff696b02ce6d683c97640.png)
+
+   ͬ���ģ�`service2` �е����� `service1` ҲΪ `null`��
+
+2. ��ȡ��Ҫע��������뷽����`service2` ������ `service1` �ᱻ�ҵ�����Ϊ�����Ա�ע�� `@Autowired` ע�⣻
+
+3. �� bean ���ӵ� `singletonFactories` �У���һ��֮��5 ���ṹ�е��������£�
+
+   | �ṹ                            | ����                               |
+      | ------------------------------- | ---------------------------------- |
+   | `singletonObjects`              |                                    |
+   | `earlySingletonObjects`         |                                    |
+   | `singletonFactories`            | lambda(service1), lambda(service2) |
+   | `singletonsCurrentlyInCreation` | service1, service2                 |
+   | `earlyProxyReferences`          |                                    |
+
+   ��һ���Ĺؼ����ڣ�`service2` ���ӵ������������ˣ�
+
+4. ����ע�룬�ڵ� 2 ���У�spring �ҵ� `service2` ��Ҫע������� `service1`��������ٵ��� `getBean("service2")` �������ֻص��� `AbstractBeanFactory#getBean(String)` �����ˡ�
+
+�������`service2` �Ļ�ȡ����ҲҪ��ͣһ���ˣ���Ϊ `service2` Ҫע�� `service1`����������Ҫ��ʼ��ȡ `service1` �����̡�
+
+��С�ڽ���ʱ��5 ���ṹ�е��������£�
+
+| �ṹ                            | ����                               |
+| ------------------------------- | ---------------------------------- |
+| `singletonObjects`              |                                    |
+| `earlySingletonObjects`         |                                    |
+| `singletonFactories`            | lambda(service1), lambda(service2) |
+| `singletonsCurrentlyInCreation` | service1, service2                 |
+| `earlyProxyReferences`          |                                    |
+
+### 4\. �����ε��� `AbstractBeanFactory#getBean(String)`���ٴλ�ȡ `service1`
+
+#### 4.1 `AbstractBeanFactory#doGetBean`
+
+`AbstractBeanFactory#doGetBean` �������£�
+
+```
+    protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
+            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
+
+        ...
+        // 1\. ����Ƿ��ѳ�ʼ����������beanName����singletonsCurrentlyInCreation��
+        Object sharedInstance = getSingleton(beanName);
+        ...
+}
+
+```
+
+�����е� `Object sharedInstance = getSingleton(beanName)` ǰ��`AbstractBeanFactory#doGetBean` ������������ǰ����С���������� `Object sharedInstance = getSingleton(beanName)` ������˱仯������������������ `getSingleton(beanName)` ��ִ�С�
+
+#### 4.2 `DefaultSingletonBeanRegistry#getSingleton(String, boolean)`
+
+```
+/*
+ * beanName: �����ֵΪ service1
+ * allowEarlyReference�������ֵΪ true
+ */
+protected Object getSingleton(String beanName, boolean allowEarlyReference) {
+    // 1\. ��һ�������л�ȡ�������ǻ�ȡ����
+    Object singletonObject = this.singletonObjects.get(beanName);
+    // 2\. isSingletonCurrentlyInCreation(...) �ж�service1�Ƿ��ڴ����У����� true
+    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
+            synchronized (this.singletonObjects) {
+                // 3\. �Ӷ��������л�ȡ������Ҳ��ȡ����
+                singletonObject = this.earlySingletonObjects.get(beanName);
+                // 4\. �����allowEarlyReference��true������ִ�����������
+                if (singletonObject == null && allowEarlyReference) {
+                    // 5\. �����������л�ȡ���ܻ�ȡ��
+                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
+                    if (singletonFactory != null) {
+                        // 6\. ���� singletonFactory.getObject()
+                        // ���յ��õ��� AbstractAutowireCapableBeanFactory.getEarlyBeanReference ����
+                        singletonObject = singletonFactory.getObject();
+                        // 7\. ��������
+                        // �ŵ�����������
+                        this.earlySingletonObjects.put(beanName, singletonObject);
+                        // ���������������
+                        this.singletonFactories.remove(beanName);
+                    }
+                }
+            }
+    }
+    return singletonObject;
+}
+
+```
+
+�ڷ�������ǰ������������ʱ 5 ��ṹ�е����ݣ�
+
+| �ṹ                            | ����                               |
+| ------------------------------- | ---------------------------------- |
+| `singletonObjects`              |                                    |
+| `earlySingletonObjects`         |                                    |
+| `singletonFactories`            | lambda(service1), lambda(service2) |
+| `singletonsCurrentlyInCreation` | service1, service2                 |
+| `earlyProxyReferences`          |                                    |
+
+��������������ݣ��������£�
+
+1. ��һ�������л�ȡ�������� 5 ���ṹ�е����ݣ���ȡ���������� `null`;
+
+2. `isSingletonCurrentlyInCreation(...)` �ж� `service1` �Ƿ��ڴ����У������� 5 ���ṹ�е����ݣ�`service1` �� `singletonsCurrentlyInCreation` �У����� true��������������̣�**�������һ�λ�ȡ `service1` �IJ�֮ͬ��**��
+
+3. �����Ӷ��������л�ȡ�������� 5 ���ṹ�е����ݣ�`service1` ���� `earlySingletonObjects`����Ȼ���� `null`��
+
+4. `allowEarlyReference` �Ǵ���IJ�����Ϊ `true`������ִ�� ����Ĵ��룻
+
+5. �����Ӵ����������л�ȡ�������� 5 ���ṹ�е����ݣ�`service1` �� `singletonFactories` �У������ܻ�ȡ�������صĽ�����£�
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-57677e20855580e5bc2f5163d87ecfda7d2.png)
+
+6. ���� `singletonFactory.getObject()` �������������Ǵ��� `singletonFactories` �Ļ��Ǹ� lambda ����ʽ��`() -> getEarlyBeanReference(beanName, mbd, bean)`������ `singletonFactory.getObject()` ���յ��õľ��� `AbstractAutowireCapableBeanFactory#getEarlyBeanReference`��
+
+   ```
+   protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
+       Object exposedObject = bean;
+       if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
+           for (BeanPostProcessor bp : getBeanPostProcessors()) {
+               if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
+                   // ���ú��ô����������������aop����
+                   SmartInstantiationAwareBeanPostProcessor ibp = 
+                         (SmartInstantiationAwareBeanPostProcessor) bp;
+                   // ���� `AbstractAutoProxyCreator#getEarlyBeanReference`����ǰ���� aop
+                   exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
+               }
+           }
+       }
+       return exposedObject;
+   }
+   
+   ```
+
+   ���Ǹ��� `AbstractAutoProxyCreator#getEarlyBeanReference` ������
+
+   ```
+   public Object getEarlyBeanReference(Object bean, String beanName) {
+       Object cacheKey = getCacheKey(bean.getClass(), beanName);
+       this.earlyProxyReferences.put(cacheKey, bean);
+       // �������ɴ�������
+       return wrapIfNecessary(bean, beanName, cacheKey);
+   }
+   
+   ```
+
+   ���� aop �����̣��ɲο� [spring aop ֮ AnnotationAwareAspectJAutoProxyCreator �������£�](https://my.oschina.net/funcy/blog/4687961)������Ͳ��ٷ����ˡ�ִ���� `AbstractAutoProxyCreator#getEarlyBeanReference` ֮��5 ���ṹ�е��������£�
+
+   | �ṹ                            | ����                               |
+      | ------------------------------- | ---------------------------------- |
+   | `singletonObjects`              |                                    |
+   | `earlySingletonObjects`         |                                    |
+   | `singletonFactories`            | lambda(service1), lambda(service2) |
+   | `singletonsCurrentlyInCreation` | service1, service2                 |
+   | `earlyProxyReferences`          | service1                           |
+
+   �������ٻص� `getSingleton` ������ִ���� `singletonFactory.getObject()` �󣬵õ��� `singletonObject` Ϊ
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-cf72a8ff3d91c3d2a4e300741ba7f0268e6.png)
+
+   ����һ���������󣬲��� `service2` Ϊ `null`��
+
+7. ���������Ǵ��������ˣ�һЩ map �� put �� remove �������Ͳ���˵�ˡ�
+
+`DefaultSingletonBeanRegistry#getSingleton(String, boolean)` ����ִ����ɺ�5 ���ṹ�е��������£�
+
+| �ṹ                            | ����               |
+| ------------------------------- | ------------------ |
+| `singletonObjects`              |                    |
+| `earlySingletonObjects`         | service1           |
+| `singletonFactories`            | lambda(service2)   |
+| `singletonsCurrentlyInCreation` | service1, service2 |
+| `earlyProxyReferences`          | service1           |
+
+#### 4.3 �ٴλص� `AbstractBeanFactory#doGetBean`
+
+ִ���� `DefaultSingletonBeanRegistry#getSingleton(String, boolean)` �������ٻص� `AbstractBeanFactory#doGetBean`��
+
+```
+protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
+        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
+    ...
+
+    // ����Ƿ��ѳ�ʼ��
+    Object sharedInstance = getSingleton(beanName);
+
+    // 1\. ����ܻ�ȡ������if ����Ĵ����ִ��
+    if (sharedInstance != null && args == null) {
+        // 2\. �����������ͨBean �Ļ���ֱ�ӷ��أ������ FactoryBean �Ļ����������������Ǹ�ʵ������
+        // �����bean��service1�Ĵ�������
+        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
+    } else {
+        // ����Ĵ��벻��ִ�е����Ͳ�������
+        ...
+    }
+
+    // ����bean��ת�����������ﷵ��false������ִ�е�
+    if (requiredType != null && !requiredType.isInstance(bean)) {
+    ...
+    }
+
+    // 3\. ���ش�`getSingleton(beanName)`�õ��Ķ���
+    return bean;
+
+}
+
+```
+
+1. ����ܻ�ȡ������if ����Ĵ����ִ�У�
+
+2. `service1` ���� `FactoryBean`���� `getSingleton(beanName)` �õ��Ķ�����ͬһ�������������£�
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-0cd9c129bf2387d85a7bee4f4e135143f63.png)
+
+3. ���ش� `getSingleton(beanName)` �õ��Ķ����� `getSingleton(beanName)` �з��صĶ���Ϊ�պ󣬾Ͳ���ִ�� bean �Ĵ��������ˣ����շ��ص��ǵ� 2 ���еõ��� bean �ˡ�
+
+��������������ڻ�ȡ���� `service1` �Ĵ������󣬾��ܴ��������Ӧ��ԭʼ����û���������ע�룬��������Ȼ���Խ��к��������̣�����ȡ�� `service1` �Ĵ��������`service2` �Ϳ��Խ�������ע�룬�����������������ˡ�
+
+�������������������ִ����֮��5 ��ṹ�е����ݣ�
+
+| �ṹ                            | ����                            |
+| ------------------------------- | ------------------------------- |
+| `singletonObjects`              |                                 |
+| `earlySingletonObjects`         | service1$$EnhancerBySpringCGLIB |
+| `singletonFactories`            | lambda(service2)                |
+| `singletonsCurrentlyInCreation` | service1, service2              |
+| `earlyProxyReferences`          | service1                        |
+
+��ȡ�� `service1` �󣬽������ͼ��� `service2` �Ļ�ȡ�����ˡ�
+
+### 5 ���� `service2` �Ļ�ȡ����
+
+�ڵ� 3 ���У���Ϊ `service2` ��Ҫע�� `service1`�������˵� 4 ���ֵ��ٴλ�ȡ `service1` �����̣�����Ҳ�ɹ��ػ�ȡ���� `service1` �Ĵ������� `service1$$EnhancerBySpringCGLIB`������� `service2` �����������ע�롣
+
+������������������ �� 3 �� �����̣��ص� `AbstractAutowireCapableBeanFactory#doCreateBean`������ `service2` �����̡�
+
+#### 5.1 �ص� `AbstractAutowireCapableBeanFactory#doCreateBean`
+
+�������£�
+
+```
+protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, 
+            final @Nullable Object[] args) throws BeanCreationException {
+
+        // ����Ĵ����� 3.2 ���Ѿ��������ˣ��Ͳ��ٷ�����
+        ...
+
+        Object exposedObject = bean;
+        try {
+            // 1\. ��������װ��, Ҳ�������dz���˵������ע��
+            populateBean(beanName, mbd, instanceWrapper);
+            // 2\. ��ʼ����������ᴦ�� aop ����
+            exposedObject = initializeBean(beanName, exposedObject, mbd);
+        }
+        catch (Throwable ex) {
+            ...
+        }
+
+        //ͬ���ģ��������ѭ������
+        if (earlySingletonExposure) {
+            // 3\. �ӻ����л�ȡ beanName ��Ӧ��bean
+            Object earlySingletonReference = getSingleton(beanName, false);
+            // 4\. earlySingletonReference Ϊ null��if ��������ݲ���ִ��
+            if (earlySingletonReference != null) {
+                ...
+            }
+        }
+
+        // ʡ�Բ���Ҫ�Ĵ���
+        ...
+
+        return exposedObject;
+    }
+
+```
+
+����˵�����£�
+
+1. ��������ע�룬�������ﴥ���˵� 4 ���ֵ����̣�ִ����õ��� `service2` ���£�
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-b294a02be5431c0aa66e5f126a6c6abbb92.png)
+
+   ���Կ�������ʱע�뵽 `service2` �е� `service1` ���Ǵ��������ˣ�
+
+2. ��ʼ����������ᴦ�� aop ������ִ�� aop �ķ���Ϊ `AbstractAutoProxyCreator#postProcessAfterInitialization`���������£�
+
+   ```
+   // �����beanΪservice2��beanNameΪ��service2��
+   public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
+       if (bean != null) {
+           Object cacheKey = getCacheKey(bean.getClass(), beanName);
+           // 1\. earlyProxyReferences �в�û�� service2��if��Ĵ����ִ�е�
+           if (this.earlyProxyReferences.remove(cacheKey) != bean) {
+               // 2\. �����ﴦ��aop����
+               return wrapIfNecessary(bean, beanName, cacheKey);
+           }
+       }
+       return bean;
+   }
+   
+   ```
+
+   ���ϴ����ȴ� `earlyProxyReferences` �Ƴ� `service2`��Ȼ�����봫��� bean ���Ƚϣ������� 5 ��ṹ�е����ݣ����Ƿ��� `service2` ������ `earlyProxyReferences` �У�
+
+   | �ṹ                            | ����                            |
+      | ------------------------------- | ------------------------------- |
+   | `singletonObjects`              |                                 |
+   | `earlySingletonObjects`         | service1$$EnhancerBySpringCGLIB |
+   | `singletonFactories`            | lambda(service2)                |
+   | `singletonsCurrentlyInCreation` | service1, service2              |
+   | `earlyProxyReferences`          | service1                        |
+
+   ��ˣ����ﷵ�� `null`����Ȼ�����ڴ���� bean����� if �еĴ����ִ�У�`service2` ���� aop��ִ������һ���󣬵õ��� `exposedObject` Ϊ��
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-d62ebdbb71b76ada963a01c9b8c84b88b00.png)
+
+   `service2` Ҳ����˴��������������������ע�롣
+
+3. �ӻ����л�ȡ beanName ��Ӧ�� bean��ִ�е��� `DefaultSingletonBeanRegistry#getSingleton(String, boolean)`���������£�
+
+   ```
+   /**
+    * beanName: service2
+    * allowEarlyReference��false
+    */
+   protected Object getSingleton(String beanName, boolean allowEarlyReference) {
+       // 1\. ��һ�������л�ȡ service2����ȡ����������null
+       Object singletonObject = this.singletonObjects.get(beanName);
+       // 2\. �ж� service2 �Ƿ��ڴ����У�����true��ִ��if�еĴ���
+       if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
+           synchronized (this.singletonObjects) {
+               // 3\. �Ӷ��������л�ȡ service2����ȡ����������null
+               singletonObject = this.earlySingletonObjects.get(beanName);
+               // 4\. ��ʱ����� allowEarlyReference Ϊfalse��if��Ĵ��벻��ִ��
+               if (singletonObject == null && allowEarlyReference) {
+                   ...
+               }
+           }
+       }
+       return singletonObject;
+   }
+   
+   ```
+
+   ���ǻ������� һ�� 5 ��ṹ�е����ݣ������������ִ�о�һĿ��Ȼ�ˣ�
+
+   | �ṹ                            | ����                            |
+      | ------------------------------- | ------------------------------- |
+   | `singletonObjects`              |                                 |
+   | `earlySingletonObjects`         | service1$$EnhancerBySpringCGLIB |
+   | `singletonFactories`            | lambda(service2)                |
+   | `singletonsCurrentlyInCreation` | service1, service2              |
+   | `earlyProxyReferences`          | service1                        |
+
+   ������ִ�У��ڴ������Ѿ�ע�͵ú������ˣ��Ͷ�˵�ˣ�
+
+4. �� 3 �����ص� `earlySingletonReference` Ϊ null��if ��������ݲ���ִ�С�
+
+������õ��� `service2` �ͷ����ˡ�
+
+#### 5.2 �ص� `DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)`
+
+�õ� `service2` �� bean �����ǻص� `DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)`������ `service2` �����̣��������£�
+
+```
+public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
+    Assert.notNull(beanName, "Bean name must not be null");
+    synchronized (this.singletonObjects) {
+        ...
+            try {
+                // 1\. ���������bean�Ĵ���
+                singletonObject = singletonFactory.getObject();
+                newSingleton = true;
+            }
+            catch (...) {
+                ...
+            }
+            finally {
+                ...
+                // 2\. ������ɺ���һЩ������
+                // ������ service2 �� singletonsCurrentlyInCreation �Ƴ�
+                afterSingletonCreation(beanName);
+            }
+            if (newSingleton) {
+                // 3\. ���ö������ӵ� beanFactory �У����������ɾ������������
+                addSingleton(beanName, singletonObject);
+            }
+        ...
+        return singletonObject;
+    }
+}
+
+```
+
+˵�����£�
+
+1. ����ǧ�����գ�`singletonFactory.getObject()` ����ִ�����ˣ����������֮�����ջ��ǵõ��� `service2` �Ĵ�������
+
+2. `service2` ������ɺ󣬾ͻὫ��� `singletonsCurrentlyInCreation` �Ƴ��������Ƚϼ򵥣��Ͳ���˵�ˣ���һ���õ��� 5 ��ṹ���£�
+
+   | �ṹ                            | ����                            |
+      | ------------------------------- | ------------------------------- |
+   | `singletonObjects`              |                                 |
+   | `earlySingletonObjects`         | service1$$EnhancerBySpringCGLIB |
+   | `singletonFactories`            | lambda(service2)                |
+   | `singletonsCurrentlyInCreation` | service1                        |
+   | `earlyProxyReferences`          | service1                        |
+
+3. ���ţ����ǻ���Ĵ���������Ϊ `DefaultSingletonBeanRegistry#addSingleton`��
+
+   ```
+   /*
+    * beanName��service2
+    * singletonObject��service2$$EnhancerBySpringCGLIB(service2�Ĵ�������)
+    */ 
+   protected void addSingleton(String beanName, Object singletonObject) {
+       synchronized (this.singletonObjects) {
+           // �������������put��remove����������ֻ��һ���������иö���
+           this.singletonObjects.put(beanName, singletonObject);
+           this.singletonFactories.remove(beanName);
+           this.earlySingletonObjects.remove(beanName);
+           this.registeredSingletons.add(beanName);
+       }
+   }
+   
+   ```
+
+   �����Ƚϼ򵥣��Ͳ���˵�ˣ����� 5 ��ṹΪ��
+
+   | �ṹ                            | ����                            |
+      | ------------------------------- | ------------------------------- |
+   | `singletonObjects`              | service2$$EnhancerBySpringCGLIB |
+   | `earlySingletonObjects`         | service1$$EnhancerBySpringCGLIB |
+   | `singletonFactories`            |                                 |
+   | `singletonsCurrentlyInCreation` | service1                        |
+   | `earlyProxyReferences`          | service1                        |
+
+���ˣ�`service2` ��ȡ��ɣ����ձ��浽 `singletonObjects` �е� bean Ϊ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-763dad35376ed1d88086c45f01ee9c4cedd.png)
+
+���ڵ��������Ҳ������ 5 ���ṹ�е����ݣ�
+
+| �ṹ                            | ����                            |
+| ------------------------------- | ------------------------------- |
+| `singletonObjects`              | service2$$EnhancerBySpringCGLIB |
+| `earlySingletonObjects`         | service1$$EnhancerBySpringCGLIB |
+| `singletonFactories`            |                                 |
+| `singletonsCurrentlyInCreation` | service1                        |
+| `earlyProxyReferences`          | service1                        |
+
+���ˣ�`service2` ��ȡ��ɣ����������Ǽ��� `service1` �Ļ�ȡ���̡�
+
+### 6 ���� `service1` �Ļ�ȡ����
+
+�ڵ� 2 ���У���Ϊ `servic1` ��Ҫע�� `service2`�������˵� 3 �ڻ�ȡ `service2` �����̣�Ȼ���־���һϵ�еIJ����������ڵ� 5 �ڳɹ��ػ�ȡ���� `service2` �Ĵ������� `service2$$EnhancerBySpringCGLIB`������� `service2` �����������ע�롣
+
+�������������������� 2 �ڣ��ص� `AbstractAutowireCapableBeanFactory#doCreateBean` ���������� `service1` �����̡�
+
+#### 6.1 �ص� `AbstractAutowireCapableBeanFactory#doCreateBean`
+
+�������£�
+
+```
+protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, 
+            final @Nullable Object[] args) throws BeanCreationException {
+
+        // ����Ĵ����� 3.1 ���Ѿ��������ˣ��Ͳ��ٷ�����
+        ...
+
+        Object exposedObject = bean;
+        try {
+            // 1\. ��������װ��, Ҳ�������dz���˵������ע��
+            populateBean(beanName, mbd, instanceWrapper);
+            // 2\. ��ʼ����������ᴦ�� aop ����
+            exposedObject = initializeBean(beanName, exposedObject, mbd);
+        }
+        catch (Throwable ex) {
+            ...
+        }
+
+        //ͬ���ģ��������ѭ������
+        if (earlySingletonExposure) {
+            // 3\. �ӻ����л�ȡ beanName ��Ӧ��bean
+            Object earlySingletonReference = getSingleton(beanName, false);
+            // 4\. earlySingletonReference ��Ϊ null��if ��������ݻ�ִ��
+            if (earlySingletonReference != null) {
+                if (exposedObject == bean) {
+                    // 5\. �����صĶ���ֵ�� exposedObject�����ض���Ϊ��������
+                    exposedObject = earlySingletonReference;
+                }
+            }
+        }
+
+        // ʡ�Բ���Ҫ�Ĵ���
+        ...
+
+        return exposedObject;
+    }
+
+```
+
+����˵�����£�
+
+1. ��������ע�룬�������ﴥ���˵� 3 �ڵ����̣�ִ����õ��� `service1` ���£�
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-3883285be5904e056bc517d35bfd44c47a0.png)
+
+   ���Կ�����`service1` �Ѿ����������ע�룬�Ҵ�ʱע�뵽 `service1` �е� `service2` �Ѿ��Ǵ��������ˣ����� `service1` ��ʱ����ԭʼ�������Ǽ������¿���
+
+2. ��ʼ����������ᴦ�� aop ������ִ�� aop �ķ���Ϊ `AbstractAutoProxyCreator#postProcessAfterInitialization`���������£�
+
+   ```
+   // �����beanΪservice1��beanNameΪ��service1��
+   public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
+       if (bean != null) {
+           Object cacheKey = getCacheKey(bean.getClass(), beanName);
+           // 1\. earlyProxyReferences ���� service1��if��Ĵ��벻��ִ�е�
+           if (this.earlyProxyReferences.remove(cacheKey) != bean) {
+               // 2\. �����ﴦ��aop������service1 �Ѿ�ִ�й�aop��
+               return wrapIfNecessary(bean, beanName, cacheKey);
+           }
+       }
+       return bean;
+   }
+   
+   ```
+
+   ���ϴ����ȴ� `earlyProxyReferences` �Ƴ� `service1`��Ȼ�����봫��� bean ���Ƚϣ������� 5 ��ṹ�е����ݣ����Ƿ��� `service1` ��ʱ���� `earlyProxyReferences` �У�
+
+   | �ṹ                            | ����                            |
+      | ------------------------------- | ------------------------------- |
+   | `singletonObjects`              | service2$$EnhancerBySpringCGLIB |
+   | `earlySingletonObjects`         | service1$$EnhancerBySpringCGLIB |
+   | `singletonFactories`            |                                 |
+   | `singletonsCurrentlyInCreation` | service1                        |
+   | `earlyProxyReferences`          | service1                        |
+
+   ��ˣ�����᷵�� `service1`��if �еĴ��벻��ִ�С�ִ������һ����5 ���ṹ�е�����Ϊ��
+
+   | �ṹ                            | ����                            |
+      | ------------------------------- | ------------------------------- |
+   | `singletonObjects`              | service2$$EnhancerBySpringCGLIB |
+   | `earlySingletonObjects`         | service1$$EnhancerBySpringCGLIB |
+   | `singletonFactories`            |                                 |
+   | `singletonsCurrentlyInCreation` | service1                        |
+   | `earlyProxyReferences`          |                                 |
+
+3. �ӻ����л�ȡ beanName ��Ӧ�� bean��ִ�е��� `DefaultSingletonBeanRegistry#getSingleton(String, boolean)`���������£�
+
+   ```
+   /**
+    * beanName: service1
+    * allowEarlyReference��false
+    */
+   protected Object getSingleton(String beanName, boolean allowEarlyReference) {
+       // 1\. ��һ�������л�ȡ service1����ȡ����������null
+       Object singletonObject = this.singletonObjects.get(beanName);
+       // 2\. �ж� service1 �Ƿ��ڴ����У�����true��ִ��if�еĴ���
+       if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
+           synchronized (this.singletonObjects) {
+               // 3\. �Ӷ��������л�ȡ service1���ܻ�ȡ��
+               singletonObject = this.earlySingletonObjects.get(beanName);
+               // 4\. singletonObject ��Ϊnull��if��Ĵ��벻��ִ��
+               if (singletonObject == null && allowEarlyReference) {
+                   ...
+               }
+           }
+       }
+       return singletonObject;
+   }
+   
+   ```
+
+   ���ǿ� һ�� 5 ��ṹ�е����ݣ������������ִ�о�һĿ��Ȼ�ˣ�
+
+   | �ṹ                            | ����                            |
+      | ------------------------------- | ------------------------------- |
+   | `singletonObjects`              | service2$$EnhancerBySpringCGLIB |
+   | `earlySingletonObjects`         | service1$$EnhancerBySpringCGLIB |
+   | `singletonFactories`            |                                 |
+   | `singletonsCurrentlyInCreation` | service1                        |
+   | `earlyProxyReferences`          |                                 |
+
+   ������ִ�У��ڴ������Ѿ�ע�͵ú������ˣ��Ͷ�˵�ˣ���һ����� `service1` �Ĵ������󷵻أ�
+
+4. ��һ���õ��� `earlySingletonReference` Ϊ
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-425636328820897c75890f01614d94fe9dd.png)
+
+   ���������Ѿ��������ˣ����Լ���ִ�� if ��Ĵ����ˣ�
+
+5. ���һ���Ǹ�ֵ�����������صĶ���ֵ�� `exposedObject`��Ȼ�󷵻� `exposedObject`�����շ��صĶ���Ϊ `service1` �Ĵ�������
+
+������һ����`service1` �Ĵ�������Ҳ��ȡ����ˡ�
+
+#### 6.2 �ص� `DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)`
+
+��һ���IJ���������һЩ���棬�Ͳ��ٷ����ˣ����� 5 ���ṹ�е��������£�
+
+| �ṹ                            | ����                                                         |
+| ------------------------------- | ------------------------------------------------------------ |
+| `singletonObjects`              | service2<nobr aria-hidden="true">EnhancerBySpringCGLIB,service1</nobr><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mo>,</mo><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mi>?</mi><mn>1</mn></math><mi>E</mi><mi>n</mi><mi>h</mi><mi>a</mi><mi>n</mi><mi>c</mi><mi>e</mi><mi>r</mi><mi>B</mi><mi>y</mi><mi>S</mi><mi>p</mi><mi>r</mi><mi>i</mi><mi>n</mi><mi>g</mi><mi>C</mi><mi>G</mi><mi>L</mi><mi>I</mi><mi>B</mi><mo>,</mo><mi>s</mi><mi>e</mi><mi>r</mi><mi>v</mi><mi>i</mi><mi>c</mi><mi>e</mi><mn>1</mn></math>" role="presentation">EnhancerBySpringCGLIB |
+| `earlySingletonObjects`         |                                                              |
+| `singletonFactories`            |                                                              |
+| `singletonsCurrentlyInCreation` |                                                              |
+| `earlyProxyReferences`          |                                                              |
+
+ͨ�����ԣ��鿴�õ� `singletonObjects` �ж������£�
+
+1. service1
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-b6ba35a7a701056ae55a8f9b2ef9345cac5.png)
+
+2. service2
+
+   ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-563d6e323ef8fc5e9fd02f7a938ddbac655.png)
+
+���Կ�����`singletonObjects` �����߶��Ǵ������󣬱˴�ע��ģ�Ҳ�Ǵ�������ѭ�������õ��˽����
+
+### 4\. �ܽ�
+
+spring ѭ�������ķ���������ͽ����ˣ�ѭ�������н�ĺ�������**���������ǰ���� aop**��spring ����������һ�㣬����� 5 ��ṹ�洢��Ҫ����Ϣ��һ�������ѭ���������⡣
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4815992](https://my.oschina.net/funcy/blog/4815992) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213\347\233\221\345\220\254\345\231\250\346\263\250\350\247\243EventListener.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213\347\233\221\345\220\254\345\231\250\346\263\250\350\247\243EventListener.md"
new file mode 100644
index 0000000..d83f8b5
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213\347\233\221\345\220\254\345\231\250\346\263\250\350\247\243EventListener.md"
@@ -0,0 +1,662 @@
+��������� `BeanFactoryPostProcessor` ����ʱ�������˴����¼���������һ�ִ�����ʽ��ʹ�� `@EventListener` ע�⣬��������� `EventListenerMethodProcessor`�������ȴ�һ��ʾ�����������𲽷��� `@EventListener` �Ĵ������̡�
+
+### 1. `@EventListener` ʹ��ʾ��
+
+�ȶ���һ���¼���
+
+```
+public class MyApplicationEvent extends ApplicationEvent {
+
+    private static final long serialVersionUID = -1L;
+
+    public MyApplicationEvent(Object source) {
+        super(source);
+    }
+}
+
+```
+
+��׼��һ���¼������������ʹ�� `@EventListener` ָ����������
+
+```
+@Configuration
+public class Demo08Config {
+
+    /**
+     * ���Ǹ��¼�������
+     */
+    @EventListener(MyApplicationEvent.class)
+    public void listener(MyApplicationEvent event) {
+        System.out.println("@EventListener���������¼���"
+                + Thread.currentThread().getName() + " | " + event.getSource());
+    }
+}
+
+```
+
+Ȼ�󷢲��¼���
+
+```
+@ComponentScan
+public class Demo08Main {
+
+    public static void main(String[] args) {
+        ApplicationContext context = new AnnotationConfigApplicationContext(Demo08Config.class);
+        // �����¼�
+        context.publishEvent(new MyApplicationEvent(
+            Thread.currentThread().getName() + " | �Զ����¼� ..."));
+    }
+}
+
+```
+
+���У�������£�
+
+```
+@EventListener���������¼���main | main | �Զ����¼� ...
+
+```
+
+���Կ������� `@EventListener` ��ǵķ���ȷʵ������¼��ļ�����
+
+### 2. `@EventListener` ����
+
+ʹ�� `@EventListener` �����������ʵ�� `ApplicationListener` ����ʵ���¼����������˴���Ŀ������������������� `@EventListener` ��Ϊ������Щʲô��
+
+`@EventListener` �Ĵ������£�
+
+```
+@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface EventListener {
+
+    /**
+     * classes �ı���
+     * ����ָ���������¼�������ͬʱ��������¼� 
+     */
+    @AliasFor("classes")
+    Class<?>[] value() default {};
+
+    /**
+     * value �ı���
+     * ����ָ���������¼�������ͬʱ��������¼� 
+     */
+    @AliasFor("value")
+    Class<?>[] classes() default {};
+
+    /**
+     * ����ָ��һ����������������ʱ�����Ż�ִ��
+     * ֧��spring el ����ʽ
+     */
+    String condition() default "";
+
+}
+
+```
+
+�Ӵ���������`@EventListener` �ṩ�������ܣ�
+
+*   ָ���������¼�������ָ������¼�
+*   ָ��һ����������������ʱ�����Ż�ִ�У�����֧�� spring EL ����ʽ
+
+�˽� `@EventListener` �ṩ�Ĺ��ܺ󣬽��������������� spring ����δ������ע��ġ�
+
+### 3. `@EventListener` �Ĵ�����`EventListenerMethodProcessor`
+
+���¿�ƪ��˵�������� `@EventListener` �Ĺ��ܣ����������� `BeanFactoryPostProcessor` ����ʱ���ֵģ���ʱ���� `BeanFactoryPostProcessor` ��ʵ���� `EventListenerMethodProcessor` �ᴦ�� `@EventListener` ע�⣬�������ʹӴ���Ƕ������� `EventListenerMethodProcessor` ���� `@EventListener` �����̡�
+
+������������ʶ�� `EventListenerMethodProcessor`��
+
+```
+public class EventListenerMethodProcessor
+        implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor {
+    ...
+}
+
+```
+
+����Ҫ��ʵ���������ӿڣ�
+
+*   `BeanFactoryPostProcessor`������������ `BeanFactoryPostProcessor` �������Զ��ƻ� `BeanFactory` ��һЩ��Ϊ��
+*   `SmartInitializingSingleton`���������� bean �ij�ʼ��������ִ��ʱ������ `bean` ��ʼ�����֮��
+
+���������������� `BeanFactoryPostProcessor#postProcessBeanFactory` ��ʵ�֣�
+
+```
+    @Nullable
+    private List<EventListenerFactory> eventListenerFactories;
+
+    /**
+     * ���� BeanFactoryPostProcessor �� postProcessBeanFactory(...) ����.
+     * �������������ǻ�ȡ�� EventListenerFactory��Ȼ�󱣴��� eventListenerFactories��.
+     * spring Ĭ���ṩ�� EventListenerFactory ��������
+     *     1\. DefaultEventListenerFactory��spring Ĭ�ϵ�
+     *     2\. TransactionalEventListenerFactory���������������
+     * �ⲿ�ֲ�û����ʲô��
+     */
+    @Override
+    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
+        this.beanFactory = beanFactory;
+
+        Map<String, EventListenerFactory> beans = beanFactory
+                .getBeansOfType(EventListenerFactory.class, false, false);
+        List<EventListenerFactory> factories = new ArrayList<>(beans.values());
+        // ����
+        AnnotationAwareOrderComparator.sort(factories);
+        this.eventListenerFactories = factories;
+    }
+
+```
+
+����������DZȽϼ򵥵ģ���ֻ�Ǵ������л�ȡ�� `EventListenerFactory` ����ֵ���� `eventListenerFactories`��
+
+`EventListenerFactory` �Ĺ������������� `ApplicationListener`���������ǻ���� spring ����ΰ� `@EventListener` ��ǵķ���ת���� `ApplicationListener` ����ġ��Ӵ���������spring �ṩ�� `EventListenerFactory` ��������
+
+*   `DefaultEventListenerFactory`��spring Ĭ�ϵ�
+*   `TransactionalEventListenerFactory`���������������
+
+���������������������� `SmartInitializingSingleton#afterSingletonsInstantiated()` ��ʵ�֣�
+
+```
+    /**
+     * ��������� SmartInitializingSingleton �� afterSingletonsInstantiated() ����.
+     * ����bean��ʼ����ɺ���á�
+     * ����������У���Ҫ�ǽ������ @EventListener �ķ���ת���� ApplicationListener ���󣬲�ע�ᵽ��������
+     */
+    @Override
+    public void afterSingletonsInstantiated() {
+        ConfigurableListableBeanFactory beanFactory = this.beanFactory;
+        Assert.state(this.beanFactory != null, "No ConfigurableListableBeanFactory set");
+        String[] beanNames = beanFactory.getBeanNamesForType(Object.class);
+        for (String beanName : beanNames) {
+            if (!ScopedProxyUtils.isScopedTarget(beanName)) {
+                Class<?> type = null;
+                try {
+                    // ��ȡ aop ������Ӧ��Ŀ���࣬�� beanName ��Ӧ�� BeanDefinition �л�ȡ.
+                    // �����ȡ��������ʾ�Dz��Ǵ�������ʹ�� beanFactory.getType(beanName) ��ȡ
+                    type = AutoProxyUtils.determineTargetClass(beanFactory, beanName);
+                }
+                catch (Throwable ex) {
+                    ...
+                }
+                if (type != null) {
+                    if (ScopedObject.class.isAssignableFrom(type)) {
+                        try {
+                            Class<?> targetClass = AutoProxyUtils.determineTargetClass(
+                                    beanFactory, ScopedProxyUtils.getTargetBeanName(beanName));
+                            if (targetClass != null) {
+                                type = targetClass;
+                            }
+                        }
+                        catch (Throwable ex) {
+                            ...
+                        }
+                    }
+                    try {
+                        // ����Ĵ�������
+                        processBean(beanName, type);
+                    }
+                    catch (Throwable ex) {
+                        ...
+                    }
+                }
+            }
+        }
+    }
+
+```
+
+���������ִ���������£�
+
+1.  ��ȡ��ǰ `beanFactory` �е����� `bean`�����õ��� `beanFactory.getBeanNamesForType(Object.class)` ������ע�⴫��� `class` �� `Object`���������ó������е� `bean`��
+2.  ������Щ `bean`����ÿһ�� `bean`������Ǵ������������ `AutoProxyUtils.determineTargetClass(beanFactory, beanName)` ������ȡ��Ŀ���࣬����֪��ע���Dz��ܼ̳еģ�Ҫ��ȡ `@EventListener` ��ǵķ�������Ҫ��Ŀ����ȥ��ȡ��������Ǵ���������Ŀ������� `bean` ��Ӧ���ࣻ
+3.  ���� `processBean(beanName, type)` ������һ������.
+
+�����ؼ����� `EventListenerMethodProcessor#processBean` �����ˣ�
+
+```
+/**
+ * ���� bean�� ��������Ὣ @EventListener ע���ǵķ���ת��Ϊ ApplicationListener ���󣬲�ע�ᵽ������.
+ * @param beanName
+ * @param targetType
+ */
+private void processBean(final String beanName, final Class<?> targetType) {
+    if (!this.nonAnnotatedClasses.contains(targetType) &&
+            AnnotationUtils.isCandidateClass(targetType, EventListener.class) &&
+            !isSpringContainerClass(targetType)) {
+        Map<Method, EventListener> annotatedMethods = null;
+
+        try {
+            // 1\. �ҵ���� @EventListener �ķ���
+            annotatedMethods = MethodIntrospector.selectMethods(targetType,
+                (MethodIntrospector.MetadataLookup<EventListener>) method ->
+                    AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));
+        }
+        catch (Throwable ex) {
+            ...
+        }
+
+        if (CollectionUtils.isEmpty(annotatedMethods)) {
+            this.nonAnnotatedClasses.add(targetType);
+        }
+        else {
+            ConfigurableApplicationContext context = this.applicationContext;
+            Assert.state(context != null, "No ApplicationContext set");
+            List<EventListenerFactory> factories = this.eventListenerFactories;
+            Assert.state(factories != null, "EventListenerFactory List not initialized");
+            // 2\. ʹ�� EventListenerFactory ������ ApplicationListener ����
+            for (Method method : annotatedMethods.keySet()) {
+                for (EventListenerFactory factory : factories) {
+                    // �жϵ�ǰ EventListenerFactory �Ƿ�֧�ֵ�ǰ����
+                    if (factory.supportsMethod(method)) {
+                        // ����Ǵ���������õ�������ķ���
+                        Method methodToUse = AopUtils.selectInvocableMethod(
+                                method, context.getType(beanName));
+                        // ���� ApplicationListener��������Ǵ�����ķ���
+                        ApplicationListener<?> applicationListener = factory
+                                .createApplicationListener(beanName, targetType, methodToUse);
+                        // ��ʼ����������һ����Ҫ�Ƕ������ж�����ֵ��this.evaluator
+                        if (applicationListener instanceof ApplicationListenerMethodAdapter) {
+                            ((ApplicationListenerMethodAdapter) applicationListener)
+                                    .init(context, this.evaluator);
+                        }
+                        // ���ӵ��������У����� Listener ��Set�����Զ�ȥ��
+                        context.addApplicationListener(applicationListener);
+                        // ������һ������� EventListenerFactory �Ͳ�����ִ���ˣ�
+                        // ����ʱ��ͻᷢ�� factories ��˳�����Ҫ
+                        // ������ EventListenerFactory ��ָ��˳��
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}
+
+```
+
+�� `processBean(...)` �����Ĺؼ�����������ע�ͣ��������ܽ��´������̣�
+
+1.  �ҵ���� `@EventListener` �ķ���������ʹ�õ��� `MethodIntrospector#selectMethods(...)` �������в��ң����������鵽��ǰ��ķ������丸��ķ����Լ��ӿڵ�Ĭ�Ϸ�����һֱ�� Object Ϊֹ����Щ�������������� `@EventListener`�����ᱻ�ҵ������ջ���ҵ������з����ŵ�һ�� Map �У�
+2.  ���������õ��� map����ÿ������ת��Ϊ `ApplicationListener` ���������ӵ� `applicationContext` �� `ApplicationListener` �У������������£�
+    1.  ����ǰ��õ��� `EventListenerFactory`��
+    2.  ������ǰ�� `EventListenerFactory` �Ƿ�֧�ָ÷�����֧���������һ������֧���򲻴�����
+    3.  ���ڴ��������ҵ���ǰ�����Ĵ�������������ִ�е�Ҳ�Ǵ���������
+    4.  ���� `ApplicationListener` ���󣬹��췽���IJ����ᴫ�� `method`�����ڴ���������� `method` �Ǵ�������� `method`��
+    5.  ���� `ApplicationListenerMethodAdapter` ʵ�������г�ʼ����������Ҫ�Ǹ�ֵ��this.evaluator��
+    6.  ���õ��� `ApplicationListener` ���ӵ��������У����� `Listener` ��һ�� `Set`�����Զ�ȥ�ء�
+
+������������ `@EventListener` ��ǵķ���֮�����ܶ��¼����м���������Ϊ spring ���÷�����װ��һ�� `ApplicationListener` ���ӵ��������ˣ�֮������������͸�ʵ���� `ApplicationListener` �ӿڵļ�����һ���ܶ��¼����м����ˡ�
+
+### 5. `ApplicationListener` ���������
+
+ǰ������� `@EventListener` �Ĵ������̣����ڽ������� `ApplicationListener` ��������ɣ���Ӧ�Ĵ���Ϊ��
+
+```
+// EventListenerMethodProcessor#processBean
+ApplicationListener<?> applicationListener = factory
+        .createApplicationListener(beanName, targetType, methodToUse);
+
+```
+
+ǰ�����ǽ��ܹ� spring �ṩ�� `EventListenerFactory` ��������
+
+*   `DefaultEventListenerFactory`��spring Ĭ�ϵ�
+*   `TransactionalEventListenerFactory`���������������
+
+���������Ǿ������������� `EventListenerFactory`��
+
+#### 5.1 `DefaultEventListenerFactory`
+
+```
+public class DefaultEventListenerFactory implements EventListenerFactory, Ordered {
+    ...
+
+    /**
+     * ������Ĭ�ϵ�ʵ�֣���֧�����еķ���
+     */
+    @Override
+    public boolean supportsMethod(Method method) {
+        return true;
+    }
+
+    /**
+     * ��������
+     */ 
+    @Override
+    public ApplicationListener<?> createApplicationListener(String beanName, 
+            Class<?> type, Method method) {
+        return new ApplicationListenerMethodAdapter(beanName, type, method);
+    }
+}
+
+```
+
+�����ϴ���˵�����£�
+
+1.  `DefaultEventListenerFactory` �� spring �ṩ��Ĭ��ʵ�֣���֧�����б���� `@EventListener` �ķ�����
+2.  ���� `ApplicationListener` �ķ����� `createApplicationListener`�������õ��� `ApplicationListenerMethodAdapter` �Ĺ��췽����
+
+���Ǽ����� `ApplicationListenerMethodAdapter`��
+
+```
+public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
+
+    ...
+
+    public ApplicationListenerMethodAdapter(String beanName, Class<?> targetClass, Method method) {
+        this.beanName = beanName;
+        // ��������
+        this.method = BridgeMethodResolver.findBridgedMethod(method);
+        this.targetMethod = (!Proxy.isProxyClass(targetClass) ?
+                AopUtils.getMostSpecificMethod(method, targetClass) : this.method);
+        this.methodKey = new AnnotatedElementKey(this.targetMethod, targetClass);
+
+        EventListener ann = AnnotatedElementUtils
+                .findMergedAnnotation(this.targetMethod, EventListener.class);
+        // ����֧�ֵ��¼�
+        this.declaredEventTypes = resolveDeclaredEventTypes(method, ann);
+        // ע��ָ��������
+        this.condition = (ann != null ? ann.condition() : null);
+        this.order = resolveOrder(this.targetMethod);
+    }
+
+    ...
+}
+
+```
+
+`ApplicationListenerMethodAdapter` �Ĺ��췽������һ�ѵĸ�ֵ���������������ص�����ע���¼��Ĵ�����
+
+```
+public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
+
+    ...
+
+    /**
+     * ���������ܼ������¼�����
+     */
+    private static List<ResolvableType> resolveDeclaredEventTypes(Method method, 
+            @Nullable EventListener ann) {
+        // �������ֻ����һ���������������¼������� @EventListener ָ��
+        int count = method.getParameterCount();
+        if (count > 1) {
+            throw new IllegalStateException(
+                    "Maximum one parameter is allowed for event listener method: " + method);
+        }
+
+        if (ann != null) {
+            // �¼�����ָ���������ȡ���� classes ����ֵ
+            Class<?>[] classes = ann.classes();
+            if (classes.length > 0) {
+                List<ResolvableType> types = new ArrayList<>(classes.length);
+                for (Class<?> eventType : classes) {
+                    types.add(ResolvableType.forClass(eventType));
+                }
+                return types;
+            }
+        }
+
+        if (count == 0) {
+            throw new IllegalStateException(
+                    "Event parameter is mandatory for event listener method: " + method);
+        }
+        return Collections.singletonList(ResolvableType.forMethodParameter(method, 0));
+    }
+}
+
+```
+
+�Ӵ�����Եó����½��ۣ�
+
+1.  �� `@EventListener` ��ǵķ������������ֻ����һ��
+2.  �����ܼ������¼������ж������ `@EventListener` ָ��
+
+#### 5.2 `TransactionalEventListenerFactory`
+
+������������������ `TransactionalEventListenerFactory`��
+
+```
+public class TransactionalEventListenerFactory implements EventListenerFactory, Ordered {
+
+    ...
+
+    /**
+     * ֻ֧�ֱ���� @TransactionalEventListener ע��ķ���
+     */
+    @Override
+    public boolean supportsMethod(Method method) {
+        return AnnotatedElementUtils.hasAnnotation(method, TransactionalEventListener.class);
+    }
+
+    /**
+     * �����Ķ����� ApplicationListenerMethodTransactionalAdapter
+     */
+    @Override
+    public ApplicationListener<?> createApplicationListener(String beanName, 
+            Class<?> type, Method method) {
+        return new ApplicationListenerMethodTransactionalAdapter(beanName, type, method);
+    }
+}
+
+```
+
+�Ӵ���������`TransactionalEventListenerFactory` �� `DefaultEventListenerFactory` ������£�
+
+*   `ApplicationListenerMethodTransactionalAdapter` ֻ֧�ֱ���� `@TransactionalEventListener` �ķ�����
+*   ������ `ApplicationListener` ʵ������Ϊ `ApplicationListenerMethodTransactionalAdapter`��
+
+������������ `@TransactionalEventListener` �Ǹ�ɶ��
+
+```
+@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+/**
+ * ����� @EventListener ע��
+ */
+@EventListener
+public @interface TransactionalEventListener {
+    /**
+     * ������
+     */
+    TransactionPhase phase() default TransactionPhase.AFTER_COMMIT;
+
+    /**
+     * ������
+     */
+    boolean fallbackExecution() default false;
+
+    /**
+     * ָ�������¼�
+     */
+    @AliasFor(annotation = EventListener.class, attribute = "classes")
+    Class<?>[] value() default {};
+
+    /**
+     * ָ�������¼�
+     */
+    @AliasFor(annotation = EventListener.class, attribute = "classes")
+    Class<?>[] classes() default {};
+
+    /**
+     * ָ������
+     */
+    String condition() default "";
+}
+
+```
+
+���Կ��������ע������ `@EventListener`����˾����� `@EventListener` ��ͬ�Ĺ��ܡ����⣬�� `@EventListener` ��ȣ������������ԣ�`phase()` �� `fallbackExecution()`��������������������ġ�
+
+�˽��� `TransactionalEventListener` ֮�������������� `ApplicationListenerMethodTransactionalAdapter`��
+
+```
+/**
+ * �̳��� ApplicationListenerMethodAdapter
+ */
+class ApplicationListenerMethodTransactionalAdapter extends ApplicationListenerMethodAdapter {
+    ...
+
+    private final TransactionalEventListener annotation;
+
+    public ApplicationListenerMethodTransactionalAdapter(String beanName, 
+            Class<?> targetClass, Method method) {
+        // ���ø���ķ���
+        super(beanName, targetClass, method);
+        // �����ע���� @TransactionalEventListener
+        TransactionalEventListener ann = AnnotatedElementUtils
+                .findMergedAnnotation(method, TransactionalEventListener.class);
+        if (ann == null) {
+            throw new IllegalStateException(...);
+        }
+        this.annotation = ann;
+    }
+
+    ...
+}
+
+```
+
+�Ӵ�����������`ApplicationListenerMethodTransactionalAdapter` �̳��� `ApplicationListenerMethodAdapter`���乹�췽��Ҳ���ȵ��� `ApplicationListenerMethodAdapter` �Ĺ��췽����Ȼ���ٸ� `annotation` ��ֵ��
+
+### 6\. �¼�����
+
+�����������������¼��ļ���������
+
+#### 6.1 `ApplicationListenerMethodAdapter` �����¼�
+
+��ǰ��������У�����֪�� `ApplicationListener` Ҫ����һ���¼��������������������
+
+1.  �жϵ�ǰ `ApplicationListener` �Ƿ�֧�ֵ�ǰ�¼�
+2.  ���֧�֣�������¼�����
+
+���������� `ApplicationListenerMethodAdapter` ��������������
+
+```
+public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
+
+    ...
+
+    /**
+     * ��ǰ listener �Ƿ�֧�ִ�����¼�.
+     * ʹ�õķ����� ResolvableType#isAssignableFrom(ResolvableType)�����Խ��÷���������
+     * Ϊ�Ƕ� Class#isAssignableFrom ���ܵ���չ
+     */
+    @Override
+    public boolean supportsEventType(ResolvableType eventType) {
+        for (ResolvableType declaredEventType : this.declaredEventTypes) {
+            if (declaredEventType.isAssignableFrom(eventType)) {
+                return true;
+            }
+            if (PayloadApplicationEvent.class.isAssignableFrom(eventType.toClass())) {
+                ResolvableType payloadType = eventType
+                        .as(PayloadApplicationEvent.class).getGeneric();
+                if (declaredEventType.isAssignableFrom(payloadType)) {
+                    return true;
+                }
+            }
+        }
+        return eventType.hasUnresolvableGenerics();
+    }
+
+    /**
+     * �¼�����
+     */
+    @Override
+    public void onApplicationEvent(ApplicationEvent event) {
+        processEvent(event);
+    }
+
+    public void processEvent(ApplicationEvent event) {
+        // ��������
+        Object[] args = resolveArguments(event);
+        // shouldHandle���ж��������� EventListener.condition() �ṩ
+        if (shouldHandle(event, args)) {
+            // ������÷���
+            Object result = doInvoke(args);
+            if (result != null) {
+                // ����ִ�н���������صĽ�������¼�������ȥ
+                handleResult(result);
+            }
+            else {
+                logger.trace("No result object given - no result to handle");
+            }
+        }
+    }
+
+}
+
+```
+
+���Կ������жϵ�ǰ��ǰ `ApplicationListener` �Ƿ�֧�ֵ�ǰ�¼�ʱ��ʹ�õ��� `ResolvableType#isAssignableFrom(ResolvableType)`����������������IJ�������������������Լ򵥵ؽ��÷�������Ϊ�Ƕ� `Class#isAssignableFrom` ���ܵ���չ��
+
+`ApplicationListenerMethodAdapter` �����¼��������������£�
+
+1.  ����������������� `event` ת��Ϊ���������о����ֵ
+2.  ͨ��������ñ� `@EventListener` ��ǵķ���
+3.  ���� `@EventListener` �����ķ��ؽ������ `handleResult(...)` ��������Խ����صĽ�������¼��ٷ�����ȥ
+
+���� `ApplicationListenerMethodAdapter` �����¼������ͷ����������ˡ�
+
+#### 6.2 `ApplicationListenerMethodTransactionalAdapter` �����¼�
+
+`ApplicationListenerMethodTransactionalAdapter` ���¼������� `ApplicationListenerMethodAdapter` Ҫ��һЩ��
+
+```
+/**
+ * �̳��� ApplicationListenerMethodAdapter
+ */
+class ApplicationListenerMethodTransactionalAdapter extends ApplicationListenerMethodAdapter {
+
+    ...
+
+    // supportsEventType(...) Ҳ�Ǽ̳�������ķ�������������ʵ��
+
+    /**
+     * �¼�����
+     */
+    @Override
+    public void onApplicationEvent(ApplicationEvent event) {
+        // ������ڴ�������IJ����������л������о�
+        if (TransactionSynchronizationManager.isSynchronizationActive()
+                && TransactionSynchronizationManager.isActualTransactionActive()) {
+            TransactionSynchronization transactionSynchronization 
+                    = createTransactionSynchronization(event);
+            TransactionSynchronizationManager.registerSynchronization(transactionSynchronization);
+        }
+        else if (this.annotation.fallbackExecution()) {
+            // ���õ��Ǹ���ķ���
+            processEvent(event);
+        }
+        else {
+            // ֻ��log ��ӡ��ʡ��
+            ...
+        }
+    }
+
+    ...
+}
+
+```
+
+�����ϴ���˵�����£�
+
+1.  `ApplicationListenerMethodTransactionalAdapter` �� `ApplicationListenerMethodAdapter` �����࣬��̳����� `ApplicationListenerMethodAdapter` �ķ���
+2.  `ApplicationListenerMethodTransactionalAdapter` ��û����д `supportsEventType(...)` ���������Ҳ��ʹ�� `ApplicationListenerMethodAdapter` �� `supportsEventType(...)` �������ж��¼���֧�����
+3.  �ڴ����¼�ʱ��`ApplicationListenerMethodTransactionalAdapter` �����������صĴ���������Ĵ����߼����ľͲ�������
+
+### 7\. �ܽ�
+
+������Ҫ������ `@EventListener` �Ĵ������̣��ܽ����£�
+
+1.  `@EventListener` ����ָ���������¼����¼�����������
+2.  ���� `@EventListener` ������ `EventListenerMethodProcessor`�������ѱ� `@EventListener` ��ǵķ���ת����һ�� `ApplicationListener` ����Ȼ�����ӵ� `ApplicationContext` �ļ�������
+3.  ����ת���� `ApplicationListener` ����IJ����� `EventListenerFactory` �ṩ��spring �ṩ������ `EventListenerFactory`��
+    *   `DefaultEventListenerFactory`��spring Ĭ�ϵģ�ת���ɵ� `ApplicationListener` Ϊ `ApplicationListenerMethodAdapter`
+    *   `TransactionalEventListenerFactory`��������������ģ�ת���ɵ� `ApplicationListener` Ϊ `ApplicationListenerMethodTransactionalAdapter`
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4926344](https://my.oschina.net/funcy/blog/4926344) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213\347\273\204\345\220\210\346\263\250\350\247\243\347\232\204\345\244\204\347\220\206.md" "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213\347\273\204\345\220\210\346\263\250\350\247\243\347\232\204\345\244\204\347\220\206.md"
new file mode 100644
index 0000000..57e42d1
--- /dev/null
+++ "b/docs/Spring\345\205\250\345\256\266\346\241\266/Spring\346\272\220\347\240\201\345\210\206\346\236\220/Spring\351\207\215\350\246\201\346\234\272\345\210\266\346\216\242\347\247\230/Spring\346\216\242\347\247\230\344\271\213\347\273\204\345\220\210\346\263\250\350\247\243\347\232\204\345\244\204\347\220\206.md"
@@ -0,0 +1,710 @@
+### 1\. ʲô�����ע�⣿
+
+�� spring �У���һ���ر��ע�⣺���ע�⡣������˵��springmvc �У�`@Controller` ע���������÷���·���ȣ�`@ResponseBody` ע����������������ͼ��Ⱦ��ֱ��չʾ���������н����һ����ת�� json ���أ����� `@RestController` ��������ߵĹ��ܣ��������÷���·����ͬʱҲ����ֱ��չʾ���������н�����������£�
+
+```
+@Controller
+@ResponseBody
+public @interface RestController {
+    /**
+     * ע�����
+     */
+    @AliasFor(annotation = Controller.class)
+    String value() default "";
+
+}
+
+```
+
+���Կ�����`@RestController` �ϱ��������ע�⣺`@Controller` �� `@ResponseBody`����������ͬʱӵ�������ߵĹ��ܡ�
+
+������һ�����ӣ�spring �У������ڱ�ʶһ����Ϊ spring bean ��ʱ�򣬿����õ���Щע�⣺`@Component`��`@Repository`��`@Service` �ȣ��ٽ�һ��������룬���� `@Repository`��`@Service` �ж��� `@Component`��
+
+```
+@Component
+public @interface Repository {
+    @AliasFor(annotation = Component.class)
+    String value() default "";
+}
+
+@Component
+public @interface Service {
+    @AliasFor(annotation = Component.class)
+    String value() default "";
+}
+
+```
+
+Ҳ����˵��`@Repository`��`@Service` ������� `@Component` �Ĺ��ܣ�
+
+ʵ���ϣ���������Լ�дһ��ע�⣬��������
+
+```
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Component
+public @interface MyComponent {
+
+    @AliasFor(annotation = Component.class)
+    String value() default "";
+
+}
+
+```
+
+Ȼ������ʹ�ã�
+
+```
+@MyComponent("beanObj3")
+public class BeanObj3 {
+    ...
+}
+
+```
+
+spring ��Ȼ��� `BeanObj3` ��ʼ��Ϊ spring bean��
+
+��ô spring �����������һ�����أ�ʵ���ϣ�spring �ڴ��� `@MyComponent` ʱ�����жϸ�ע�����Ƿ���� `@Component` ע�⣬����������ͻ�ȡ��ע������ã�Ȼ�� `@Component` �Ĵ����߼������д�����
+
+ͬ���أ�spring �ڴ��� `@RestController` ʱ�������ǰ�Ǵ��� `@Controller` ���߼����ʹ� `@RestController` �л�ȡ `@Controller` ������Ȼ����д����������ǰ�Ǵ��� `@ResponseBody` �߼����ʹ� `@RestController` �л�ȡ `@ResponseBody` ������Ȼ����д�����
+
+### 2\. �ݹ��ȡָ���������ע��
+
+���������ˣ����ע���е�ע��Ҫ��ô��ȡ�أ�
+
+������� jdk �ṩ�ķ�������������
+
+```
+RestController annotation = BeanObj3.class.getAnnotation(MyComponent.class);
+
+```
+
+�õ��� `annotation` �ض�Ϊ `null`��ԭ���� `Class#getAnnotation` ����ֻ�ܻ�ȡ������ֱ�ӳ��ֵ�ע�⣬`BeanObj3` ��û��ֱ�ӳ��� `@Component` �ģ���˵õ��Ľ��Ϊ null���취Ҳ����Ҳ�뵽�ˣ����Ǽ������¶�ȡ "ע���ע��"���ô���ʾ���£�����������
+
+```
+public class AnnotationHandler {
+
+    /**
+     * ���jdk�ṩ��Ԫע��
+     */
+    private static Set<Class<?>> metaAnnotations = new HashSet<>();
+    static {
+        metaAnnotations.add(Target.class);
+        metaAnnotations.add(Documented.class);
+        metaAnnotations.add(Retention.class);
+    }
+
+    public static void main(String[] args) {
+        List<Class<?>> list = getAnnotations(BeanObj3.class);
+        System.out.println(list);
+    }
+
+    /**
+     * ��ȡ�������ݹ����
+     */
+    public static List<Class<?>> getAnnotations(Class<?> cls) {
+        // ������Ÿ����ϵ�����ע�⣬����ע���ע��
+        List<Class<?>> list = new ArrayList<>();
+        // ���� doGetAnnotations(...) ��ȡ
+        doGetAnnotations(list, cls);
+        return list;
+    }
+
+    /**
+     * ��ȡע��ľ������
+     */
+    private static void doGetAnnotations(List<Class<?>> list, Class<?> cls) {
+        // ��ȡ���е�ע��
+        Annotation[] annotations = cls.getAnnotations();
+        if(annotations != null && annotations.length > 0) {
+            for(Annotation annotation : annotations) {
+                // ��ȡע�������
+                Class<?> annotationType = annotation.annotationType();
+                // ����jdk�ṩ��Ԫע��
+                if(metaAnnotations.contains(annotationType)) {
+                    continue;
+                }
+                // �ݹ����
+                doGetAnnotations(list, annotationType);
+            }
+        }
+        // �����ע�⣬�����ӵ� list ��
+        if(cls.isAnnotation()) {
+            list.add(cls);
+        }
+    }
+}
+
+```
+
+����Ҫ��ȡ `BeanObj3` ������ע�⣬�Ϳ������������ˣ�
+
+```
+// �õ� BeanObj3 �ϵ�����ע�⣬������ע���ע�⡱
+List<Class<?>> list = AnnotationHandler.getAnnotations(BeanObj3.class);
+// �ж� BeanObj3 ��ע�����Ƿ���� @Component
+list.contains(Component.class);
+
+```
+
+���� demo ���DZȽϴֲڣ������� jdk ��Ԫע�⣬����ֻ�ų��������������������� `@Component` �г��ֵģ����� `@Component` ֮�ϵ�ע���ȡ�Ѿ��㹻�ˣ����Ҳ������Ҫ�ģ�����û�л�ȡע������ݡ��� spring �У�ע�Ⲣ��ֻ��һ����ǣ������Զ���һϵ����������������
+
+```
+// ���� spring bean ������Ϊ beanObj3
+@MyComponent("beanObj3")
+public class BeanObj3 {
+    ...
+}
+
+```
+
+�� `AnnotationHandler` �����ܻ�ȡ��ע������ݣ�
+
+���������������� spring ����ô����ע�����ݵĶ�ȡ�ġ�
+
+### 3\. spring ��ȡע����Ϣ
+
+spring 5.2 �У�����ע����Ϣ�Ķ�ȡ���ṩ�������ࣺ
+
+*   `AnnotationMetadataReadingVisitor`��ע�����ݵĶ�ȡ�࣬���� asm ʵ�֣������� spring5.2 ���Ѿ������������ `@Deprecated`��������ʹ�� `SimpleAnnotationMetadataReadingVisitor`����˱��IJ�������
+*   `SimpleAnnotationMetadataReadingVisitor`��ע�����ݵĶ�ȡ�࣬���� asm ʵ�֣�spring 5.2 ���������࣬������� `AnnotationMetadataReadingVisitor`����Ҫע����ǣ�`SimpleAnnotationMetadataReadingVisitor` �ķ��ʼ�����Ĭ�ϵģ��޷������ڰ�֮����ʣ�ͬʱ��Ҳ�� `final` �ģ����ܱ��̳У���������޷�ֱ�Ӳ����������� spring �ṩ��һ���ࣺ`SimpleMetadataReaderFactory`��ͨ�����Ϳ���ʹ�� `SimpleAnnotationMetadataReadingVisitor` ��
+*   `StandardAnnotationMetadata`��ע�����ݵĶ�ȡ�࣬���ڷ���ʵ��
+
+#### 3.1 `SimpleAnnotationMetadataReadingVisitor`
+
+spring ��û���ṩֱ�Ӳ��� `SimpleAnnotationMetadataReadingVisitor` �Ļ��ᣬ���Ƿ�װ�� `SimpleMetadataReaderFactory` �ˣ�����������������ࣺ
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-f2926fbc022517409bfb6f6641c87a193c2.png)
+
+���Կ�����`SimpleMetadataReaderFactory` ������Ҫ��Ϊ�����֣�
+
+1.  ���췽��
+2.  ��Դ�Ļ�ȡ
+
+��������ֱ�ӿ���ȡ�Ļ�ȡ��Ҳ���� `getMetadataReader(...)` ������
+
+`getMetadataReader(Resource resource)`: ���� `Resource` ��ȡ���� `getMetadataReader(String className)`: ����������ȡ���ݣ��������ȫ�޶��������� �������������������Ӵ��������������������Ҳ��ת��Ϊ `Resource`��Ȼ����� `getMetadataReader(Resource)` ���ж�ȡ
+
+�����������ķ���ֵ���� `MetadataReader`�����Ǹ�ɶ�أ����Ǽ������¿�.
+
+##### `MetadataReader`
+
+`MetadataReader` �IJ��ַ������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-4a1184918664e8a4bd363d6399ed4092692.png)
+
+���Կ��������Ǹ��ӿڣ����ﷵ�صľ������;��� `SimpleMetadataReader` �ˣ�������� 3 ��������
+
+*   `getResource()`: ��ȡ��Դ
+*   `getClassMetadata()`: ��ȡ���Ԫ����
+*   `getAnnotationMetadata()`: ��ȡע���Ԫ����
+
+�����ǻ�ȡע�����Ϣ����������ֻ��ע `getAnnotationMetadata()` ������
+
+```
+AnnotationMetadata getAnnotationMetadata();
+
+```
+
+����������ص��� `AnnotationMetadata`�������Ǹ�ɶ��
+
+##### `AnnotationMetadata`
+
+�����������ķ�����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-fc19d57bbba3d70da04fd32e6eef511ad4f.png)
+
+��Щ������Ϊ���ࣺ
+
+*   `getXxx(...)`������ע���ȡ��Ӧ����Ϣ
+*   `hasXxx(...)`���ж��Ƿ����ijע��
+
+�����һ�����⼸��������Ĭ��ʵ�֣����ֶ����� `getAnnotations()` ������
+
+```
+public interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata {
+
+    default Set<String> getAnnotationTypes() {
+        // ������ getAnnotations()
+    return getAnnotations().stream()
+        .filter(MergedAnnotation::isDirectlyPresent)
+        .map(annotation -> annotation.getType().getName())
+        .collect(Collectors.toCollection(LinkedHashSet::new));
+    }
+
+    default Set<String> getMetaAnnotationTypes(String annotationName) {
+        // ������ getAnnotations()
+    MergedAnnotation<?> annotation = getAnnotations().get(annotationName, 
+        MergedAnnotation::isDirectlyPresent);
+    if (!annotation.isPresent()) {
+        return Collections.emptySet();
+    }
+    return MergedAnnotations.from(annotation.getType(), SearchStrategy.INHERITED_ANNOTATIONS)
+                .stream()
+        .map(mergedAnnotation -> mergedAnnotation.getType().getName())
+        .collect(Collectors.toCollection(LinkedHashSet::new));
+    }
+
+    default boolean hasAnnotation(String annotationName) {
+        // ������ getAnnotations()
+    return getAnnotations().isDirectlyPresent(annotationName);
+    }
+
+    ...
+}
+
+```
+
+�ٽ�һ���鿴 `getAnnotations()` ������������ `AnnotatedTypeMetadata`��
+
+```
+public interface AnnotatedTypeMetadata {
+
+    /**
+     * ��ȡע��
+     */
+    MergedAnnotations getAnnotations();
+
+    ...
+
+}
+
+```
+
+��һ�������ƺ�ע��õ����ռ������ `MergedAnnotations` �ˣ����Ǽ���̽����
+
+##### `MergedAnnotations`
+
+`MergedAnnotations` �IJ���ע�����£�
+
+> Provides access to a collection of merged annotations, usually obtained from a source such as a {@link Class} or {@link Method}.
+>
+> �ṩ�����ע��ļ��ϵķ��ʣ���Щע��ͨ���Ǵ� Class �� Method ֮�����Դ��õġ�
+
+������`MergedAnnotations` �������յ����ע��ļ����ˣ��������������ļ���������
+
+```
+// �ж�ע���Ƿ���ڣ�������е�ע�����ж�
+<A extends Annotation> boolean isPresent(Class<A> annotationType);
+
+// �ж�ע���Ƿ���ڣ�������е�ע�����жϣ�������ķ�����ͬ���ǣ����ﴫ������ַ���
+boolean isPresent(String annotationType);
+
+// �ж�ֱ��ע���Ƿ���ڣ�Ҳ����ֻ�жϵ�ǰ������û�и�ע�⣬���ж�ע���ע��
+<A extends Annotation> boolean isDirectlyPresent(Class<A> annotationType);
+
+// ����ͬ�ϣ����ﴫ����������ַ�������ʽΪ"����.����"
+boolean isDirectlyPresent(String annotationType);
+
+// ��ȡע��
+<A extends Annotation> MergedAnnotation<A> get(Class<A> annotationType);
+
+// ��ȡע�⣬���ﴫ����������ַ�������ʽΪ"����.����"
+<A extends Annotation> MergedAnnotation<A> get(String annotationType);
+
+```
+
+�ӷ����ϴ��¿��Կ�����`MergedAnnotations` �����ע��ļ��ϣ��ṩ��ע������ж�ijע���Ƿ���ڣ�Ҳ���Ի�ȡ���е�ij��ע�⡣
+
+##### `MergedAnnotation`
+
+`MergedAnnotations` ��ע��ļ��ϣ�����������зŵ���ɶ�أ������� `get(...)` ��������������ŵ��� `MergedAnnotation`�������������� `MergedAnnotation` ֧�ֵķ�����
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-a3a749f4546d63b49bfd25d2fc2c73dcb6f.png)
+
+�����ϵķ������Կ�����`MergedAnnotation` ����ע������ݳ������ṩ�˷ḻ�� api ������ȡע������ݡ�
+
+##### ʹ��ʾ��
+
+����������ʾ����
+
+```
+// �õ� SimpleMetadataReaderFactory ʵ�������յ��õ��� SimpleAnnotationMetadataReadingVisitor ����ȡ
+SimpleMetadataReaderFactory readerFactory = new SimpleMetadataReaderFactory();
+MetadataReader metadataReader = readerFactory.getMetadataReader(BeanObj3.class.getName());
+AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
+
+// AnnotationMetadata �ṩ������IJ������ص��עע����ص�
+Set<String> annotationTypes = annotationMetadata.getAnnotationTypes();
+System.out.println("-------------");
+annotationTypes.forEach(type -> System.out.println(type));
+System.out.println("-------------");
+
+// ������ֱ�ӻ�ȡ��BeanObj3 ��ֱ�ӱ�� @MyComponent�ģ����ص���true
+boolean exist1 = annotationMetadata.hasAnnotation(MyComponent.class.getName());
+System.out.println("hasAnnotation @MyComponent:" + exist1);
+
+// ������ֱ�ӻ�ȡ��BeanObj3 ����û��ֱ�ӱ�� @Component�ģ����ص���false
+boolean exist2 = annotationMetadata.hasAnnotation(Component.class.getName());
+System.out.println("hasAnnotation @Component:" + exist2);
+
+// ��ȡ MergedAnnotations
+MergedAnnotations annotations = annotationMetadata.getAnnotations();
+System.out.println("-------------");
+annotations.forEach(annotationMergedAnnotation -> System.out.println(annotationMergedAnnotation));
+System.out.println("-------------");
+
+// ������ֱ�ӻ�ȡ��BeanObj3 ����û��ֱ�ӱ�� @Component�ģ����ص���false
+boolean directlyPresent = annotations.isDirectlyPresent(Component.class);
+System.out.println("directlyPresent Component:" + directlyPresent);
+
+// �ж���û�����ע�⣬BeanObj3 �ϵ�@MyComponent�У������ @Component �ģ����ص���true
+boolean present = annotations.isPresent(Component.class);
+System.out.println("present Component:" + present);
+
+// ��ȡ @Component ע��
+MergedAnnotation<Component> mergedAnnotation = annotations.get(Component.class);
+// ���� @MyComponent �� value() ���� @AliasFor(annotation = Component.class)
+// �������õ��� value �� beanObj3 ��BeanObj3����ôָ���ģ�@MyComponent("beanObj3")��
+String value = mergedAnnotation.getString("value");
+System.out.println("Component value:" + value);
+
+// �� @Component ��ע�������ת��Ϊ AnnotationAttributes
+AnnotationAttributes annotationAttributes = mergedAnnotation.asAnnotationAttributes();
+System.out.println(annotationAttributes);
+
+```
+
+���У�������£�
+
+```
+-------------
+org.springframework.learn.explore.demo01.MyComponent
+-------------
+hasAnnotation @MyComponent:true
+hasAnnotation @Component:false
+-------------
+@org.springframework.learn.explore.demo01.MyComponent(value=beanObj3)
+@org.springframework.stereotype.Component(value=beanObj3)
+@org.springframework.stereotype.Indexed()
+-------------
+directlyPresent Component:false
+present Component:true
+Component value:beanObj3
+{value=beanObj3}
+
+```
+
+##### ���䣺`AnnotationAttributes`
+
+����˵���� `AnnotationAttributes`��
+
+```
+public class AnnotationAttributes extends LinkedHashMap<String, Object> {
+    ...
+}
+
+```
+
+��ʵ���� `LinkedHashMap`���ṩ�IJ��ַ������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-a8c8dc975790719c37a8e41a4b0067c517c.png)
+
+�����ﲻ�ѿ�����`AnnotationAttributes` ���ǰ���ע����������ֵ�� map��key Ϊ��������value Ϊ����ֵ��
+
+#### 3.2 `StandardAnnotationMetadata`
+
+���ǽ��������� `StandardAnnotationMetadata`:
+
+```
+public class StandardAnnotationMetadata extends StandardClassMetadata 
+        implements AnnotationMetadata {
+
+    /**
+     * Create a new {@code StandardAnnotationMetadata} wrapper for the given Class.
+     * @param introspectedClass the Class to introspect
+     * @see #StandardAnnotationMetadata(Class, boolean)
+     * @deprecated since 5.2 in favor of the factory method 
+     *   {@link AnnotationMetadata#introspect(Class)}
+     */
+    @Deprecated
+    public StandardAnnotationMetadata(Class<?> introspectedClass) {
+    this(introspectedClass, false);
+    }
+
+    ...
+}
+
+```
+
+`StandardAnnotationMetadata` ʵ���� `AnnotationMetadata` �ӿڣ�����ע��IJ�����������ܵ� `AnnotationMetadata` ����̫����������Ͳ�׸���ˡ�
+
+�� `StandardAnnotationMetadata` �Ĺ��췽�����������Ѿ������ˣ�������ʹ�� `AnnotationMetadata#introspect(Class)` ����ȡ `StandardAnnotationMetadata` ��ʵ�������ǣ����ǿ�����������������
+
+```
+// ��ȡ���� annotationMetadata ʵ������ StandardAnnotationMetadata
+AnnotationMetadata annotationMetadata = AnnotationMetadata.introspect(BeanObj3.class);
+
+//----------- ����������SimpleAnnotationMetadataReadingVisitor һģһ��
+
+// AnnotationMetadata �ṩ������IJ������ص��עע����ص�
+Set<String> annotationTypes = annotationMetadata.getAnnotationTypes();
+System.out.println("-------------");
+annotationTypes.forEach(type -> System.out.println(type));
+System.out.println("-------------");
+
+// ������ֱ�ӻ�ȡ��BeanObj3 ��ֱ�ӱ�� @MyComponent�ģ����ص���true
+boolean exist1 = annotationMetadata.hasAnnotation(MyComponent.class.getName());
+System.out.println("hasAnnotation @MyComponent:" + exist1);
+
+// ������ֱ�ӻ�ȡ��BeanObj3 ����û��ֱ�ӱ�� @Component�ģ����ص���false
+boolean exist2 = annotationMetadata.hasAnnotation(Component.class.getName());
+System.out.println("hasAnnotation @Component:" + exist2);
+
+// ��ȡ MergedAnnotations
+MergedAnnotations annotations = annotationMetadata.getAnnotations();
+System.out.println("-------------");
+annotations.forEach(annotationMergedAnnotation -> System.out.println(annotationMergedAnnotation));
+System.out.println("-------------");
+
+// ������ֱ�ӻ�ȡ��BeanObj3 ����û��ֱ�ӱ�� @Component�ģ����ص���false
+boolean directlyPresent = annotations.isDirectlyPresent(Component.class);
+System.out.println("directlyPresent Component:" + directlyPresent);
+
+// �ж���û�����ע�⣬BeanObj3 �ϵ�@MyComponent�У������ @Component �ģ����ص���true
+boolean present = annotations.isPresent(Component.class);
+System.out.println("present Component:" + present);
+
+// ��ȡ @Component ע��
+MergedAnnotation<Component> mergedAnnotation = annotations.get(Component.class);
+// ���� @MyComponent �� value() ���� @AliasFor(annotation = Component.class)
+// �������õ��� value �� beanObj3 ��BeanObj3����ôָ���ģ�@MyComponent("beanObj3")��
+String value = mergedAnnotation.getString("value");
+System.out.println("Component value:" + value);
+
+// �� @Component ��ע�������ת��Ϊ AnnotationAttributes
+AnnotationAttributes annotationAttributes = mergedAnnotation.asAnnotationAttributes();
+System.out.println(annotationAttributes);
+
+```
+
+���н�����£�
+
+```
+-------------
+org.springframework.learn.explore.demo01.MyComponent
+-------------
+hasAnnotation @MyComponent:true
+hasAnnotation @Component:false
+-------------
+@org.springframework.learn.explore.demo01.MyComponent(value=beanObj3)
+@org.springframework.stereotype.Component(value=beanObj3)
+@org.springframework.stereotype.Indexed()
+-------------
+directlyPresent Component:false
+present Component:true
+Component value:beanObj3
+{value=beanObj3}
+
+```
+
+�������ʾ����������������ǧ����࣬���յõ��� `MergedAnnotations`��Ȼ��ͨ�������ж�ע���Ƿ���ڡ���ȡע���ֵ��
+
+#### 3.3 ���ߵ�ʹ�ó���
+
+`SimpleAnnotationMetadataReadingVisitor` �� `StandardAnnotationMetadata` ����Ҫ�������ڣ�`SimpleAnnotationMetadataReadingVisitor` �ǻ��� asm ��ʵ�֣�`StandardAnnotationMetadata` �ǻ��ڷ����ʵ�֣���������ʹ��ʱ��Ӧ��Ҫ��ôѡ�أ�
+
+���ڻ��ڷ�����Ҫ�ȼ�����ص� jvm �еģ�����ҵ��ж��ǣ�**�����ǰ��û�м��ص� jvm �У���ʹ�� `SimpleAnnotationMetadataReadingVisitor`��������Ѿ����ص� jvm ���ˣ����߽Կ�ʹ��**��
+
+��ʵ�ϣ��� spring ��ɨ��׶Σ���ȡ���ϵ�ע��ʱ��ʹ�õĶ��� `SimpleAnnotationMetadataReadingVisitor`����Ϊ��ʱ�ಢû�м��ص� jvm�����ʹ�� `StandardAnnotationMetadata` ��ȡ���ͻᵼ������ǰ���ء�����ǰ������ʲô�����أ�java ���ǰ�����صģ��е������������ jvm ���������ڶ�û�õ������ȫ�������ˣ��Ͱװ��˷��ڴ��ˡ�
+
+### 4\. spring �ṩ��ע�⹤����
+
+��ǰ���ʾ���У�������������ȡע��ģ�
+
+```
+// ��ȡ annotationMetadata��Ҳ����ʹ�� SimpleMetadataReaderFactory ��ȡ
+AnnotationMetadata annotationMetadata = AnnotationMetadata.introspect(BeanObj3.class);
+MergedAnnotations annotations = annotationMetadata.getAnnotations();
+
+// �ж�ע���Ƿ����
+boolean present = annotations.isPresent(Component.class);
+// ��ȡע�������
+MergedAnnotation<Component> mergedAnnotation = annotations.get(Component.class);
+AnnotationAttributes annotationAttributes = mergedAnnotation.asAnnotationAttributes();
+
+```
+
+�����˵����ȡע������Բ���Ƚ϶࣬�������㣬���뵽���Խ���Щ�����װ��һ�������н��д�����spring Ҳ����ô���ģ���͵ý��� spring ����ע����ص������ࣺ`AnnotationUtils` �� `AnnotatedElementUtils`��`AnnotationUtils` ��ֱ�ӻ�ȡע���ֵ�����ᴦ�����Ը��ǣ��� `AnnotatedElementUtils` �ᴦ�����Ը��ǡ�
+
+ʲô�����Ը����أ�
+
+������˵��`@MyComponent` ��������
+
+```
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+// ע��Componentָ����ֵ��123
+@Component("123")
+public @interface MyComponent {
+
+    @AliasFor(annotation = Component.class)
+    String value() default "";
+
+}
+
+```
+
+�� `@MyComponent` ע���У�����ָ���� `@Component` �� `value` ֵΪ ��123����Ȼ������ôָ�� `@MyComponent` �� `value` ֵ��
+
+```
+@MyComponent("beanObj3")
+public class BeanObj3 {
+
+    ...
+}    
+
+```
+
+���� spring ��ʼ���õ��� `BeanObj3` �������� `123` ���� `beanObj3` �أ����������� `@MyComponent` �� `value` Ϊ `beanObj3` ��˵����Ȼ��ϣ�� bean ������Ϊ `beanObj3`�������� spring Ҳ����ô���ģ���������Ը����ˣ�`@MyComponent` �� `value` ������ `@Component` �� `value` ֵ��
+
+`AnnotationUtils`/`AnnotatedElementUtils` ��������ܵ� `SimpleAnnotationMetadataReadingVisitor`/`StandardAnnotationMetadata` �Ǻι�ϵ�أ�
+
+������ʹ�� `SimpleAnnotationMetadataReadingVisitor`/`StandardAnnotationMetadata` ʱ��������Ҫ�õ� `MergedAnnotations` �ٽ���һϵ�в������ж�ע���Ƿ���ڡ���ȡע�������ֵ�ȣ���������� `AnnotationUtils`/`AnnotatedElementUtils` ��Դ�룬�ͻᷢ�����ǵ���ط���Ҳ�Dz��� `MergedAnnotations` �࣬�����ȡע�⣺
+
+`AnnotationUtils#getAnnotation(AnnotatedElement, Class<A>)` ������
+
+```
+public static <A extends Annotation> A getAnnotation(AnnotatedElement annotatedElement, 
+        Class<A> annotationType) {
+    if (AnnotationFilter.PLAIN.matches(annotationType) ||
+            AnnotationsScanner.hasPlainJavaAnnotationsOnly(annotatedElement)) {
+        return annotatedElement.getAnnotation(annotationType);
+    }
+    // ͨ������ MergedAnnotations ���л�ȡ
+    return MergedAnnotations.from(annotatedElement, 
+            SearchStrategy.INHERITED_ANNOTATIONS, RepeatableContainers.none())
+            .get(annotationType).withNonMergedAttributes()
+            .synthesize(AnnotationUtils::isSingleLevelPresent).orElse(null);
+}
+
+```
+
+`AnnotatedElementUtils#getAllMergedAnnotations(AnnotatedElement, Class<A>)` ������
+
+```
+public static <A extends Annotation> Set<A> getAllMergedAnnotations(
+        AnnotatedElement element, Class<A> annotationType) {
+    return getAnnotations(element).stream(annotationType)
+            .collect(MergedAnnotationCollectors.toAnnotationSet());
+}
+
+// AnnotatedElementUtils#getAnnotations ������Ҳ�Dz��� MergedAnnotations �ķ���
+private static MergedAnnotations getAnnotations(AnnotatedElement element) {
+    return MergedAnnotations.from(element, SearchStrategy.INHERITED_ANNOTATIONS, 
+            RepeatableContainers.none());
+}
+
+```
+
+��ˣ�`AnnotationUtils`/`AnnotatedElementUtils` �� `SimpleAnnotationMetadataReadingVisitor`/`StandardAnnotationMetadata` �ײ㶼�Dz��� `MergedAnnotations` ��ġ�
+
+#### 4.1 `AnnotationUtils`
+
+`AnnotationUtils` ֧�ֵIJ��ַ������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-51b0f496180a16d947b8f83285370cabd8f.png)
+
+������ʵ��ʹ������Щ������
+
+```
+// �� BeanObj3 ��ȡ @Component
+Annotation annotation = AnnotationUtils.getAnnotation(BeanObj3.class, Component.class);
+if(null == annotation) {
+    System.out.println("ע�ⲻ���ڣ�");
+    return;
+}
+System.out.println("annotation: " + annotation);
+
+// ��ȡ AnnotationAttributes
+AnnotationAttributes annotationAttributes
+        = AnnotationUtils.getAnnotationAttributes(BeanObj3.class, annotation);
+System.out.println("AnnotationAttributes: " + annotationAttributes);
+
+// ��ȡ annotationAttributeMap
+Map<String, Object> annotationAttributeMap = AnnotationUtils.getAnnotationAttributes(annotation);
+System.out.println("annotationAttributeMap: " + annotationAttributeMap);
+
+// ��ȡvalue��ֵ
+Object value = AnnotationUtils.getValue(annotation, "value");
+System.out.println("value: " + value);
+
+```
+
+������£�
+
+```
+annotation: @org.springframework.stereotype.Component(value=123)
+AnnotationAttributes: {value=123}
+annotationAttributeMap: {value=123}
+value: 123
+
+```
+
+�ӽ��������ֱ��ͨ�� `AnnotationUtils.getAnnotation(...)` Ҳ���ܻ�ȡ�� `@Component` ע��ģ����� `BeanObj3` ��û��ֱ�ӱ�� `@Component`. ��Ҫע����ǣ�������ȡ���� `@Component` �� `value` ֵ�� "123"�������� `@MyComponent` ���õ� `beanObj3`����Ҳ֤���� `AnnotationUtils` ��ȡ����ֵʱ�����������Ը��Dz�����
+
+#### 4.2 `AnnotatedElementUtils`
+
+`AnnotatedElementUtils` ֧�ֵIJ��ַ������£�
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/up-9815fe697f5ccf14d3aa215952bfcbcc3ab.png)
+
+����ʾ���ɣ�
+
+```
+// 1\. �ж��Ƿ��� Component ע��
+boolean result = AnnotatedElementUtils.hasAnnotation(BeanObj3.class, Component.class);
+System.out.println("hasAnnotation: " + result);
+
+// 2\. ��ȡ attributeMap�����Կ������ǣ���ȡ @Component �� @MyComponent �õ��Ľ����һ��
+// Component attributeMap: {value=[123]}
+MultiValueMap<String, Object> attributeMap1 = AnnotatedElementUtils
+        .getAllAnnotationAttributes(BeanObj3.class, Component.class.getName());
+System.out.println("Component attributeMap: " + attributeMap1);
+// MyComponent attributeMap: {value=[beanObj3]}
+MultiValueMap<String, Object> attributeMap2 = AnnotatedElementUtils
+        .getAllAnnotationAttributes(BeanObj3.class, MyComponent.class.getName());
+System.out.println("MyComponent attributeMap: " + attributeMap2);
+
+// 3\. ��ȡ���е� @Component ע�⣬value=beanObj3
+Set<Component> mergedAnnotations = AnnotatedElementUtils
+        .getAllMergedAnnotations(BeanObj3.class, Component.class);
+System.out.println("mergedAnnotations: " + mergedAnnotations);
+
+// 4\. ��ȡ����ֵ��{value=beanObj3}
+AnnotationAttributes attributes = AnnotatedElementUtils
+        .getMergedAnnotationAttributes(BeanObj3.class, Component.class);
+System.out.println("attributes: " + attributes);
+
+// 5\. ��ȡ MyComponent �ϵ�ע��
+Set<String> types = AnnotatedElementUtils
+        .getMetaAnnotationTypes(BeanObj3.class, MyComponent.class);
+System.out.println("types: " + types);
+
+```
+
+������£�
+
+```
+hasAnnotation: true
+Component attributeMap: {value=[123]}
+MyComponent attributeMap: {value=[beanObj3]}
+mergedAnnotations: [@org.springframework.stereotype.Component(value=beanObj3)]
+attributes: {value=beanObj3}
+types: [org.springframework.stereotype.Component, org.springframework.stereotype.Indexed]
+
+```
+
+�Ӵ����������ڵõ��� `Set<Component>` �� `AnnotationAttributes` �У�����ֵ�Ѿ��ϲ���.
+
+��ѡ��ʹ�� `AnnotationUtils` ���� `AnnotatedElementUtils` ʱ�����Ը���Ҫ��Ҫ���Ը�����ѡ�������Ҫ�������Ը��ǣ���ʹ�� `AnnotatedElementUtils`���������Ҫ����ʹ�� `AnnotationUtils` �ɣ�
+
+### 5\. �ܽ�
+
+���Ľ����� spring ����ע��IJ�������Ҫ������ `SimpleAnnotationMetadataReadingVisitor` �� `StandardAnnotationMetadata` ��������ʹ�÷�����������������ʹ����������Ƚ϶࣬�����ֽ����� spring �ṩ�����������ࣺ`AnnotationUtils` �� `AnnotatedElementUtils`�������Ҫ�������Ը��ǣ���Ҫʹ�� `AnnotatedElementUtils`���������Ҫ����ʹ�� `AnnotationUtils`��
+
+* * *
+
+_����ԭ�����ӣ�[https://my.oschina.net/funcy/blog/4633161](https://my.oschina.net/funcy/blog/4633161) ���������߸���ˮƽ�����������д���֮������ӭָ����ԭ�����ף���ҵת������ϵ���߻����Ȩ������ҵת����ע��������_
\ No newline at end of file
diff --git "a/docs/big-backEnd/Hadoop\347\224\237\346\200\201\346\200\273\347\273\223.md" "b/docs/backend/Hadoop\347\224\237\346\200\201\346\200\273\347\273\223.md"
similarity index 78%
rename from "docs/big-backEnd/Hadoop\347\224\237\346\200\201\346\200\273\347\273\223.md"
rename to "docs/backend/Hadoop\347\224\237\346\200\201\346\200\273\347\273\223.md"
index 0dbb50d..21b547b 100644
--- "a/docs/big-backEnd/Hadoop\347\224\237\346\200\201\346\200\273\347\273\223.md"
+++ "b/docs/backend/Hadoop\347\224\237\346\200\201\346\200\273\347\273\223.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
 * [Hadoop生态](#hadoop生态)
   * [hdfs](#hdfs)
@@ -17,35 +17,22 @@
   * [yarn](#yarn)
   * [kafka](#kafka)
   * [flume](#flume)
-  * [ambari](#ambari)
   * [spark](#spark)
   * [storm](#storm)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-
----
-title: Hadoop生态学习总结
-date: 2018-07-08 22:15:53
-tags:
-	- Hadoop
-categories:
-	- 后端
-	- 技术总结
----
-这篇总结主要是基于我之前Hadoop生态基础系列文章而形成的的。主要是把重要的知识点用自己的话说了一遍，可能会有一些错误，还望见谅和指点。谢谢
 
-更多详细内容可以查看我的专栏文章：Hadoop生态学习
 
-https://blog.csdn.net/a724888/article/category/7779280
-<!-- more -->
+[toc]
+
+这篇总结主要是基于我之前Hadoop生态基础系列文章而形成的的。主要是把重要的知识点用自己的话说了一遍，可能会有一些错误，还望见谅和指点。谢谢
+
+<!-- more -->  
 
 # Hadoop生态
 
 ## hdfs
 
 ### 架构
+
 hdfs是一个分布式文件系统。底层的存储采用廉价的磁盘阵列RAID，由于可以并发读写所以效率很高。
 
 基本架构是一个namenode和多个dataNode。node的意思是节点，一般指主机，也可以是虚拟机。
@@ -76,8 +63,8 @@ MapReduce是基于Hadoop集群的分布式计算方案。一般先编写map函
 
 ### wordcount
 
-首先是一个文本文件:hi hello good hello hi hi。
-三个节点，则进行三次map。hi hello，good hello，hi hi分别由三个节点处理。结果分别是hi 1 hello 1,good 1 hello 1,hi 1,hi 1。
+首先是一个文本文件:hi hello good hello hi hi。  
+三个节点，则进行三次map。hi hello，good hello，hi hi分别由三个节点处理。结果分别是hi 1 hello 1,good 1 hello 1,hi 1,hi 1。  
 shuffle时进行combine操作，得到hi 1,hello 1,good 1 hello 1,hi 2。最终reduce的结果是hi 3 hello 2 good 1.
 
 ## hive
@@ -94,10 +81,11 @@ hbase是基于列的数据库。
 
 首先在表结构上，hbase使用rowkey行键作为唯一主键，通过行键唯一确定一行数据。
 
-同时，hbase使用列族的概念，每个表都有固定的列族，每一行的数据的列族都一样，但是每一行所在列族的实际列都可以不一样。
+同时，hbase使用列族的概念，每个表都有固定的列族，每一行的数据的列族都一样，但是每一行所在列族的实际列都可以不一样。  
 比如列族是info，列可以是name age，也可以是sex address等。也就是说具体列可以在插入数据时再进行确认。
 
 并且，hbase的每一行数据还可以有多个版本，通过时间戳来表示不同的数据版本。
+
 ### 存储
 
 一般情况下hbase使用hdfs作为底层存储，所以hdfs提供了数据的可靠性以及并发读写的高效率。
@@ -129,42 +117,44 @@ zab协议实现原理：
 3选主结束以后，主节点与slave进行主从同步，保证数据一致性，然后对外提供服务，并且写入只能通过master而读取可以通过任意一台机器。
 
 ## sqoop
+
 将hive表中的内容导入到MySQL数据库，也可以将MySQL中的数据导入hive中。
 
 ## yarn
 
-没有yarn之前，hdfs使用jobtracker和tasktracker来执行和跟踪任务，jobtracker的任务太重，又要执行又要监控还要获取结果。
+没有yarn之前，hdfs使用jobtracker和tasktracker来执行和跟踪任务，jobtracker的任务太重，又要执行又要监控还要获取结果。  
 并且不同机器的资源情况没有被考虑在内。
 
 yarn是一个资源调度系统。提供applicationmaster对一个调度任务进行封装，然后有一个resourcemanager专门负责各节点资源的管理和监控。同时nodemanager则运行每个节点中用于监控节点状态和向rm汇报。还有一个container则是对节点资源的一个抽象，applicationmaster任务将由节点上的一个container进行执行。rm会将他调度到最合适的机器上。
+
 ## kafka
 
 架构
 
 > kafka是一个分布式的消息队列。
-> 
+>
 > 它组成一般包括kafka broker，每个broker中有多个的partition作为存储消息的队列。
-> 
+>
 > 并且向上提供服务时抽象为一个topic，我们访问topic时实际上执行的是对partition的写入和读取操作。
 
 
 读写和高可用
 
 > partition支持顺序写入，效率比较高，并且支持零拷贝机制，通过内存映射磁盘mmap的方式，写入partition的数据顺序写入到映射的磁盘中，比传统的IO要快。
-> 
-> 由于partition可能会宕机，所以一般也要支持partition的备份，1个broker ，master通常会有多个
+>
+> 由于partition可能会宕机，所以一般也要支持partition的备份，1个broker ，master通常会有多个  
 > broker slave，是主从关系，通过zookeeper进行选主和故障切换。
-> 
+>
 > 当数据写入队列时，一般也会通过日志文件的方式进行数据备份，会把broker中的partition被分在各个slave中以便于均匀分布和恢复。
 
 生产者和消费者
 
 > 生产者消费者需要访问kafka的队列时，如果是写入，直接向zk发送请求，一般是向一个topic写入消息，broker会自动分配partition进行写入。然后zk会告诉生产者写入的partition所在的broker地址，然后进行写入。
-> 
+>
 > 如果是读取的话，也是通过zk获取partition所在位置，然后通过给定的offset进行读取，读取完后更新offset。
-> 
+>
 > 由于kafka的partition支持顺序读写。所以保证一个partition中的读取和写入时是顺序的，但是如果是多个partition则不保证顺序。
-> 
+>
 > 正常情况下kafka使用topic来实现消息点对点发送，并且每个consumer都要在一个consumer group中，而且comsumer group中每次只能有一个消费者能接受对应topic的消息。因为为了实现订阅也就是一对多发送，我们让每个consumer在一个单独的group，于是每个consumer都可以接受到该消息。
 
 
@@ -172,25 +162,20 @@ yarn是一个资源调度系统。提供applicationmaster对一个调度任务
 
 flume用于数据的收集和分发，flume可以监听端口的数据流入，监视文件的变动以及各种数据形式的数据流入，然后再把数据重新转发到其他需要数据的节点或存储中。
 
-1、Flume的概念 
-
-flume是分布式的日志收集系统，它将各个服务器中的数据收集起来并送到指定的地方去，比如说送到图中的HDFS，简单来说flume就是收集日志的。 
-
-2、Event的概念 
-在这里有必要先介绍一下flume中event的相关概念：flume的核心是把数据从数据源(source)收集过来，在将收集到的数据送到指定的目的地(sink)。为了保证输送的过程一定成功，在送到目的地(sink)之前，会先缓存数据(channel),待数据真正到达目的地(sink)后，flume在删除自己缓存的数据。 
-
-在整个数据的传输的过程中，流动的是event，即事务保证是在event级别进行的。那么什么是event呢？—–event将传输的数据进行封装，是flume传输数据的基本单位，如果是文本文件，通常是一行记录，event也是事务的基本单位。event从source，流向channel，再到sink，本身为一个字节数组，并可携带headers(头信息)信息。event代表着一个数据的最小完整单元，从外部数据源来，向外部的目的地去。       
-
-flume使用   
-## ambari
+1、Flume的概念   
+flume是分布式的日志收集系统，它将各个服务器中的数据收集起来并送到指定的地方去，比如说送到图中的HDFS，简单来说flume就是收集日志的。   
+2、Event的概念 在这里有必要先介绍一下flume中event的相关概念：flume的核心是把数据从数据源(source)收集过来，在将收集到的数据送到指定的目的地(sink)。为了保证输送的过程一定成功，在送到目的地(sink)之前，会先缓存数据(channel),待数据真正到达目的地(sink)后，flume在删除自己缓存的数据。   
+在整个数据的传输的过程中，流动的是event，即事务保证是在event级别进行的。那么什么是event呢？—–event将传输的数据进行封装，是flume传输数据的基本单位，如果是文本文件，通常是一行记录，event也是事务的基本单位。event从source，流向channel，再到sink，本身为一个字节数组，并可携带headers(头信息)信息。event代表着一个数据的最小完整单元，从外部数据源来，向外部的目的地去。         
+flume使用   ## ambari  
 ambari就是一个Hadoop的Web应用。
 
 ## spark
+
 spark和MapReduce不同的地方就是，把计算过程放在内存中运行。
 
 spark提出了抽象的RDD分布式内存模型，把每一步的计算操作转换成一个RDD结构，然后形成一个RDD连接而成的有向图。
 
-比如data.map().filter().reduce();
+比如data.map().filter().reduce();  
 程序提交到master以后，会解析成多个RDD，并且形成一个有向图，然后spark再根据这些RD结构在内存中执行对应的操作。当然这个拓扑结构会被拆分为各个子任务分发到各个spark节点上，然后计算完以后再形成下一个rdd。最后汇总结果即可。
 
 由于是在内存中对数据进行操作，省去了不必要的IO操作，，不需要像Mapreduce一样还得先去hdfs读取文件再完成计算。
@@ -216,9 +201,8 @@ Storm集群和Hadoop集群表面上看很类似。但是Hadoop上运行的是Map
 
 在Storm的集群里面有两种节点： 控制节点（master node）和工作节点（worker node）。控制节点上面运行一个叫Nimbus后台程序，它的作用类似Hadoop里面的JobTracker。Nimbus负责在集群里面分发代码，分配计算任务给机器， 并且监控状态。
 
-每一个工作节点上面运行一个叫做Supervisor的节点。Supervisor会监听分配给它那台机器的工作，根据需要启动/关闭工作进程。每一个工作进程执行一个topology的一个子集；一个运行的topology由运行在很多机器上的很多工作进程组成。 
-
-![](https://img-blog.csdn.net/20160107221357281?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+每一个工作节点上面运行一个叫做Supervisor的节点。Supervisor会监听分配给它那台机器的工作，根据需要启动/关闭工作进程。每一个工作进程执行一个topology的一个子集；一个运行的topology由运行在很多机器上的很多工作进程组成。   
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408112703.png)
 
 Nimbus和Supervisor之间的所有协调工作都是通过Zookeeper集群完成。另外，Nimbus进程和Supervisor进程都是快速失败（fail-fast)和无状态的。所有的状态要么在zookeeper里面， 要么在本地磁盘上。这也就意味着你可以用kill -9来杀死Nimbus和Supervisor进程， 然后再重启它们，就好像什么都没有发生过。这个设计使得Storm异常的稳定。
 
@@ -230,65 +214,37 @@ storm则不然。
 
 1.Topology
 
-　　Storm对任务的抽象，其实 就是将实时数据分析任务 分解为 不同的阶段　　　　
-
+Storm对任务的抽象，其实 就是将实时数据分析任务 分解为 不同的阶段　　　　  
 　　点： 计算组件   Spout   Bolt
 
-　　边： 数据流向    数据从上一个组件流向下一个组件  带方向
-
- 
+边： 数据流向    数据从上一个组件流向下一个组件  带方向
 
 2.tuple
 
-　　Storm每条记录 封装成一个tuple
+Storm每条记录 封装成一个tuple
 
-　　其实就是一些keyvalue对按顺序排列
+其实就是一些keyvalue对按顺序排列
 
-　　方便组件获取数据
-
- 
+方便组件获取数据
 
 3.Spout
 
-　　数据采集器
-
+数据采集器  
 　　源源不断的日志记录  如何被topology接收进行处理？
 
-　　Spout负责从数据源上获取数据，简单处理 封装成tuple向后面的bolt发射
+Spout负责从数据源上获取数据，简单处理 封装成tuple向后面的bolt发射
 
- 
 
 4.Bolt
 
-　　数据处理器
-　　
-二：开发wordcount案例
+数据处理器　　二：开发wordcount案例
 
 1.书写整个大纲的点线图
 
-　　![](https://images2015.cnblogs.com/blog/1027015/201701/1027015-20170126164121691-1448959654.png)
-　　
-topology就是一个拓扑图，类似于spark中的dag有向图，只不过storm执行的流式的数据，比dag执行更加具有实时性。
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408112730.png) 
+　　topology就是一个拓扑图，类似于spark中的dag有向图，只不过storm执行的流式的数据，比dag执行更加具有实时性。
 
-topology包含了spout和bolt。
+topology包含了spout和bolt。  
 spout负责获取数据，并且将数据发送给bolt，这个过程就是把任务派发到多个节点，bolt则负责对数据进行处理，比如splitbolt负责把每个单词提取出来，countbolt负责单词数量的统计，最后的printbolt将每个结果集tuple打印出来。
 
 这就形成了一个完整的流程。
-
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\345\274\200\347\257\207\357\274\232\344\272\221\350\256\241\347\256\227\357\274\214\345\244\247\346\225\260\346\215\256\344\270\216AI\347\232\204\346\225\205\344\272\213.md" "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\345\274\200\347\257\207\357\274\232\344\272\221\350\256\241\347\256\227\357\274\214\345\244\247\346\225\260\346\215\256\344\270\216AI\347\232\204\346\225\205\344\272\213.md"
similarity index 88%
rename from "docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\345\274\200\347\257\207\357\274\232\344\272\221\350\256\241\347\256\227\357\274\214\345\244\247\346\225\260\346\215\256\344\270\216AI\347\232\204\346\225\205\344\272\213.md"
rename to "docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\345\274\200\347\257\207\357\274\232\344\272\221\350\256\241\347\256\227\357\274\214\345\244\247\346\225\260\346\215\256\344\270\216AI\347\232\204\346\225\205\344\272\213.md"
index 5fb6b8c..df0e6bc 100644
--- "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\345\274\200\347\257\207\357\274\232\344\272\221\350\256\241\347\256\227\357\274\214\345\244\247\346\225\260\346\215\256\344\270\216AI\347\232\204\346\225\205\344\272\213.md"
+++ "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\345\274\200\347\257\207\357\274\232\344\272\221\350\256\241\347\256\227\357\274\214\345\244\247\346\225\260\346\215\256\344\270\216AI\347\232\204\346\225\205\344\272\213.md"
@@ -1,43 +1,62 @@
-# Table of Contents
-
-* [[快速看懂云计算，大数据，人工智能](https://www.cnblogs.com/popsuper1982/p/8505203.html)](#[快速看懂云计算，大数据，人工智能]httpswwwcnblogscompopsuper1982p8505203html)
-
-
-# [快速看懂云计算，大数据，人工智能](https://www.cnblogs.com/popsuper1982/p/8505203.html)
-
-
-
-
-
+# 目录
+
+* [一、云计算最初是实现资源管理的灵活性](#一、云计算最初是实现资源管理的灵活性)
+  * [1.1 管数据中心就像配电脑](#11-管数据中心就像配电脑)
+  * [1.2 灵活就是想啥时要都有，想要多少都行](#12-灵活就是想啥时要都有，想要多少都行)
+  * [1.3 物理设备不灵活](#13-物理设备不灵活)
+  * [1.4 虚拟化灵活多了](#14-虚拟化灵活多了)
+  * [1.5 虚拟世界的赚钱与情怀](#15-虚拟世界的赚钱与情怀)
+  * [1.6 虚拟化的半自动和云计算的全自动](#16-虚拟化的半自动和云计算的全自动)
+  * [1.7 云计算的私有与公有](#17-云计算的私有与公有)
+  * [1.8 云计算的赚钱与情怀](#18-云计算的赚钱与情怀)
+  * [1.9 IaaS,资源层面的灵活性](#19-iaas资源层面的灵活性)
+* [二、云计算不光管资源，也要管应用](#二、云计算不光管资源，也要管应用)
+* [三、大数据拥抱云计算](#三、大数据拥抱云计算)
+  * [3.1 数据不大也包含智慧](#31-数据不大也包含智慧)
+  * [3.2 数据如何升华为智慧](#32-数据如何升华为智慧)
+  * [3.3 大数据时代，众人拾柴火焰高](#33-大数据时代，众人拾柴火焰高)
+  * [3.4 大数据需要云计算，云计算需要大数据](#34-大数据需要云计算，云计算需要大数据)
+  * [4.1 机器什么时候才能懂人心](#41-机器什么时候才能懂人心)
+  * [4.2 让机器学会推理](#42-让机器学会推理)
+  * [4.3 教给机器知识](#43-教给机器知识)
+  * [4.4 算了，教不会你自己学吧](#44-算了，教不会你自己学吧)
+  * [4.5 模拟大脑的工作方式](#45-模拟大脑的工作方式)
+  * [4.6 没道理但做得到](#46-没道理但做得到)
+  * [4.7 人工智能的经济学解释](#47-人工智能的经济学解释)
+  * [4.8 人工智能需要大数据](#48-人工智能需要大数据)
+* [五、云计算，大数据，人工智能过上了美好的生活](#五、云计算，大数据，人工智能过上了美好的生活)
+
+
+[toc]
 我今天要讲这三个话题，一个是云计算，一个大数据，一个人工智能，我为什么要讲这三个东西呢？因为这三个东西现在非常非常的火，它们之间好像互相有关系，一般谈云计算的时候也会提到大数据，谈人工智能的时候也会提大数据，谈人工智能的时候也会提云计算。所以说感觉他们又相辅相成不可分割，如果是非技术的人员来讲可能比较难理解说这三个之间的相互关系，所以有必要解释一下。
 
-一、云计算最初是实现资源管理的灵活性
+#  一、云计算最初是实现资源管理的灵活性
 
 我们首先来说云计算，云计算最初的目标是对资源的管理，管理的主要是计算资源，网络资源，存储资源三个方面。
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304165200175-1916661625.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304165200175-1916661625.png)
+
 
- 
 
-1.1 管数据中心就像配电脑
+## 1.1 管数据中心就像配电脑
+
 
- 
 
 什么叫计算，网络，存储资源呢？就说你要买台笔记本电脑吧，你是不是要关心这台电脑什么样的CPU啊？多大的内存啊？这两个我们称为计算资源。
 
- 
+
 
 这台电脑要能上网吧，需要有个网口可以插网线，或者有无线网卡可以连接我们家的路由器，您家也需要到运营商比如联通，移动，电信开通一个网络，比如100M的带宽，然后会有师傅弄一根网线到您家来，师傅可能会帮您将您的路由器和他们公司的网络连接配置好，这样您家的所有的电脑，手机，平板就都可以通过您的路由器上网了。这就是网络。
 
- 
+
 
 您可能还会问硬盘多大啊？原来硬盘都很小，10G之类的，后来500G，1T，2T的硬盘也不新鲜了。(1T是1000G)，这就是存储。
 
- 
+
 
 对于一台电脑是这个样子的，对于一个数据中心也是同样的。想象你有一个非常非常大的机房，里面堆了很多的服务器，这些服务器也是有CPU，内存，硬盘的，也是通过类似路由器的设备上网的。这个时候的一个问题就是，运营数据中心的人是怎么把这些设备统一的管理起来的呢？
 
-1.2 灵活就是想啥时要都有，想要多少都行
+## 1.2 灵活就是想啥时要都有，想要多少都行
 
 管理的目标就是要达到两个方面的灵活性。哪两个方面呢？比如有个人需要一台很小很小的电脑，只有一个CPU，1G内存，10G的硬盘，一兆的带宽，你能给他吗？像这种这么小规格的电脑，现在随便一个笔记本电脑都比这个配置强了，家里随便拉一个宽带都要100M。然而如果去一个云计算的平台上，他要想要这个资源的时候，只要一点就有了。
 
@@ -51,13 +70,13 @@
 
 为了解决这个弹性的问题，经历了漫长时间的发展。
 
-1.3 物理设备不灵活
+## 1.3 物理设备不灵活
 
 首先第一个阶段就是物理机，或者说物理设备时期。这个时期相当于客户需要一台电脑，我们就买一台放在数据中心里。物理设备当然是越来越牛，例如服务器，内存动不动就是百G内存，例如网络设备，一个端口的带宽就能有几十G甚至上百G，例如存储，在数据中心至少是PB级别的(一个P是1000个T，一个T是1000个G)。
 
 然而物理设备不能做到很好的灵活性。首先它不能够达到想什么时候要就什么时候要、比如买台服务器，哪怕买个电脑，都有采购的时间。突然用户告诉某个云厂商，说想要开台电脑，如果使用物理服务器，当时去采购啊就很难，如果说供应商啊关系一般，可能采购一个月，供应商关系好的话也需要一个星期。用户等了一个星期后，这时候电脑才到位，用户还要登录上去开始慢慢部署自己的应用，时间灵活性非常差。第二是空间灵活性也不行，例如上述的用户，要一个很小很小的电脑，现在哪还有这么小型号的电脑啊。不能为了满足用户只要一个G的内存是80G硬盘的，就去买一个这么小的机器。但是如果买一个大的呢，因为电脑大，就向用户多收钱，用户说他只用这么小的一点，如果让用户多付钱就很冤。
 
-1.4 虚拟化灵活多了
+## 1.4 虚拟化灵活多了
 
 有人就想办法了。第一个办法就是虚拟化。用户不是只要一个很小的电脑么？数据中心的物理设备都很强大，我可以从物理的CPU，内存，硬盘中虚拟出一小块来给客户，同时也可以虚拟出一小块来给其他客户，每个客户都只能看到自己虚的那一小块，其实每个客户用的是整个大的设备上其中的一小块。虚拟化的技术能使得不同的客户的电脑看起来是隔离的，我看着好像这块盘就是我的，你看这呢这块盘就是你的，实际情况可能我这个10G和您这个10G是落在同样一个很大很大的这个存储上的。
 
@@ -65,7 +84,7 @@
 
 这个空间灵活性和时间灵活性就基本解决了。
 
-1.5 虚拟世界的赚钱与情怀
+## 1.5 虚拟世界的赚钱与情怀
 
 在虚拟化阶段，最牛的公司是Vmware，是实现虚拟化技术比较早的一家公司，可以实现计算，网络，存储的虚拟化，这家公司很牛，性能也做得非常好，然后虚拟化软件卖的也非常好，赚了好多的钱，后来让EMC(世界五百强，存储厂商第一品牌)给收购了。
 
@@ -79,13 +98,13 @@
 
 在虚拟化软件也一样，有了Vmware，这个软件非常非常的贵。那就有大牛写了两个开源的虚拟化软件，一个叫做Xen，一个叫做KVM，如果不做技术的，可以不用管这两个名字，但是后面还是会提到。
 
-1.6 虚拟化的半自动和云计算的全自动
+## 1.6 虚拟化的半自动和云计算的全自动
 
 虚拟化软件似乎解决了灵活性问题，其实不全对。因为虚拟化软件一般创建一台虚拟的电脑，是需要人工指定这台虚拟电脑放在哪台物理机上的，可能还需要比较复杂的人工配置，所以使用Vmware的虚拟化软件，需要考一个很牛的证书，能拿到这个证书的人，薪资是相当的高，也可见复杂程度。所以仅仅凭虚拟化软件所能管理的物理机的集群规模都不是特别的大，一般在十几台，几十台，最多百台这么一个规模。这一方面会影响时间灵活性，虽然虚拟出一台电脑的时间很短，但是随着集群规模的扩大，人工配置的过程越来越复杂，越来越耗时。另一方面也影响空间灵活性，当用户数量多的时候，这点集群规模，还远达不到想要多少要多少的程度，很可能这点资源很快就用完了，还得去采购。所以随着集群的规模越来越大，基本都是千台起步，动辄上万台，甚至几十上百万台，如果去查一下BAT，包括网易，包括谷歌，亚马逊，服务器数目都大的吓人。这么多机器要靠人去选一个位置放这台虚拟化的电脑并做相应的配置，几乎是不可能的事情，还是需要机器去做这个事情。
 
 人们发明了各种各样的算法来做这个事情，算法的名字叫做调度(Scheduler)。通俗一点的说，就是有一个调度中心，几千台机器都在一个池子里面，无论用户需要多少CPU，内存，硬盘的虚拟电脑，调度中心会自动在大池子里面找一个能够满足用户需求的地方，把虚拟电脑启动起来做好配置，用户就直接能用了。这个阶段，我们称为池化，或者云化，到了这个阶段，才可以称为云计算，在这之前都只能叫虚拟化。
 
-1.7 云计算的私有与公有
+## 1.7 云计算的私有与公有
 
 云计算大致分两种，一个是私有云，一个是公有云，还有人把私有云和公有云连接起来称为混合云，我们暂且不说这个。私有云就是把虚拟化和云化的这套软件部署在别人的数据中心里面，使用私有云的用户往往很有钱，自己买地建机房，自己买服务器，然后让云厂商部署在自己这里，Vmware后来除了虚拟化，也推出了云计算的产品，并且在私有云市场赚的盆满钵满。所谓公有云就是虚拟化和云化软件部署在云厂商自己数据中心里面的，用户不需要很大的投入，只要注册一个账号，就能在一个网页上点一下创建一台虚拟电脑，例如AWS也即亚马逊的公有云，例如国内的阿里云，腾讯云，网易云等。
 
@@ -93,7 +112,7 @@
 
 然而商用的虚拟化软件实在是太贵了，亚马逊总不能把自己在电商赚的钱全部给了虚拟化厂商吧。于是亚马逊基于开源的虚拟化技术，如上所述的Xen或者KVM，开发了一套自己的云化软件。没想到亚马逊后来电商越做越牛，云平台也越做越牛。而且由于他的云平台需要支撑自己的电商应用，而传统的云计算厂商多为IT厂商出身，几乎没有自己的应用，因而亚马逊的云平台对应用更加的友好，迅速发展成为云计算的第一品牌，赚了很多钱。在亚马逊公布其云计算平台财报之前，人们都猜测，亚马逊电商赚钱，云也赚钱吗？后来一公布财报，发现不是一般的赚钱，仅仅去年，亚马逊AWS年营收达122亿美元，运营利润31亿美元。
 
-1.8 云计算的赚钱与情怀
+## 1.8 云计算的赚钱与情怀
 
 公有云的第一名亚马逊过得很爽，第二名Rackspace过的就一般了。没办法，这就是互联网行业的残酷性，多是赢者通吃的模式。所以第二名如果不是云计算行业的，很多人可能都没听过了。第二名就想，我干不过老大怎么办呢？开源吧。如上所述，亚马逊虽然使用了开源的虚拟化技术，但是云化的代码是闭源的，很多想做又做不了云化平台的公司，只能眼巴巴的看着亚马逊挣大钱。Rackspace把源代码一公开，整个行业就可以一起把这个平台越做越好，兄弟们大家一起上，和老大拼了。
 
@@ -101,15 +120,15 @@
 
 当然第二名的技术也是非常棒的，有了OpenStack之后，果真像Rackspace想象的一样，所有想做云的大企业都疯了，你能想象到的所有如雷贯耳的大型IT企业，IBM，惠普，戴尔，华为，联想等等，都疯了。原来云平台大家都想做，看着亚马逊和Vmware赚了这么多钱，眼巴巴看着没办法，想自己做一个好像难度还挺大。现在好了，有了这样一个开源的云平台OpenStack，所有的IT厂商都加入到这个社区中来，对这个云平台进行贡献，包装成自己的产品，连同自己的硬件设备一起卖。有的做了私有云，有的做了公有云，OpenStack已经成为开源云平台的事实标准。
 
-1.9 IaaS, 资源层面的灵活性
+## 1.9 IaaS,资源层面的灵活性
 
 随着OpenStack的技术越来越成熟，可以管理的规模也越来越大，并且可以有多个OpenStack集群部署多套，比如北京部署一套，杭州部署两套，广州部署一套，然后进行统一的管理。这样整个规模就更大了。在这个规模下，对于普通用户的感知来讲，基本能够做到想什么时候要就什么什么药，想要多少就要多少。还是拿云盘举例子，每个用户云盘都分配了5T甚至更大的空间，如果有1亿人，那加起来空间多大啊。其实背后的机制是这样的，分配你的空间，你可能只用了其中很少一点，比如说它分配给你了5个T，这么大的空间仅仅是你看到的，而不是真的就给你了，你其实只用了50个G，则真实给你的就是50个G，随着你文件的不断上传，分给你的空间会越来越多。当大家都上传，云平台发现快满了的时候(例如用了70%)，会采购更多的服务器，扩充背后的资源，这个对用户是透明的，看不到的，从感觉上来讲，就实现了云计算的弹性。其实有点像银行，给储户的感觉是什么时候取钱都有，只要不同时挤兑，银行就不会垮。
 
 这里做一个简单的总结，到了这个阶段，云计算基本上实现了时间灵活性和空间灵活性，实现了计算，网络，存储资源的弹性。计算，网络，存储我们常称为基础设施Infranstracture, 因而这个阶段的弹性称为资源层面的弹性，管理资源的云平台，我们称为基础设施服务，就是我们常听到的IaaS，Infranstracture As A Service。
 
-二、云计算不光管资源，也要管应用
+# 二、云计算不光管资源，也要管应用
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304165352365-1674249597.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304165352365-1674249597.png)
 
 有了IaaS，实现了资源层面的弹性就够了吗？显然不是。还有应用层面的弹性。这里举个例子，比如说实现一个电商的应用，平时十台机器就够了，双十一需要一百台。你可能觉得很好办啊，有了IaaS，新创建九十台机器就可以了啊。但是90台机器创建出来是空的啊，电商应用并没有放上去啊，只能你公司的运维人员一台一台的弄，还是需要很长时间才能安装好的。虽然资源层面实现了弹性，但是没有应用层的弹性，依然灵活性是不够的。
 
@@ -121,45 +140,45 @@
 
 要么是自动部署，要么是不用部署，总的来说就是应用层你也要少操心，这就是PaaS层的重要作用。
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304171116823-2125176837.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304171116823-2125176837.png)
 
- 虽说脚本的方式能够解决自己的应用的部署问题，然而不同的环境千差万别，一个脚本往往在一个环境上运行正确，到另一个环境就不正确了。
+虽说脚本的方式能够解决自己的应用的部署问题，然而不同的环境千差万别，一个脚本往往在一个环境上运行正确，到另一个环境就不正确了。
 
 而容器是能更好的解决这个问题的。
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304171549380-884329721.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304171549380-884329721.png)
 
 容器是 Container，Container另一个意思是集装箱，其实容器的思想就是要变成软件交付的集装箱。集装箱的特点，一是封装，二是标准。
 
- 
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304174029819-460006657.png)
 
- 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304174029819-460006657.png)
+
+
 
 在没有集装箱的时代，假设将货物从 A运到 B，中间要经过三个码头、换三次船。每次都要将货物卸下船来，摆的七零八落，然后搬上船重新整齐摆好。因此在没有集装箱的时候，每次换船，船员们都要在岸上待几天才能走。
 
- 
 
- ![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304174049081-1911645088.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304174049081-1911645088.png)
 
 有了集装箱以后，所有的货物都打包在一起了，并且集装箱的尺寸全部一致，所以每次换船的时候，一个箱子整体搬过去就行了，小时级别就能完成，船员再也不用上岸长时间耽搁了。
 
- 
+
 
 这是集装箱“封装”、“标准”两大特点在生活中的应用。
 
- 
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304174111204-554853341.png)
 
- 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304174111204-554853341.png)
+
+
+
 
- 
 
 那么容器如何对应用打包呢？还是要学习集装箱，首先要有个封闭的环境，将货物封装起来，让货物之间互不干扰，互相隔离，这样装货卸货才方便。好在 Ubuntu中的LXC技术早就能做到这一点。
 
- 
+
 
 封闭的环境主要使用了两种技术，一种是看起来是隔离的技术，称为 Namespace，也即每个 Namespace中的应用看到的是不同的 IP地址、用户空间、程号等。另一种是用起来是隔离的技术，称为 Cgroups，也即明明整台机器有很多的 CPU、内存，而一个应用只能用其中的一部分。
 
@@ -167,11 +186,11 @@
 
 有了容器，使得 PaaS层对于用户自身应用的自动部署变得快速而优雅。
 
-三、大数据拥抱云计算
+# 三、大数据拥抱云计算
 
 在PaaS层中一个复杂的通用应用就是大数据平台。大数据是如何一步一步融入云计算的呢？
 
-3.1 数据不大也包含智慧
+## 3.1 数据不大也包含智慧
 
 一开始这个大数据并不大，你想象原来才有多少数据？现在大家都去看电子书，上网看新闻了，在我们80后小时候，信息量没有那么大，也就看看书，看看报，一个星期的报纸加起来才有多少字啊，如果你不在一个大城市，一个普通的学校的图书馆加起来也没几个书架，是后来随着信息化的到来，信息才会越来越多。
 
@@ -181,9 +200,9 @@
 
 所以数据的应用分这四个步骤：数据，信息，知识，智慧。这是很多商家都想要的，你看我收集了这么多的数据，能不能基于这些数据来帮我做下一步的决策，改善我的产品，例如让用户看视频的时候旁边弹出广告，正好是他想买的东西，再如让用户听音乐的时候，另外推荐一些他非常想听的其他音乐。用户在我的应用或者网站上随便点点鼠标，输入文字对我来说都是数据，我就是要将其中某些东西提取出来，指导实践，形成智慧，让用户陷入到我的应用里面不可自拔，上了我的网就不想离开，手不停的点，不停的买，很多人说双十一我都想断网了，我老婆在上面不断的买买买，买了A又推荐B，老婆大人说，“哎呀，B也是我喜欢的啊，老公我要买”。你说这个程序怎么这么牛，这么有智慧，比我还了解我老婆，这件事情是怎么做到的呢？
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304172910727-1535815123.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304172910727-1535815123.png)
 
-3.2 数据如何升华为智慧
+## 3.2 数据如何升华为智慧
 
 数据的处理分几个步骤，完成了才最后会有智慧。
 
@@ -197,41 +216,41 @@
 
 第五个步骤就是对于数据的检索和挖掘。检索就是搜索，所谓外事不决问google，内事不决问百度。内外两大搜索引擎都是讲分析后的数据放入搜索引擎，从而人们想寻找信息的时候，一搜就有了。另外就是挖掘，仅仅搜索出来已经不能满足人们的要求了，还需要从信息中挖掘出相互的关系。比如财经搜索，当搜索某个公司股票的时候，该公司的高管是不是也应该被挖掘出来呢？如果仅仅搜索出这个公司的股票发现涨的特别好，于是你就去买了，其实其高管发了一个声明，对股票十分不利，第二天就跌了，这不坑害广大股民么？所以通过各种算法挖掘数据中的关系，形成知识库，十分重要。
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304173120622-1040592225.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304173120622-1040592225.png)
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304173217309-1598751514.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304173217309-1598751514.png)
 
-3.3 大数据时代，众人拾柴火焰高
+## 3.3 大数据时代，众人拾柴火焰高
 
 当数据量很小的时候，很少的几台机器就能解决。慢慢的当数据量越来越大，最牛的服务器都解决不了问题的时候，就想怎么办呢？要聚合多台机器的力量，大家齐心协力一起把这个事搞定，众人拾柴火焰高。
 
 对于数据的收集，对于IoT来讲，外面部署这成千上万的检测设备，将大量的温度，适度，监控，电力等等数据统统收集上来，对于互联网网页的搜索引擎来讲，需要将整个互联网所有的网页都下载下来，这显然一台机器做不到，需要多台机器组成网络爬虫系统，每台机器下载一部分，同时工作，才能在有限的时间内，将海量的网页下载完毕。
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304173243017-953751892.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304173243017-953751892.png)
+
 
- 
 
 对于数据的传输，一个内存里面的队列肯定会被大量的数据挤爆掉，于是就产生了基于硬盘的分布式队列，这样队列可以多台机器同时传输，随你数据量多大，只要我的队列足够多，管道足够粗，就能够撑得住。
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304173256198-1194238978.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304173256198-1194238978.png)
 
 对于数据的存储，一台机器的文件系统肯定是放不下了，所以需要一个很大的分布式文件系统来做这件事情，把多台机器的硬盘打成一块大的文件系统。
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304173309193-29645192.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304173309193-29645192.png)
+
 
- 
 
 再如数据的分析，可能需要对大量的数据做分解，统计，汇总，一台机器肯定搞不定，处理到猴年马月也分析不完，于是就有分布式计算的方法，将大量的数据分成小份，每台机器处理一小份，多台机器并行处理，很快就能算完。例如著名的Terasort对1个TB的数据排序，相当于1000G，如果单机处理，怎么也要几个小时，但是并行处理209秒就完成了。
 
- ![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304173340325-454046253.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304173340325-454046253.png)
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304173407555-1514738312.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304173407555-1514738312.png)
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304173430982-1156642033.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304173430982-1156642033.png)
 
 所以说大数据平台，什么叫做大数据，说白了就是一台机器干不完，大家一起干。随着数据量越来越大，很多不大的公司都需要处理相当多的数据，这些小公司没有这么多机器可怎么办呢？
 
-3.4 大数据需要云计算，云计算需要大数据
+## 3.4 大数据需要云计算，云计算需要大数据
 
 说到这里，大家想起云计算了吧。当想要干这些活的时候，需要好多好多的机器一块做，真的是想什么时候要，想要多少就要多少。例如大数据分析公司的财务情况，可能一周分析一次，如果要把这一百台机器或者一千台机器都在那放着，一周用一次对吧，非常浪费。那能不能需要计算的时候，把这一千台机器拿出来，然后不算的时候，这一千台机器可以去干别的事情。谁能做这个事儿呢？只有云计算，可以为大数据的运算提供资源层的灵活性。而云计算也会部署大数据放到它的PaaS平台上，作为一个非常非常重要的通用应用。因为大数据平台能够使得多台机器一起干一个事儿，这个东西不是一般人能开发出来的，也不是一般人玩得转的，怎么也得雇个几十上百号人才能把这个玩起来，所以说就像数据库一样，其实还是需要有一帮专业的人来玩这个东西。现在公有云上基本上都会有大数据的解决方案了，一个小公司我需要大数据平台的时候，不需要采购一千台机器，只要到公有云上一点，这一千台机器都出来了，并且上面已经部署好了的大数据平台，只要把数据放进去算就可以了。
 
@@ -239,23 +258,23 @@
 
 四、人工智能拥抱大数据
 
-4.1 机器什么时候才能懂人心
+## 4.1 机器什么时候才能懂人心
 
 虽说有了大数据，人的欲望总是这个不能够满足。虽说在大数据平台里面有搜索引擎这个东西，想要什么东西我一搜就出来了。但是也存在这样的情况，我想要的东西不会搜，表达不出来，搜索出来的又不是我想要的。例如音乐软件里面推荐一首歌，这首歌我没听过，当然不知道名字，也没法搜，但是软件推荐给我，我的确喜欢，这就是搜索做不到的事情。当人们使用这种应用的时候，会发现机器知道我想要什么，而不是说当我想要的时候，去机器里面搜索。这个机器真像我的朋友一样懂我，这就有点人工智能的意思了。
 
 人们很早就在想这个事情了。最早的时候，人们想象，如果要是有一堵墙，墙后面是个机器，我给它说话，它就给我回应，我如果感觉不出它那边是人还是机器，那它就真的是一个人工智能的东西了。
 
-4.2 让机器学会推理
+## 4.2 让机器学会推理
 
 怎么才能做到这一点呢？人们就想：我首先要告诉计算机人类的推理的能力。你看人重要的是什么呀，人和动物的区别在什么呀，就是能推理。我要是把我这个推理的能力啊告诉机器，机器就能根据你的提问，推理出相应的回答，真能这样多好。推理其实人们慢慢的让机器能够做到一些了，例如证明数学公式。这是一个非常让人惊喜的一个过程，机器竟然能够证明数学公式。但是慢慢发现其实这个结果，也没有那么令人惊喜，因为大家发现了一个问题，数学公式非常严谨，推理过程也非常严谨，而且数学公式很容易拿机器来进行表达，程序也相对容易表达。然而人类的语言就没这么简单了，比如今天晚上，你和你女朋友约会，你女朋友说：如果你早来，我没来，你等着，如果我早来，你没来，你等着。这个机器就比比较难理解了，但是人都懂，所以你和女朋友约会，你是不敢迟到的。
 
-4.3 教给机器知识
+## 4.3 教给机器知识
 
 所以仅仅告诉机器严格的推理是不够的，还要告诉机器一些知识。但是知识这个事儿，一般人可能就做不来了，可能专家可以，比如语言领域的专家，或者财经领域的专家。语言领域和财经领域知识能不能表示成像数学公式一样稍微严格点呢？例如语言专家可能会总结出主谓宾定状补这些语法规则，主语后面一定是谓语，谓语后面一定是宾语，将这些总结出来，并严格表达出来不久行了吗？后来发现这个不行，太难总结了，语言表达千变万化。就拿主谓宾的例子，很多时候在口语里面就省略了谓语，别人问：你谁啊？我回答：我刘超。但是你不能规定在语音语义识别的时候，要求对着机器说标准的书面语，这样还是不够智能，就像罗永浩在一次演讲中说的那样，每次对着手机，用书面语说：请帮我呼叫某某某，这是一件很尴尬的事情。
 
 人工智能这个阶段叫做专家系统。专家系统不易成功，一方面是知识比较难总结，另一方面总结出来的知识难以教给计算机。因为你自己还迷迷糊糊，似乎觉得有规律，就是说不出来，就怎么能够通过编程教给计算机呢？
 
-4.4 算了，教不会你自己学吧
+## 4.4 算了，教不会你自己学吧
 
 于是人们想到，看来机器是和人完全不一样的物种，干脆让机器自己学习好了。机器怎么学习呢？既然机器的统计能力这么强，基于统计学习，一定能从大量的数字中发现一定的规律。
 
@@ -263,24 +282,23 @@
 
 有一位网友统计了知名歌手在大陆发行的 9 张专辑中 117 首歌曲的歌词，同一词语在一首歌出现只算一次，形容词、名词和动词的前十名如下表所示（词语后面的数字是出现的次数）：
 
- 
 
 
 
-<colgroup><col><col><col><col><col><col></colgroup>
-| a | 形容词 | b | 名词 | c | 动词 |
-| 0 | 孤独:34 | 0 | 生命:50 | 0 | 爱:54 |
-| 1 | 自由:17 | 1 | 路:37 | 1 | 碎:37 |
-| 2 | 迷惘:16 | 2 | 夜:29 | 2 | 哭:35 |
-| 3 | 坚强:13 | 3 | 天空:24 | 3 | 死:27 |
-| 4 | 绝望:8 | 4 | 孩子:23 | 4 | 飞:26 |
-| 5 | 青春:7 | 5 | 雨:21 | 5 | 梦想:14 |
-| 6 | 迷茫:6 | 6 | 石头:9 | 6 | 祈祷:10 |
-| 7 | 光明:6 | 7 | 鸟:9 | 7 | 离去:10 |
+````
+| a | 形容词 | b | 名词 | c | 动词 |  
+| 0 | 孤独:34 | 0 | 生命:50 | 0 | 爱:54 |  
+| 1 | 自由:17 | 1 | 路:37 | 1 | 碎:37 |  
+| 2 | 迷惘:16 | 2 | 夜:29 | 2 | 哭:35 |  
+| 3 | 坚强:13 | 3 | 天空:24 | 3 | 死:27 |  
+| 4 | 绝望:8 | 4 | 孩子:23 | 4 | 飞:26 |  
+| 5 | 青春:7 | 5 | 雨:21 | 5 | 梦想:14 |  
+| 6 | 迷茫:6 | 6 | 石头:9 | 6 | 祈祷:10 |  
+| 7 | 光明:6 | 7 | 鸟:9 | 7 | 离去:10 |  
+````
 
 
 
- 
 
 如果我们随便写一串数字，然后按照数位依次在形容词、名词和动词中取出一个词，连在一起会怎么样呢？
 
@@ -294,61 +312,61 @@
 
 让雨水埋葬他的迷惘。
 
- 
+
 
 是不是有点感觉了？当然真正基于统计的学习算法比这个简单的统计复杂的多。
 
 然而统计学习比较容易理解简单的相关性，例如一个词和另一个词总是一起出现，两个词应该有关系，而无法表达复杂的相关性，并且统计方法的公式往往非常复杂，为了简化计算，常常做出各种独立性的假设，来降低公式的计算难度，然而现实生活中，具有独立性的事件是相对较少的。
 
-4.5 模拟大脑的工作方式
+## 4.5 模拟大脑的工作方式
+
 
- 
 
 于是人类开始从机器的世界，反思人类的世界是怎么工作的。
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304173542876-248664847.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304173542876-248664847.png)
+
 
- 
 
 人类的脑子里面不是存储着大量的规则，也不是记录着大量的统计数据，而是通过神经元的触发实现的，每个神经元有从其他神经元的输入，当接收到输入的时候，会产生一个输出来刺激其他的神经元，于是大量的神经元相互反应，最终形成各种输出的结果。例如当人们看到美女瞳孔放大，绝不是大脑根据身材比例进行规则判断，也不是将人生中看过的所有的美女都统计一遍，而是神经元从视网膜触发到大脑再回到瞳孔。在这个过程中，其实很难总结出每个神经元对最终的结果起到了哪些作用，反正就是起作用了。
 
- 
+
 
 于是人们开始用一个数学单元模拟神经元
 
 这个神经元有输入，有输出，输入和输出之间通过一个公式来表示，输入根据重要程度不同(权重)，影响着输出。
 
- 
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304173608115-399984901.png)
 
- 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304173608115-399984901.png)
+
+
 
 于是将n个神经元通过像一张神经网络一样连接在一起，n这个数字可以很大很大，所有的神经元可以分成很多列，每一列很多个排列起来，每个神经元的对于输入的权重可以都不相同，从而每个神经元的公式也不相同。当人们从这张网络中输入一个东西的时候，希望输出一个对人类来讲正确的结果。例如上面的例子，输入一个写着2的图片，输出的列表里面第二个数字最大，其实从机器来讲，它既不知道输入的这个图片写的是2，也不知道输出的这一系列数字的意义，没关系，人知道意义就可以了。正如对于神经元来说，他们既不知道视网膜看到的是美女，也不知道瞳孔放大是为了看的清楚，反正看到美女，瞳孔放大了，就可以了。
 
 对于任何一张神经网络，谁也不敢保证输入是2，输出一定是第二个数字最大，要保证这个结果，需要训练和学习。毕竟看到美女而瞳孔放大也是人类很多年进化的结果。学习的过程就是，输入大量的图片，如果结果不是想要的结果，则进行调整。如何调整呢，就是每个神经元的每个权重都向目标进行微调，由于神经元和权重实在是太多了，所以整张网络产生的结果很难表现出非此即彼的结果，而是向着结果微微的进步，最终能够达到目标结果。当然这些调整的策略还是非常有技巧的，需要算法的高手来仔细的调整。正如人类见到美女，瞳孔一开始没有放大到能看清楚，于是美女跟别人跑了，下次学习的结果是瞳孔放大一点点，而不是放大鼻孔。
 
-4.6 没道理但做得到
+## 4.6 没道理但做得到
+
 
- 
 
 听起来也没有那么有道理，但是的确能做到，就是这么任性。
 
 神经网络的普遍性定理是这样说的，假设某个人给你某种复杂奇特的函数，f(x)：
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304173627213-1028735538.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304173627213-1028735538.png)
 
 不管这个函数是什么样的，总会确保有个神经网络能够对任何可能的输入x，其值f(x)（或者某个能够准确的近似）是神经网络的输出。
 
 如果在函数代表着规律，也意味着这个规律无论多么奇妙，多么不能理解，都是能通过大量的神经元，通过大量权重的调整，表示出来的。
 
-4.7 人工智能的经济学解释
+## 4.7 人工智能的经济学解释
+
 
- 
 
 这让我想到了经济学，于是比较容易理解了。
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180304173647419-351927988.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180304173647419-351927988.png)
 
 我们把每个神经元当成社会中从事经济活动的个体。于是神经网络相当于整个经济社会，每个神经元对于社会的输入，都有权重的调整，做出相应的输出，比如工资涨了，菜价也涨了，股票跌了，我应该怎么办，怎么花自己的钱。这里面没有规律么？肯定有，但是具体什么规律呢？却很难说清楚。
 
@@ -358,9 +376,9 @@
 
 基于神经网络的微观经济学才是对整个经济规律最最准确的表达，每个人对于从社会中的输入，进行各自的调整，并且调整同样会作为输入反馈到社会中。想象一下股市行情细微的波动曲线，正是每个独立的个体各自不断交易的结果，没有统一的规律可循。而每个人根据整个社会的输入进行独立决策，当某些因素经过多次训练，也会形成宏观上的统计性的规律，这也就是宏观经济学所能看到的。例如每次货币大量发行，最后房价都会上涨，多次训练后，人们也就都学会了。
 
-4.8 人工智能需要大数据
+## 4.8 人工智能需要大数据
+
 
- 
 
 然而神经网络包含这么多的节点，每个节点包含非常多的参数，整个参数量实在是太大了，需要的计算量实在太大，但是没有关系啊，我们有大数据平台，可以汇聚多台机器的力量一起来计算，才能在有限的时间内得到想要的结果。
 
@@ -370,9 +388,6 @@
 
 于是工智能程序作为SaaS平台进入了云计算。
 
-五、云计算，大数据，人工智能过上了美好的生活
+# 五、云计算，大数据，人工智能过上了美好的生活
 
 终于云计算的三兄弟凑齐了，分别是IaaS，PaaS和SaaS，所以一般在一个云计算平台上，云，大数据，人工智能都能找得到。对一个大数据公司，积累了大量的数据，也会使用一些人工智能的算法提供一些服务。对于一个人工智能公司，也不可能没有大数据平台支撑。所以云计算，大数据，人工智能就这样整合起来，完成了相遇，相识，相知。
-
-
-
diff --git "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\21010\357\274\232Docker \346\240\270\345\277\203\346\212\200\346\234\257\344\270\216\345\256\236\347\216\260\345\216\237\347\220\206.md" "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232Docker \346\240\270\345\277\203\346\212\200\346\234\257\344\270\216\345\256\236\347\216\260\345\216\237\347\220\206.md"
similarity index 55%
rename from "docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\21010\357\274\232Docker \346\240\270\345\277\203\346\212\200\346\234\257\344\270\216\345\256\236\347\216\260\345\216\237\347\220\206.md"
rename to "docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232Docker \346\240\270\345\277\203\346\212\200\346\234\257\344\270\216\345\256\236\347\216\260\345\216\237\347\220\206.md"
index 054addd..38c3e32 100644
--- "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\21010\357\274\232Docker \346\240\270\345\277\203\346\212\200\346\234\257\344\270\216\345\256\236\347\216\260\345\216\237\347\220\206.md"	
+++ "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232Docker \346\240\270\345\277\203\346\212\200\346\234\257\344\270\216\345\256\236\347\216\260\345\216\237\347\220\206.md"	
@@ -1,20 +1,22 @@
-# Table of Contents
-
-  * [[](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#namespaces)Namespaces](#[]httpsdravenessmedockerhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoionamespacesnamespaces)
-    * [[](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E8%BF%9B%E7%A8%8B)进程](#[]httpsdravenessmedockerhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioe8bf9be7a88b进程)
-    * [[](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E7%BD%91%E7%BB%9C)网络](#[]httpsdravenessmedockerhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioe7bd91e7bb9c网络)
-      * [[](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#libnetwork)libnetwork](#[]httpsdravenessmedockerhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoiolibnetworklibnetwork)
-    * [[](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E6%8C%82%E8%BD%BD%E7%82%B9)挂载点](#[]httpsdravenessmedockerhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioe68c82e8bdbde782b9挂载点)
-    * [[](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#chroot)chroot
](#[]httpsdravenessmedockerhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoiochrootchroot
)
-  * [[](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#cgroups)CGroups](#[]httpsdravenessmedockerhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoiocgroupscgroups)
-  * [[](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#unionfs)UnionFS](#[]httpsdravenessmedockerhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoiounionfsunionfs)
-    * [[](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E5%AD%98%E5%82%A8%E9%A9%B1%E5%8A%A8)存储驱动](#[]httpsdravenessmedockerhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioe5ad98e582a8e9a9b1e58aa8存储驱动)
-    * [[](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#aufs)AUFS](#[]httpsdravenessmedockerhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioaufsaufs)
-    * [[](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E5%85%B6%E4%BB%96%E5%AD%98%E5%82%A8%E9%A9%B1%E5%8A%A8)其他存储驱动](#[]httpsdravenessmedockerhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioe585b6e4bb96e5ad98e582a8e9a9b1e58aa8其他存储驱动)
-  * [[](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E6%80%BB%E7%BB%93)总结](#[]httpsdravenessmedockerhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioe680bbe7bb93总结)
-
-
-本文转自互联网，侵删
+# 目录
+
+  * [Namespaces](#namespaces)
+  * [进程](#进程)
+  * [网络](#网络)
+    * [libnetwork](#libnetwork)
+  * [挂载点](#挂载点)
+  * [chroot](#chroot)
+  * [CGroups](#cgroups)
+  * [UnionFS](#unionfs)
+  * [存储驱动](#存储驱动)
+  * [AUFS](#aufs)
+  * [其他存储驱动](#其他存储驱动)
+  * [总结](#总结)
+
+
+[toc]
+
+本文转自互联网，侵删  
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
 
@@ -23,13 +25,13 @@
 本系列文章将整理到我的个人博客
 > www.how2playlife.com
 
-更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注
+更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注  
 该系列博文会介绍常见的后端技术，这对后端工程师来说是一种综合能力，我们会逐步了解搜索技术，云计算相关技术、大数据研发等常见的技术喜提，以便让你更完整地了解后端技术栈的全貌，为后续参与分布式应用的开发和学习做好准备。
 
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系我，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 
 
 
@@ -38,135 +40,135 @@
 
 提到虚拟化技术，我们首先想到的一定是 Docker，经过四年的快速发展 Docker 已经成为了很多公司的标配，也不再是一个只能在开发阶段使用的玩具了。作为在生产环境中广泛应用的产品，Docker 有着非常成熟的社区以及大量的使用者，代码库中的内容也变得非常庞大。
 
-![docker-logo](https://img.draveness.me/2017-11-30-docker-logo.png)
+![docker-logo](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-docker-logo.png)
 
-同样，由于项目的发展、功能的拆分以及各种奇怪的改名 [PR](https://github.com/moby/moby/pull/32691)，让我们再次理解 Docker 的的整体架构变得更加困难。
+同样，由于项目的发展、功能的拆分以及各种奇怪的改名[PR](https://github.com/moby/moby/pull/32691)，让我们再次理解 Docker 的的整体架构变得更加困难。
 
 虽然 Docker 目前的组件较多，并且实现也非常复杂，但是本文不想过多的介绍 Docker 具体的实现细节，我们更想谈一谈 Docker 这种虚拟化技术的出现有哪些核心技术的支撑。
 
-![docker-core-techs](https://img.draveness.me/2017-11-30-docker-core-techs.png)
+![docker-core-techs](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-docker-core-techs.png)
 
 首先，Docker 的出现一定是因为目前的后端在开发和运维阶段确实需要一种虚拟化技术解决开发环境和生产环境环境一致的问题，通过 Docker 我们可以将程序运行的环境也纳入到版本控制中，排除因为环境造成不同运行结果的可能。但是上述需求虽然推动了虚拟化技术的产生，但是如果没有合适的底层技术支撑，那么我们仍然得不到一个完美的产品。本文剩下的内容会介绍几种 Docker 使用的核心技术，如果我们了解它们的使用方法和原理，就能清楚 Docker 的实现原理。
 
-## [](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#namespaces)Namespaces
+## Namespaces
 
 命名空间 (namespaces) 是 Linux 为我们提供的用于分离进程树、网络接口、挂载点以及进程间通信等资源的方法。在日常使用 Linux 或者 macOS 时，我们并没有运行多个完全分离的服务器的需要，但是如果我们在服务器上启动了多个服务，这些服务其实会相互影响的，每一个服务都能看到其他服务的进程，也可以访问宿主机器上的任意文件，这是很多时候我们都不愿意看到的，我们更希望运行在同一台机器上的不同服务能做到完全隔离，就像运行在多台不同的机器上一样。
 
-![multiple-servers-on-linux](https://img.draveness.me/2017-11-30-multiple-servers-on-linux.png)
+![multiple-servers-on-linux](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-multiple-servers-on-linux.png)
 
 在这种情况下，一旦服务器上的某一个服务被入侵，那么入侵者就能够访问当前机器上的所有服务和文件，这也是我们不想看到的，而 Docker 其实就通过 Linux 的 Namespaces 对不同的容器实现了隔离。
 
-Linux 的命名空间机制提供了以下七种不同的命名空间，包括 `CLONE_NEWCGROUP`、`CLONE_NEWIPC`、`CLONE_NEWNET`、`CLONE_NEWNS`、`CLONE_NEWPID`、`CLONE_NEWUSER` 和 `CLONE_NEWUTS`，通过这七个选项我们能在创建新的进程时设置新进程应该在哪些资源上与宿主机器进行隔离。
+Linux 的命名空间机制提供了以下七种不同的命名空间，包括`CLONE_NEWCGROUP`、`CLONE_NEWIPC`、`CLONE_NEWNET`、`CLONE_NEWNS`、`CLONE_NEWPID`、`CLONE_NEWUSER`和`CLONE_NEWUTS`，通过这七个选项我们能在创建新的进程时设置新进程应该在哪些资源上与宿主机器进行隔离。
 
-### [](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E8%BF%9B%E7%A8%8B)进程
+## 进程
 
-进程是 Linux 以及现在操作系统中非常重要的概念，它表示一个正在执行的程序，也是在现代分时系统中的一个任务单元。在每一个 *nix 的操作系统上，我们都能够通过 `ps` 命令打印出当前操作系统中正在执行的进程，比如在 Ubuntu 上，使用该命令就能得到以下的结果：
+进程是 Linux 以及现在操作系统中非常重要的概念，它表示一个正在执行的程序，也是在现代分时系统中的一个任务单元。在每一个 *nix 的操作系统上，我们都能够通过`ps`命令打印出当前操作系统中正在执行的进程，比如在 Ubuntu 上，使用该命令就能得到以下的结果：
 
-```
-$ ps -efUID        PID  PPID  C STIME TTY          TIME CMDroot         1     0  0 Apr08 ?        00:00:09 /sbin/initroot         2     0  0 Apr08 ?        00:00:00 [kthreadd]root         3     2  0 Apr08 ?        00:00:05 [ksoftirqd/0]root         5     2  0 Apr08 ?        00:00:00 [kworker/0:0H]root         7     2  0 Apr08 ?        00:07:10 [rcu_sched]root        39     2  0 Apr08 ?        00:00:00 [migration/0]root        40     2  0 Apr08 ?        00:01:54 [watchdog/0]...
-```
+```  
+$ ps -efUID        PID  PPID  C STIME TTY          TIME CMDroot         1     0  0 Apr08 ?        00:00:09 /sbin/initroot         2     0  0 Apr08 ?        00:00:00 [kthreadd]root         3     2  0 Apr08 ?        00:00:05 [ksoftirqd/0]root         5     2  0 Apr08 ?        00:00:00 [kworker/0:0H]root         7     2  0 Apr08 ?        00:07:10 [rcu_sched]root        39     2  0 Apr08 ?        00:00:00 [migration/0]root        40     2  0 Apr08 ?        00:01:54 [watchdog/0]...  
+```  
 
-当前机器上有很多的进程正在执行，在上述进程中有两个非常特殊，一个是 `pid` 为 1 的 `/sbin/init` 进程，另一个是 `pid` 为 2 的 `kthreadd` 进程，这两个进程都是被 Linux 中的上帝进程 `idle` 创建出来的，其中前者负责执行内核的一部分初始化工作和系统配置，也会创建一些类似 `getty` 的注册进程，而后者负责管理和调度其他的内核进程。
+当前机器上有很多的进程正在执行，在上述进程中有两个非常特殊，一个是`pid`为 1 的`/sbin/init`进程，另一个是`pid`为 2 的`kthreadd`进程，这两个进程都是被 Linux 中的上帝进程`idle`创建出来的，其中前者负责执行内核的一部分初始化工作和系统配置，也会创建一些类似`getty`的注册进程，而后者负责管理和调度其他的内核进程。
 
-![linux-processes](https://img.draveness.me/2017-11-30-linux-processes.png)
+![linux-processes](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-linux-processes.png)
 
-如果我们在当前的 Linux 操作系统下运行一个新的 Docker 容器，并通过 `exec` 进入其内部的 `bash` 并打印其中的全部进程，我们会得到以下的结果：
+如果我们在当前的 Linux 操作系统下运行一个新的 Docker 容器，并通过`exec`进入其内部的`bash`并打印其中的全部进程，我们会得到以下的结果：
 
-```
-root@iZ255w13cy6Z:~# docker run -it -d ubuntub809a2eb3630e64c581561b08ac46154878ff1c61c6519848b4a29d412215e79root@iZ255w13cy6Z:~# docker exec -it b809a2eb3630 /bin/bashroot@b809a2eb3630:/# ps -efUID        PID  PPID  C STIME TTY          TIME CMDroot         1     0  0 15:42 pts/0    00:00:00 /bin/bashroot         9     0  0 15:42 pts/1    00:00:00 /bin/bashroot        17     9  0 15:43 pts/1    00:00:00 ps -ef
-```
+```  
+root@iZ255w13cy6Z:~# docker run -it -d ubuntub809a2eb3630e64c581561b08ac46154878ff1c61c6519848b4a29d412215e79root@iZ255w13cy6Z:~# docker exec -it b809a2eb3630 /bin/bashroot@b809a2eb3630:/# ps -efUID        PID  PPID  C STIME TTY          TIME CMDroot         1     0  0 15:42 pts/0    00:00:00 /bin/bashroot         9     0  0 15:42 pts/1    00:00:00 /bin/bashroot        17     9  0 15:43 pts/1    00:00:00 ps -ef  
+```  
 
-在新的容器内部执行 `ps` 命令打印出了非常干净的进程列表，只有包含当前 `ps -ef` 在内的三个进程，在宿主机器上的几十个进程都已经消失不见了。
+在新的容器内部执行`ps`命令打印出了非常干净的进程列表，只有包含当前`ps -ef`在内的三个进程，在宿主机器上的几十个进程都已经消失不见了。
 
 当前的 Docker 容器成功将容器内的进程与宿主机器中的进程隔离，如果我们在宿主机器上打印当前的全部进程时，会得到下面三条与 Docker 相关的结果：
 
-```
-UID        PID  PPID  C STIME TTY          TIME CMDroot     29407     1  0 Nov16 ?        00:08:38 /usr/bin/dockerd --raw-logsroot      1554 29407  0 Nov19 ?        00:03:28 docker-containerd -l unix:///var/run/docker/libcontainerd/docker-containerd.sock --metrics-interval=0 --start-timeout 2m --state-dir /var/run/docker/libcontainerd/containerd --shim docker-containerd-shim --runtime docker-runcroot      5006  1554  0 08:38 ?        00:00:00 docker-containerd-shim b809a2eb3630e64c581561b08ac46154878ff1c61c6519848b4a29d412215e79 /var/run/docker/libcontainerd/b809a2eb3630e64c581561b08ac46154878ff1c61c6519848b4a29d412215e79 docker-runc
-```
+```  
+UID        PID  PPID  C STIME TTY          TIME CMDroot     29407     1  0 Nov16 ?        00:08:38 /usr/bin/dockerd --raw-logsroot      1554 29407  0 Nov19 ?        00:03:28 docker-containerd -l unix:///var/run/docker/libcontainerd/docker-containerd.sock --metrics-interval=0 --start-timeout 2m --state-dir /var/run/docker/libcontainerd/containerd --shim docker-containerd-shim --runtime docker-runcroot      5006  1554  0 08:38 ?        00:00:00 docker-containerd-shim b809a2eb3630e64c581561b08ac46154878ff1c61c6519848b4a29d412215e79 /var/run/docker/libcontainerd/b809a2eb3630e64c581561b08ac46154878ff1c61c6519848b4a29d412215e79 docker-runc  
+```  
 
 在当前的宿主机器上，可能就存在由上述的不同进程构成的进程树：
 
-![docker-process-group](https://img.draveness.me/2017-11-30-docker-process-group.png)
-
-这就是在使用 `clone(2)` 创建新进程时传入 `CLONE_NEWPID` 实现的，也就是使用 Linux 的命名空间实现进程的隔离，Docker 容器内部的任意进程都对宿主机器的进程一无所知。
+![docker-process-group](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-docker-process-group.png)
 
-```
-containerRouter.postContainersStart└── daemon.ContainerStart    └── daemon.createSpec        └── setNamespaces            └── setNamespace
-```
+这就是在使用`clone(2)`创建新进程时传入`CLONE_NEWPID`实现的，也就是使用 Linux 的命名空间实现进程的隔离，Docker 容器内部的任意进程都对宿主机器的进程一无所知。
 
-Docker 的容器就是使用上述技术实现与宿主机器的进程隔离，当我们每次运行 `docker run` 或者 `docker start` 时，都会在下面的方法中创建一个用于设置进程间隔离的 Spec：
+```  
+containerRouter.postContainersStart└── daemon.ContainerStart    └── daemon.createSpec        └── setNamespaces            └── setNamespace  
+```  
 
-```
-func (daemon *Daemon) createSpec(c *container.Container) (*specs.Spec, error) {	s := oci.DefaultSpec() 	// ...	if err := setNamespaces(daemon, &s, c); err != nil {		return nil, fmt.Errorf("linux spec namespaces: %v", err)	} 	return &s, nil}
-```
+Docker 的容器就是使用上述技术实现与宿主机器的进程隔离，当我们每次运行`docker run`或者`docker start`时，都会在下面的方法中创建一个用于设置进程间隔离的 Spec：
 
-在 `setNamespaces` 方法中不仅会设置进程相关的命名空间，还会设置与用户、网络、IPC 以及 UTS 相关的命名空间：
+```  
+func (daemon *Daemon) createSpec(c *container.Container) (*specs.Spec, error) {    s := oci.DefaultSpec()     // ... if err := setNamespaces(daemon, &s, c); err != nil {      return nil, fmt.Errorf("linux spec namespaces: %v", err)   }  return &s, nil}  
+```  
 
-```
-func setNamespaces(daemon *Daemon, s *specs.Spec, c *container.Container) error {	// user	// network	// ipc	// uts 	// pid	if c.HostConfig.PidMode.IsContainer() {		ns := specs.LinuxNamespace{Type: "pid"}		pc, err := daemon.getPidContainer(c)		if err != nil {			return err		}		ns.Path = fmt.Sprintf("/proc/%d/ns/pid", pc.State.GetPID())		setNamespace(s, ns)	} else if c.HostConfig.PidMode.IsHost() {		oci.RemoveNamespace(s, specs.LinuxNamespaceType("pid"))	} else {		ns := specs.LinuxNamespace{Type: "pid"}		setNamespace(s, ns)	} 	return nil}
-```
+在`setNamespaces`方法中不仅会设置进程相关的命名空间，还会设置与用户、网络、IPC 以及 UTS 相关的命名空间：
 
-所有命名空间相关的设置 `Spec` 最后都会作为 `Create` 函数的入参在创建新的容器时进行设置：
+```  
+func setNamespaces(daemon *Daemon, s *specs.Spec, c *container.Container) error {  // user    // network // ipc // uts     // pid if c.HostConfig.PidMode.IsContainer() {       ns := specs.LinuxNamespace{Type: "pid"}       pc, err := daemon.getPidContainer(c)      if err != nil {          return err    }     ns.Path = fmt.Sprintf("/proc/%d/ns/pid", pc.State.GetPID())       setNamespace(s, ns)    } else if c.HostConfig.PidMode.IsHost() {     oci.RemoveNamespace(s, specs.LinuxNamespaceType("pid"))    } else {      ns := specs.LinuxNamespace{Type: "pid"}       setNamespace(s, ns)    }  return nil}  
+```  
 
-```
-daemon.containerd.Create(context.Background(), container.ID, spec, createOptions)
+所有命名空间相关的设置`Spec`最后都会作为`Create`函数的入参在创建新的容器时进行设置：
 
-```
+```  
+daemon.containerd.Create(context.Background(), container.ID, spec, createOptions)  
+  
+```  
 
 所有与命名空间的相关的设置都是在上述的两个函数中完成的，Docker 通过命名空间成功完成了与宿主机进程和网络的隔离。
 
-### [](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E7%BD%91%E7%BB%9C)网络
+## 网络
 
 如果 Docker 的容器通过 Linux 的命名空间完成了与宿主机进程的网络隔离，但是却有没有办法通过宿主机的网络与整个互联网相连，就会产生很多限制，所以 Docker 虽然可以通过命名空间创建一个隔离的网络环境，但是 Docker 中的服务仍然需要与外界相连才能发挥作用。
 
-每一个使用 `docker run` 启动的容器其实都具有单独的网络命名空间，Docker 为我们提供了四种不同的网络模式，Host、Container、None 和 Bridge 模式。
+每一个使用`docker run`启动的容器其实都具有单独的网络命名空间，Docker 为我们提供了四种不同的网络模式，Host、Container、None 和 Bridge 模式。
 
-![docker-network](https://img.draveness.me/2017-11-30-docker-network.png)
+![docker-network](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-docker-network.png)
 
 在这一部分，我们将介绍 Docker 默认的网络设置模式：网桥模式。在这种模式下，除了分配隔离的网络命名空间之外，Docker 还会为所有的容器设置 IP 地址。当 Docker 服务器在主机上启动之后会创建新的虚拟网桥 docker0，随后在该主机上启动的全部服务在默认情况下都与该网桥相连。
 
-![docker-network-topology](https://img.draveness.me/2017-11-30-docker-network-topology.png)
+![docker-network-topology](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-docker-network-topology.png)
 
 在默认情况下，每一个容器在创建时都会创建一对虚拟网卡，两个虚拟网卡组成了数据的通道，其中一个会放在创建的容器中，会加入到名为 docker0 网桥中。我们可以使用如下的命令来查看当前网桥的接口：
 
-```
-$ brctl showbridge name	bridge id		STP enabled	interfacesdocker0		8000.0242a6654980	no		veth3e84d4f							            veth9953b75
-```
+```  
+$ brctl showbridge name    bridge id     STP enabled    interfacesdocker0     8000.0242a6654980  no    veth3e84d4f                                  veth9953b75  
+```  
 
 docker0 会为每一个容器分配一个新的 IP 地址并将 docker0 的 IP 地址设置为默认的网关。网桥 docker0 通过 iptables 中的配置与宿主机器上的网卡相连，所有符合条件的请求都会通过 iptables 转发到 docker0 并由网桥分发给对应的机器。
 
-```
-$ iptables -t nat -LChain PREROUTING (policy ACCEPT)target     prot opt source               destinationDOCKER     all  --  anywhere             anywhere             ADDRTYPE match dst-type LOCAL Chain DOCKER (2 references)target     prot opt source               destinationRETURN     all  --  anywhere             anywhere
-```
-
-我们在当前的机器上使用 `docker run -d -p 6379:6379 redis` 命令启动了一个新的 Redis 容器，在这之后我们再查看当前 `iptables` 的 NAT 配置就会看到在 `DOCKER` 的链中出现了一条新的规则：
+```  
+$ iptables -t nat -LChain PREROUTING (policy ACCEPT)target     prot opt source               destinationDOCKER     all  --  anywhere             anywhere             ADDRTYPE match dst-type LOCAL Chain DOCKER (2 references)target     prot opt source               destinationRETURN     all  --  anywhere             anywhere  
+```  
 
-```
-DNAT       tcp  --  anywhere             anywhere             tcp dpt:6379 to:192.168.0.4:6379
+我们在当前的机器上使用`docker run -d -p 6379:6379 redis`命令启动了一个新的 Redis 容器，在这之后我们再查看当前`iptables`的 NAT 配置就会看到在`DOCKER`的链中出现了一条新的规则：
 
-```
+```  
+DNAT       tcp  --  anywhere             anywhere             tcp dpt:6379 to:192.168.0.4:6379  
+  
+```  
 
 上述规则会将从任意源发送到当前机器 6379 端口的 TCP 包转发到 192.168.0.4:6379 所在的地址上。
 
 这个地址其实也是 Docker 为 Redis 服务分配的 IP 地址，如果我们在当前机器上直接 ping 这个 IP 地址就会发现它是可以访问到的：
 
-```
-$ ping 192.168.0.4PING 192.168.0.4 (192.168.0.4) 56(84) bytes of data.64 bytes from 192.168.0.4: icmp_seq=1 ttl=64 time=0.069 ms64 bytes from 192.168.0.4: icmp_seq=2 ttl=64 time=0.043 ms^C--- 192.168.0.4 ping statistics ---2 packets transmitted, 2 received, 0% packet loss, time 999msrtt min/avg/max/mdev = 0.043/0.056/0.069/0.013 ms
-```
+```  
+$ ping 192.168.0.4PING 192.168.0.4 (192.168.0.4) 56(84) bytes of data.64 bytes from 192.168.0.4: icmp_seq=1 ttl=64 time=0.069 ms64 bytes from 192.168.0.4: icmp_seq=2 ttl=64 time=0.043 ms^C--- 192.168.0.4 ping statistics ---2 packets transmitted, 2 received, 0% packet loss, time 999msrtt min/avg/max/mdev = 0.043/0.056/0.069/0.013 ms  
+```  
 
 从上述的一系列现象，我们就可以推测出 Docker 是如何将容器的内部的端口暴露出来并对数据包进行转发的了；当有 Docker 的容器需要将服务暴露给宿主机器，就会为容器分配一个 IP 地址，同时向 iptables 中追加一条新的规则。
 
-![docker-network-forward](https://img.draveness.me/2017-11-30-docker-network-forward.png)
+![docker-network-forward](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-docker-network-forward.png)
 
-当我们使用 `redis-cli` 在宿主机器的命令行中访问 127.0.0.1:6379 的地址时，经过 iptables 的 NAT PREROUTING 将 ip 地址定向到了 192.168.0.4，重定向过的数据包就可以通过 iptables 中的 FILTER 配置，最终在 NAT POSTROUTING 阶段将 ip 地址伪装成 127.0.0.1，到这里虽然从外面看起来我们请求的是 127.0.0.1:6379，但是实际上请求的已经是 Docker 容器暴露出的端口了。
+当我们使用`redis-cli`在宿主机器的命令行中访问 127.0.0.1:6379 的地址时，经过 iptables 的 NAT PREROUTING 将 ip 地址定向到了 192.168.0.4，重定向过的数据包就可以通过 iptables 中的 FILTER 配置，最终在 NAT POSTROUTING 阶段将 ip 地址伪装成 127.0.0.1，到这里虽然从外面看起来我们请求的是 127.0.0.1:6379，但是实际上请求的已经是 Docker 容器暴露出的端口了。
 
-```
-$ redis-cli -h 127.0.0.1 -p 6379 pingPONG
-```
+```  
+$ redis-cli -h 127.0.0.1 -p 6379 pingPONG  
+```  
 
 Docker 通过 Linux 的命名空间实现了网络的隔离，又通过 iptables 进行数据包转发，让 Docker 容器能够优雅地为宿主机器或者其他容器提供服务。
 
-#### [](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#libnetwork)libnetwork
+### libnetwork
 
 整个网络部分的功能都是通过 Docker 拆分出来的 libnetwork 实现的，它提供了一个连接不同容器的实现，同时也能够为应用给出一个能够提供一致的编程接口和网络层抽象的容器网络模型。
 
@@ -174,167 +176,160 @@ Docker 通过 Linux 的命名空间实现了网络的隔离，又通过 iptables
 
 libnetwork 中最重要的概念，容器网络模型由以下的几个主要组件组成，分别是 Sandbox、Endpoint 和 Network：
 
-![container-network-model](https://img.draveness.me/2017-11-30-container-network-model.png)
+![container-network-model](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-container-network-model.png)
 
 在容器网络模型中，每一个容器内部都包含一个 Sandbox，其中存储着当前容器的网络栈配置，包括容器的接口、路由表和 DNS 设置，Linux 使用网络命名空间实现这个 Sandbox，每一个 Sandbox 中都可能会有一个或多个 Endpoint，在 Linux 上就是一个虚拟的网卡 veth，Sandbox 通过 Endpoint 加入到对应的网络中，这里的网络可能就是我们在上面提到的 Linux 网桥或者 VLAN。
 
-> 想要获得更多与 libnetwork 或者容器网络模型相关的信息，可以阅读 [Design · libnetwork](https://github.com/docker/libnetwork/blob/master/docs/design.md) 了解更多信息，当然也可以阅读源代码了解不同 OS 对容器网络模型的不同实现。
+> 想要获得更多与 libnetwork 或者容器网络模型相关的信息，可以阅读[Design · libnetwork](https://github.com/docker/libnetwork/blob/master/docs/design.md)了解更多信息，当然也可以阅读源代码了解不同 OS 对容器网络模型的不同实现。
 
-### [](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E6%8C%82%E8%BD%BD%E7%82%B9)挂载点
+## 挂载点
 
 虽然我们已经通过 Linux 的命名空间解决了进程和网络隔离的问题，在 Docker 进程中我们已经没有办法访问宿主机器上的其他进程并且限制了网络的访问，但是 Docker 容器中的进程仍然能够访问或者修改宿主机器上的其他目录，这是我们不希望看到的。
 
-在新的进程中创建隔离的挂载点命名空间需要在 `clone` 函数中传入 `CLONE_NEWNS`，这样子进程就能得到父进程挂载点的拷贝，如果不传入这个参数子进程对文件系统的读写都会同步回父进程以及整个主机的文件系统。
+在新的进程中创建隔离的挂载点命名空间需要在`clone`函数中传入`CLONE_NEWNS`，这样子进程就能得到父进程挂载点的拷贝，如果不传入这个参数子进程对文件系统的读写都会同步回父进程以及整个主机的文件系统。
 
 如果一个容器需要启动，那么它一定需要提供一个根文件系统（rootfs），容器需要使用这个文件系统来创建一个新的进程，所有二进制的执行都必须在这个根文件系统中。
 
-![libcontainer-filesystem](https://img.draveness.me/2017-11-30-libcontainer-filesystem.png)
+![libcontainer-filesystem](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-libcontainer-filesystem.png)
 
 想要正常启动一个容器就需要在 rootfs 中挂载以上的几个特定的目录，除了上述的几个目录需要挂载之外我们还需要建立一些符号链接保证系统 IO 不会出现问题。
 
-![libcontainer-symlinks-and-io](https://img.draveness.me/2017-11-30-libcontainer-symlinks-and-io.png)
+![libcontainer-symlinks-and-io](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-libcontainer-symlinks-and-io.png)
 
-为了保证当前的容器进程没有办法访问宿主机器上其他目录，我们在这里还需要通过 libcontainer 提供的 `pivot_root` 或者 `chroot` 函数改变进程能够访问个文件目录的根节点。
+为了保证当前的容器进程没有办法访问宿主机器上其他目录，我们在这里还需要通过 libcontainer 提供的`pivot_root`或者`chroot`函数改变进程能够访问个文件目录的根节点。
 
-```
-// pivor_rootput_old = mkdir(...);pivot_root(rootfs, put_old);chdir("/");unmount(put_old, MS_DETACH);rmdir(put_old); // chrootmount(rootfs, "/", NULL, MS_MOVE, NULL);chroot(".");chdir("/");
-```
+```  
+// pivor_rootput_old = mkdir(...);pivot_root(rootfs, put_old);chdir("/");unmount(put_old, MS_DETACH);rmdir(put_old); // chrootmount(rootfs, "/", NULL, MS_MOVE, NULL);chroot(".");chdir("/");  
+```  
 
 到这里我们就将容器需要的目录挂载到了容器中，同时也禁止当前的容器进程访问宿主机器上的其他目录，保证了不同文件系统的隔离。
 
-> 这一部分的内容是作者在 libcontainer 中的 [SPEC.md](https://github.com/opencontainers/runc/blob/master/libcontainer/SPEC.md) 文件中找到的，其中包含了 Docker 使用的文件系统的说明，对于 Docker 是否真的使用 `chroot` 来确保当前的进程无法访问宿主机器的目录，作者其实也没有确切的答案，一是 Docker 项目的代码太多庞大，不知道该从何入手，作者尝试通过 Google 查找相关的结果，但是既找到了无人回答的 [问题](https://forums.docker.com/t/does-the-docker-engine-use-chroot/25429)，也得到了与 SPEC 中的描述有冲突的 [答案](https://www.quora.com/Do-Docker-containers-use-a-chroot-environment) ，如果各位读者有明确的答案可以在博客下面留言，非常感谢。
+> 这一部分的内容是作者在 libcontainer 中的[SPEC.md](https://github.com/opencontainers/runc/blob/master/libcontainer/SPEC.md)文件中找到的，其中包含了 Docker 使用的文件系统的说明，对于 Docker 是否真的使用`chroot`来确保当前的进程无法访问宿主机器的目录，作者其实也没有确切的答案，一是 Docker 项目的代码太多庞大，不知道该从何入手，作者尝试通过 Google 查找相关的结果，但是既找到了无人回答的[问题](https://forums.docker.com/t/does-the-docker-engine-use-chroot/25429)，也得到了与 SPEC 中的描述有冲突的[答案](https://www.quora.com/Do-Docker-containers-use-a-chroot-environment)，如果各位读者有明确的答案可以在博客下面留言，非常感谢。
 
-### [](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#chroot)chroot

+## chroot  
+在这里不得不简单介绍一下`chroot`（change root），在 Linux 系统中，系统默认的目录就都是以`/`也就是根目录开头的，`chroot`的使用能够改变当前的系统根目录结构，通过改变当前系统的根目录，我们能够限制用户的权利，在新的根目录下并不能够访问旧系统根目录的结构个文件，也就建立了一个与原系统完全隔离的目录结构。
 
-在这里不得不简单介绍一下 `chroot`（change root），在 Linux 系统中，系统默认的目录就都是以 `/` 也就是根目录开头的，`chroot` 的使用能够改变当前的系统根目录结构，通过改变当前系统的根目录，我们能够限制用户的权利，在新的根目录下并不能够访问旧系统根目录的结构个文件，也就建立了一个与原系统完全隔离的目录结构。
+> 与 chroot 的相关内容部分来自[理解 chroot](https://www.ibm.com/developerworks/cn/linux/l-cn-chroot/index.html)一文，各位读者可以阅读这篇文章获得更详细的信息。
 
-> 与 chroot 的相关内容部分来自 [理解 chroot](https://www.ibm.com/developerworks/cn/linux/l-cn-chroot/index.html) 一文，各位读者可以阅读这篇文章获得更详细的信息。
-
-## [](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#cgroups)CGroups
+## CGroups
 
 我们通过 Linux 的命名空间为新创建的进程隔离了文件系统、网络并与宿主机器之间的进程相互隔离，但是命名空间并不能够为我们提供物理资源上的隔离，比如 CPU 或者内存，如果在同一台机器上运行了多个对彼此以及宿主机器一无所知的『容器』，这些容器却共同占用了宿主机器的物理资源。
 
-![docker-shared-resources](https://img.draveness.me/2017-11-30-docker-shared-resources.png)
+![docker-shared-resources](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-docker-shared-resources.png)
 
 如果其中的某一个容器正在执行 CPU 密集型的任务，那么就会影响其他容器中任务的性能与执行效率，导致多个容器相互影响并且抢占资源。如何对多个容器的资源使用进行限制就成了解决进程虚拟资源隔离之后的主要问题，而 Control Groups（简称 CGroups）就是能够隔离宿主机器上的物理资源，例如 CPU、内存、磁盘 I/O 和网络带宽。
 
 每一个 CGroup 都是一组被相同的标准和参数限制的进程，不同的 CGroup 之间是有层级关系的，也就是说它们之间可以从父类继承一些用于限制资源使用的标准和参数。
 
-![cgroups-inheritance](https://img.draveness.me/2017-11-30-cgroups-inheritance.png)
+![cgroups-inheritance](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-cgroups-inheritance.png)
 
 Linux 的 CGroup 能够为一组进程分配资源，也就是我们在上面提到的 CPU、内存、网络带宽等资源，通过对资源的分配，CGroup 能够提供以下的几种功能：
 
-![groups-features](https://img.draveness.me/2017-11-30-groups-features.png)
+![groups-features](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-groups-features.png)
 
 > 在 CGroup 中，所有的任务就是一个系统的一个进程，而 CGroup 就是一组按照某种标准划分的进程，在 CGroup 这种机制中，所有的资源控制都是以 CGroup 作为单位实现的，每一个进程都可以随时加入一个 CGroup 也可以随时退出一个 CGroup。
-> 
-> – [CGroup 介绍、应用实例及原理描述](https://www.ibm.com/developerworks/cn/linux/1506_cgroup/index.html)
+> > –[CGroup 介绍、应用实例及原理描述](https://www.ibm.com/developerworks/cn/linux/1506_cgroup/index.html)
 
 Linux 使用文件系统来实现 CGroup，我们可以直接使用下面的命令查看当前的 CGroup 中有哪些子系统：
 
-```
-$ lssubsys -mcpuset /sys/fs/cgroup/cpusetcpu /sys/fs/cgroup/cpucpuacct /sys/fs/cgroup/cpuacctmemory /sys/fs/cgroup/memorydevices /sys/fs/cgroup/devicesfreezer /sys/fs/cgroup/freezerblkio /sys/fs/cgroup/blkioperf_event /sys/fs/cgroup/perf_eventhugetlb /sys/fs/cgroup/hugetlb
-```
+```  
+$ lssubsys -mcpuset /sys/fs/cgroup/cpusetcpu /sys/fs/cgroup/cpucpuacct /sys/fs/cgroup/cpuacctmemory /sys/fs/cgroup/memorydevices /sys/fs/cgroup/devicesfreezer /sys/fs/cgroup/freezerblkio /sys/fs/cgroup/blkioperf_event /sys/fs/cgroup/perf_eventhugetlb /sys/fs/cgroup/hugetlb  
+```  
 
 大多数 Linux 的发行版都有着非常相似的子系统，而之所以将上面的 cpuset、cpu 等东西称作子系统，是因为它们能够为对应的控制组分配资源并限制资源的使用。
 
 如果我们想要创建一个新的 cgroup 只需要在想要分配或者限制资源的子系统下面创建一个新的文件夹，然后这个文件夹下就会自动出现很多的内容，如果你在 Linux 上安装了 Docker，你就会发现所有子系统的目录下都有一个名为 docker 的文件夹：
 
-```
-$ ls cpucgroup.clone_children  ...cpu.stat  docker  notify_on_release release_agent tasks $ ls cpu/docker/9c3057f1291b53fd54a3d12023d2644efe6a7db6ddf330436ae73ac92d401cf1 cgroup.clone_children  ...cpu.stat  notify_on_release release_agent tasks
-```
+```  
+$ ls cpucgroup.clone_children  ...cpu.stat  docker  notify_on_release release_agent tasks $ ls cpu/docker/9c3057f1291b53fd54a3d12023d2644efe6a7db6ddf330436ae73ac92d401cf1 cgroup.clone_children  ...cpu.stat  notify_on_release release_agent tasks  
+```  
 
-`9c3057xxx` 其实就是我们运行的一个 Docker 容器，启动这个容器时，Docker 会为这个容器创建一个与容器标识符相同的 CGroup，在当前的主机上 CGroup 就会有以下的层级关系：
+`9c3057xxx`其实就是我们运行的一个 Docker 容器，启动这个容器时，Docker 会为这个容器创建一个与容器标识符相同的 CGroup，在当前的主机上 CGroup 就会有以下的层级关系：
 
-![linux-cgroups](https://img.draveness.me/2017-11-30-linux-cgroups.png)
+![linux-cgroups](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-linux-cgroups.png)
 
-每一个 CGroup 下面都有一个 `tasks` 文件，其中存储着属于当前控制组的所有进程的 pid，作为负责 cpu 的子系统，`cpu.cfs_quota_us` 文件中的内容能够对 CPU 的使用作出限制，如果当前文件的内容为 50000，那么当前控制组中的全部进程的 CPU 占用率不能超过 50%。
+每一个 CGroup 下面都有一个`tasks`文件，其中存储着属于当前控制组的所有进程的 pid，作为负责 cpu 的子系统，`cpu.cfs_quota_us`文件中的内容能够对 CPU 的使用作出限制，如果当前文件的内容为 50000，那么当前控制组中的全部进程的 CPU 占用率不能超过 50%。
 
-如果系统管理员想要控制 Docker 某个容器的资源使用率就可以在 `docker`这个父控制组下面找到对应的子控制组并且改变它们对应文件的内容，当然我们也可以直接在程序运行时就使用参数，让 Docker 进程去改变相应文件中的内容。
+如果系统管理员想要控制 Docker 某个容器的资源使用率就可以在`docker`这个父控制组下面找到对应的子控制组并且改变它们对应文件的内容，当然我们也可以直接在程序运行时就使用参数，让 Docker 进程去改变相应文件中的内容。
 
-```
-$ docker run -it -d --cpu-quota=50000 busybox53861305258ecdd7f5d2a3240af694aec9adb91cd4c7e210b757f71153cdd274$ cd 53861305258ecdd7f5d2a3240af694aec9adb91cd4c7e210b757f71153cdd274/$ lscgroup.clone_children  cgroup.event_control  cgroup.procs  cpu.cfs_period_us  cpu.cfs_quota_us  cpu.shares  cpu.stat  notify_on_release  tasks$ cat cpu.cfs_quota_us50000
-```
+```  
+$ docker run -it -d --cpu-quota=50000 busybox53861305258ecdd7f5d2a3240af694aec9adb91cd4c7e210b757f71153cdd274$ cd 53861305258ecdd7f5d2a3240af694aec9adb91cd4c7e210b757f71153cdd274/$ lscgroup.clone_children  cgroup.event_control  cgroup.procs  cpu.cfs_period_us  cpu.cfs_quota_us  cpu.shares  cpu.stat  notify_on_release  tasks$ cat cpu.cfs_quota_us50000  
+```  
 
 当我们使用 Docker 关闭掉正在运行的容器时，Docker 的子控制组对应的文件夹也会被 Docker 进程移除，Docker 在使用 CGroup 时其实也只是做了一些创建文件夹改变文件内容的文件操作，不过 CGroup 的使用也确实解决了我们限制子容器资源占用的问题，系统管理员能够为多个容器合理的分配资源并且不会出现多个容器互相抢占资源的问题。
 
-## [](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#unionfs)UnionFS
+## UnionFS
 
 Linux 的命名空间和控制组分别解决了不同资源隔离的问题，前者解决了进程、网络以及文件系统的隔离，后者实现了 CPU、内存等资源的隔离，但是在 Docker 中还有另一个非常重要的问题需要解决 - 也就是镜像。
 
-镜像到底是什么，它又是如何组成和组织的是作者使用 Docker 以来的一段时间内一直比较让作者感到困惑的问题，我们可以使用 `docker run` 非常轻松地从远程下载 Docker 的镜像并在本地运行。
+镜像到底是什么，它又是如何组成和组织的是作者使用 Docker 以来的一段时间内一直比较让作者感到困惑的问题，我们可以使用`docker run`非常轻松地从远程下载 Docker 的镜像并在本地运行。
 
 Docker 镜像其实本质就是一个压缩包，我们可以使用下面的命令将一个 Docker 镜像中的文件导出：
 
-```
-$ docker export $(docker create busybox) | tar -C rootfs -xvf -$ lsbin  dev  etc  home proc root sys  tmp  usr  var
-```
+```  
+$ docker export $(docker create busybox) | tar -C rootfs -xvf -$ lsbin  dev  etc  home proc root sys  tmp  usr  var  
+```  
 
-你可以看到这个 busybox 镜像中的目录结构与 Linux 操作系统的根目录中的内容并没有太多的区别，可以说 Docker 镜像就是一个文件。
+你可以看到这个 busybox 镜像中的目录结构与 Linux 操作系统的根目录中的内容并没有太多的区别，可以说Docker 镜像就是一个文件。
 
-### [](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E5%AD%98%E5%82%A8%E9%A9%B1%E5%8A%A8)存储驱动
+## 存储驱动
 
 Docker 使用了一系列不同的存储驱动管理镜像内的文件系统并运行容器，这些存储驱动与 Docker 卷（volume）有些不同，存储引擎管理着能够在多个容器之间共享的存储。
 
 想要理解 Docker 使用的存储驱动，我们首先需要理解 Docker 是如何构建并且存储镜像的，也需要明白 Docker 的镜像是如何被每一个容器所使用的；Docker 中的每一个镜像都是由一系列只读的层组成的，Dockerfile 中的每一个命令都会在已有的只读层上创建一个新的层：
 
-```
-FROM ubuntu:15.04COPY . /appRUN make /appCMD python /app/app.py
-```
+```  
+FROM ubuntu:15.04COPY . /appRUN make /appCMD python /app/app.py  
+```  
 
 容器中的每一层都只对当前容器进行了非常小的修改，上述的 Dockerfile 文件会构建一个拥有四层 layer 的镜像：
 
-![docker-container-laye](https://img.draveness.me/2017-11-30-docker-container-layer.png)
+![docker-container-laye](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-docker-container-layer.png)
 
-当镜像被 `docker run` 命令创建时就会在镜像的最上层添加一个可写的层，也就是容器层，所有对于运行时容器的修改其实都是对这个容器读写层的修改。
+当镜像被`docker run`命令创建时就会在镜像的最上层添加一个可写的层，也就是容器层，所有对于运行时容器的修改其实都是对这个容器读写层的修改。
 
 容器和镜像的区别就在于，所有的镜像都是只读的，而每一个容器其实等于镜像加上一个可读写的层，也就是同一个镜像可以对应多个容器。
 
-![docker-images-and-container](https://img.draveness.me/2017-12-06-docker-images-and-container.png)
+![docker-images-and-container](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-12-06-docker-images-and-container.png)
 
-### [](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#aufs)AUFS
+## AUFS
 
 UnionFS 其实是一种为 Linux 操作系统设计的用于把多个文件系统『联合』到同一个挂载点的文件系统服务。而 AUFS 即 Advanced UnionFS 其实就是 UnionFS 的升级版，它能够提供更优秀的性能和效率。
 
 AUFS 作为联合文件系统，它能够将不同文件夹中的层联合（Union）到了同一个文件夹中，这些文件夹在 AUFS 中称作分支，整个『联合』的过程被称为_联合挂载（Union Mount）_：
 
-![docker-aufs](https://img.draveness.me/2017-11-30-docker-aufs.png)
+![docker-aufs](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-docker-aufs.png)
 
-每一个镜像层或者容器层都是 `/var/lib/docker/` 目录下的一个子文件夹；在 Docker 中，所有镜像层和容器层的内容都存储在 `/var/lib/docker/aufs/diff/` 目录中：
+每一个镜像层或者容器层都是`/var/lib/docker/`目录下的一个子文件夹；在 Docker 中，所有镜像层和容器层的内容都存储在`/var/lib/docker/aufs/diff/`目录中：
 
-```
-$ ls /var/lib/docker/aufs/diff/00adcccc1a55a36a610a6ebb3e07cc35577f2f5a3b671be3dbc0e74db9ca691c       93604f232a831b22aeb372d5b11af8c8779feb96590a6dc36a80140e38e764d800adcccc1a55a36a610a6ebb3e07cc35577f2f5a3b671be3dbc0e74db9ca691c-init  93604f232a831b22aeb372d5b11af8c8779feb96590a6dc36a80140e38e764d8-init019a8283e2ff6fca8d0a07884c78b41662979f848190f0658813bb6a9a464a90       93b06191602b7934fafc984fbacae02911b579769d0debd89cf2a032e7f35cfa...
-```
+```  
+$ ls /var/lib/docker/aufs/diff/00adcccc1a55a36a610a6ebb3e07cc35577f2f5a3b671be3dbc0e74db9ca691c       93604f232a831b22aeb372d5b11af8c8779feb96590a6dc36a80140e38e764d800adcccc1a55a36a610a6ebb3e07cc35577f2f5a3b671be3dbc0e74db9ca691c-init  93604f232a831b22aeb372d5b11af8c8779feb96590a6dc36a80140e38e764d8-init019a8283e2ff6fca8d0a07884c78b41662979f848190f0658813bb6a9a464a90       93b06191602b7934fafc984fbacae02911b579769d0debd89cf2a032e7f35cfa...  
+```  
 
-而 `/var/lib/docker/aufs/layers/` 中存储着镜像层的元数据，每一个文件都保存着镜像层的元数据，最后的 `/var/lib/docker/aufs/mnt/` 包含镜像或者容器层的挂载点，最终会被 Docker 通过联合的方式进行组装。
+而`/var/lib/docker/aufs/layers/`中存储着镜像层的元数据，每一个文件都保存着镜像层的元数据，最后的`/var/lib/docker/aufs/mnt/`包含镜像或者容器层的挂载点，最终会被 Docker 通过联合的方式进行组装。
 
-![docker-filesystems](https://img.draveness.me/2017-11-30-docker-filesystems.png)
+![docker-filesystems](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-docker-filesystems.png)
 
 上面的这张图片非常好的展示了组装的过程，每一个镜像层都是建立在另一个镜像层之上的，同时所有的镜像层都是只读的，只有每个容器最顶层的容器层才可以被用户直接读写，所有的容器都建立在一些底层服务（Kernel）上，包括命名空间、控制组、rootfs 等等，这种容器的组装方式提供了非常大的灵活性，只读的镜像层通过共享也能够减少磁盘的占用。
 
-### [](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E5%85%B6%E4%BB%96%E5%AD%98%E5%82%A8%E9%A9%B1%E5%8A%A8)其他存储驱动
+## 其他存储驱动
 
-AUFS 只是 Docker 使用的存储驱动的一种，除了 AUFS 之外，Docker 还支持了不同的存储驱动，包括 `aufs`、`devicemapper`、`overlay2`、`zfs` 和 `vfs` 等等，在最新的 Docker 中，`overlay2` 取代了 `aufs` 成为了推荐的存储驱动，但是在没有 `overlay2` 驱动的机器上仍然会使用 `aufs` 作为 Docker 的默认驱动。
+AUFS 只是 Docker 使用的存储驱动的一种，除了 AUFS 之外，Docker 还支持了不同的存储驱动，包括`aufs`、`devicemapper`、`overlay2`、`zfs`和`vfs`等等，在最新的 Docker 中，`overlay2`取代了`aufs`成为了推荐的存储驱动，但是在没有`overlay2`驱动的机器上仍然会使用`aufs`作为 Docker 的默认驱动。
 
-![docker-storage-driver](https://img.draveness.me/2017-11-30-docker-storage-driver.png)
+![docker-storage-driver](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2017-11-30-docker-storage-driver.png)
 
-不同的存储驱动在存储镜像和容器文件时也有着完全不同的实现，有兴趣的读者可以在 Docker 的官方文档 [Select a storage driver](https://docs.docker.com/engine/userguide/storagedriver/selectadriver/) 中找到相应的内容。
+不同的存储驱动在存储镜像和容器文件时也有着完全不同的实现，有兴趣的读者可以在 Docker 的官方文档[Select a storage driver](https://docs.docker.com/engine/userguide/storagedriver/selectadriver/)中找到相应的内容。
 
 想要查看当前系统的 Docker 上使用了哪种存储驱动只需要使用以下的命令就能得到相对应的信息：
 
-```
-$ docker info | grep StorageStorage Driver: aufs
-```
+```  
+$ docker info | grep StorageStorage Driver: aufs  
+```  
 
-作者的这台 Ubuntu 上由于没有 `overlay2` 存储驱动，所以使用 `aufs` 作为 Docker 的默认存储驱动。
+作者的这台 Ubuntu 上由于没有`overlay2`存储驱动，所以使用`aufs`作为 Docker 的默认存储驱动。
 
-## [](https://draveness.me/docker?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E6%80%BB%E7%BB%93)总结
+## 总结
 
 Docker 目前已经成为了非常主流的技术，已经在很多成熟公司的生产环境中使用，但是 Docker 的核心技术其实已经有很多年的历史了，Linux 命名空间、控制组和 UnionFS 三大技术支撑了目前 Docker 的实现，也是 Docker 能够出现的最重要原因。
 
-作者在学习 Docker 实现原理的过程中查阅了非常多的资料，从中也学习到了很多与 Linux 操作系统相关的知识，不过由于 Docker 目前的代码库实在是太过庞大，想要从源代码的角度完全理解 Docker 实现的细节已经是非常困难的了，但是如果各位读者真的对其实现细节感兴趣，可以从 [Docker CE](https://github.com/docker/docker-ce) 的源代码开始了解 Docker 的原理。
-
-
-
-
-
+作者在学习 Docker 实现原理的过程中查阅了非常多的资料，从中也学习到了很多与 Linux 操作系统相关的知识，不过由于 Docker 目前的代码库实在是太过庞大，想要从源代码的角度完全理解 Docker 实现的细节已经是非常困难的了，但是如果各位读者真的对其实现细节感兴趣，可以从[Docker CE](https://github.com/docker/docker-ce)的源代码开始了解 Docker 的原理。
diff --git "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2104\357\274\232Elasticsearch\344\270\216solr\345\205\245\351\227\250\345\256\236\350\267\265.md" "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232Elasticsearch\344\270\216solr\345\205\245\351\227\250\345\256\236\350\267\265.md"
similarity index 54%
rename from "docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2104\357\274\232Elasticsearch\344\270\216solr\345\205\245\351\227\250\345\256\236\350\267\265.md"
rename to "docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232Elasticsearch\344\270\216solr\345\205\245\351\227\250\345\256\236\350\267\265.md"
index 3efc648..aa8f4ca 100644
--- "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2104\357\274\232Elasticsearch\344\270\216solr\345\205\245\351\227\250\345\256\236\350\267\265.md"
+++ "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232Elasticsearch\344\270\216solr\345\205\245\351\227\250\345\256\236\350\267\265.md"
@@ -1,6 +1,5 @@
-# Table of Contents
+# 目录
 
-* [阮一峰：全文搜索引擎 Elasticsearch 入门教程](#阮一峰：全文搜索引擎-elasticsearch-入门教程)
   * [一、安装](#一、安装)
   * [二、基本概念](#二、基本概念)
     * [2.1 Node 与 Cluster](#21-node-与-cluster)
@@ -27,31 +26,31 @@
       * [六、总结](#六、总结)
       * [七、附录](#七、附录)
 * [搜索引擎选型整理：Elasticsearch vs Solr](#搜索引擎选型整理：elasticsearch-vs-solr)
-  * [Elasticsearch简介[*](https://link.juejin.im/?target=http%3A%2F%2Ffuxiaopang.gitbooks.io%2Flearnelasticsearch)](#elasticsearch简介[]httpslinkjuejinimtargethttp3a2f2ffuxiaopanggitbooksio2flearnelasticsearch)
-  * [Elasticsearch的优缺点[*](https://link.juejin.im/?target=http%3A%2F%2Fstackoverflow.com%2Fquestions%2F10213009%2Fsolr-vs-elasticsearch)[*](https://link.juejin.im/?target=http%3A%2F%2Fhuangx.in%2F22%2Ftranslation-solr-vs-elasticsearch):](#elasticsearch的优缺点[]httpslinkjuejinimtargethttp3a2f2fstackoverflowcom2fquestions2f102130092fsolr-vs-elasticsearch[]httpslinkjuejinimtargethttp3a2f2fhuangxin2f222ftranslation-solr-vs-elasticsearch)
+  * [Elasticsearch简介](#elasticsearch简介)
+  * [Elasticsearch的优缺点](#elasticsearch的优缺点)
     * [优点](#优点)
     * [缺点](#缺点)
-  * [Solr简介[*](https://link.juejin.im/?target=http%3A%2F%2Fzh.wikipedia.org%2Fwiki%2FSolr)](#solr简介[]httpslinkjuejinimtargethttp3a2f2fzhwikipediaorg2fwiki2fsolr)
+  * [Solr简介](#solr简介)
   * [Solr的优缺点](#solr的优缺点)
     * [优点](#优点-1)
     * [缺点](#缺点-1)
-  * [Elasticsearch与Solr的比较[*](https://link.juejin.im/?target=http%3A%2F%2Fblog.socialcast.com%2Frealtime-search-solr-vs-elasticsearch%2F)](#elasticsearch与solr的比较[]httpslinkjuejinimtargethttp3a2f2fblogsocialcastcom2frealtime-search-solr-vs-elasticsearch2f)
-  * [实际生产环境测试[*](https://link.juejin.im/?target=http%3A%2F%2Fblog.socialcast.com%2Frealtime-search-solr-vs-elasticsearch%2F)](#实际生产环境测试[]httpslinkjuejinimtargethttp3a2f2fblogsocialcastcom2frealtime-search-solr-vs-elasticsearch2f)
+  * [Elasticsearch与Solr的比较](#elasticsearch与solr的比较)
+  * [实际生产环境测试](#实际生产环境测试)
   * [Elasticsearch 与 Solr 的比较总结](#elasticsearch-与-solr-的比较总结)
-  * [其他基于Lucene的开源搜索引擎解决方案[*](https://link.juejin.im/?target=http%3A%2F%2Fmail-archives.apache.org%2Fmod_mbox%2Fhbase-user%2F201006.mbox%2F%253C149150.78881.qm%40web50304.mail.re2.yahoo.com%253E)](#其他基于lucene的开源搜索引擎解决方案[]httpslinkjuejinimtargethttp3a2f2fmail-archivesapacheorg2fmod_mbox2fhbase-user2f201006mbox2f253c14915078881qm40web50304mailre2yahoocom253e)
-
-
-# 阮一峰：全文搜索引擎 Elasticsearch 入门教程
+  * [其他基于Lucene的开源搜索引擎解决方案](#其他基于lucene的开源搜索引擎解决方案)
 
 
+[toc]
 作者：阮一峰
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本系列文章将整理到我的个人博客
+
 > www.how2playlife.com
 
 更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注
@@ -61,49 +60,56 @@
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系我，欢迎你参与本系列博文的创作和修订。
 
 <!-- more -->
-原文链接：[www.ruanyifeng.com](https://link.juejin.im/?target=http%3A%2F%2Fwww.ruanyifeng.com%2Fblog%2F2017%2F08%2Felasticsearch.html)
-
-[9月7日-8日 北京，与 Google Twitch 等团队技术大咖面对面www.bagevent.com](https://www.bagevent.com/event/1291755?bag_track=juejin)
+原文链接：www.ruanyifeng.com
 
 
-
-[全文搜索](https://link.juejin.im/?target=https%3A%2F%2Fbaike.baidu.com%2Fitem%2F%25E5%2585%25A8%25E6%2596%2587%25E6%2590%259C%25E7%25B4%25A2%25E5%25BC%2595%25E6%2593%258E)属于最常见的需求，开源的 [Elasticsearch](https://link.juejin.im/?target=https%3A%2F%2Fwww.elastic.co%2F) （以下简称 Elastic）是目前全文搜索引擎的首选。
-
 它可以快速地储存、搜索和分析海量数据。维基百科、Stack Overflow、Github 都采用它。
 
-![](https://user-gold-cdn.xitu.io/2017/8/23/1744dd6de08a90846583b11bd4638e8f?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-Elastic 的底层是开源库 [Lucene](https://link.juejin.im/?target=https%3A%2F%2Flucene.apache.org%2F)。但是，你没法直接用 Lucene，必须自己写代码去调用它的接口。Elastic 是 Lucene 的封装，提供了 REST API 的操作接口，开箱即用。
+Elastic 的底层是开源库Lucene
+但是，你没法直接用 Lucene，必须自己写代码去调用它的接口。
+Elastic 是 Lucene 的封装，提供了 REST API 的操作接口，开箱即用。
 
 本文从零开始，讲解如何使用 Elastic 搭建自己的全文搜索引擎。每一步都有详细的说明，大家跟着做就能学会。
 
 ## 一、安装
 
-Elastic 需要 Java 8 环境。如果你的机器还没安装 Java，可以参考[这篇文章](https://link.juejin.im/?target=https%3A%2F%2Fwww.digitalocean.com%2Fcommunity%2Ftutorials%2Fhow-to-install-java-with-apt-get-on-debian-8)，注意要保证环境变量`JAVA_HOME`正确设置。
+Elastic 需要 Java 8 环境。注意要保证环境变量`JAVA_HOME`正确设置。
 
-安装完 Java，就可以跟着[官方文档](https://link.juejin.im/?target=https%3A%2F%2Fwww.elastic.co%2Fguide%2Fen%2Felasticsearch%2Freference%2Fcurrent%2Fzip-targz.html)安装 Elastic。直接下载压缩包比较简单。
+安装完 Java，就可以跟着官方文档安装 Elastic。直接下载压缩包比较简单。
 
 > ```
->  $ wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-5.5.1.zip$ unzip elasticsearch-5.5.1.zip$ cd elasticsearch-5.5.1/ 
+> $ wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-5.5.1.zip$ unzip elasticsearch-5.5.1.zip$ cd elasticsearch-5.5.1/ 
 > ```
 
 接着，进入解压后的目录，运行下面的命令，启动 Elastic。
 
 > ```
->  $ ./bin/elasticsearch
+> $ ./bin/elasticsearch
 > ```
 
-如果这时[报错](https://link.juejin.im/?target=https%3A%2F%2Fgithub.com%2Fspujadas%2Felk-docker%2Fissues%2F92)"max virtual memory areas vm.max_map_count [65530] is too low"，要运行下面的命令。
 
 > ```
->  $ sudo sysctl -w vm.max_map_count=262144
+> $ sudo sysctl -w vm.max_map_count=262144
 > ```
 
 如果一切正常，Elastic 就会在默认的9200端口运行。这时，打开另一个命令行窗口，请求该端口，会得到说明信息。
 
-> ```
->  $ curl localhost:9200 {  "name" : "atntrTf",  "cluster_name" : "elasticsearch",  "cluster_uuid" : "tf9250XhQ6ee4h7YI11anA",  "version" : {    "number" : "5.5.1",    "build_hash" : "19c13d0",    "build_date" : "2017-07-18T20:44:24.823Z",    "build_snapshot" : false,    "lucene_version" : "6.6.0"  },  "tagline" : "You Know, for Search"}
-> ```
+```
+> $ curl localhost:9200
+{
+"name": "atntrTf",
+"cluster_name": "elasticsearch",
+"cluster_uuid": "tf9250XhQ6ee4h7YI11anA",
+"version": {
+"number": "5.5.1",
+"build_hash": "19c13d0",
+"build_date": "2017-07-18T20:44:24.823Z",
+"build_snapshot": false,
+"lucene_version": "6.6.0"
+},
+"tagline": "You Know, for Search"
+}
+```
 
 上面代码中，请求9200端口，Elastic 返回一个 JSON 对象，包含当前节点、集群、版本等信息。
 
@@ -112,7 +118,7 @@ Elastic 需要 Java 8 环境。如果你的机器还没安装 Java，可以参
 默认情况下，Elastic 只允许本机访问，如果需要远程访问，可以修改 Elastic 安装目录的`config/elasticsearch.yml`文件，去掉`network.host`的注释，将它的值改成`0.0.0.0`，然后重新启动 Elastic。
 
 > ```
->  network.host: 0.0.0.0
+> network.host: 0.0.0.0
 > ```
 
 上面代码中，设成`0.0.0.0`让任何人都可以访问。线上服务不要这样设置，要设成具体的 IP。
@@ -134,7 +140,7 @@ Elastic 会索引所有字段，经过处理后写入一个反向索引（Invert
 下面的命令可以查看当前节点的所有 Index。
 
 > ```
->  $ curl -X GET 'http://localhost:9200/_cat/indices?v'
+> $ curl -X GET 'http://localhost:9200/_cat/indices?v'
 > ```
 
 ### 2.3 Document
@@ -144,7 +150,7 @@ Index 里面单条的记录称为 Document（文档）。许多条 Document 构
 Document 使用 JSON 格式表示，下面是一个例子。
 
 > ```
->  {  "user": "张三",  "title": "工程师",  "desc": "数据库管理"}
+> {  "user": "张三",  "title": "工程师",  "desc": "数据库管理"}
 > ```
 
 同一个 Index 里面的 Document，不要求有相同的结构（scheme），但是最好保持相同，这样有利于提高搜索效率。
@@ -153,42 +159,44 @@ Document 使用 JSON 格式表示，下面是一个例子。
 
 Document 可以分组，比如`weather`这个 Index 里面，可以按城市分组（北京和上海），也可以按气候分组（晴天和雨天）。这种分组就叫做 Type，它是虚拟的逻辑分组，用来过滤 Document。
 
-不同的 Type 应该有相似的结构（schema），举例来说，`id`字段不能在这个组是字符串，在另一个组是数值。这是与关系型数据库的表的[一个区别](https://link.juejin.im/?target=https%3A%2F%2Fwww.elastic.co%2Fguide%2Fen%2Felasticsearch%2Fguide%2Fcurrent%2Fmapping.html)。性质完全不同的数据（比如`products`和`logs`）应该存成两个 Index，而不是一个 Index 里面的两个 Type（虽然可以做到）。
+不同的 Type 应该有相似的结构（schema），举例来说，`id`字段不能在这个组是字符串，在另一个组是数值。
+这是与关系型数据库的表的一个区别。
+性质完全不同的数据（比如`products`和`logs`）应该存成两个 Index，而不是一个 Index 里面的两个 Type（虽然可以做到）。
 
 下面的命令可以列出每个 Index 所包含的 Type。
 
 > ```
->  $ curl 'localhost:9200/_mapping?pretty=true'
+> $ curl 'localhost:9200/_mapping?pretty=true'
 > ```
 
-根据[规划](https://link.juejin.im/?target=https%3A%2F%2Fwww.elastic.co%2Fblog%2Findex-type-parent-child-join-now-future-in-elasticsearch)，Elastic 6.x 版只允许每个 Index 包含一个 Type，7.x 版将会彻底移除 Type。
+根据规划Elastic 6.x 版只允许每个 Index 包含一个 Type，7.x 版将会彻底移除 Type。
 
 ## 三、新建和删除 Index
 
 新建 Index，可以直接向 Elastic 服务器发出 PUT 请求。下面的例子是新建一个名叫`weather`的 Index。
 
 > ```
->  $ curl -X PUT 'localhost:9200/weather'
+> $ curl -X PUT 'localhost:9200/weather'
 > ```
 
 服务器返回一个 JSON 对象，里面的`acknowledged`字段表示操作成功。
 
 > ```
->  {  "acknowledged":true,  "shards_acknowledged":true}
+> {  "acknowledged":true,  "shards_acknowledged":true}
 > ```
 
 然后，我们发出 DELETE 请求，删除这个 Index。
 
 > ```
->  $ curl -X DELETE 'localhost:9200/weather'
+> $ curl -X DELETE 'localhost:9200/weather'
 > ```
 
 ## 四、中文分词设置
 
-首先，安装中文分词插件。这里使用的是 [ik](https://link.juejin.im/?target=https%3A%2F%2Fgithub.com%2Fmedcl%2Felasticsearch-analysis-ik%2F)，也可以考虑其他插件（比如 [smartcn](https://link.juejin.im/?target=https%3A%2F%2Fwww.elastic.co%2Fguide%2Fen%2Felasticsearch%2Fplugins%2Fcurrent%2Fanalysis-smartcn.html)）。
+首先，安装中文分词插件。这里使用的是ik，也可以考虑其他插件（比如smartcn）。
 
 > ```
->  $ ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v5.5.1/elasticsearch-analysis-ik-5.5.1.zip
+> $ ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v5.5.1/elasticsearch-analysis-ik-5.5.1.zip
 > ```
 
 上面代码安装的是5.5.1版的插件，与 Elastic 5.5.1 配合使用。
@@ -197,9 +205,31 @@ Document 可以分组，比如`weather`这个 Index 里面，可以按城市分
 
 然后，新建一个 Index，指定需要分词的字段。这一步根据数据结构而异，下面的命令只针对本文。基本上，凡是需要搜索的中文字段，都要单独设置一下。
 
-> ```
->  $ curl -X PUT 'localhost:9200/accounts' -d '{  "mappings": {    "person": {      "properties": {        "user": {          "type": "text",          "analyzer": "ik_max_word",          "search_analyzer": "ik_max_word"        },        "title": {          "type": "text",          "analyzer": "ik_max_word",          "search_analyzer": "ik_max_word"        },        "desc": {          "type": "text",          "analyzer": "ik_max_word",          "search_analyzer": "ik_max_word"        }      }    }  }}'
-> ```
+```
+> $ curl -X PUT 'localhost:9200/accounts' -d 
+{
+	"mappings": {
+		"person": {
+			"properties": {
+				"user": {
+					"type": "text",
+					"analyzer": "ik_max_word",
+					"search_analyzer": "ik_max_word"
+				},
+				"title": {
+					"type": "text",
+					"analyzer": "ik_max_word",
+					"search_analyzer": "ik_max_word"
+				},
+				"desc": {
+					"type": "text",
+					"analyzer": "ik_max_word",
+					"search_analyzer": "ik_max_word"
+				}
+			}
+		}
+	}
+}```
 
 上面代码中，首先新建一个名称为`accounts`的 Index，里面有一个名称为`person`的 Type。`person`有三个字段。
 
@@ -209,10 +239,10 @@ Document 可以分组，比如`weather`这个 Index 里面，可以按城市分
 
 这三个字段都是中文，而且类型都是文本（text），所以需要指定中文分词器，不能使用默认的英文分词器。
 
-Elastic 的分词器称为 [analyzer](https://link.juejin.im/?target=https%3A%2F%2Fwww.elastic.co%2Fguide%2Fen%2Felasticsearch%2Freference%2Fcurrent%2Fanalysis.html)。我们对每个字段指定分词器。
+Elastic 的分词器称为analyzer。我们对每个字段指定分词器。
 
 > ```
->  "user": {  "type": "text",  "analyzer": "ik_max_word",  "search_analyzer": "ik_max_word"}
+> "user": {  "type": "text",  "analyzer": "ik_max_word",  "search_analyzer": "ik_max_word"}
 > ```
 
 上面代码中，`analyzer`是字段文本的分词器，`search_analyzer`是搜索词的分词器。`ik_max_word`分词器是插件`ik`提供的，可以对文本进行最大数量的分词。
@@ -224,13 +254,13 @@ Elastic 的分词器称为 [analyzer](https://link.juejin.im/?target=https%3A%2
 向指定的 /Index/Type 发送 PUT 请求，就可以在 Index 里面新增一条记录。比如，向`/accounts/person`发送请求，就可以新增一条人员记录。
 
 > ```
->  $ curl -X PUT 'localhost:9200/accounts/person/1' -d '{  "user": "张三",  "title": "工程师",  "desc": "数据库管理"}' 
+> $ curl -X PUT 'localhost:9200/accounts/person/1' -d '{  "user": "张三",  "title": "工程师",  "desc": "数据库管理"}' 
 > ```
 
 服务器返回的 JSON 对象，会给出 Index、Type、Id、Version 等信息。
 
 > ```
->  {  "_index":"accounts",  "_type":"person",  "_id":"1",  "_version":1,  "result":"created",  "_shards":{"total":2,"successful":1,"failed":0},  "created":true}
+> {  "_index":"accounts",  "_type":"person",  "_id":"1",  "_version":1,  "result":"created",  "_shards":{"total":2,"successful":1,"failed":0},  "created":true}
 > ```
 
 如果你仔细看，会发现请求路径是`/accounts/person/1`，最后的`1`是该条记录的 Id。它不一定是数字，任意字符串（比如`abc`）都可以。
@@ -238,14 +268,26 @@ Elastic 的分词器称为 [analyzer](https://link.juejin.im/?target=https%3A%2
 新增记录的时候，也可以不指定 Id，这时要改成 POST 请求。
 
 > ```
->  $ curl -X POST 'localhost:9200/accounts/person' -d '{  "user": "李四",  "title": "工程师",  "desc": "系统管理"}'
+> $ curl -X POST 'localhost:9200/accounts/person' -d '{  "user": "李四",  "title": "工程师",  "desc": "系统管理"}'
 > ```
 
 上面代码中，向`/accounts/person`发出一个 POST 请求，添加一个记录。这时，服务器返回的 JSON 对象里面，`_id`字段就是一个随机字符串。
 
-> ```
->  {  "_index":"accounts",  "_type":"person",  "_id":"AV3qGfrC6jMbsbXb6k1p",  "_version":1,  "result":"created",  "_shards":{"total":2,"successful":1,"failed":0},  "created":true}
-> ```
+```
+{
+	"_index": "accounts",
+	"_type": "person",
+	"_id": "AV3qGfrC6jMbsbXb6k1p",
+	"_version": 1,
+	"result": "created",
+	"_shards": {
+		"total": 2,
+		"successful": 1,
+		"failed": 0
+	},
+	"created": true
+}
+```
 
 注意，如果没有先创建 Index（这个例子是`accounts`），直接执行上面的命令，Elastic 也不会报错，而是直接生成指定的 Index。所以，打字的时候要小心，不要写错 Index 的名称。
 
@@ -254,21 +296,32 @@ Elastic 的分词器称为 [analyzer](https://link.juejin.im/?target=https%3A%2
 向`/Index/Type/Id`发出 GET 请求，就可以查看这条记录。
 
 > ```
->  $ curl 'localhost:9200/accounts/person/1?pretty=true'
+> $ curl 'localhost:9200/accounts/person/1?pretty=true'
 > ```
 
 上面代码请求查看`/accounts/person/1`这条记录，URL 的参数`pretty=true`表示以易读的格式返回。
 
 返回的数据中，`found`字段表示查询成功，`_source`字段返回原始记录。
 
-> ```
->  {  "_index" : "accounts",  "_type" : "person",  "_id" : "1",  "_version" : 1,  "found" : true,  "_source" : {    "user" : "张三",    "title" : "工程师",    "desc" : "数据库管理"  }}
-> ```
+```
+{
+	"_index": "accounts",
+	"_type": "person",
+	"_id": "1",
+	"_version": 1,
+	"found": true,
+	"_source": {
+		"user": "张三",
+		"title": "工程师",
+		"desc": "数据库管理"
+	}
+}
+```
 
 如果 Id 不正确，就查不到数据，`found`字段就是`false`。
 
 > ```
->  $ curl 'localhost:9200/weather/beijing/abc?pretty=true' {  "_index" : "accounts",  "_type" : "person",  "_id" : "abc",  "found" : false}
+> $ curl 'localhost:9200/weather/beijing/abc?pretty=true' {  "_index" : "accounts",  "_type" : "person",  "_id" : "abc",  "found" : false}
 > ```
 
 ### 5.3 删除记录
@@ -276,7 +329,7 @@ Elastic 的分词器称为 [analyzer](https://link.juejin.im/?target=https%3A%2
 删除记录就是发出 DELETE 请求。
 
 > ```
->  $ curl -X DELETE 'localhost:9200/accounts/person/1'
+> $ curl -X DELETE 'localhost:9200/accounts/person/1'
 > ```
 
 这里先不要删除这条记录，后面还要用到。
@@ -285,14 +338,15 @@ Elastic 的分词器称为 [analyzer](https://link.juejin.im/?target=https%3A%2
 
 更新记录就是使用 PUT 请求，重新发送一次数据。
 
-> ```
->  $ curl -X PUT 'localhost:9200/accounts/person/1' -d '{    "user" : "张三",    "title" : "工程师",    "desc" : "数据库管理，软件开发"}'  {  "_index":"accounts",  "_type":"person",  "_id":"1",  "_version":2,  "result":"updated",  "_shards":{"total":2,"successful":1,"failed":0},  "created":false}
-> ```
+>```
+> $ curl -X PUT 'localhost:9200/accounts/person/1' -d 
+> '{    "user" : "张三",    "title" : "工程师",    "desc" : "数据库管理，软件开发"}'  
+>```
 
 上面代码中，我们将原始数据从"数据库管理"改成"数据库管理，软件开发"。 返回结果里面，有几个字段发生了变化。
 
 > ```
->  "_version" : 2,"result" : "updated","created" : false
+> "_version" : 2,"result" : "updated","created" : false
 > ```
 
 可以看到，记录的 Id 没变，但是版本（version）从`1`变成`2`，操作类型（result）从`created`变成`updated`，`created`字段变成`false`，因为这次不是新建记录。
@@ -303,11 +357,45 @@ Elastic 的分词器称为 [analyzer](https://link.juejin.im/?target=https%3A%2
 
 使用 GET 方法，直接请求`/Index/Type/_search`，就会返回所有记录。
 
-> ```
->  $ curl 'localhost:9200/accounts/person/_search' {  "took":2,  "timed_out":false,  "_shards":{"total":5,"successful":5,"failed":0},  "hits":{    "total":2,    "max_score":1.0,    "hits":[      {        "_index":"accounts",        "_type":"person",        "_id":"AV3qGfrC6jMbsbXb6k1p",        "_score":1.0,        "_source": {          "user": "李四",          "title": "工程师",          "desc": "系统管理"        }      },      {        "_index":"accounts",        "_type":"person",        "_id":"1",        "_score":1.0,        "_source": {          "user" : "张三",          "title" : "工程师",          "desc" : "数据库管理，软件开发"        }      }    ]  }}
-> ```
-
-上面代码中，返回结果的 `took`字段表示该操作的耗时（单位为毫秒），`timed_out`字段表示是否超时，`hits`字段表示命中的记录，里面子字段的含义如下。
+```
+> $ curl 'localhost:9200/accounts/person/_search' 
+{
+	"took": 2,
+	"timed_out": false,
+	"_shards": {
+		"total": 5,
+		"successful": 5,
+		"failed": 0
+	},
+	"hits": {
+		"total": 2,
+		"max_score": 1.0,
+		"hits": [{
+			"_index": "accounts",
+			"_type": "person",
+			"_id": "AV3qGfrC6jMbsbXb6k1p",
+			"_score": 1.0,
+			"_source": {
+				"user": "李四",
+				"title": "工程师",
+				"desc": "系统管理"
+			}
+		}, {
+			"_index": "accounts",
+			"_type": "person",
+			"_id": "1",
+			"_score": 1.0,
+			"_source": {
+				"user": "张三",
+				"title": "工程师",
+				"desc": "数据库管理，软件开发"
+			}
+		}]
+	}
+}
+```
+
+上面代码中，返回结果的`took`字段表示该操作的耗时（单位为毫秒），`timed_out`字段表示是否超时，`hits`字段表示命中的记录，里面子字段的含义如下。
 
 > *   `total`：返回记录数，本例是2条。
 > *   `max_score`：最高的匹配程度，本例是`1.0`。
@@ -317,31 +405,57 @@ Elastic 的分词器称为 [analyzer](https://link.juejin.im/?target=https%3A%2
 
 ### 6.2 全文搜索
 
-Elastic 的查询非常特别，使用自己的[查询语法](https://link.juejin.im/?target=https%3A%2F%2Fwww.elastic.co%2Fguide%2Fen%2Felasticsearch%2Freference%2F5.5%2Fquery-dsl.html)，要求 GET 请求带有数据体。
-
-> ```
->  $ curl 'localhost:9200/accounts/person/_search'  -d '{  "query" : { "match" : { "desc" : "软件" }}}'
-> ```
-
-上面代码使用 [Match 查询](https://link.juejin.im/?target=https%3A%2F%2Fwww.elastic.co%2Fguide%2Fen%2Felasticsearch%2Freference%2F5.5%2Fquery-dsl-match-query.html)，指定的匹配条件是`desc`字段里面包含"软件"这个词。返回结果如下。
-
-> ```
->  {  "took":3,  "timed_out":false,  "_shards":{"total":5,"successful":5,"failed":0},  "hits":{    "total":1,    "max_score":0.28582606,    "hits":[      {        "_index":"accounts",        "_type":"person",        "_id":"1",        "_score":0.28582606,        "_source": {          "user" : "张三",          "title" : "工程师",          "desc" : "数据库管理，软件开发"        }      }    ]  }}
-> ```
+Elastic 的查询非常特别，使用自己的查询语法，要求 GET 请求带有数据体。
+
+```
+> $ curl 'localhost:9200/accounts/person/_search'  -d 
+'{  "query" : { "match" : { "desc" : "软件" }}}'
+```
+
+上面代码使用Match 查询，指定的匹配条件是`desc`字段里面包含"软件"这个词。返回结果如下。
+
+```
+{
+	"took": 3,
+	"timed_out": false,
+	"_shards": {
+		"total": 5,
+		"successful": 5,
+		"failed": 0
+	},
+	"hits": {
+		"total": 1,
+		"max_score": 0.28582606,
+		"hits": [{
+			"_index": "accounts",
+			"_type": "person",
+			"_id": "1",
+			"_score": 0.28582606,
+			"_source": {
+				"user": "张三",
+				"title": "工程师",
+				"desc": "数据库管理，软件开发"
+			}
+		}]
+	}
+}
+```
 
 Elastic 默认一次返回10条结果，可以通过`size`字段改变这个设置。
 
-> ```
->  $ curl 'localhost:9200/accounts/person/_search'  -d '{  "query" : { "match" : { "desc" : "管理" }},  "size": 1}'
-> ```
+```
+> $ curl 'localhost:9200/accounts/person/_search'  -d 
+'{  "query" : { "match" : { "desc" : "管理" }},  "size": 1}'
+```
 
 上面代码指定，每次只返回一条结果。
 
 还可以通过`from`字段，指定位移。
 
-> ```
->  $ curl 'localhost:9200/accounts/person/_search'  -d '{  "query" : { "match" : { "desc" : "管理" }},  "from": 1,  "size": 1}'
-> ```
+ ```
+> $ curl 'localhost:9200/accounts/person/_search'  -d 
+'{  "query" : { "match" : { "desc" : "管理" }},  "from": 1,  "size": 1}'
+ ```
 
 上面代码指定，从位置1开始（默认是从位置0开始），只返回一条结果。
 
@@ -349,17 +463,33 @@ Elastic 默认一次返回10条结果，可以通过`size`字段改变这个设
 
 如果有多个搜索关键字， Elastic 认为它们是`or`关系。
 
-> ```
->  $ curl 'localhost:9200/accounts/person/_search'  -d '{  "query" : { "match" : { "desc" : "软件 系统" }}}'
-> ```
+```
+> $ curl 'localhost:9200/accounts/person/_search'  -d 
+'{  "query" : { "match" : { "desc" : "软件 系统" }}}'
+```
 
 上面代码搜索的是`软件 or 系统`。
 
 如果要执行多个关键词的`and`搜索，必须使用[布尔查询](https://link.juejin.im/?target=https%3A%2F%2Fwww.elastic.co%2Fguide%2Fen%2Felasticsearch%2Freference%2F5.5%2Fquery-dsl-bool-query.html)。
 
-> ```
->  $ curl 'localhost:9200/accounts/person/_search'  -d '{  "query": {    "bool": {      "must": [        { "match": { "desc": "软件" } },        { "match": { "desc": "系统" } }      ]    }  }}'
-> ```
+```
+> $ curl 'localhost:9200/accounts/person/_search'  -d 
+{
+	"query": {
+		"bool": {
+			"must": [{
+				"match": {
+					"desc": "软件"
+				}
+			}, {
+				"match": {
+					"desc": "系统"
+				}
+			}]
+		}
+	}
+}
+```
 
 ## 七、参考链接
 
@@ -376,7 +506,7 @@ Elastic 默认一次返回10条结果，可以通过`size`字段改变这个设
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-3a3865f474573947.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-3a3865f474573947.png)
 
 
 
@@ -393,19 +523,19 @@ Elastic 默认一次返回10条结果，可以通过`size`字段改变这个设
 可以查询到所有标题含有 "法拉利跑车" 关键词的新闻，但是这种方式有明显的弊端：
 
 > 1、模糊查询性能极低，当数据量庞大的时候，往往会使数据库服务中断；
-> 
+>
 > 2、无法查询相关的数据，只能严格在标题中匹配关键词。
 
 因此，需要搭建专门提供搜索功能的服务，具备分词、全文检索等高级功能。 Solr 就是这样一款搜索引擎，可以让你快速搭建适用于自己业务的搜索服务。
 
 #### 二、安装
 
-到官网 [http://lucene.apache.org/solr/](https://link.jianshu.com/?t=http://lucene.apache.org/solr/) 下载安装包，解压并进入 Solr 目录：
+到官网[http://lucene.apache.org/solr/](https://link.jianshu.com/?t=http://lucene.apache.org/solr/)下载安装包，解压并进入 Solr 目录：
 
 > wget 'http://apache.website-solution.net/lucene/solr/6.2.0/solr-6.2.0.tgz'
-> 
+>
 > tar xvf solr-6.2.0.tgz
-> 
+>
 > cd solr-6.2.0
 
 目录结构如下：
@@ -414,7 +544,7 @@ Elastic 默认一次返回10条结果，可以通过`size`字段改变这个设
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-ddbb880dd1a7bcb0.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-ddbb880dd1a7bcb0.png)
 
 
 
@@ -428,7 +558,7 @@ Solr 6.2 目录结构
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-049501dade838caf.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-049501dade838caf.png)
 
 
 
@@ -450,7 +580,7 @@ Solr 将默认监听 8983 端口，其中 -m 1g 指定分配给 JVM 的内存为
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-19bdf6ec1077db99.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-19bdf6ec1077db99.png)
 
 
 
@@ -468,7 +598,7 @@ Solr 管理后台
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-9911b7416917ca06.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-9911b7416917ca06.png)
 
 
 
@@ -482,7 +612,7 @@ my_news 目录结构
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-81af0fb0b5d89edd.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-81af0fb0b5d89edd.png)
 
 
 
@@ -500,7 +630,7 @@ my_news 目录结构
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-cbc2ba3d84087319.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-cbc2ba3d84087319.png)
 
 
 
@@ -518,7 +648,7 @@ fieldType 指定一个字段类型的名称以及在查询/索引的时候可能
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-2657cfb3507d1bae.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-2657cfb3507d1bae.png)
 
 
 
@@ -532,7 +662,7 @@ fieldType 指定一个字段类型的名称以及在查询/索引的时候可能
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-3a3e436e33fa9311.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-3a3e436e33fa9311.png)
 
 
 
@@ -550,7 +680,7 @@ my_news 目录结构
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-5609a84930ed96f0.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-5609a84930ed96f0.png)
 
 
 
@@ -564,7 +694,7 @@ text_ik 类型
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-a46bba01779c0701.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-a46bba01779c0701.png)
 
 
 
@@ -578,7 +708,7 @@ text_ik 类型
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-ab4dec5179c0f5c3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-ab4dec5179c0f5c3.png)
 
 
 
@@ -590,7 +720,7 @@ text_ik 类型
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-e3dc609b92f395a1.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-e3dc609b92f395a1.png)
 
 
 
@@ -602,7 +732,7 @@ text_ik 类型
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-7a145baf9aa36599.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-7a145baf9aa36599.png)
 
 
 
@@ -616,7 +746,7 @@ dataimport config
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-edc3bb352c36e8c2.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-edc3bb352c36e8c2.png)
 
 
 
@@ -624,13 +754,13 @@ dataimport config
 
 
 
-将数据库连接组件 mysql-connector-java-5.1.39-bin.jar 放到 lib 目录下，重启 Solr，访问管理后台，执行全量导入数据： 
+将数据库连接组件 mysql-connector-java-5.1.39-bin.jar 放到 lib 目录下，重启 Solr，访问管理后台，执行全量导入数据：
 
 
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-a4462a20df0716a2.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-a4462a20df0716a2.png)
 
 
 
@@ -644,7 +774,7 @@ dataimport config
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-f437d561069eedd2.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-f437d561069eedd2.png)
 
 
 
@@ -658,7 +788,7 @@ dataimport config
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-73d93e996f0a132c.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-73d93e996f0a132c.png)
 
 
 
@@ -672,7 +802,7 @@ dataimport config
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-9f003409af70ae7a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-9f003409af70ae7a.png)
 
 
 
@@ -692,7 +822,7 @@ dataimport config
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-09494ec9437338cd.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-09494ec9437338cd.png)
 
 
 
@@ -706,7 +836,7 @@ dataimport config
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-3f2587b4bb0dcee3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-3f2587b4bb0dcee3.png)
 
 
 
@@ -718,7 +848,7 @@ dataimport config
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-b12a6ec2234beaef.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-b12a6ec2234beaef.png)
 
 
 
@@ -732,7 +862,7 @@ dataimport config
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-f57a54656abc2f62.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-f57a54656abc2f62.png)
 
 
 
@@ -750,7 +880,7 @@ dataimport config
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-bc4dfa9a4801846f.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-bc4dfa9a4801846f.png)
 
 
 
@@ -758,7 +888,7 @@ dataimport config
 
 
 
-上例可以看到，使用 [IKAnalyzer](https://blog.csdn.net/a724888/article/details/80993677) 分词插件，对 “北京科技大学” 分词的测试结果。当用户搜索 “北京”、“科技大学”、“科技大”、“科技”、“大学” 这些关键词的时候，都会搜索到文本内容含 “北京科技大学” 的文档。
+上例可以看到，使用[IKAnalyzer](https://blog.csdn.net/a724888/article/details/80993677)分词插件，对 “北京科技大学” 分词的测试结果。当用户搜索 “北京”、“科技大学”、“科技大”、“科技”、“大学” 这些关键词的时候，都会搜索到文本内容含 “北京科技大学” 的文档。
 
 常用的中文分词插件有 IKAnalyzer、mmseg4j和 Solr 自带的 smartcn 等，分词效果各有优劣，具体选择哪个，可以根据自己的业务场景，分别测试效果再选择。
 
@@ -768,7 +898,7 @@ dataimport config
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-ac9e935a3b98661c.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-ac9e935a3b98661c.png)
 
 
 
@@ -782,7 +912,7 @@ dataimport config
 
 
 
-![](https://upload-images.jianshu.io/upload_images/19687-34e025db9e4db451.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19687-34e025db9e4db451.png)
 
 
 
@@ -810,7 +940,7 @@ dataimport config
 
 [https://github.com/Ceelog/OpenSchool/blob/master/my_news.zip](https://link.jianshu.com/?t=https://github.com/Ceelog/OpenSchool/blob/master/my_news.zip)
 
-3、还有疑问？联系作者微博/微信 [@Ceelog](https://link.jianshu.com/?t=http://weibo.com/ceelog/)
+3、还有疑问？联系作者微博/微信[@Ceelog](https://link.jianshu.com/?t=http://weibo.com/ceelog/)
 
 
 
@@ -821,7 +951,7 @@ dataimport config
 > 本文首发于[我的博客](https://link.juejin.im/?target=https%3A%2F%2Fblog.kittypanic.com%2F)
 > 原文链接：[Elasticsearch 与 Solr 的比较](https://link.juejin.im/?target=https%3A%2F%2Fblog.kittypanic.com%2Felastic_vs_solr%2F)
 
-## Elasticsearch简介[*](https://link.juejin.im/?target=http%3A%2F%2Ffuxiaopang.gitbooks.io%2Flearnelasticsearch)
+## Elasticsearch简介
 
 Elasticsearch是一个实时的分布式搜索和分析引擎。它可以帮助你用前所未有的速度去处理大规模数据。
 
@@ -863,7 +993,7 @@ Elasticsearch的上手是非常简单的。它附带了很多非常合理的默
 
 但是Elasticsearch并不只是面向大型企业的，它还帮助了很多类似DataDog以及Klout的创业公司进行了功能的扩展。
 
-## Elasticsearch的优缺点[*](https://link.juejin.im/?target=http%3A%2F%2Fstackoverflow.com%2Fquestions%2F10213009%2Fsolr-vs-elasticsearch)[*](https://link.juejin.im/?target=http%3A%2F%2Fhuangx.in%2F22%2Ftranslation-solr-vs-elasticsearch):
+## Elasticsearch的优缺点
 
 ### 优点
 
@@ -880,7 +1010,7 @@ Elasticsearch的上手是非常简单的。它附带了很多非常合理的默
 
 *   还不够自动（不适合当前新的Index Warmup API）
 
-## Solr简介[*](https://link.juejin.im/?target=http%3A%2F%2Fzh.wikipedia.org%2Fwiki%2FSolr)
+## Solr简介
 
 Solr（读作“solar”）是Apache Lucene项目的开源企业搜索平台。其主要功能包括全文检索、命中标示、分面搜索、动态聚类、数据库集成，以及富文本（如Word、PDF）的处理。Solr是高度可扩展的，并提供了分布式搜索和索引复制。Solr是最流行的企业级搜索引擎，Solr4 还增加了NoSQL支持。
 
@@ -902,7 +1032,7 @@ Solr是用Java编写、运行在Servlet容器（如 Apache Tomcat 或Jetty）的
 
 1.  建立索引时，搜索效率下降，实时索引搜索效率不高。
 
-## Elasticsearch与Solr的比较[*](https://link.juejin.im/?target=http%3A%2F%2Fblog.socialcast.com%2Frealtime-search-solr-vs-elasticsearch%2F)
+## Elasticsearch与Solr的比较
 
 当单纯的对已有数据进行搜索时，Solr更快。
 
@@ -918,7 +1048,7 @@ Solr是用Java编写、运行在Servlet容器（如 Apache Tomcat 或Jetty）的
 
 综上所述，Solr的架构不适合实时搜索的应用。
 
-## 实际生产环境测试[*](https://link.juejin.im/?target=http%3A%2F%2Fblog.socialcast.com%2Frealtime-search-solr-vs-elasticsearch%2F)
+## 实际生产环境测试
 
 下图为将搜索引擎从Solr转到Elasticsearch以后的平均查询速度有了50倍的提升。
 
@@ -935,55 +1065,55 @@ Solr是用Java编写、运行在Servlet容器（如 Apache Tomcat 或Jetty）的
 
 Solr 是传统搜索应用的有力解决方案，但 Elasticsearch 更适用于新兴的实时搜索应用。
 
-## 其他基于Lucene的开源搜索引擎解决方案[*](https://link.juejin.im/?target=http%3A%2F%2Fmail-archives.apache.org%2Fmod_mbox%2Fhbase-user%2F201006.mbox%2F%253C149150.78881.qm%40web50304.mail.re2.yahoo.com%253E)
+## 其他基于Lucene的开源搜索引擎解决方案
 
-1.  直接使用 [Lucene](https://link.juejin.im/?target=http%3A%2F%2Flucene.apache.org)
+1. 直接使用[Lucene](https://link.juejin.im/?target=http%3A%2F%2Flucene.apache.org)
 
-    说明：Lucene 是一个 JAVA 搜索类库，它本身并不是一个完整的解决方案，需要额外的开发工作。
+   说明：Lucene 是一个 JAVA 搜索类库，它本身并不是一个完整的解决方案，需要额外的开发工作。
 
-    优点：成熟的解决方案，有很多的成功案例。apache 顶级项目，正在持续快速的进步。庞大而活跃的开发社区，大量的开发人员。它只是一个类库，有足够的定制和优化空间：经过简单定制，就可以满足绝大部分常见的需求；经过优化，可以支持 10亿+ 量级的搜索。
+   优点：成熟的解决方案，有很多的成功案例。apache 顶级项目，正在持续快速的进步。庞大而活跃的开发社区，大量的开发人员。它只是一个类库，有足够的定制和优化空间：经过简单定制，就可以满足绝大部分常见的需求；经过优化，可以支持 10亿+ 量级的搜索。
 
-    缺点：需要额外的开发工作。所有的扩展，分布式，可靠性等都需要自己实现；非实时，从建索引到可以搜索中间有一个时间延迟，而当前的“近实时”(Lucene Near Real Time search)搜索方案的可扩展性有待进一步完善
+   缺点：需要额外的开发工作。所有的扩展，分布式，可靠性等都需要自己实现；非实时，从建索引到可以搜索中间有一个时间延迟，而当前的“近实时”(Lucene Near Real Time search)搜索方案的可扩展性有待进一步完善
 
-*   [Katta](https://link.juejin.im/?target=http%3A%2F%2Fkatta.sourceforge.net)
+* [Katta](https://link.juejin.im/?target=http%3A%2F%2Fkatta.sourceforge.net)
 
-    说明：基于 Lucene 的，支持分布式，可扩展，具有容错功能，准实时的搜索方案。
+  说明：基于 Lucene 的，支持分布式，可扩展，具有容错功能，准实时的搜索方案。
 
-    优点：开箱即用，可以与 Hadoop 配合实现分布式。具备扩展和容错机制。
+  优点：开箱即用，可以与 Hadoop 配合实现分布式。具备扩展和容错机制。
 
-    缺点：只是搜索方案，建索引部分还是需要自己实现。在搜索功能上，只实现了最基本的需求。成功案例较少，项目的成熟度稍微差一些。因为需要支持分布式，对于一些复杂的查询需求，定制的难度会比较大。
+  缺点：只是搜索方案，建索引部分还是需要自己实现。在搜索功能上，只实现了最基本的需求。成功案例较少，项目的成熟度稍微差一些。因为需要支持分布式，对于一些复杂的查询需求，定制的难度会比较大。
 
-*   [Hadoop contrib/index](https://link.juejin.im/?target=http%3A%2F%2Fsvn.apache.org%2Frepos%2Fasf%2Fhadoop%2Fmapreduce%2Ftrunk%2Fsrc%2Fcontrib%2Findex%2FREADME)
+* [Hadoop contrib/index](https://link.juejin.im/?target=http%3A%2F%2Fsvn.apache.org%2Frepos%2Fasf%2Fhadoop%2Fmapreduce%2Ftrunk%2Fsrc%2Fcontrib%2Findex%2FREADME)
 
-    说明：Map/Reduce 模式的，分布式建索引方案，可以跟 Katta 配合使用。
+  说明：Map/Reduce 模式的，分布式建索引方案，可以跟 Katta 配合使用。
 
-    优点：分布式建索引，具备可扩展性。
+  优点：分布式建索引，具备可扩展性。
 
-    缺点：只是建索引方案，不包括搜索实现。工作在批处理模式，对实时搜索的支持不佳。
+  缺点：只是建索引方案，不包括搜索实现。工作在批处理模式，对实时搜索的支持不佳。
 
-*   [LinkedIn 的开源方案](https://link.juejin.im/?target=http%3A%2F%2Fsna-projects.com)
+* [LinkedIn 的开源方案](https://link.juejin.im/?target=http%3A%2F%2Fsna-projects.com)
 
-    说明：基于 Lucene 的一系列解决方案，包括 准实时搜索 zoie ，facet 搜索实现 bobo ，机器学习算法 decomposer ，摘要存储库 krati ，数据库模式包装 sensei 等等
+  说明：基于 Lucene 的一系列解决方案，包括 准实时搜索 zoie ，facet 搜索实现 bobo ，机器学习算法 decomposer ，摘要存储库 krati ，数据库模式包装 sensei 等等
 
-    优点：经过验证的解决方案，支持分布式，可扩展，丰富的功能实现
+  优点：经过验证的解决方案，支持分布式，可扩展，丰富的功能实现
 
-    缺点：与 linkedin 公司的联系太紧密，可定制性比较差
+  缺点：与 linkedin 公司的联系太紧密，可定制性比较差
 
-*   [Lucandra](https://link.juejin.im/?target=https%3A%2F%2Fgithub.com%2Ftjake%2FLucandra)
+* [Lucandra](https://link.juejin.im/?target=https%3A%2F%2Fgithub.com%2Ftjake%2FLucandra)
 
-    说明：基于 Lucene，索引存在 cassandra 数据库中
+  说明：基于 Lucene，索引存在 cassandra 数据库中
 
-    优点：参考 cassandra 的优点
+  优点：参考 cassandra 的优点
 
-    缺点：参考 cassandra 的缺点。另外，这只是一个 demo，没有经过大量验证
+  缺点：参考 cassandra 的缺点。另外，这只是一个 demo，没有经过大量验证
 
-*   [HBasene](https://link.juejin.im/?target=https%3A%2F%2Fgithub.com%2Fakkumar%2Fhbasene)
+* [HBasene](https://link.juejin.im/?target=https%3A%2F%2Fgithub.com%2Fakkumar%2Fhbasene)
 
-    说明：基于 Lucene，索引存在 HBase 数据库中
+  说明：基于 Lucene，索引存在 HBase 数据库中
 
-    优点：参考 HBase 的优点
+  优点：参考 HBase 的优点
 
-    缺点：参考 HBase 的缺点。另外，在实现中，lucene terms 是存成行，但每个 term 对应的 posting lists 是以列的方式存储的。随着单个 term 的 posting lists 的增大，查询时的速度受到的影响会非常大
+  缺点：参考 HBase 的缺点。另外，在实现中，lucene terms 是存成行，但每个 term 对应的 posting lists 是以列的方式存储的。随着单个 term 的 posting lists 的增大，查询时的速度受到的影响会非常大
 
 
 
diff --git "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2103\357\274\232Lucene\345\237\272\347\241\200\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md" "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232Lucene\345\237\272\347\241\200\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
similarity index 53%
rename from "docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2103\357\274\232Lucene\345\237\272\347\241\200\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
rename to "docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232Lucene\345\237\272\347\241\200\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
index bf1322d..0f55792 100644
--- "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2103\357\274\232Lucene\345\237\272\347\241\200\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
+++ "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232Lucene\345\237\272\347\241\200\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [二、索引里面究竟存些什么](#二、索引里面究竟存些什么)
   * [三、如何创建索引](#三、如何创建索引)
@@ -11,10 +11,10 @@
     * [第二步：对查询语句进行词法分析，语法分析，及语言处理。](#第二步：对查询语句进行词法分析，语法分析，及语言处理。)
     * [第三步：搜索索引，得到符合语法树的文档。](#第三步：搜索索引，得到符合语法树的文档。)
     * [第四步：根据得到的文档和查询语句的相关性，对结果进行排序。](#第四步：根据得到的文档和查询语句的相关性，对结果进行排序。)
-      * [1\. 计算权重(Term weight)的过程。](#1-计算权重term-weight的过程。)
-      * [2\. 判断Term之间的关系从而得到文档相关性的过程，也即向量空间模型的算法(VSM)。](#2-判断term之间的关系从而得到文档相关性的过程，也即向量空间模型的算法vsm。)
-* [Spring Boot 中使用 Java API 调用 lucene](#spring-boot-中使用-java-api-调用-lucene)
-* [Github 代码](#github-代码)
+    * [1. 计算权重(Term weight)的过程。](#1-计算权重term-weight的过程。)
+    * [2\. 判断Term之间的关系从而得到文档相关性的过程，也即向量空间模型的算法(VSM)。](#2-判断term之间的关系从而得到文档相关性的过程，也即向量空间模型的算法vsm。)
+  * [Spring Boot 中使用 Java API 调用 lucene](#spring-boot-中使用-java-api-调用-lucene)
+  * [Github 代码](#github-代码)
   * [添加依赖](#添加依赖)
   * [配置 lucene](#配置-lucene)
   * [创建索引](#创建索引)
@@ -32,30 +32,7 @@
   * [高亮处理](#高亮处理)
 
 
-本文转自互联网，侵删
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-本系列文章将整理到我的个人博客
-> www.how2playlife.com
-
-更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注
-该系列博文会介绍常见的后端技术，这对后端工程师来说是一种综合能力，我们会逐步了解搜索技术，云计算相关技术、大数据研发等常见的技术喜提，以便让你更完整地了解后端技术栈的全貌，为后续参与分布式应用的开发和学习做好准备。
-
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系我，欢迎你参与本系列博文的创作和修订。
-
-
-
-
-
-**一、总论**
-
-根据[lucene.apache.org/java/docs/i…](https://link.juejin.im/?target=http%3A%2F%2Flucene.apache.org%2Fjava%2Fdocs%2Findex.html)定义：
-
+[toc]
 Lucene是一个高效的，基于Java的全文检索库。
 
 所以在了解Lucene之前要费一番工夫了解一下全文检索。
@@ -92,8 +69,6 @@ Lucene是一个高效的，基于Java的全文检索库。
 
 下面这幅图来自《Lucene in action》，但却不仅仅描述了Lucene的检索过程，而是描述了全文检索的一般过程。
 
-[![](https://user-gold-cdn.xitu.io/2016/11/29/a3cea9bc799d798340ded4e405204c4b.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2Fimage_2.png)
-
 全文检索大体分两个过程，索引创建(Indexing)和搜索索引(Search)。
 
 *   索引创建：将现实世界中所有的结构化和非结构化数据提取信息，创建索引的过程。
@@ -101,11 +76,11 @@ Lucene是一个高效的，基于Java的全文检索库。
 
 于是全文检索就存在三个重要问题：
 
-1. 索引里面究竟存些什么？(Index)
+1\. 索引里面究竟存些什么？(Index)
 
-2. 如何创建索引？(Indexing)
+2\. 如何创建索引？(Indexing)
 
-3. 如何对索引进行搜索？(Search)
+3\. 如何对索引进行搜索？(Search)
 
 下面我们顺序对每个个问题进行研究。
 
@@ -125,8 +100,6 @@ Lucene是一个高效的，基于Java的全文检索库。
 
 假设我的文档集合里面有100篇文档，为了方便表示，我们为文档编号从1到100，得到下面的结构
 
-[![](https://user-gold-cdn.xitu.io/2016/11/29/13bee3be594a9cc60a0be2217b794a55.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2Finverted%2520index_2.jpg)
-
 左边保存的是一系列字符串，称为词典。
 
 每个字符串都指向包含此字符串的文档(Document)链表，此文档链表称为倒排表(Posting List)。
@@ -141,7 +114,12 @@ Lucene是一个高效的，基于Java的全文检索库。
 
 3\. 通过合并链表，找出既包含“lucene”又包含“solr”的文件。
 
-[![](https://user-gold-cdn.xitu.io/2016/11/29/e4beee6343728d0086aa878e44ef6f13.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2Finverted%2520index%2520merge_2.jpg)
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-c1064a6ada64169f76ec63e44e82f0f5_720w.webp)
+
+</figure>
 
 看到这个地方，有人可能会说，全文检索的确加快了搜索的速度，但是多了索引的过程，两者加起来不一定比顺序扫描快多少。的确，加上索引的过程，全文检索不一定比顺序扫描快，尤其是在数据量小的时候更是如此。而对一个很大量的数据创建索引也是一个很慢的过程。
 
@@ -165,11 +143,11 @@ Lucene是一个高效的，基于Java的全文检索库。
 
 分词组件(Tokenizer)会做以下几件事情(此过程称为Tokenize)：
 
-1. 将文档分成一个一个单独的单词。
+1\. 将文档分成一个一个单独的单词。
 
-2. 去除标点符号。
+2\. 去除标点符号。
 
-3. 去除停词(Stop word)。
+3\. 去除停词(Stop word)。
 
 所谓停词(Stop word)就是一种语言中最普通的一些单词，由于没有特别的意义，因而大多数情况下不能成为搜索的关键词，因而创建索引时，这种词会被去掉而减少索引的大小。
 
@@ -181,7 +159,13 @@ Lucene是一个高效的，基于Java的全文检索库。
 
 在我们的例子中，便得到以下词元(Token)：
 
+
+
+```
 “Students”，“allowed”，“go”，“their”，“friends”，“allowed”，“drink”，“beer”，“My”，“friend”，“Jerry”，“went”，“school”，“see”，“his”，“students”，“found”，“them”，“drunk”，“allowed”。
+```
+
+
 
 ### 第三步：将得到的词元(Token)传给语言处理组件(Linguistic Processor)。
 
@@ -189,28 +173,38 @@ Lucene是一个高效的，基于Java的全文检索库。
 
 对于英语，语言处理组件(Linguistic Processor)一般做以下几点：
 
-1. 变为小写(Lowercase)。
+1\. 变为小写(Lowercase)。
 
-2. 将单词缩减为词根形式，如“cars”到“car”等。这种操作称为：stemming。
+2\. 将单词缩减为词根形式，如“cars”到“car”等。这种操作称为：stemming。
 
-3. 将单词转变为词根形式，如“drove”到“drive”等。这种操作称为：lemmatization。
+3\. 将单词转变为词根形式，如“drove”到“drive”等。这种操作称为：lemmatization。
 
 Stemming 和 lemmatization的异同：
 
 *   相同之处：Stemming和lemmatization都要使词汇成为词根形式。
 *   两者的方式不同：
-    *   Stemming采用的是“缩减”的方式：“cars”到“car”，“driving”到“drive”。
-    *   Lemmatization采用的是“转变”的方式：“drove”到“drove”，“driving”到“drive”。
+
+*   Stemming采用的是“缩减”的方式：“cars”到“car”，“driving”到“drive”。
+*   Lemmatization采用的是“转变”的方式：“drove”到“drove”，“driving”到“drive”。
+
 *   两者的算法不同：
-    *   Stemming主要是采取某种固定的算法来做这种缩减，如去除“s”，去除“ing”加“e”，将“ational”变为“ate”，将“tional”变为“tion”。
-    *   Lemmatization主要是采用保存某种字典的方式做这种转变。比如字典中有“driving”到“drive”，“drove”到“drive”，“am, is, are”到“be”的映射，做转变时，只要查字典就可以了。
+
+*   Stemming主要是采取某种固定的算法来做这种缩减，如去除“s”，去除“ing”加“e”，将“ational”变为“ate”，将“tional”变为“tion”。
+*   Lemmatization主要是采用保存某种字典的方式做这种转变。比如字典中有“driving”到“drive”，“drove”到“drive”，“am, is, are”到“be”的映射，做转变时，只要查字典就可以了。
+
 *   Stemming和lemmatization不是互斥关系，是有交集的，有的词利用这两种方式都能达到相同的转换。
 
 语言处理组件(linguistic processor)的结果称为词(Term)。
 
 在我们的例子中，经过语言处理，得到的词(Term)如下：
 
+
+
+```
 “student”，“allow”，“go”，“their”，“friend”，“allow”，“drink”，“beer”，“my”，“friend”，“jerry”，“go”，“school”，“see”，“his”，“student”，“find”，“them”，“drink”，“allow”。
+```
+
+
 
 也正是因为有语言处理的步骤，才能使搜索drove，而drive也能被搜索出来。
 
@@ -222,69 +216,23 @@ Stemming 和 lemmatization的异同：
 
 在我们的例子中字典如下：
 
+<figure data-size="normal">
 
 
-| Term | Document ID |
-| --- | --- |
-| student | 1 |
-| allow | 1 |
-| go | 1 |
-| their | 1 |
-| friend | 1 |
-| allow | 1 |
-| drink | 1 |
-| beer | 1 |
-| my | 2 |
-| friend | 2 |
-| jerry | 2 |
-| go | 2 |
-| school | 2 |
-| see | 2 |
-| his | 2 |
-| student | 2 |
-| find | 2 |
-| them | 2 |
-| drink | 2 |
-| allow | 2 |
-
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-b8477ac42cb442585aa090f33c0b34a6_720w.webp)
 
+</figure>
 
-2. 对字典按字母顺序进行排序。
+2\. 对字典按字母顺序进行排序。
 
+<figure data-size="normal">
 
 
-| Term | Document ID |
-| --- | --- |
-| allow | 1 |
-| allow | 1 |
-| allow | 2 |
-| beer | 1 |
-| drink | 1 |
-| drink | 2 |
-| find | 2 |
-| friend | 1 |
-| friend | 2 |
-| go | 1 |
-| go | 2 |
-| his | 2 |
-| jerry | 2 |
-| my | 2 |
-| school | 2 |
-| see | 2 |
-| student | 1 |
-| student | 2 |
-| their | 1 |
-| them | 2 |
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408113241.png)
 
+</figure>
 
-
-
-
-3. 合并相同的词(Term)成为文档倒排(Posting List)链表。
-
-[![](https://user-gold-cdn.xitu.io/2016/11/29/dd7f48aa10cc188b651f9aa7fea1473d.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2Fpostinglist_2.jpg)
+3\. 合并相同的词(Term)成为文档倒排(Posting List)链表。
 
 在此表中，有几个定义：
 
@@ -305,8 +253,6 @@ Stemming 和 lemmatization的异同：
 
 打开Google吧，比如说您想在微软找份工作，于是您输入“Microsoft job”，您却发现总共有22600000个结果返回。好大的数字呀，突然发现找不到是一个问题，找到的太多也是一个问题。在如此多的结果中，如何将最相关的放在最前面呢？
 
-[![](https://user-gold-cdn.xitu.io/2016/11/29/878a1496bd894af493571ce4d24ac127.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2Fclip_image0024.jpg)
-
 当然Google做的很不错，您一下就找到了jobs at Microsoft。想象一下，如果前几个全部是“Microsoft does a good job at software industry…”将是多么可怕的事情呀。
 
 如何像Google一样，在成千上万的搜索结果中，找到和查询语句最相关的呢？
@@ -345,7 +291,12 @@ Stemming 和 lemmatization的异同：
 
 如上述例子，lucene AND learned NOT hadoop形成的语法树如下：
 
-[![](https://user-gold-cdn.xitu.io/2016/11/29/55095158d2639bde41aa734f2fa374e4.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2F%25E8%25AF%25AD%25E6%25B3%2595%25E6%25A0%2591_2.jpg)
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-5acb4fdbd41e04fe83396ea82679bee9_720w.webp)
+
+</figure>
 
 3\. 语言处理同索引过程中的语言处理几乎相同。
 
@@ -353,7 +304,12 @@ Stemming 和 lemmatization的异同：
 
 经过第二步，我们得到一棵经过语言处理的语法树。
 
-[![](https://user-gold-cdn.xitu.io/2016/11/29/81ff3124457dd330914b29d8768ec794.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2F%25E8%25AF%25AD%25E6%25B3%2595%25E6%25A0%25911_2.jpg)
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408113252.png)
+
+</figure>
 
 ### 第三步：搜索索引，得到符合语法树的文档。
 
@@ -408,7 +364,7 @@ Stemming 和 lemmatization的异同：
 
 下面仔细分析一下这两个过程：
 
-#### 1\. 计算权重(Term weight)的过程。
+### 1. 计算权重(Term weight)的过程。
 
 影响一个词(Term)在一篇文档中的重要性主要有两个因素：
 
@@ -421,13 +377,9 @@ Stemming 和 lemmatization的异同：
 
 道理明白了，我们来看看公式：
 
-[![](https://user-gold-cdn.xitu.io/2016/11/29/80b276886139c74129edaf696adaedae.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2Fimage_6.png)
-
-[![](https://user-gold-cdn.xitu.io/2016/11/29/68a0c696bfeb06818a6809d8757024e9.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2Fimage_4.png)
-
 这仅仅只term weight计算公式的简单典型实现。实现全文检索系统的人会有自己的实现，Lucene就与此稍有不同。
 
-#### 2\. 判断Term之间的关系从而得到文档相关性的过程，也即向量空间模型的算法(VSM)。
+### 2\. 判断Term之间的关系从而得到文档相关性的过程，也即向量空间模型的算法(VSM)。
 
 我们把文档看作一系列词(Term)，每一个词(Term)都有一个权重(Term weight)，不同的词(Term)根据自己在文档中的权重来影响文档相关性的打分计算。
 
@@ -445,10 +397,6 @@ Query Vector = {weight1, weight2, …… , weight N}
 
 我们把所有搜索出的文档向量及查询向量放到一个N维空间中，每个词(term)是一维。
 
-如图：
-
-[![](https://user-gold-cdn.xitu.io/2016/11/29/3b2b2a7e8a43a5a7e2f05356dbf73f94.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2Fvsm_2.jpg)
-
 我们认为两个向量之间的夹角越小，相关性越大。
 
 所以我们计算夹角的余弦值作为相关性的打分，夹角越小，余弦值越大，打分越高，相关性越大。
@@ -459,29 +407,17 @@ Query Vector = {weight1, weight2, …… , weight N}
 
 相关性打分公式如下：
 
-[![](https://user-gold-cdn.xitu.io/2016/11/29/3972cef9c3a49cc167bc4462cd484bc7.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2Fimage11.png)
-
 举个例子，查询语句有11个Term，共有三篇文档搜索出来。其中各自的权重(Term weight)，如下表格。
 
+<figure data-size="normal">
 
 
-|   |   |   |   |   |   |   |   |   |   | t10 | t11 |
-| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
-|   |   |   | .477 |   | .477 | .176 |   |   |   | .176 |   |
-|   |   | .176 |   | .477 |   |   |   |   | .954 |   | .176 |
-|   |   | .176 |   |   |   | .176 |   |   |   | .176 | .176 |
-|   |   |   |   |   |   | .176 |   |   | .477 |   | .176 |
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408113310.png)
 
+</figure>
 
 于是计算，三篇文档同查询语句的相关性打分分别为：
 
-[![](https://user-gold-cdn.xitu.io/2016/11/29/4013f1bb4372740f7016dd482c4783a5.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2Fimage17.png)
-
-[](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2Fimage20.png)
-
-[![](https://user-gold-cdn.xitu.io/2016/11/29/92f27945e9db90f897883acad3361cb1.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2Fimage23.png)
-
 于是文档二相关性最高，先返回，其次是文档一，最后是文档三。
 
 到此为止，我们可以找到我们最想要的文档了。
@@ -490,235 +426,528 @@ Query Vector = {weight1, weight2, …… , weight N}
 
 在进入Lucene之前，对上述索引创建和搜索过程所一个总结，如图：
 
-此图参照[www.lucene.com.cn/about.htm](https://link.juejin.im/?target=http%3A%2F%2Fwww.lucene.com.cn%2Fabout.htm)中文章《开放源代码的全文检索引擎Lucene》
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408113319.png)
 
-[![](https://user-gold-cdn.xitu.io/2016/11/29/6d0d90f77554a1bbc3e80bc42e719438.jpg?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)](https://link.juejin.im/?target=http%3A%2F%2Fimages.cnblogs.com%2Fcnblogs_com%2Fforfuture1978%2FWindowsLiveWriter%2F185c4e9316f3_147FA%2Fclip_image016_2.jpg)
+</figure>
 
 1\. 索引过程：
 
-1) 有一系列被索引文件
+1) 有一系列被索引文件
 
-2) 被索引文件经过语法分析和语言处理形成一系列词(Term)。
+2) 被索引文件经过语法分析和语言处理形成一系列词(Term)。
 
-3) 经过索引创建形成词典和反向索引表。
+3) 经过索引创建形成词典和反向索引表。
 
-4) 通过索引存储将索引写入硬盘。
+4) 通过索引存储将索引写入硬盘。
 
 2\. 搜索过程：
 
-a) 用户输入查询语句。
+a) 用户输入查询语句。
 
-b) 对查询语句经过语法分析和语言分析得到一系列词(Term)。
+b) 对查询语句经过语法分析和语言分析得到一系列词(Term)。
 
-c) 通过语法分析得到一个查询树。
+c) 通过语法分析得到一个查询树。
 
-d) 通过索引存储将索引读入到内存。
+d) 通过索引存储将索引读入到内存。
 
-e) 利用查询树搜索索引，从而得到每个词(Term)的文档链表，对文档链表进行交，差，并得到结果文档。
+e) 利用查询树搜索索引，从而得到每个词(Term)的文档链表，对文档链表进行交，差，并得到结果文档。
 
-f) 将搜索到的结果文档对查询的相关性进行排序。
+f) 将搜索到的结果文档对查询的相关性进行排序。
 
-g) 返回查询结果给用户。
+g) 返回查询结果给用户。
 
 下面我们可以进入Lucene的世界了。
 
-CSDN中此文章链接为[blog.csdn.net/forfuture19…](https://link.juejin.im/?target=http%3A%2F%2Fblog.csdn.net%2Fforfuture1978%2Farchive%2F2009%2F10%2F22%2F4711308.aspx)
+## Spring Boot 中使用 Java API 调用 lucene
 
-Javaeye中此文章链接为[forfuture1978.javaeye.com/blog/546771](https://link.juejin.im/?target=http%3A%2F%2Fforfuture1978.javaeye.com%2Fblog%2F546771) 
+## Github 代码
 
-# Spring Boot 中使用 Java API 调用 lucene
+代码我已放到 Github ，导入`spring-boot-lucene-demo` 项目
 
-# Github 代码
+github [spring-boot-lucene-demo](https://link.juejin.im/?target=https%3A%2F%2Fgithub.com%2Fsouyunku%2Fspring-boot-examples%2Ftree%2Fmaster%2Fspring-boot-lucene-demo)
 
-代码我已放到 Github ，导入`spring-boot-lucene-demo` 项目
+## 添加依赖
 
-github [spring-boot-lucene-demo](https://link.juejin.im/?target=https%3A%2F%2Fgithub.com%2Fsouyunku%2Fspring-boot-examples%2Ftree%2Fmaster%2Fspring-boot-lucene-demo)
 
-## 添加依赖
 
 ```
-<!--对分词索引查询解析--><dependency>    <groupId>org.apache.lucene</groupId>    lucene-queryparser    <version>7.1.0</version></dependency> <!--高亮 --><dependency>    <groupId>org.apache.lucene</groupId>    lucene-highlighter    <version>7.1.0</version></dependency> <!--smartcn 中文分词器 SmartChineseAnalyzer  smartcn分词器 需要lucene依赖 且和lucene版本同步--><dependency>    <groupId>org.apache.lucene</groupId>    lucene-analyzers-smartcn    <version>7.1.0</version></dependency> <!--ik-analyzer 中文分词器--><dependency>    <groupId>cn.bestwu</groupId>    ik-analyzers    <version>5.1.0</version></dependency> <!--MMSeg4j 分词器--><dependency>    <groupId>com.chenlb.mmseg4j</groupId>    mmseg4j-solr    <version>2.4.0</version>    <exclusions>        <exclusion>            <groupId>org.apache.solr</groupId>            solr-core        </exclusion>    </exclusions></dependency>
+      21  <!--对分词索引查询解析-->
+        <dependency>
+            <groupId>org.apache.lucene</groupId>
+            <artifactId>lucene-queryparser</artifactId>
+            <version>7.1.0</version>
+        </dependency>
+        <!--高亮 -->
+        <dependency>
+            <groupId>org.apache.lucene</groupId>
+            <artifactId>lucene-highlighter</artifactId>
+            <version>7.1.0</version>
+        </dependency>
+        <!--smartcn 中文分词器 SmartChineseAnalyzer  smartcn分词器 需要lucene依赖 且和lucene版本同步-->
+        <dependency>
+            <groupId>org.apache.lucene</groupId>
+            <artifactId>lucene-analyzers-smartcn</artifactId>
+            <version>7.1.0</version>
+        </dependency>
+        <!--ik-analyzer 中文分词器-->
+        <dependency>
+            <groupId>cn.bestwu</groupId>
+            <artifactId>ik-analyzers</artifactId>
+            <version>5.1.0</version>
+        </dependency> <!--MMSeg4j 分词器-->
+        <dependency>
+            <groupId>com.chenlb.mmseg4j</groupId>
+            <artifactId>mmseg4j-solr</artifactId>
+            <version>2.4.0</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.apache.solr</groupId>
+                    <artifactId>solr-core</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
 ```
 
+
+
 ## 配置 lucene
 
+
+
 ```
-private Directory directory; private IndexReader indexReader; private IndexSearcher indexSearcher; @Beforepublic void setUp() throws IOException {    //索引存放的位置，设置在当前目录中    directory = FSDirectory.open(Paths.get("indexDir/"));     //创建索引的读取器    indexReader = DirectoryReader.open(directory);     //创建一个索引的查找器，来检索索引库    indexSearcher = new IndexSearcher(indexReader);} @Afterpublic void tearDown() throws Exception {    indexReader.close();} ** * 执行查询，并打印查询到的记录数 * * @param query * @throws IOException */public void executeQuery(Query query) throws IOException {     TopDocs topDocs = indexSearcher.search(query, 100);     //打印查询到的记录数    System.out.println("总共查询到" + topDocs.totalHits + "个文档");    for (ScoreDoc scoreDoc : topDocs.scoreDocs) {         //取得对应的文档对象        Document document = indexSearcher.doc(scoreDoc.doc);        System.out.println("id：" + document.get("id"));        System.out.println("title：" + document.get("title"));        System.out.println("content：" + document.get("content"));    }} /** * 分词打印 * * @param analyzer * @param text * @throws IOException */public void printAnalyzerDoc(Analyzer analyzer, String text) throws IOException {     TokenStream tokenStream = analyzer.tokenStream("content", new StringReader(text));    CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);    try {        tokenStream.reset();        while (tokenStream.incrementToken()) {            System.out.println(charTermAttribute.toString());        }        tokenStream.end();    } finally {        tokenStream.close();        analyzer.close();    }}
+private Directory directory; private IndexReader indexReader; 
+private IndexSearcher indexSearcher; 
+@Beforepublic void setUp() throws IOException {
+//索引存放的位置，设置在当前目录中    
+directory = FSDirectory.open(Paths.get("indexDir/"));     
+//创建索引的读取器    
+indexReader = DirectoryReader.open(directory);     
+//创建一个索引的查找器，来检索索引库    
+indexSearcher = new IndexSearcher(indexReader);
+} 
+@Afterpublic void tearDown() throws Exception {    
+indexReader.close();
+} 
+** * 执行查询，并打印查询到的记录数 * * 
+@param query * @throws IOException */
+public void executeQuery(Query query) throws IOException {     
+TopDocs topDocs = indexSearcher.search(query, 100);     
+//打印查询到的记录数    
+System.out.println("总共查询到" + topDocs.totalHits + "个文档");    
+for (ScoreDoc scoreDoc : topDocs.scoreDocs) {         
+//取得对应的文档对象        Document document = indexSearcher.doc(scoreDoc.doc);
+System.out.println("id：" + document.get("id"));        
+System.out.println("title：" + document.get("title"));        
+System.out.println("content：" + document.get("content"));    
+}} 
+/** * 分词打印 * * @param analyzer * @param text * @throws IOException */
+public void printAnalyzerDoc(Analyzer analyzer, String text) throws IOException {     
+TokenStream tokenStream = analyzer.tokenStream("content", new StringReader(text));    
+CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);    
+try {        
+tokenStream.reset();        
+while (tokenStream.incrementToken()) {            
+System.out.println(charTermAttribute.toString());        
+}        
+tokenStream.end();    
+} finally {        
+tokenStream.close();        
+analyzer.close();    
+}}
 ```
 
+
+
 ## 创建索引
 
+
+
 ```
-@Testpublic void indexWriterTest() throws IOException {    long start = System.currentTimeMillis();     //索引存放的位置，设置在当前目录中    Directory directory = FSDirectory.open(Paths.get("indexDir/"));     //在 6.6 以上版本中 version 不再是必要的，并且，存在无参构造方法，可以直接使用默认的 StandardAnalyzer 分词器。    Version version = Version.LUCENE_7_1_0;     //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文    //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词    //Analyzer analyzer = new ComplexAnalyzer();//中文分词    //Analyzer analyzer = new IKAnalyzer();//中文分词     Analyzer analyzer = new IKAnalyzer();//中文分词     //创建索引写入配置    IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer);     //创建索引写入对象    IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);     //创建Document对象，存储索引     Document doc = new Document();     int id = 1;     //将字段加入到doc中    doc.add(new IntPoint("id", id));    doc.add(new StringField("title", "Spark", Field.Store.YES));    doc.add(new TextField("content", "Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎", Field.Store.YES));    doc.add(new StoredField("id", id));     //将doc对象保存到索引库中    indexWriter.addDocument(doc);     indexWriter.commit();    //关闭流    indexWriter.close();     long end = System.currentTimeMillis();    System.out.println("索引花费了" + (end - start) + " 毫秒");}
+@Test
+public void indexWriterTest() throws IOException {    
+long start = System.currentTimeMillis();     
+//索引存放的位置，设置在当前目录中   
+Directory directory = FSDirectory.open(Paths.get("indexDir/"));    
+//在 6.6 以上版本中 version 不再是必要的，并且，存在无参构造方法，可以直接使用默认的 StandardAnalyzer 分词器。    Version version = Version.LUCENE_7_1_0;     
+//Analyzer analyzer = new StandardAnalyzer(); 
+// 标准分词器，适用于英文    
+//Analyzer analyzer = new SmartChineseAnalyzer();
+//中文分词    
+//Analyzer analyzer = new ComplexAnalyzer();//中文分词    
+//Analyzer analyzer = new IKAnalyzer();//中文分词     
+Analyzer analyzer = new IKAnalyzer();
+//中文分词     
+//创建索引写入配置    
+IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer);     
+//创建索引写入对象    
+IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);     
+//创建Document对象，存储索引     
+Document doc = new Document();     int id = 1;     
+//将字段加入到doc中    
+doc.add(new IntPoint("id", id));    
+doc.add(new StringField("title", "Spark", Field.Store.YES));    
+doc.add(new TextField("content", "Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎", Field.Store.YES));    
+doc.add(new StoredField("id", id));     
+//将doc对象保存到索引库中    
+indexWriter.addDocument(doc);     
+indexWriter.commit();    
+//关闭流    
+indexWriter.close();     
+long end = System.currentTimeMillis();    
+System.out.println("索引花费了" + (end - start) + " 毫秒");}
 ```
 
+
+
 响应
 
-```
 17:58:14.655 [main] DEBUG org.wltea.analyzer.dic.Dictionary - 加载扩展词典：ext.dic17:58:14.660 [main] DEBUG org.wltea.analyzer.dic.Dictionary - 加载扩展停止词典：stopword.dic索引花费了879 毫秒
-```
 
 ## 删除文档
 
+
+
 ```
-@Testpublic void deleteDocumentsTest() throws IOException {    //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文    //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词    //Analyzer analyzer = new ComplexAnalyzer();//中文分词    //Analyzer analyzer = new IKAnalyzer();//中文分词     Analyzer analyzer = new IKAnalyzer();//中文分词     //创建索引写入配置    IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer);     //创建索引写入对象    IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);     // 删除title中含有关键词“Spark”的文档    long count = indexWriter.deleteDocuments(new Term("title", "Spark"));     //  除此之外IndexWriter还提供了以下方法：    // DeleteDocuments(Query query):根据Query条件来删除单个或多个Document    // DeleteDocuments(Query[] queries):根据Query条件来删除单个或多个Document    // DeleteDocuments(Term term):根据Term来删除单个或多个Document    // DeleteDocuments(Term[] terms):根据Term来删除单个或多个Document    // DeleteAll():删除所有的Document     //使用IndexWriter进行Document删除操作时，文档并不会立即被删除，而是把这个删除动作缓存起来，当IndexWriter.Commit()或IndexWriter.Close()时，删除操作才会被真正执行。     indexWriter.commit();    indexWriter.close();     System.out.println("删除完成:" + count);}
+@Testpublic void deleteDocumentsTest() throws IOException 
+// 标准分词器，适用于英文   
+//Analyzer analyzer = new SmartChineseAnalyzer();
+//中文分词    
+//Analyzer analyzer = new ComplexAnalyzer();
+//中文分词    
+//Analyzer analyzer = new IKAnalyzer();
+//中文分词     
+Analyzer analyzer = new IKAnalyzer();
+//中文分词     
+//创建索引写入配置    
+IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer);     
+//创建索引写入对象    
+IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);     
+// 删除title中含有关键词“Spark”的文档    
+long count = indexWriter.deleteDocuments(new Term("title", "Spark"));     
+//  除此之外IndexWriter还提供了以下方法：   
+// DeleteDocuments(Query query):根据Query条件来删除单个或多个Document    
+// DeleteDocuments(Query[] queries):根据Query条件来删除单个或多个Document    
+// DeleteDocuments(Term term):根据Term来删除单个或多个Document    
+// DeleteDocuments(Term[] terms):根据Term来删除单个或多个Document    
+// DeleteAll():删除所有的Document     
+//使用IndexWriter进行Document删除操作时，文档并不会立即被删除，而是把这个删除动作缓存起来，当IndexWriter.Commit()或IndexWriter.Close()时，删除操作才会被真正执行。     
+indexWriter.commit();    
+indexWriter.close();     
+System.out.println("删除完成:" + count);
+}
 ```
 
+
+
 响应
 
-```
 删除完成:1
-```
 
 ## 更新文档
 
+
+
 ```
-/** * 测试更新 * 实际上就是删除后新增一条 * * @throws IOException */@Testpublic void updateDocumentTest() throws IOException {    //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文    //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词    //Analyzer analyzer = new ComplexAnalyzer();//中文分词    //Analyzer analyzer = new IKAnalyzer();//中文分词     Analyzer analyzer = new IKAnalyzer();//中文分词     //创建索引写入配置    IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer);     //创建索引写入对象    IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);     Document doc = new Document();     int id = 1;     doc.add(new IntPoint("id", id));    doc.add(new StringField("title", "Spark", Field.Store.YES));    doc.add(new TextField("content", "Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎", Field.Store.YES));    doc.add(new StoredField("id", id));     long count = indexWriter.updateDocument(new Term("id", "1"), doc);    System.out.println("更新文档:" + count);    indexWriter.close();}
+/** * 测试更新 * 实际上就是删除后新增一条 * * @throws IOException */
+@Test
+public void updateDocumentTest() throws IOException {    
+//Analyzer analyzer = new StandardAnalyzer(); 
+// 标准分词器，适用于英文   
+//Analyzer analyzer = new SmartChineseAnalyzer();//中文分词    
+//Analyzer analyzer = new ComplexAnalyzer();
+//中文分词    
+//Analyzer analyzer = new IKAnalyzer();
+//中文分词     
+Analyzer analyzer = new IKAnalyzer();
+//中文分词     
+//创建索引写入配置    
+IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer);     
+//创建索引写入对象    
+IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);    
+Document doc = new Document();     
+int id = 1;     
+doc.add(new IntPoint("id", id));    
+doc.add(new StringField("title", "Spark", Field.Store.YES));    
+doc.add(new TextField("content", "Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎", Field.Store.YES));    
+doc.add(new StoredField("id", id));     
+long count = indexWriter.updateDocument(new Term("id", "1"), doc);    
+System.out.println("更新文档:" + count);    
+indexWriter.close();
+}
 ```
 
+
+
 响应
 
-```
 更新文档:1
-```
 
 ## 按词条搜索
 
+
+
 ```
-/** * 按词条搜索 * <p> * TermQuery是最简单、也是最常用的Query。TermQuery可以理解成为“词条搜索”， * 在搜索引擎中最基本的搜索就是在索引中搜索某一词条，而TermQuery就是用来完成这项工作的。 * 在Lucene中词条是最基本的搜索单位，从本质上来讲一个词条其实就是一个名/值对。 * 只不过这个“名”是字段名，而“值”则表示字段中所包含的某个关键字。 * * @throws IOException */@Testpublic void termQueryTest() throws IOException {     String searchField = "title";    //这是一个条件查询的api，用于添加条件    TermQuery query = new TermQuery(new Term(searchField, "Spark"));     //执行查询，并打印查询到的记录数    executeQuery(query);}
+/** * 按词条搜索 * <p> * TermQuery是最简单、也是最常用的Query。TermQuery可以理解成为“词条搜索”， * 在搜索引擎中最基本的搜索就是在索引中搜索某一词条，而TermQuery就是用来完成这项工作的。 * 在Lucene中词条是最基本的搜索单位，从本质上来讲一个词条其实就是一个名/值对。 * 只不过这个“名”是字段名，而“值”则表示字段中所包含的某个关键字。 * * @throws IOException */
+@Test
+public void termQueryTest() throws IOException {
+     String searchField = "title";    
+     //这是一个条件查询的api，用于添加条件    
+     TermQuery query = new TermQuery(new Term(searchField, "Spark"));     
+     //执行查询，并打印查询到的记录数    
+     executeQuery(query);
+     }
 ```
 
+
+
 响应
 
-```
 总共查询到1个文档id：1title：Sparkcontent：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
-```
 
 ## 多条件查询
 
+
+
 ```
-/** * 多条件查询 * * BooleanQuery也是实际开发过程中经常使用的一种Query。 * 它其实是一个组合的Query，在使用时可以把各种Query对象添加进去并标明它们之间的逻辑关系。 * BooleanQuery本身来讲是一个布尔子句的容器，它提供了专门的API方法往其中添加子句， * 并标明它们之间的关系，以下代码为BooleanQuery提供的用于添加子句的API接口： * * @throws IOException */@Testpublic void BooleanQueryTest() throws IOException {     String searchField1 = "title";    String searchField2 = "content";    Query query1 = new TermQuery(new Term(searchField1, "Spark"));    Query query2 = new TermQuery(new Term(searchField2, "Apache"));    BooleanQuery.Builder builder = new BooleanQuery.Builder();     // BooleanClause用于表示布尔查询子句关系的类，    // 包 括：    // BooleanClause.Occur.MUST，    // BooleanClause.Occur.MUST_NOT，    // BooleanClause.Occur.SHOULD。    // 必须包含,不能包含,可以包含三种.有以下6种组合：    //    // 1．MUST和MUST：取得连个查询子句的交集。    // 2．MUST和MUST_NOT：表示查询结果中不能包含MUST_NOT所对应得查询子句的检索结果。    // 3．SHOULD与MUST_NOT：连用时，功能同MUST和MUST_NOT。    // 4．SHOULD与MUST连用时，结果为MUST子句的检索结果,但是SHOULD可影响排序。    // 5．SHOULD与SHOULD：表示“或”关系，最终检索结果为所有检索子句的并集。    // 6．MUST_NOT和MUST_NOT：无意义，检索无结果。     builder.add(query1, BooleanClause.Occur.SHOULD);    builder.add(query2, BooleanClause.Occur.SHOULD);     BooleanQuery query = builder.build();     //执行查询，并打印查询到的记录数    executeQuery(query);}
+/** * 多条件查询 * * BooleanQuery也是实际开发过程中经常使用的一种Query。 * 它其实是一个组合的Query，在使用时可以把各种Query对象添加进去并标明它们之间的逻辑关系。 * BooleanQuery本身来讲是一个布尔子句的容器，它提供了专门的API方法往其中添加子句， * 并标明它们之间的关系，以下代码为BooleanQuery提供的用于添加子句的API接口： * * @throws IOException */
+@Testpublic void BooleanQueryTest() throws IOException { 
+    String searchField1 = "title";    
+    String searchField2 = "content";    
+    Query query1 = new TermQuery(new Term(searchField1, "Spark"));    
+    Query query2 = new TermQuery(new Term(searchField2, "Apache"));    
+    BooleanQuery.Builder builder = new BooleanQuery.Builder();     
+    // BooleanClause用于表示布尔查询子句关系的类，    
+    // 包 括：    
+    // BooleanClause.Occur.MUST，    
+    // BooleanClause.Occur.MUST_NOT，    
+    // BooleanClause.Occur.SHOULD。    
+    // 必须包含,不能包含,可以包含三种.有以下6种组合：    
+    //    
+    // 1．MUST和MUST：取得连个查询子句的交集。    
+    // 2．MUST和MUST_NOT：表示查询结果中不能包含MUST_NOT所对应得查询子句的检索结果。    
+    // 3．SHOULD与MUST_NOT：连用时，功能同MUST和MUST_NOT。    
+    // 4．SHOULD与MUST连用时，结果为MUST子句的检索结果,但是SHOULD可影响排序。    
+    // 5．SHOULD与SHOULD：表示“或”关系，最终检索结果为所有检索子句的并集。    
+    // 6．MUST_NOT和MUST_NOT：无意义，检索无结果。     
+    builder.add(query1, BooleanClause.Occur.SHOULD);   
+    builder.add(query2, BooleanClause.Occur.SHOULD);     
+    BooleanQuery query = builder.build();     
+    //执行查询，并打印查询到的记录数    
+    executeQuery(query);
+    }
 ```
 
+
+
 响应
 
-```
 总共查询到1个文档id：1title：Sparkcontent：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
-```
 
 ## 匹配前缀
 
+
+
 ```
-/** * 匹配前缀 * <p> * PrefixQuery用于匹配其索引开始以指定的字符串的文档。就是文档中存在xxx% * <p> * * @throws IOException */@Testpublic void prefixQueryTest() throws IOException {    String searchField = "title";    Term term = new Term(searchField, "Spar");    Query query = new PrefixQuery(term);     //执行查询，并打印查询到的记录数    executeQuery(query);}
+/** * 匹配前缀 * <p> * PrefixQuery用于匹配其索引开始以指定的字符串的文档。就是文档中存在xxx% * <p> * * @throws IOException */
+@Testpublic void prefixQueryTest() throws IOException {    
+String searchField = "title";    
+Term term = new Term(searchField, "Spar");    
+Query query = new PrefixQuery(term);     
+//执行查询，并打印查询到的记录数    
+executeQuery(query);
+}
 ```
 
+
+
 响应
 
-```
 总共查询到1个文档id：1title：Sparkcontent：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
-```
 
 ## 短语搜索
 
+
+
 ```
-/** * 短语搜索 * <p> * 所谓PhraseQuery，就是通过短语来检索，比如我想查“big car”这个短语， * 那么如果待匹配的document的指定项里包含了"big car"这个短语， * 这个document就算匹配成功。可如果待匹配的句子里包含的是“big black car”， * 那么就无法匹配成功了，如果也想让这个匹配，就需要设定slop， * 先给出slop的概念：slop是指两个项的位置之间允许的最大间隔距离 * * @throws IOException */@Testpublic void phraseQueryTest() throws IOException {     String searchField = "content";    String query1 = "apache";    String query2 = "spark";     PhraseQuery.Builder builder = new PhraseQuery.Builder();    builder.add(new Term(searchField, query1));    builder.add(new Term(searchField, query2));    builder.setSlop(0);    PhraseQuery phraseQuery = builder.build();     //执行查询，并打印查询到的记录数    executeQuery(phraseQuery);}
+/** * 短语搜索 * <p> * 所谓PhraseQuery，就是通过短语来检索，比如我想查“big car”这个短语， * 那么如果待匹配的document的指定项里包含了"big car"这个短语， * 这个document就算匹配成功。可如果待匹配的句子里包含的是“big black car”， * 那么就无法匹配成功了，如果也想让这个匹配，就需要设定slop， * 先给出slop的概念：slop是指两个项的位置之间允许的最大间隔距离 * * @throws IOException */
+@Testpublic void phraseQueryTest() throws IOException {     
+String searchField = "content";    
+String query1 = "apache";    
+String query2 = "spark";     
+PhraseQuery.Builder builder = new PhraseQuery.Builder();    
+builder.add(new Term(searchField, query1));    
+builder.add(new Term(searchField, query2));    
+builder.setSlop(0);    
+PhraseQuery phraseQuery = builder.build();     
+//执行查询，并打印查询到的记录数    
+executeQuery(phraseQuery);
+}
 ```
 
+
+
 响应
 
-```
 总共查询到1个文档id：1title：Sparkcontent：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
-```
 
 ## 相近词语搜索
 
-```
-/** * 相近词语搜索 * <p> * FuzzyQuery是一种模糊查询，它可以简单地识别两个相近的词语。 * * @throws IOException */@Testpublic void fuzzyQueryTest() throws IOException {     String searchField = "content";    Term t = new Term(searchField, "大规模");    Query query = new FuzzyQuery(t);     //执行查询，并打印查询到的记录数    executeQuery(query);}
-```
+/** * 相近词语搜索 * <p> * FuzzyQuery是一种模糊查询，它可以简单地识别两个相近的词语。 * * @throws IOException */@Testpublic void fuzzyQueryTest() throws IOException { String searchField = "content"; Term t = new Term(searchField, "大规模"); Query query = new FuzzyQuery(t); //执行查询，并打印查询到的记录数 executeQuery(query);}
 
 响应
 
-```
 总共查询到1个文档id：1title：Sparkcontent：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
-```
 
 ## 通配符搜索
 
-```
-/** * 通配符搜索 * <p> * Lucene也提供了通配符的查询，这就是WildcardQuery。 * 通配符“?”代表1个字符，而“*”则代表0至多个字符。 * * @throws IOException */@Testpublic void wildcardQueryTest() throws IOException {    String searchField = "content";    Term term = new Term(searchField, "大*规模");    Query query = new WildcardQuery(term);     //执行查询，并打印查询到的记录数    executeQuery(query);}
-```
+/** * 通配符搜索 * <p> * Lucene也提供了通配符的查询，这就是WildcardQuery。 * 通配符“?”代表1个字符，而“*”则代表0至多个字符。 * * @throws IOException */@Testpublic void wildcardQueryTest() throws IOException { String searchField = "content"; Term term = new Term(searchField, "大*规模"); Query query = new WildcardQuery(term); //执行查询，并打印查询到的记录数 executeQuery(query);}
 
 响应
 
-```
 总共查询到1个文档id：1title：Sparkcontent：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
-```
 
 ## 分词查询
 
+
+
 ```
-/** * 分词查询 * * @throws IOException * @throws ParseException */@Testpublic void queryParserTest() throws IOException, ParseException {    //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文    //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词    //Analyzer analyzer = new ComplexAnalyzer();//中文分词    //Analyzer analyzer = new IKAnalyzer();//中文分词     Analyzer analyzer = new IKAnalyzer();//中文分词     String searchField = "content";     //指定搜索字段和分析器    QueryParser parser = new QueryParser(searchField, analyzer);     //用户输入内容    Query query = parser.parse("计算引擎");     //执行查询，并打印查询到的记录数    executeQuery(query);}
+/** * 分词查询 * * @throws IOException * @throws ParseException */
+@Test
+public void queryParserTest() throws IOException, ParseException {    
+//Analyzer analyzer = new StandardAnalyzer(); 
+// 标准分词器，适用于英文    
+//Analyzer analyzer = new SmartChineseAnalyzer();
+//中文分词    
+//Analyzer analyzer = new ComplexAnalyzer();
+//中文分词    //Analyzer analyzer = new IKAnalyzer();
+//中文分词     Analyzer analyzer = new IKAnalyzer();
+//中文分词     String searchField = "content";     
+//指定搜索字段和分析器    
+QueryParser parser = new QueryParser(searchField, analyzer);     
+//用户输入内容    Query query = parser.parse("计算引擎");     
+//执行查询，并打印查询到的记录数    
+executeQuery(query);
+}
 ```
 
+
+
 响应
 
-```
 总共查询到1个文档id：1title：Sparkcontent：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
-```
 
 ## 多个 Field 分词查询
 
+
+
 ```
-/** * 多个 Field 分词查询 * * @throws IOException * @throws ParseException */@Testpublic void multiFieldQueryParserTest() throws IOException, ParseException {    //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文    //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词    //Analyzer analyzer = new ComplexAnalyzer();//中文分词    //Analyzer analyzer = new IKAnalyzer();//中文分词     Analyzer analyzer = new IKAnalyzer();//中文分词     String[] filedStr = new String[]{"title", "content"};     //指定搜索字段和分析器    QueryParser queryParser = new MultiFieldQueryParser(filedStr, analyzer);     //用户输入内容    Query query = queryParser.parse("Spark");     //执行查询，并打印查询到的记录数    executeQuery(query);}
+/** * 多个 Field 分词查询 * * @throws IOException * @throws ParseException */
+@Testpublic void multiFieldQueryParserTest() throws IOException, ParseException {    
+//Analyzer analyzer = new StandardAnalyzer(); 
+// 标准分词器，适用于英文    
+//Analyzer analyzer = new SmartChineseAnalyzer();//中文分词    
+//Analyzer analyzer = new ComplexAnalyzer();
+//中文分词    
+//Analyzer analyzer = new IKAnalyzer();
+//中文分词     Analyzer analyzer = new IKAnalyzer();
+//中文分词     String[] filedStr = new String[]{"title", "content"};     
+//指定搜索字段和分析器    
+QueryParser queryParser = new MultiFieldQueryParser(filedStr, analyzer);     
+//用户输入内容    
+Query query = queryParser.parse("Spark");     
+//执行查询，并打印查询到的记录数    executeQuery(query);}
 ```
 
+
+
 响应
 
-```
 总共查询到1个文档id：1title：Sparkcontent：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
-```
 
 ## 中文分词器
 
+
+
 ```
-/** * IKAnalyzer  中文分词器 * SmartChineseAnalyzer  smartcn分词器 需要lucene依赖 且和lucene版本同步 * * @throws IOException */@Testpublic void AnalyzerTest() throws IOException {    //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文    //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词    //Analyzer analyzer = new ComplexAnalyzer();//中文分词    //Analyzer analyzer = new IKAnalyzer();//中文分词     Analyzer analyzer = null;    String text = "Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎";     analyzer = new IKAnalyzer();//IKAnalyzer 中文分词    printAnalyzerDoc(analyzer, text);    System.out.println();     analyzer = new ComplexAnalyzer();//MMSeg4j 中文分词    printAnalyzerDoc(analyzer, text);    System.out.println();     analyzer = new SmartChineseAnalyzer();//Lucene 中文分词器    printAnalyzerDoc(analyzer, text);}
+/** * IKAnalyzer  中文分词器 * SmartChineseAnalyzer  smartcn分词器 需要lucene依赖 且和lucene版本同步 * * @throws IOException */
+@Test
+public void AnalyzerTest() throws IOException { 
+//Analyzer analyzer = new StandardAnalyzer(); 
+// 标准分词器，适用于英文    
+//Analyzer analyzer = new SmartChineseAnalyzer();
+//中文分词    //Analyzer analyzer = new ComplexAnalyzer();
+//中文分词    //Analyzer analyzer = new IKAnalyzer();
+//中文分词     
+Analyzer analyzer = null;    
+String text = "Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎";
+analyzer = new IKAnalyzer();//IKAnalyzer 中文分词    
+printAnalyzerDoc(analyzer, text);    
+System.out.println();     
+analyzer = new ComplexAnalyzer();
+//MMSeg4j 中文分词    
+printAnalyzerDoc(analyzer, text);    
+System.out.println();     
+analyzer = new SmartChineseAnalyzer();
+//Lucene 中文分词器    
+printAnalyzerDoc(analyzer, text);}
 ```
 
+
+
 三种分词响应
 
-```
 apachespark专为大规模规模模数数据处理数据处理而设设计快速通用计算引擎
-```
 
-```
 apachespark是专为大规模数据处理而设计的快速通用的计算引擎
-```
 
-```
 apachspark是专为大规模数据处理而设计的快速通用的计算引擎
-```
 
 ## 高亮处理
 
-```
-/** * 高亮处理 * * @throws IOException */@Testpublic void HighlighterTest() throws IOException, ParseException, InvalidTokenOffsetsException {    //Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文    //Analyzer analyzer = new SmartChineseAnalyzer();//中文分词    //Analyzer analyzer = new ComplexAnalyzer();//中文分词    //Analyzer analyzer = new IKAnalyzer();//中文分词     Analyzer analyzer = new IKAnalyzer();//中文分词     String searchField = "content";    String text = "Apache Spark 大规模数据处理";     //指定搜索字段和分析器    QueryParser parser = new QueryParser(searchField, analyzer);     //用户输入内容    Query query = parser.parse(text);     TopDocs topDocs = indexSearcher.search(query, 100);     // 关键字高亮显示的html标签，需要导入lucene-highlighter-xxx.jar    SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("", "");    Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query));     for (ScoreDoc scoreDoc : topDocs.scoreDocs) {         //取得对应的文档对象        Document document = indexSearcher.doc(scoreDoc.doc);         // 内容增加高亮显示        TokenStream tokenStream = analyzer.tokenStream("content", new StringReader(document.get("content")));        String content = highlighter.getBestFragment(tokenStream, document.get("content"));         System.out.println(content);    } }
-```
 
-响应
 
 ```
-Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
+/** * 高亮处理 * * @throws IOException */
+@Test
+public void HighlighterTest() throws IOException, ParseException, InvalidTokenOffsetsException {
+//Analyzer analyzer = new StandardAnalyzer(); 
+// 标准分词器，适用于英文   
+//Analyzer analyzer = new SmartChineseAnalyzer();
+//中文分词   
+//Analyzer analyzer = new ComplexAnalyzer();
+//中文分词    
+//Analyzer analyzer = new IKAnalyzer();
+//中文分词     Analyzer analyzer = new IKAnalyzer();
+//中文分词     String searchField = "content";    
+String text = "Apache Spark 大规模数据处理";     
+//指定搜索字段和分析器    
+QueryParser parser = new QueryParser(searchField, analyzer);     
+//用户输入内容    
+Query query = parser.parse(text);     
+TopDocs topDocs = indexSearcher.search(query, 100);     
+// 关键字高亮显示的html标签，需要导入lucene-highlighter-xxx.jar    
+SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("", "");    
+Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query));     
+for (ScoreDoc scoreDoc : topDocs.scoreDocs) {         
+//取得对应的文档对象        
+Document document = indexSearcher.doc(scoreDoc.doc);         
+// 内容增加高亮显示        
+TokenStream tokenStream = analyzer.tokenStream("content", new StringReader(document.get("content")));        
+String content = highlighter.getBestFragment(tokenStream, document.get("content"));         
+System.out.println(content);    
+} 
+}
 ```
 
-代码我已放到 Github ，导入`spring-boot-lucene-demo` 项目
-
-github [spring-boot-lucene-demo](https://link.juejin.im/?target=https%3A%2F%2Fgithub.com%2Fsouyunku%2Fspring-boot-examples%2Ftree%2Fmaster%2Fspring-boot-lucene-demo)
-
-*   作者：Peng Lei
-*   出处：[Segment Fault PengLei `Blog 专栏](https://link.juejin.im/?target=https%3A%2F%2Fsegmentfault.com%2Fa%2F1190000011916639)
-*   版权归作者所有，转载请注明出处
 
 
+响应
 
+Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
 
+代码我已放到 Github ，导入`spring-boot-lucene-demo` 项目
 
+[github spring-boot-lucene-demo](https://docs.qq.com/doc/DWVNPQXRvcWhMTktC)
diff --git "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2108\357\274\232OpenStack\346\236\266\346\236\204\350\256\276\350\256\241.md" "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232OpenStack\346\236\266\346\236\204\350\256\276\350\256\241.md"
similarity index 76%
rename from "docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2108\357\274\232OpenStack\346\236\266\346\236\204\350\256\276\350\256\241.md"
rename to "docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232OpenStack\346\236\266\346\236\204\350\256\276\350\256\241.md"
index f9ee3b5..ee38091 100644
--- "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2108\357\274\232OpenStack\346\236\266\346\236\204\350\256\276\350\256\241.md"
+++ "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232OpenStack\346\236\266\346\236\204\350\256\276\350\256\241.md"
@@ -1,25 +1,29 @@
-# Table of Contents
+# 目录
 
-    * [openstack 逻辑架构图](#openstack-逻辑架构图)
-    * [OpenStack 项目和组件](#openstack-项目和组件)
-    * [生产部署架构](#生产部署架构)
-      * [控制器](#控制器)
-      * [计算](#计算)
-      * [块设备存储](#块设备存储)
-      * [对象存储](#对象存储)
-      * [网络](#网络)
-    * [涉及的 Linux 网络技术](#涉及的-linux-网络技术)
-    * [总结](#总结)
+  * [openstack 逻辑架构图](#openstack-逻辑架构图)
+  * [OpenStack 项目和组件](#openstack-项目和组件)
+  * [生产部署架构](#生产部署架构)
+    * [控制器](#控制器)
+    * [计算](#计算)
+    * [块设备存储](#块设备存储)
+    * [对象存储](#对象存储)
+    * [网络](#网络)
+  * [涉及的 Linux 网络技术](#涉及的-linux-网络技术)
+  * [总结](#总结)
 
 
+[toc]
+
 本文转自互联网，侵删
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本系列文章将整理到我的个人博客
+
 > www.how2playlife.com
 
 更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注
@@ -30,13 +34,13 @@
 
 <!-- more -->
 
-OpenStack 是开源云计算平台，支持多种虚拟化环境，并且其服务组件都提供了 API接口 便于二次开发。
+OpenStack 是开源云计算平台，支持多种虚拟化环境，并且其服务组件都提供了API接口便于二次开发。
 
 OpenStack通过各种补充服务提供基础设施即服务 Infrastructure-as-a-Service (IaaS)`的解决方案。每个服务都提供便于集成的应用程序接口`Application Programming Interface (API)。
 
-### openstack 逻辑架构图
+## openstack 逻辑架构图
 
-![](http://mmbiz.qpic.cn/mmbiz_png/MxvbhgSaC6GWEd8OJ3JRIWQfkhGo23icH3stE59wmxYcibF1kO8Eq288YjtayCVEIDpeDs5jN7lACVSsk3DwPibFQ/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408115819.png)
 
 OpenStack 本身是一个分布式系统，不但各个服务可以分布部署，服务中的组件也可以分布部署。 这种分布式特性让 OpenStack 具备极大的灵活性、伸缩性和高可用性。 当然从另一个角度讲，这也使得 OpenStack 比一般系统复杂，学习难度也更大。
 
@@ -68,35 +72,35 @@ OpenStack的各个服务之间通过统一的REST风格的API调用，实现系
 
 对Linux经验丰富的OpenStack新用户，使用openstack是非常容易的，在后续`openstack系列`文章中会逐步展开介绍。
 
-### OpenStack 项目和组件
+## OpenStack 项目和组件
 
 OpenStack services
 
-*   Dashboard     【Horizon】     提供了一个基于web的自服务门户，与OpenStack底层服务交互，诸如启动一个实例，分配IP地址以及配置访问控制。
+*   Dashboard   【Horizon】   提供了一个基于web的自服务门户，与OpenStack底层服务交互，诸如启动一个实例，分配IP地址以及配置访问控制。
 
-*   Compute       【Nova】        在OpenStack环境中计算实例的生命周期管理。按需响应包括生成、调度、回收虚拟机等操作。
+*   Compute    【Nova】    在OpenStack环境中计算实例的生命周期管理。按需响应包括生成、调度、回收虚拟机等操作。
 
-*   Networking    【Neutron】     确保为其它OpenStack服务提供网络连接即服务，比如OpenStack计算。为用户提供API定义网络和使用。基于插件的架构其支持众多的网络提供商和技术。
+*   Networking  【Neutron】   确保为其它OpenStack服务提供网络连接即服务，比如OpenStack计算。为用户提供API定义网络和使用。基于插件的架构其支持众多的网络提供商和技术。
 
-*   Object Storage    【Swift】   通过一个 RESTful,基于HTTP的应用程序接口存储和任意检索的非结构化数据对象。它拥有高容错机制，基于数据复制和可扩展架构。它的实现并像是一个文件服务器需要挂载目录。在此种方式下，它写入对象和文件到多个硬盘中，以确保数据是在集群内跨服务器的多份复制。
+*   Object Storage  【Swift】  通过一个 RESTful,基于HTTP的应用程序接口存储和任意检索的非结构化数据对象。它拥有高容错机制，基于数据复制和可扩展架构。它的实现并像是一个文件服务器需要挂载目录。在此种方式下，它写入对象和文件到多个硬盘中，以确保数据是在集群内跨服务器的多份复制。
 
-*   Block Storage       【Cinder】   为运行实例而提供的持久性块存储。它的可插拔驱动架构的功能有助于创建和管理块存储设备。
+*   Block Storage    【Cinder】  为运行实例而提供的持久性块存储。它的可插拔驱动架构的功能有助于创建和管理块存储设备。
 
-*   Identity service  【Keystone】    为其他OpenStack服务提供认证和授权服务，为所有的OpenStack服务提供一个端点目录。
+*   Identity service 【Keystone】  为其他OpenStack服务提供认证和授权服务，为所有的OpenStack服务提供一个端点目录。
 
-*   Image service     【Glance】  存储和检索虚拟机磁盘镜像，OpenStack计算会在实例部署时使用此服务。
+*   Image service   【Glance】 存储和检索虚拟机磁盘镜像，OpenStack计算会在实例部署时使用此服务。
 
-*   Telemetry服务      【Ceilometer】  为OpenStack云的计费、基准、扩展性以及统计等目的提供监测和计量。
+*   Telemetry服务   【Ceilometer】 为OpenStack云的计费、基准、扩展性以及统计等目的提供监测和计量。
 
-*   Orchestration服务   【Heat服务】   Orchestration服务支持多样化的综合的云应用，通过调用OpenStack-native REST API和CloudFormation-compatible Query API，支持`HOT <Heat Orchestration Template (HOT)>`格式模板或者AWS CloudFormation格式模板
+*   Orchestration服务  【Heat服务】  Orchestration服务支持多样化的综合的云应用，通过调用OpenStack-native REST API和CloudFormation-compatible Query API，支持`HOT <Heat Orchestration Template (HOT)>`格式模板或者AWS CloudFormation格式模板
 
 通过对这些组件的介绍，可以帮助我们在后续的内容中，了解各个组件的作用，便于排查问题，而在你对基础安装，配置，操作和故障诊断熟悉之后，你应该考虑按照生产架构来进行部署。
 
-### 生产部署架构
+## 生产部署架构
 
 建议使用自动化部署工具，例如Ansible, Chef, Puppet, or Salt来自动化部署，管理生产环境。
 
-![](http://mmbiz.qpic.cn/mmbiz_png/MxvbhgSaC6GWEd8OJ3JRIWQfkhGo23icH6JtvNllODFno0K644yCIHEpfb8icyF7B3u6gXvgsT9AgzYgV26l9P1g/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408115834.png)
 
 这个示例架构需要至少2个（主机）节点来启动基础服务`virtual machine <virtual machine (VM)>`或者实例。像块存储服务，对象存储服务这一类服务还需要额外的节点。
 
@@ -104,7 +108,7 @@ OpenStack services
 
 *   私有网络的覆盖流量通过管理网络而不是专用网络
 
-#### 控制器
+### 控制器
 
 控制节点上运行身份认证服务，镜像服务，计算服务的管理部分，网络服务的管理部分，多种网络代理以及仪表板。也需要包含一些支持服务，例如：SQL数据库，term:消息队列, and NTP。
 
@@ -112,13 +116,13 @@ OpenStack services
 
 计算节点上需要至少两块网卡。
 
-#### 计算
+### 计算
 
 计算节点上运行计算服务中管理实例的管理程序部分。默认情况下，计算服务使用 KVM。
 
 你可以部署超过一个计算节点。每个结算节点至少需要两块网卡。
 
-#### 块设备存储
+### 块设备存储
 
 可选的块存储节点上包含了磁盘，块存储服务和共享文件系统会向实例提供这些磁盘。
 
@@ -126,7 +130,7 @@ OpenStack services
 
 你可以部署超过一个块存储节点。每个块存储节点要求至少一块网卡。
 
-#### 对象存储
+### 对象存储
 
 可选的对象存储节点包含了磁盘。对象存储服务用这些磁盘来存储账号，容器和对象。
 
@@ -134,7 +138,7 @@ OpenStack services
 
 这个服务要求两个节点。每个节点要求最少一块网卡。你可以部署超过两个对象存储节点。
 
-#### 网络
+### 网络
 
 openstack网络是非常复杂的，并且也支持多种模式其中支持GRE，VLAN,VXLAN等，在openstack中网络是通过一个组件`Neutron`提供服务，Neutron 管理的网络资源包括如下。
 
@@ -154,17 +158,17 @@ openstack网络是非常复杂的，并且也支持多种模式其中支持GRE
 
 *   port 可以看做虚拟交换机上的一个端口。port 上定义了 MAC 地址和 IP 地址，当 instance 的虚拟网卡 VIF（Virtual Interface） 绑定到 port 时，port 会将 MAC 和 IP 分配给 VIF。port 与 subnet 是 1对多 关系。一个 port 必须属于某个 subnet；一个 subnet 可以有多个 port。
 
-![](http://mmbiz.qpic.cn/mmbiz_png/MxvbhgSaC6GWEd8OJ3JRIWQfkhGo23icHcCr8k5VVbooGYOMC3QYqlmOW8gwneIOEicS0txC4HtEicJLIN6bEyVcw/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408115845.png)
 
 如上图所示，为VLAN模式下，网络节点的通信方式。
 
 在我们后续实施安装的时候，选择使用VXLAN网络模式，下面我们来重点介绍一下VXLAN模式。
 
-![](http://mmbiz.qpic.cn/mmbiz_png/MxvbhgSaC6GWEd8OJ3JRIWQfkhGo23icHOLoLQuIYiar5Jm1YPBZQpxGJibVshiaJ6ZicLmwsT3dc6K53ibfHNwBsw5Q/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408115856.png)
 
 VXLAN网络模式，可以隔离广播风暴，不需要交换机配置chunk口，解决了vlan id个数限制，解决了gre点对点隧道个数过多问题，实现了大2层网络，可以让vm在机房之间无缝迁移，便于跨机房部署。缺点是，vxlan增加了ip头部大小，需要降低vm的mtu值，传输效率上会略有下降。
 
-### 涉及的 Linux 网络技术
+## 涉及的 Linux 网络技术
 
 Neutron 的设计目标是实现“网络即服务”，为了达到这一目标，在设计上遵循了基于“软件定义网络”实现网络虚拟化的原则，在实现上充分利用了 Linux 系统上的各种网络相关的技术。理解了 Linux 系统上的这些概念将有利于快速理解 Neutron 的原理和实现。
 
@@ -194,6 +198,6 @@ Neutron 的设计目标是实现“网络即服务”，为了达到这一目标
 
 *   namespace：用来实现隔离的一套机制，不同 namespace 中的资源之间彼此不可见。
 
-### 总结
+## 总结
 
 openstack是一个非法复杂的分布式软件，涉及到很多底层技术，我自己对一些网络的理解也是非常有限，主要还是应用层面的知识，所以本章内容写的比较浅显一些，有问题请留言？在下一章节我们会进入生产环境如何实施规划openstack集群，至于openstack底层的技术，我也没有很深入研究，如果有任何不恰当的地方可以进行留言，非常感谢！
diff --git "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2107\357\274\232OpenStack\347\232\204\345\237\272\347\237\263KVM.md" "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232OpenStack\347\232\204\345\237\272\347\237\263KVM.md"
similarity index 57%
rename from "docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2107\357\274\232OpenStack\347\232\204\345\237\272\347\237\263KVM.md"
rename to "docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232OpenStack\347\232\204\345\237\272\347\237\263KVM.md"
index 98961fe..ee2674b 100644
--- "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2107\357\274\232OpenStack\347\232\204\345\237\272\347\237\263KVM.md"
+++ "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232OpenStack\347\232\204\345\237\272\347\237\263KVM.md"
@@ -1,38 +1,31 @@
-# Table of Contents
+# 目录
 
-* [[Qemu，KVM，Virsh傻傻的分不清](https://www.cnblogs.com/popsuper1982/p/8522535.html)](#[qemu，kvm，virsh傻傻的分不清]httpswwwcnblogscompopsuper1982p8522535html)
-  * [ Kvm虚拟化技术实践](# kvm虚拟化技术实践)
+  * [Kvm虚拟化技术实践](#kvm虚拟化技术实践)
     * [VMware虚拟机支持Kvm虚拟化技术？](#vmware虚拟机支持kvm虚拟化技术？)
     * [安装Kvm虚拟化软件](#安装kvm虚拟化软件)
-* [ifconfig virbr0virbr0    Link encap:Ethernet  HWaddr 52:54:00:D7:23:AD            inet addr:192.168.122.1  Bcast:192.168.122.255  Mask:255.255.255.0          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1          RX packets:0 errors:0 dropped:0 overruns:0 frame:0          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0          collisions:0 txqueuelen:0           RX bytes:0 (0.0 b)  TX bytes:0 (0.0 b)](#ifconfig-virbr0virbr0----link-encapethernet--hwaddr-525400d723ad------------inet-addr1921681221--bcast192168122255--mask2552552550----------up-broadcast-running-multicast--mtu1500--metric1----------rx-packets0-errors0-dropped0-overruns0-frame0----------tx-packets0-errors0-dropped0-overruns0-carrier0----------collisions0-txqueuelen0-----------rx-bytes0-00-b--tx-bytes0-00-b)
-* [brctl showbridge name     bridge id               STP enabled     interfacesvirbr0          8000.525400d723ad       yes             virbr0-nic](#brctl-showbridge-name-----bridge-id---------------stp-enabled-----interfacesvirbr0----------8000525400d723ad-------yes-------------virbr0-nic)
-* [iptables -nvL -t natChain PREROUTING (policy ACCEPT 304 packets, 38526 bytes) pkts bytes target     prot opt in     out     source               destination          Chain POSTROUTING (policy ACCEPT 7 packets, 483 bytes) pkts bytes target     prot opt in     out     source               destination             0     0 MASQUERADE  tcp  --  *      *       192.168.122.0/24    !192.168.122.0/24    masq ports: 1024-65535     0     0 MASQUERADE  udp  --  *      *       192.168.122.0/24    !192.168.122.0/24    masq ports: 1024-65535     0     0 MASQUERADE  all  --  *      *       192.168.122.0/24    !192.168.122.0/24     Chain OUTPUT (policy ACCEPT 7 packets, 483 bytes) pkts bytes target     prot opt in     out     source               destination](#iptables--nvl--t-natchain-prerouting-policy-accept-304-packets-38526-bytes-pkts-bytes-target-----prot-opt-in-----out-----source---------------destination----------chain-postrouting-policy-accept-7-packets-483-bytes-pkts-bytes-target-----prot-opt-in-----out-----source---------------destination-------------0-----0-masquerade--tcp-------------------192168122024----192168122024----masq-ports-1024-65535-----0-----0-masquerade--udp-------------------192168122024----192168122024----masq-ports-1024-65535-----0-----0-masquerade--all-------------------192168122024----192168122024-----chain-output-policy-accept-7-packets-483-bytes-pkts-bytes-target-----prot-opt-in-----out-----source---------------destination)
     * [kvm创建虚拟机](#kvm创建虚拟机)
-* [netstat -ntlp|grep 5900tcp        0      0 0.0.0.0:5900                0.0.0.0:*                   LISTEN      2504/qemu-kvm](#netstat--ntlpgrep-5900tcp--------0------0-00005900----------------0000-------------------listen------2504qemu-kvm)
     * [虚拟机远程管理软件](#虚拟机远程管理软件)
     * [KVM虚拟机管理](#kvm虚拟机管理)
     * [libvirt虚拟机配置文件](#libvirt虚拟机配置文件)
-* [lltotal 8-rw-------. 1 root root 3047 Oct 19  2016 Centos-6.6-x68_64.xmldrwx------. 3 root root 4096 Oct 17  2016 networks](#lltotal-8-rw--------1-root-root-3047-oct-19--2016-centos-66-x68_64xmldrwx-------3-root-root-4096-oct-17--2016-networks)
     * [监控kvm虚拟机](#监控kvm虚拟机)
-    * [KVM修改NAT模式为桥接[案例]](#kvm修改nat模式为桥接[案例])
-* [virsh edit Centos-6.6-x68_64  # 命令 52     <interface type='network'>     53       <mac address='52:54:00:2a:2d:60'/>     54       <source network='default'/>     55            56     </interface> 修改为：52     <interface type='bridge'>     53       <mac address='52:54:00:2a:2d:60'/>     54       <source bridge='br0'/>     55            56     </interface>](#virsh-edit-centos-66-x68_64---命令-52-----interface-typenetwork-----53-------mac-address5254002a2d60-----54-------source-networkdefault-----55------------56-----interface-修改为：52-----interface-typebridge-----53-------mac-address5254002a2d60-----54-------source-bridgebr0-----55------------56-----interface)
-* [brctl showbridge name     bridge id               STP enabled     interfacesbr0             8000.000c29f824c9       no              eth0virbr0          8000.525400353d8e       yes             virbr0-nic](#brctl-showbridge-name-----bridge-id---------------stp-enabled-----interfacesbr0-------------8000000c29f824c9-------no--------------eth0virbr0----------8000525400353d8e-------yes-------------virbr0-nic)
-* [virsh start CentOS-6.6-x86_64Domain CentOS-6.6-x86_64 started # brctl show                   bridge name     bridge id               STP enabled     interfacesbr0             8000.000c29f824c9       no              eth0                                                        vnet0virbr0          8000.525400353d8e       yes             virbr0-nic](#virsh-start-centos-66-x86_64domain-centos-66-x86_64-started--brctl-show-------------------bridge-name-----bridge-id---------------stp-enabled-----interfacesbr0-------------8000000c29f824c9-------no--------------eth0--------------------------------------------------------vnet0virbr0----------8000525400353d8e-------yes-------------virbr0-nic)
-* [ifup eth0](#ifup-eth0)
-* [ssh 192.168.2.108root@192.168.2.108's password: Last login: Sat Jan 30 12:40:28 2016](#ssh-1921682108root1921682108s-password-last-login-sat-jan-30-124028-2016)
+    * [KVM修改NAT模式为桥接](#kvm修改nat模式为桥接)
     * [总结](#总结)
 
 
-# [Qemu，KVM，Virsh傻傻的分不清](https://www.cnblogs.com/popsuper1982/p/8522535.html)
 
- 本文转载自[Itweet](https://link.juejin.im/?target=http%3A%2F%2Fwww.itweet.cn)的博客
+
+[toc]
+
+本文转载自[Itweet](https://link.juejin.im/?target=http%3A%2F%2Fwww.itweet.cn)的博客
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本系列文章将整理到我的个人博客
+
 > www.how2playlife.com
 
 更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注
@@ -67,7 +60,7 @@ KVM（Kernel-based Virtual Machine的英文缩写）是内核内建的虚拟机
 
 Qemu向Guest OS模拟CPU，也模拟其他的硬件，GuestOS认为自己和硬件直接打交道，其实是同Qemu模拟出来的硬件打交道，Qemu将这些指令转译给真正的硬件。由于所有的指令都要从Qemu里面过一手，因而性能比较差
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180307150620008-108720261.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180307150620008-108720261.jpg)
 
 按照上一次的理论，完全虚拟化是非常慢的，所以要使用硬件辅助虚拟化技术Intel-VT，AMD-V，所以需要CPU硬件开启这个标志位，一般在BIOS里面设置。查看是否开启
 
@@ -81,11 +74,11 @@ Qemu向Guest OS模拟CPU，也模拟其他的硬件，GuestOS认为自己和硬
 
 查看内核模块中是否含有kvm, ubuntu默认加载这些模块
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180307150634298-628102674.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180307150634298-628102674.png)
 
 KVM内核模块通过/dev/kvm暴露接口，用户态程序可以通过ioctl来访问这个接口，例如书写下面的程序
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180307150654328-1662633336.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180307150654328-1662633336.png)
 
 Qemu将KVM整合进来，通过ioctl调用/dev/kvm接口，将有关CPU指令的部分交由内核模块来做，就是qemu-kvm (qemu-system-XXX)
 
@@ -101,19 +94,19 @@ qemu和kvm整合之后，CPU的性能问题解决了，另外Qemu还会模拟其
 
 至此整个关系如下：
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180307150733042-369996016.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180307150733042-369996016.jpg)
 
 qemu-kvm会创建Guest OS，当需要执行CPU指令的时候，通过/dev/kvm调用kvm内核模块，通过硬件辅助虚拟化方式加速。如果需要进行网络和存储访问，则通过类虚拟化或者直通Pass through的方式，通过加载特殊的驱动，加速访问网络和存储资源。
 
 然而直接用qemu或者qemu-kvm或者qemu-system-xxx的少，大多数还是通过virsh启动，virsh属于libvirt工具，libvirt是目前使用最为广泛的对KVM虚拟机进行管理的工具和API，可不止管理KVM。
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180307150801681-1586679180.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180307150801681-1586679180.jpg)
 
 Libvirt分服务端和客户端，Libvirtd是一个daemon进程，是服务端，可以被本地的virsh调用，也可以被远程的virsh调用，virsh相当于客户端。
 
 Libvirtd调用qemu-kvm操作虚拟机，有关CPU虚拟化的部分，qemu-kvm调用kvm的内核模块来实现
 
-![](https://images2018.cnblogs.com/blog/635909/201803/635909-20180307150815111-1223973253.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/635909-20180307150815111-1223973253.jpg)
 
 这下子，整个相互关系才搞清楚了。
 
@@ -123,7 +116,7 @@ Libvirtd调用qemu-kvm操作虚拟机，有关CPU虚拟化的部分，qemu-kvm
 
 本章节我们主要介绍通过VMware技术虚拟出相关的Linux软件环境，在Linux系统中，安装KVM虚拟化软件，实实在在的去实践一下KVM到底是一个什么样的技术？
 
-##  Kvm虚拟化技术实践
+## Kvm虚拟化技术实践
 
 ### VMware虚拟机支持Kvm虚拟化技术？
 
@@ -133,7 +126,7 @@ VMware软件版本信息，`VMware® Workstation 11.0.0 build-2305329`
 
 首先，你需要启动VMware软件，新建一个`CentOS 6.x`类型的虚拟机，正常安装完成，这个虚拟机默认的`虚拟化引擎`，`首选模式`为”自动”。
 
-如果想让我们的VMware虚拟化出来的CentOS虚拟机支持KVM虚拟化，我们需要修改它支持的`虚拟化引擎`,打开新建的虚拟机，虚拟机状态必须处于`关闭`状态，通过双击`编辑虚拟机设置` > `硬件` ，选择`处理器`菜单，右边会出现`虚拟化引擎`区域，选择`首选模式`为 _Intel Tv-x/EPT或AMD-V/RVI_,接下来勾选`虚拟化Intel Tv-x/EPT或AMD-V/RVI(v)`，点击`确定`。
+如果想让我们的VMware虚拟化出来的CentOS虚拟机支持KVM虚拟化，我们需要修改它支持的`虚拟化引擎`,打开新建的虚拟机，虚拟机状态必须处于`关闭`状态，通过双击`编辑虚拟机设置`##>##`硬件`##，选择`处理器`菜单，右边会出现`虚拟化引擎`区域，选择`首选模式`为##_Intel Tv-x/EPT或AMD-V/RVI_,接下来勾选`虚拟化Intel Tv-x/EPT或AMD-V/RVI(v)`，点击`确定`。
 
 KVM需要虚拟机宿主（host）的处理器带有虚拟化支持（对于Intel处理器来说是VT-x，对于AMD处理器来说是AMD-V）。你可以通过以下命令来检查你的处理器是否支持虚拟化：
 
@@ -144,43 +137,42 @@ KVM需要虚拟机宿主（host）的处理器带有虚拟化支持（对于Inte
 
 如果运行后没有显示，那么你的处理器不支持硬件虚拟化，你不能使用KVM。
 
-*   注意: 如果是硬件服务器，您可能需要在BIOS中启用虚拟化支持，参考 [Private Cloud personal workstation](https://link.juejin.im/?target=http%3A%2F%2Fwww.itweet.cn%2Fblog%2F2016%2F06%2F14%2FPrivate%2520Cloud%2520personal%2520workstation)
+*   注意: 如果是硬件服务器，您可能需要在BIOS中启用虚拟化支持，参考[Private Cloud personal workstation](https://link.juejin.im/?target=http%3A%2F%2Fwww.itweet.cn%2Fblog%2F2016%2F06%2F14%2FPrivate%2520Cloud%2520personal%2520workstation)
 
 ### 安装Kvm虚拟化软件
-
 安装kvm虚拟化软件，我们需要一个Linux操作系统环境，这里我们选择的Linux版本为`CentOS release 6.8 (Final)`，在这个VMware虚拟化出来的虚拟机中安装kvm虚拟化软件，具体步骤如下：
 
-*   首选安装epel源
+* 首选安装epel源
 
-    ```
-    sudo rpm -ivh http://mirrors.ustc.edu.cn/fedora/epel/6/x86_64/epel-release-6-8.noarch.rpm
+  ```
+  sudo rpm -ivh http://mirrors.ustc.edu.cn/fedora/epel/6/x86_64/epel-release-6-8.noarch.rpm
+  
+  ```
 
-    ```
+* 安装kvm虚拟化软件
 
-*   安装kvm虚拟化软件
+  ```
+  sudo yum install qemu-kvm qeum-kvm-tools virt-manager libvirt
+  
+  ```
 
-    ```
-    sudo yum install qemu-kvm qeum-kvm-tools virt-manager libvirt
+* 启动kvm虚拟化软件
 
-    ```
+  ```
+  sudo /etc/init.d/libvirtd start
+  
+  ```
 
-*   启动kvm虚拟化软件
-
-    ```
-    sudo /etc/init.d/libvirtd start
-
-    ```
-
-启动成功之后你可以通过`/etc/init.d/libvirtd status`查看启动状态，这个时候，kvm会自动生成一个本地网桥 `virbr0`，可以通过命令查看他的详细信息
+启动成功之后你可以通过`/etc/init.d/libvirtd status`查看启动状态，这个时候，kvm会自动生成一个本地网桥##`virbr0`，可以通过命令查看他的详细信息
 
 ```
-# ifconfig virbr0virbr0    Link encap:Ethernet  HWaddr 52:54:00:D7:23:AD            inet addr:192.168.122.1  Bcast:192.168.122.255  Mask:255.255.255.0          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1          RX packets:0 errors:0 dropped:0 overruns:0 frame:0          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0          collisions:0 txqueuelen:0           RX bytes:0 (0.0 b)  TX bytes:0 (0.0 b)
+ ifconfig virbr0virbr0    Link encap:Ethernet  HWaddr 52:54:00:D7:23:AD            inet addr:192.168.122.1  Bcast:192.168.122.255  Mask:255.255.255.0          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1          RX packets:0 errors:0 dropped:0 overruns:0 frame:0          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0          collisions:0 txqueuelen:0           RX bytes:0 (0.0 b)  TX bytes:0 (0.0 b)
 ```
 
 KVM默认使用NAT网络模式。虚拟机获取一个私有 IP（例如 192.168.122.0/24 网段的），并通过本地主机的NAT访问外网。
 
 ```
-# brctl showbridge name     bridge id               STP enabled     interfacesvirbr0          8000.525400d723ad       yes             virbr0-nic
+ brctl showbridge name     bridge id               STP enabled     interfacesvirbr0          8000.525400d723ad       yes             virbr0-nic
 ```
 
 创建一个本地网桥virbr0，包括两个端口：virbr0-nic 为网桥内部端口，vnet0 为虚拟机网关端口（192.168.122.1）。
@@ -194,14 +186,13 @@ ps aux|grep dnsmasq
 
 ```
 
-`注意：` 启动libvirtd之后自动启动iptables，并且写上一些默认规则。
+`注意：`##启动libvirtd之后自动启动iptables，并且写上一些默认规则。
 
 ```
-# iptables -nvL -t natChain PREROUTING (policy ACCEPT 304 packets, 38526 bytes) pkts bytes target     prot opt in     out     source               destination          Chain POSTROUTING (policy ACCEPT 7 packets, 483 bytes) pkts bytes target     prot opt in     out     source               destination             0     0 MASQUERADE  tcp  --  *      *       192.168.122.0/24    !192.168.122.0/24    masq ports: 1024-65535     0     0 MASQUERADE  udp  --  *      *       192.168.122.0/24    !192.168.122.0/24    masq ports: 1024-65535     0     0 MASQUERADE  all  --  *      *       192.168.122.0/24    !192.168.122.0/24     Chain OUTPUT (policy ACCEPT 7 packets, 483 bytes) pkts bytes target     prot opt in     out     source               destination
+ iptables -nvL -t natChain PREROUTING (policy ACCEPT 304 packets, 38526 bytes) pkts bytes target     prot opt in     out     source               destination          Chain POSTROUTING (policy ACCEPT 7 packets, 483 bytes) pkts bytes target     prot opt in     out     source               destination             0     0 MASQUERADE  tcp  --  *      *       192.168.122.0/24    !192.168.122.0/24    masq ports: 1024-65535     0     0 MASQUERADE  udp  --  *      *       192.168.122.0/24    !192.168.122.0/24    masq ports: 1024-65535     0     0 MASQUERADE  all  --  *      *       192.168.122.0/24    !192.168.122.0/24     Chain OUTPUT (policy ACCEPT 7 packets, 483 bytes) pkts bytes target     prot opt in     out     source               destination
 ```
 
 ### kvm创建虚拟机
-
 上传一个镜像文件：`CentOS-6.6-x86_64-bin-DVD1.iso`
 
 通过`qemu`创建一个raw格式的文件(注：QEMU使用的镜像文件：qcow2与raw，它们都是QEMU(KVM)虚拟机使用的磁盘文件格式)，大小为5G。
@@ -227,14 +218,13 @@ virt-install  --virt-type kvm --name CentOS-6.6-x86_64 --ram 512 --cdrom /data/C
 启动之后，通过命令查看启动状态，默认会在操作系统开一个`5900`的端口，可以通过虚拟机远程管理软件`vnc`客户端连接，然后可视化的方式安装操作系统。
 
 ```
-# netstat -ntlp|grep 5900tcp        0      0 0.0.0.0:5900                0.0.0.0:*                   LISTEN      2504/qemu-kvm
+ netstat -ntlp|grep 5900tcp        0      0 0.0.0.0:5900                0.0.0.0:*                   LISTEN      2504/qemu-kvm
 ```
 
 `注意`：kvm安装的虚拟机，不确定是那一台，在后台就是一个进程，每增加一台端口号+1，第一次创建的为5900！
 
 ### 虚拟机远程管理软件
-
-我们可以使用虚拟机远程管理软件VNC进行操作系统的安装，我使用过的两款不错的虚拟机远程管理终端软件，一个是Windows上使用，一个在Mac上为了方便安装一个Google Chrome插件后即可开始使用，软件信息 `Tightvnc` 或者 `VNC[@Viewer](https://link.juejin.im/?target=https%3A%2F%2Fgithub.com%2FViewer "@Viewer") for Google Chrome`
+我们可以使用虚拟机远程管理软件VNC进行操作系统的安装，我使用过的两款不错的虚拟机远程管理终端软件，一个是Windows上使用，一个在Mac上为了方便安装一个Google Chrome插件后即可开始使用，软件信息##`Tightvnc`##或者##`VNC[@Viewer](https://link.juejin.im/?target=https%3A%2F%2Fgithub.com%2FViewer "@Viewer")##for Google Chrome`
 
 如果你和我一样使用的是`Google Chrome`提供的VNC插件，使用方式，在`Address`输入框中输入，宿主机IP:59000,`Picture Quality`选择框使用默认选项，点击`Connect`进入到安装操作系统的界面，你可以安装常规的方式进行安装，等待系统安装完成重启，然后就可以正常使用kvm虚拟化出来的操作系统了。
 
@@ -245,7 +235,6 @@ virt-install  --virt-type kvm --name CentOS-6.6-x86_64 --ram 512 --cdrom /data/C
 *   Tightvnc下载地址：[www.tightvnc.com/download/2.…](https://link.juejin.im/?target=http%3A%2F%2Fwww.tightvnc.com%2Fdownload%2F2.7.10%2Ftightvnc-2.7.10-setup-32bit.msi)
 
 ### KVM虚拟机管理
-
 kvm虚拟机是通过virsh命令进行管理的，libvirt是Linux上的虚拟化库，是长期稳定的C语言API，支持KVM/QEMU、Xen、LXC等主流虚拟化方案。链接：[libvirt.org/](https://link.juejin.im/?target=http%3A%2F%2Flibvirt.org%2F)
 virsh是Libvirt对应的shell命令。
 
@@ -270,19 +259,18 @@ virsh list
 
 ```
 
-*   常用命令查看
-
-    ```
-    virsh --help|more less
+* 常用命令查看
 
-    ```
+  ```
+  virsh --help|more less
+  
+  ```
 
 ### libvirt虚拟机配置文件
-
 虚拟机libvirt配置文件在`/etc/libvirt/qemu`路径下，生产中我们需要去修改它的网络信息。
 
 ```
-# lltotal 8-rw-------. 1 root root 3047 Oct 19  2016 Centos-6.6-x68_64.xmldrwx------. 3 root root 4096 Oct 17  2016 networks
+ lltotal 8-rw-------. 1 root root 3047 Oct 19  2016 Centos-6.6-x68_64.xmldrwx------. 3 root root 4096 Oct 17  2016 networks
 ```
 
 `注意`：不能直接修改xml文件，需要通过提供的命令！
@@ -295,7 +283,6 @@ virsh list
 kvm三种网络类型,桥接、NAT、仅主机模式，默认NAT模式,其他机器无法登陆，生产中一般选择桥接。
 
 ### 监控kvm虚拟机
-
 *   安装软件监控虚拟机
 
 ```
@@ -309,8 +296,7 @@ yum install virt-top -y
 virt-top virt-top 23:46:39 - x86_64 1/1CPU 3392MHz 3816MB1 domains, 1 active, 1 running, 0 sleeping, 0 paused, 0 inactive D:0 O:0 X:0CPU: 5.6%  Mem: 2024 MB (2024 MB by guests)    ID S RDRQ WRRQ RXBY TXBY %CPU %MEM    TIME   NAME                                                                                                     1 R    0    1   52    0  5.6 53.0   5:16.15 centos-6.8
 ```
 
-### KVM修改NAT模式为桥接[案例]
-
+### KVM修改NAT模式为桥接
 在开始案例之前，需要知道的必要信息，宿主机IP是`192.168.2.200`，操作系统版本`Centos-6.6-x68_64`。
 
 启动虚拟网卡
@@ -328,7 +314,7 @@ ifup eth0
 brctl show ifconfig virbr0 ifconfig vnet0
 ```
 
-_实现网桥，在kvm宿主机完成_
+实现网桥，在kvm宿主机完成
 
 *   步骤1，创建一个网桥，新建网桥连接到eth0,删除eth0,让新的网桥拥有eth0的ip
 
@@ -336,7 +322,7 @@ _实现网桥，在kvm宿主机完成_
 brctl addbr br0  #创建一个网桥 brctl show       #显示网桥信息 brctl addif br0 eth0 && ip addr del dev eth0 192.168.2.200/24 && ifconfig br0 192.168.2.200/24 up brctl show      #查看结果ifconfig br0    #验证br0是否成功取代了eth0的IP
 ```
 
-`注意`: 这里的IP地址为 _宿主机ip_
+`注意`: 这里的IP地址为##_宿主机ip_
 
 *   修改虚拟机桥接到br0网卡，在宿主机修改
 
@@ -347,7 +333,7 @@ virsh list --all ps aux |grep kvm virsh stop Centos-6.6-x68_64 virsh list --all
 修改虚拟机桥接到宿主机，修改52行type为`bridge`，第54行bridge为`br0`
 
 ```
-# virsh edit Centos-6.6-x68_64  # 命令 52     <interface type='network'>     53       <mac address='52:54:00:2a:2d:60'/>     54       <source network='default'/>     55            56     </interface> 修改为：52     <interface type='bridge'>     53       <mac address='52:54:00:2a:2d:60'/>     54       <source bridge='br0'/>     55            56     </interface>
+ virsh edit Centos-6.6-x68_64  # 命令 52     <interface type='network'>     53       <mac address='52:54:00:2a:2d:60'/>     54       <source network='default'/>     55            56     </interface> 修改为：52     <interface type='bridge'>     53       <mac address='52:54:00:2a:2d:60'/>     54       <source bridge='br0'/>     55            56     </interface>
 ```
 
 启动虚拟机，看到启动前后，桥接变化，vnet0被桥接到了br0
@@ -355,38 +341,34 @@ virsh list --all ps aux |grep kvm virsh stop Centos-6.6-x68_64 virsh list --all
 启动前：
 
 ```
-# brctl showbridge name     bridge id               STP enabled     interfacesbr0             8000.000c29f824c9       no              eth0virbr0          8000.525400353d8e       yes             virbr0-nic
+ brctl showbridge name     bridge id               STP enabled     interfacesbr0             8000.000c29f824c9       no              eth0virbr0          8000.525400353d8e       yes             virbr0-nic
 ```
 
 启动后：
 
 ```
-# virsh start CentOS-6.6-x86_64Domain CentOS-6.6-x86_64 started # brctl show                   bridge name     bridge id               STP enabled     interfacesbr0             8000.000c29f824c9       no              eth0                                                        vnet0virbr0          8000.525400353d8e       yes             virbr0-nic
+ virsh start CentOS-6.6-x86_64Domain CentOS-6.6-x86_64 started # brctl show                   bridge name     bridge id               STP enabled     interfacesbr0             8000.000c29f824c9       no              eth0                                                        vnet0virbr0          8000.525400353d8e       yes             virbr0-nic
 ```
 
 Vnc登陆后，修改ip地址，看到dhcp可以使用，被桥接到现有的ip段，ip是自动获取,而且是和宿主机在同一个IP段.
 
 ```
-# ifup eth0
+ ifup eth0
 
 ```
 
 从宿主机登陆此服务器，可以成功。
 
 ```
-# ssh 192.168.2.108root@192.168.2.108's password: Last login: Sat Jan 30 12:40:28 2016
+ ssh 192.168.2.108root@192.168.2.108's password: Last login: Sat Jan 30 12:40:28 2016
 ```
 
 从同一网段其他服务器登陆此虚拟机,也可以成功,至此让kvm管理的服务器能够桥接上网就完成了，在生产环境中，桥接上网是非常必要的。
 
 ### 总结
-
 通过kvm相关的命令来创建虚拟机，安装和调试是非常必要的，因为现有的很多私有云，公有云产品都使用到了kvm这样的技术，学习基本的kvm使用对维护`openstack`集群有非常要的作用，其次所有的`openstack image`制作也得通过kvm这样的底层技术来完成，最后上传到`openstack`的镜像管理模块，才能开始通过`openstack image`生成云主机。
 
-到此，各位应该能够体会到，其实kvm是一个非常底层和核心的虚拟化技术，而openstack就是对`kvm`这样的技术进行了一个上层封装，可以非常方便，可视化的操作和维护`kvm`虚拟机，这就是现在`牛`上天的`云计算`技术最底层技术栈，具体怎么实现请看下图。
-
-![Libvirt_support](https://user-gold-cdn.xitu.io/2017/6/19/69d6aeff29b1a8ff1d9a62579ad91afb?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-如上图，没有`openstack`我们依然可以通过，`libvirt`来对虚拟机进行操作，只不过比较繁琐和难以维护。通过openstack就可以非常方便的进行底层虚拟化技术的管理、维护、使用。
+到此，各位应该能够体会到，其实kvm是一个非常底层和核心的虚拟化技术，而openstack就是对`kvm`这样的技术进行了一个上层封装，可以非常方便，可视化的操作和维护`kvm`虚拟机，这就是现在`牛`上天的`云计算`技术最底层技术栈
 
+没有`openstack`我们依然可以通过，`libvirt`来对虚拟机进行操作，只不过比较繁琐和难以维护。通过openstack就可以非常方便的进行底层虚拟化技术的管理、维护、使用。
 
diff --git "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2105\357\274\232\344\272\221\350\256\241\347\256\227\347\232\204\345\211\215\344\270\226\344\273\212\347\224\237.md" "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\344\272\221\350\256\241\347\256\227\347\232\204\345\211\215\344\270\226\344\273\212\347\224\237.md"
similarity index 92%
rename from "docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2105\357\274\232\344\272\221\350\256\241\347\256\227\347\232\204\345\211\215\344\270\226\344\273\212\347\224\237.md"
rename to "docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\344\272\221\350\256\241\347\256\227\347\232\204\345\211\215\344\270\226\344\273\212\347\224\237.md"
index edcbfa4..4b7f441 100644
--- "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2105\357\274\232\344\272\221\350\256\241\347\256\227\347\232\204\345\211\215\344\270\226\344\273\212\347\224\237.md"
+++ "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\344\272\221\350\256\241\347\256\227\347\232\204\345\211\215\344\270\226\344\273\212\347\224\237.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
 * [云计算概述](#云计算概述)
 * [云计算发展脉络](#云计算发展脉络)
@@ -17,7 +17,7 @@
     * [公有云生态及老二的逆袭](#公有云生态及老二的逆袭)
     * [OpenStack的组件](#openstack的组件)
     * [OpenStack带来私有云市场的红海](#openstack带来私有云市场的红海)
-    * [公有or私有？[网易云](https://www.163yun.com/product-cloudcompute?tag=M_smf_1190000008091499)的选择](#公有or私有？[网易云]httpswww163yuncomproduct-cloudcomputetagm_smf_1190000008091499的选择)
+    * [公有or私有？网易云的选择](#公有or私有？网易云的选择)
   * [第四阶段：分，即容器](#第四阶段：分，即容器)
     * [现在来谈谈，应用层面，即PaaS层。](#现在来谈谈，应用层面，即paas层。)
       * [1\. PaaS的定义与作用](#1-paas的定义与作用)
@@ -32,17 +32,21 @@
     * [容器管理平台初体验](#容器管理平台初体验)
 
 
-**作者简介：**刘超，[网易云](https://www.163yun.com/product-cloudcompute?tag=M_smf_1190000008091499)解决方案首席架构师。
+[toc]
+
+作者简介：刘超，网易云解决方案首席架构师。
 
 10年云计算领域研发及架构经验，Open DC/OS贡献者。
 
 长期专注于kubernetes, OpenStack、Hadoop、Docker、Lucene、Mesos等开源软件的企业级应用及产品化。曾出版《Lucene应用开发揭秘》。
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本系列文章将整理到我的个人博客
+
 > www.how2playlife.com
 
 更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注
@@ -64,7 +68,7 @@
 # 云计算发展脉络
 
 云计算整个发展过程，用一句话来形容，就是“分久必合，合久必分”。
-![图片描述](https://segmentfault.com/img/bVH66e?w=632&h=232 "图片描述")
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408115426.png)
 
 ## 第一阶段：合，即物理设备
 
@@ -156,11 +160,11 @@ OpenStack现在发展的和AWS有点像了，所以从OpenStack的模块组成
 
 有了OpenStack，所有的私有云厂商都疯了，原来VMware在私有云市场赚的实在太多了，眼巴巴的看着，没有对应的平台可以和他抗衡。现在有了现成的框架，再加上自己的硬件设备，几乎所有的IT厂商巨头，全部都加入到社区里，将OpenStack开发为自己的产品，连同硬件设备一起，杀入私有云市场。
 
-### 公有or私有？[网易云](https://www.163yun.com/product-cloudcompute?tag=M_smf_1190000008091499)的选择
+### 公有or私有？网易云的选择
 
-[网易云](https://www.163yun.com/product-cloudcompute?tag=M_smf_1190000008091499)当然也没有错过这次风口，上线了自己的OpenStack集群，[网易云](https://www.163yun.com/product-cloudcompute?tag=M_smf_1190000008091499)基于OpenStack自主研发了IaaS服务，在计算虚拟化方面，通过裁剪KVM镜像，优化虚拟机启动流程等改进，实现了虚拟机的秒级别启动。在网络虚拟化方面，通过SDN和Openvswitch技术，实现了虚拟机之间的高性能互访。在存储虚拟化方面，通过优化Ceph存储，实现高性能云盘。
+网易云当然也没有错过这次风口，上线了自己的OpenStack集群，网易云基于OpenStack自主研发了IaaS服务，在计算虚拟化方面，通过裁剪KVM镜像，优化虚拟机启动流程等改进，实现了虚拟机的秒级别启动。在网络虚拟化方面，通过SDN和Openvswitch技术，实现了虚拟机之间的高性能互访。在存储虚拟化方面，通过优化Ceph存储，实现高性能云盘。
 
-但是[网易云](https://www.163yun.com/product-cloudcompute?tag=M_smf_1190000008091499)并没有杀进私有云市场，而是使用OpenStack支撑起了自己的应用，这是互联网的思维。而仅仅是资源层面弹性是不够的，还需要开发出对应用部署友好的组件。例如数据库，负载均衡，缓存等，这些都是应用部署必不可少的，也是[网易云](https://www.163yun.com/product-cloudcompute?tag=M_smf_1190000008091499)在大规模应用实践中，千锤百炼过的。这些组件称为PaaS。
+但是网易云并没有杀进私有云市场，而是使用OpenStack支撑起了自己的应用，这是互联网的思维。而仅仅是资源层面弹性是不够的，还需要开发出对应用部署友好的组件。例如数据库，负载均衡，缓存等，这些都是应用部署必不可少的，也是网易云在大规模应用实践中，千锤百炼过的。这些组件称为PaaS。
 
 ## 第四阶段：分，即容器
 
@@ -168,7 +172,7 @@ OpenStack现在发展的和AWS有点像了，所以从OpenStack的模块组成
 
 前面一直在讲IaaS层的故事，也即基础设施即服务，基本上在谈计算、网络、存储的事情。现在应该说说应用层，即PaaS层的事情了。
 
-#### 1\. PaaS的定义与作用
+#### 1. PaaS的定义与作用
 
 IaaS的定义比较清楚，PaaS的定义就没那么清楚了。有人把数据库、负载均衡、缓存作为PaaS服务；有人把大数据Hadoop,、Spark平台作为PaaS服务；还有人将应用的安装与管理，例如Puppet、 Chef,、Ansible作为PaaS服务。
 
@@ -176,17 +180,17 @@ IaaS的定义比较清楚，PaaS的定义就没那么清楚了。有人把数据
 
 要么就是自动部署，要么就是不用部署，总的来说就是应用层你也少操心，就是PaaS的作用。当然最好还是都不用去部署，一键可得，所以公有云平台将通用的服务都做成了PaaS平台。另一些你自己开发的应用，除了你自己其他人不会知道，所以你可以用工具变成自动部署。
 
-#### 2\. PaaS的优点
+#### 2. PaaS的优点
 
 PaaS最大的优点，就是可以实现应用层的弹性伸缩。比如在双十一期间，10个节点要变成100个节点，如果使用物理设备，再买90台机器肯定来不及，仅仅有IaaS实现资源的弹性是不够的，再创建90台虚拟机，也是空的，还是需要运维人员一台一台地部署。所以有了PaaS就好了，一台虚拟机启动后，马上运行自动部署脚本，进行应用的安装，90台机器自动安装好了应用，才是真正的弹性伸缩。
 
-#### 3\. PaaS部署的问题
+#### 3. PaaS部署的问题
 
 当然这种部署方式也有一个问题，就是无论Puppet、 Chef、Ansible把安装脚本抽象的再好，说到底也是基于脚本的，然而应用所在的环境千差万别。文件路径的差别，文件权限的差别，依赖包的差别，应用环境的差别，Tomcat、 PHP、 Apache等软件版本的差别，JDK、Python等版本的差别，是否安装了一些系统软件，是否占用了哪些端口，都可能造成脚本执行的不成功。所以看起来是一旦脚本写好，就能够快速复制了，但是环境稍有改变，就需要把脚本进行新一轮的修改、测试、联调。例如在数据中心写好的脚本移到AWS上就不一定直接能用，在AWS上联调好了，迁移到Google Cloud上也可能会再出问题。
 
 ### 容器的诞生
 
-#### 1\. 容器的定义
+#### 1. 容器的定义
 
 于是容器便应运而生。容器是Container，Container另一个意思是集装箱，其实容器的思想就是要变成软件交付的集装箱。集装箱的特点，一是打包，二是标准。设想没有集装箱的时代，如果将货物从A运到B，中间要经过三个码头，换三次船的话，货物每次都要卸下船来，摆的七零八落，然后换船的时候，需要重新摆放整齐，在没有集装箱的时候，船员们都需要在岸上待几天再走。而在有了集装箱后，所有的货物都打包在一起了，并且集装箱的尺寸全部一致，所以每次换船的时候，整体一个箱子搬过去就可以了，小时级别就能完成，船员再也不用长时间上岸等待了。
 
@@ -220,7 +224,7 @@ PaaS最大的优点，就是可以实现应用层的弹性伸缩。比如在双
 
 
 
-![](https://upload-images.jianshu.io/upload_images/3947555-e2fa7af659850ef5.PNG?imageMogr2/auto-orient/strip%7CimageView2/2/w/508)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/3947555-e2fa7af659850ef5.PNG)
 
 
 
@@ -232,7 +236,7 @@ PaaS最大的优点，就是可以实现应用层的弹性伸缩。比如在双
 
 
 
-![](https://upload-images.jianshu.io/upload_images/3947555-74ef589e8d826755.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/530)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/3947555-74ef589e8d826755.png)
 
 
 
@@ -246,7 +250,7 @@ PaaS最大的优点，就是可以实现应用层的弹性伸缩。比如在双
 
 
 
-![](https://upload-images.jianshu.io/upload_images/3947555-f77373dcf00bafe5.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/528)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/3947555-f77373dcf00bafe5.png)
 
 
 
@@ -342,7 +346,7 @@ COPY/ADD将一些文件添加到容器里面；
 
 
 
-![](https://upload-images.jianshu.io/upload_images/3947555-7d07dda243e0a863.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/3947555-7d07dda243e0a863.png)
 
 
 
diff --git "a/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\345\205\210\346\220\236\346\207\202Docker\346\240\270\345\277\203\346\246\202\345\277\265\345\220\247.md" "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\345\205\210\346\220\236\346\207\202Docker\346\240\270\345\277\203\346\246\202\345\277\265\345\220\247.md"
new file mode 100644
index 0000000..0a5b0a9
--- /dev/null
+++ "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\345\205\210\346\220\236\346\207\202Docker\346\240\270\345\277\203\346\246\202\345\277\265\345\220\247.md"
@@ -0,0 +1,739 @@
+# 目录
+
+  * [1、了解Docker的前生LXC](#1、了解docker的前生lxc)
+  * [2、LXC与docker什么关系？](#2、lxc与docker什么关系？)
+  * [3、什么是docker](#3、什么是docker)
+  * [4、docker官方文档](#4、docker官方文档)
+  * [5、为什么docker越来越受欢迎](#5、为什么docker越来越受欢迎)
+  * [6、docker版本](#6、docker版本)
+  * [7、docker和openstack的几项对比](#7、docker和openstack的几项对比)
+  * [8、容器在内核中支持2种重要技术](#8、容器在内核中支持2种重要技术)
+  * [9、了解docker三个重要概念](#9、了解docker三个重要概念)
+  * [10、docker的主要用途](#10、docker的主要用途)
+  * [11、docker改变了什么](#11、docker改变了什么)
+  * [1、总体架构](#1、总体架构)
+  * [2、docker架构2](#2、docker架构2)
+  * [3、docker架构3](#3、docker架构3)
+  * [1、docker client](#1、docker-client)
+  * [2、docker daemon](#2、docker-daemon)
+  * [3、docker server](#3、docker-server)
+  * [4、engine](#4、engine)
+  * [5、job](#5、job)
+  * [6、docker registry](#6、docker-registry)
+  * [7、Graph](#7、graph)
+  * [8、driver](#8、driver)
+  * [9、libcontainer](#9、libcontainer)
+  * [10、docker container](#10、docker-container)
+
+
+[toc]
+**一、简介**
+
+
+## 1、了解Docker的前生LXC
+
+
+
+
+
+LXC为Linux Container的简写。可以提供轻量级的虚拟化，以便隔离进程和资源，而且不需要提供指令解释机制以及全虚拟化的其他复杂性。相当于C++中的NameSpace。容器有效地将由单个操作系统管理的资源划分到孤立的组中，以更好地在孤立的组之间平衡有冲突的资源使用需求。
+
+
+
+
+
+与传统虚拟化技术相比，它的优势在于：  （1）与宿主机使用同一个内核，性能损耗小；  （2）不需要指令级模拟；  （3）不需要即时(Just-in-time)编译；  （4）容器可以在CPU核心的本地运行指令，不需要任何专门的解释机制；（5）避免了准虚拟化和系统调用替换中的复杂性；  （6）轻量级隔离，在隔离的同时还提供共享机制，以实现容器与宿主机的资源共享。
+
+
+
+
+
+总结：Linux Container是一种轻量级的虚拟化的手段。  Linux Container提供了在单一可控主机节点上支持多个相互隔离的server container同时执行的机制。Linux Container有点像chroot，提供了一个拥有自己进程和网络空间的虚拟环境，但又有别于虚拟机，因为lxc是一种操作系统层次上的资源的虚拟化。
+
+
+
+
+
+## 2、LXC与docker什么关系？
+
+
+
+
+
+docker并不是LXC替代品，docker底层使用了LXC来实现，LXC将linux进程沙盒化，使得进程之间相互隔离，并且能对各进程资源合理分配。  在LXC的基础之上，docker提供了一系列更强大的功能。
+
+
+
+
+
+## 3、什么是docker
+
+
+
+
+
+docker是一个开源的应用容器引擎，基于go语言开发并遵循了apache2.0协议开源。  docker可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的linux服务器，也可以实现虚拟化。  容器是完全使用沙箱机制，相互之间不会有任何接口（类iphone的app），并且容器开销极其低。
+
+
+
+
+
+## 4、docker官方文档
+
+
+
+
+
+## 5、为什么docker越来越受欢迎
+
+
+
+
+
+官方话语：
+
+
+
+
+
+*   容器化越来越受欢迎，因为容器是：
+
+*   灵活：即使是最复杂的应用也可以集装箱化。
+
+*   轻量级：容器利用并共享主机内核。
+
+*   可互换：您可以即时部署更新和升级。
+
+*   便携式：您可以在本地构建，部署到云，并在任何地方运行。
+
+*   可扩展：您可以增加并自动分发容器副本。
+
+*   可堆叠：您可以垂直和即时堆叠服务。
+
+*   镜像和容器（contalners）
+
+
+
+
+
+通过镜像启动一个容器，一个镜像是一个可执行的包，其中包括运行应用程序所需要的所有内容包含代码，运行时间，库、环境变量、和配置文件。  容器是镜像的运行实例，当被运行时有镜像状态和用户进程，可以使用docker ps 查看。
+
+
+
+
+
+*   容器和虚拟机
+
+
+
+
+
+容器是在linux上本机运行，并与其他容器共享主机的内核，它运行的一个独立的进程，不占用其他任何可执行文件的内存，非常轻量。  虚拟机运行的是一个完成的操作系统，通过虚拟机管理程序对主机资源进行虚拟访问，相比之下需要的资源更多。
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408120435.png)
+
+
+
+
+
+## 6、docker版本
+
+
+
+
+
+Docker Community Edition（CE）社区版  Enterprise Edition(EE) 商业版
+
+
+
+
+
+## 7、docker和openstack的几项对比
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408120450.png)
+
+
+
+
+
+
+
+## 8、容器在内核中支持2种重要技术
+
+
+
+
+
+docker本质就是宿主机的一个进程，docker是通过namespace实现资源隔离，通过cgroup实现资源限制，通过写时复制技术（copy-on-write）实现了高效的文件操作（类似虚拟机的磁盘比如分配500g并不是实际占用物理磁盘500g）
+
+
+
+
+
+1）namespaces 名称空间
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408120519.png)
+
+
+
+
+
+
+
+
+
+
+
+2）control Group 控制组cgroup的特点是：
+
+
+
+
+
+*   cgroup的api以一个伪文件系统的实现方式，用户的程序可以通过文件系统实现cgroup的组件管理
+
+*   cgroup的组件管理操作单元可以细粒度到线程级别，另外用户可以创建和销毁cgroup，从而实现资源的分配和再利用
+
+*   所有资源管理的功能都以子系统的方式实现，接口统一子任务创建之初与其父任务处于同一个cgroup的控制组
+
+
+
+
+
+四大功能：
+
+
+
+
+
+*   资源限制：可以对任务使用的资源总额进行限制
+
+*   优先级分配：通过分配的cpu时间片数量以及磁盘IO带宽大小，实际上相当于控制了任务运行优先级
+
+*   资源统计：可以统计系统的资源使用量，如cpu时长，内存用量等
+
+*   任务控制：cgroup可以对任务执行挂起、恢复等操作
+
+
+
+
+
+## 9、了解docker三个重要概念
+
+
+
+
+
+1）image镜像  docker镜像就是一个只读模板，比如，一个镜像可以包含一个完整的centos，里面仅安装apache或用户的其他应用，镜像可以用来创建docker容器，另外docker提供了一个很简单的机制来创建镜像或者更新现有的镜像，用户甚至可以直接从其他人那里下一个已经做好的镜像来直接使用
+
+
+
+
+
+2）container容器  docker利用容器来运行应用，容器是从镜像创建的运行实例，它可以被启动，开始、停止、删除、每个容器都是互相隔离的，保证安全的平台，可以把容器看做是要给简易版的linux环境（包括root用户权限、镜像空间、用户空间和网络空间等）和运行在其中的应用程序
+
+
+
+
+
+3）repostory仓库  仓库是集中存储镜像文件的沧桑，registry是仓库主从服务器，实际上参考注册服务器上存放着多个仓库，每个仓库中又包含了多个镜像，每个镜像有不同的标签（tag）  仓库分为两种，公有参考，和私有仓库，最大的公开仓库是docker Hub，存放了数量庞大的镜像供用户下载，国内的docker pool，这里仓库的概念与Git类似，registry可以理解为github这样的托管服务。
+
+
+
+
+
+## 10、docker的主要用途
+
+
+
+
+
+官方就是Bulid 、ship、run any app/any where，编译、装载、运行、任何app/在任意地方都能运行。就是实现了应用的封装、部署、运行的生命周期管理只要在glibc的环境下，都可以运行。运维生成环境中：docker化。
+
+
+
+
+
+*   发布服务不用担心服务器的运行环境，所有的服务器都是自动分配docker，自动部署，自动安装，自动运行
+
+*   再不用担心其他服务引擎的磁盘问题，cpu问题，系统问题了
+
+*   资源利用更出色
+
+*   自动迁移，可以制作镜像，迁移使用自定义的镜像即可迁移，不会出现什么问题
+
+*   管理更加方便了
+
+
+
+
+
+## 11、docker改变了什么
+
+
+
+
+
+*   面向产品：产品交付
+
+*   面向开发：简化环境配置
+
+*   面向测试：多版本测试
+
+*   面向运维：环境一致性
+
+*   面向架构：自动化扩容（微服务）
+
+
+
+
+
+**二、docker架构**
+
+
+
+
+
+## 1、总体架构
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408120534.png)
+
+
+
+
+
+*   distribution 负责与docker registry交互，上传洗澡镜像以及v2 registry 有关的源数据
+
+*   registry负责docker registry有关的身份认证、镜像查找、镜像验证以及管理registry mirror等交互操作
+
+*   image 负责与镜像源数据有关的存储、查找，镜像层的索引、查找以及镜像tar包有关的导入、导出操作
+
+*   reference负责存储本地所有镜像的repository和tag名，并维护与镜像id之间的映射关系
+
+*   layer模块负责与镜像层和容器层源数据有关的增删改查，并负责将镜像层的增删改查映射到实际存储镜像层文件的graphdriver模块
+
+*   graghdriver是所有与容器镜像相关操作的执行者
+
+
+
+
+
+## 2、docker架构2
+
+
+
+
+
+如果觉得上面架构图比较乱可以看这个架构：
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408120545.png)
+
+
+
+
+
+从上图不难看出，用户是使用Docker Client与Docker Daemon建立通信，并发送请求给后者。
+
+
+
+
+
+而Docker Daemon作为Docker架构中的主体部分，首先提供Server的功能使其可以接受Docker Client的请求；而后Engine执行Docker内部的一系列工作，每一项工作都是以一个Job的形式的存在。
+
+
+
+
+
+Job的运行过程中，当需要容器镜像时，则从Docker Registry中下载镜像，并通过镜像管理驱动graphdriver将下载镜像以Graph的形式存储；当需要为Docker创建网络环境时，通过网络管理驱动networkdriver创建并配置Docker容器网络环境；当需要限制Docker容器运行资源或执行用户指令等操作时，则通过execdriver来完成。
+
+
+
+
+
+而libcontainer是一项独立的容器管理包，networkdriver以及execdriver都是通过libcontainer来实现具体对容器进行的操作。当执行完运行容器的命令后，一个实际的Docker容器就处于运行状态，该容器拥有独立的文件系统，独立并且安全的运行环境等。
+
+
+
+
+
+## 3、docker架构3
+
+
+
+
+
+再来看看另外一个架构，这个个架构就简单清晰指明了server/client交互，容器和镜像、数据之间的一些联系。
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408120558.png)
+
+
+
+
+
+这个架构图更加清晰了架构
+
+
+
+
+
+docker daemon就是docker的守护进程即server端，可以是远程的，也可以是本地的，这个不是C/S架构吗，客户端Docker client 是通过rest api进行通信。
+
+
+
+
+
+docker cli 用来管理容器和镜像，客户端提供一个只读镜像，然后通过镜像可以创建多个容器，这些容器可以只是一个RFS（Root file system根文件系统），也可以ishi一个包含了用户应用的RFS，容器在docker client中只是要给进程，两个进程之间互不可见。
+
+
+
+
+
+用户不能与server直接交互，但可以通过与容器这个桥梁来交互，由于是操作系统级别的虚拟技术，中间的损耗几乎可以不计。
+
+
+
+
+
+**三、docker架构2各个模块的功能（待完善）**
+
+
+
+
+
+主要的模块有：Docker Client、Docker Daemon、Docker Registry、Graph、Driver、libcontainer以及Docker container。
+
+
+
+
+
+## 1、docker client
+
+
+
+
+
+docker client 是docker架构中用户用来和docker daemon建立通信的客户端，用户使用的可执行文件为docker，通过docker命令行工具可以发起众多管理container的请求。
+
+
+
+
+
+docker client可以通过一下三宗方式和docker daemon建立通信：docker client可以通过设置命令行flag参数的形式设置安全传输层协议(TLS)的有关参数，保证传输的安全性。
+
+
+
+
+
+docker client发送容器管理请求后，由docker daemon接受并处理请求，当docker client 接收到返回的请求相应并简单处理后，docker client 一次完整的生命周期就结束了，当需要继续发送容器管理请求时，用户必须再次通过docker可以执行文件创建docker client。
+
+
+
+
+
+## 2、docker daemon
+
+
+
+
+
+docker daemon 是docker架构中一个常驻在后台的系统进程，功能是：接收处理docker client发送的请求。该守护进程在后台启动一个server，server负载接受docker client发送的请求；接受请求后，server通过路由与分发调度，找到相应的handler来执行请求。
+
+
+
+
+
+docker daemon启动所使用的可执行文件也为docker，与docker client启动所使用的可执行文件docker相同，在docker命令执行时，通过传入的参数来判别docker daemon与docker client。
+
+
+
+
+
+docker daemon的架构可以分为：docker server、engine、job。daemon
+
+
+
+
+
+## 3、docker server
+
+
+
+
+
+docker server在docker架构中时专门服务于docker client的server，该server的功能是：接受并调度分发docker client发送的请求，架构图如下：
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408120607.png)
+
+
+
+
+
+在Docker的启动过程中，通过包gorilla/mux（golang的类库解析），创建了一个mux.Router，提供请求的路由功能。在Golang中，gorilla/mux是一个强大的URL路由器以及调度分发器。该mux.Router中添加了众多的路由项，每一个路由项由HTTP请求方法（PUT、POST、GET或DELETE）、URL、Handler三部分组成。
+
+
+
+
+
+若Docker Client通过HTTP的形式访问Docker Daemon，创建完mux.Router之后，Docker将Server的监听地址以及mux.Router作为参数，创建一个httpSrv=http.Server{}，最终执行httpSrv.Serve()为请求服务。
+
+
+
+
+
+在Server的服务过程中，Server在listener上接受Docker Client的访问请求，并创建一个全新的goroutine来服务该请求。在goroutine中，首先读取请求内容，然后做解析工作，接着找到相应的路由项，随后调用相应的Handler来处理该请求，最后Handler处理完请求之后回复该请求。
+
+
+
+
+
+需要注意的是：Docker Server的运行在Docker的启动过程中，是靠一个名为”serveapi”的job的运行来完成的。原则上，Docker Server的运行是众多job中的一个，但是为了强调Docker Server的重要性以及为后续job服务的重要特性，将该”serveapi”的job单独抽离出来分析，理解为Docker Server。
+
+
+
+
+
+## 4、engine
+
+
+
+
+
+Engine是Docker架构中的运行引擎，同时也Docker运行的核心模块。它扮演Docker container存储仓库的角色，并且通过执行job的方式来操纵管理这些容器。
+
+
+
+
+
+在Engine数据结构的设计与实现过程中，有一个handler对象。该handler对象存储的都是关于众多特定job的handler处理访问。举例说明，Engine的handler对象中有一项为：{“create”: daemon.ContainerCreate,}，则说明当名为”create”的job在运行时，执行的是daemon.ContainerCreate的handler。
+
+
+
+
+
+## 5、job
+
+
+
+
+
+一个Job可以认为是Docker架构中Engine内部最基本的工作执行单元。Docker可以做的每一项工作，都可以抽象为一个job。例如：在容器内部运行一个进程，这是一个job；创建一个新的容器，这是一个job，从Internet上下载一个文档，这是一个job；包括之前在Docker Server部分说过的，创建Server服务于HTTP的API，这也是一个job，等等。
+
+
+
+
+
+Job的设计者，把Job设计得与Unix进程相仿。比如说：Job有一个名称，有参数，有环境变量，有标准的输入输出，有错误处理，有返回状态等。
+
+
+
+
+
+## 6、docker registry
+
+
+
+
+
+Docker Registry是一个存储容器镜像的仓库。而容器镜像是在容器被创建时，被加载用来初始化容器的文件架构与目录。
+
+
+
+
+
+在Docker的运行过程中，Docker Daemon会与Docker Registry通信，并实现搜索镜像、下载镜像、上传镜像三个功能，这三个功能对应的job名称分别为”search”，”pull” 与 “push”。
+
+
+
+
+
+其中，在Docker架构中，Docker可以使用公有的Docker Registry，即大家熟知的Docker Hub，如此一来，Docker获取容器镜像文件时，必须通过互联网访问Docker Hub；同时Docker也允许用户构建本地私有的Docker Registry，这样可以保证容器镜像的获取在内网完成。
+
+
+
+
+
+## 7、Graph
+
+
+
+
+
+Graph在Docker架构中扮演已下载容器镜像的保管者，以及已下载容器镜像之间关系的记录者。一方面，Graph存储着本地具有版本信息的文件系统镜像，另一方面也通过GraphDB记录着所有文件系统镜像彼此之间的关系。Graph的架构如下：
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408120623.png)
+
+
+
+
+
+其中，GraphDB是一个构建在SQLite之上的小型图数据库，实现了节点的命名以及节点之间关联关系的记录。它仅仅实现了大多数图数据库所拥有的一个小的子集，但是提供了简单的接口表示节点之间的关系。
+
+
+
+
+
+同时在Graph的本地目录中，关于每一个的容器镜像，具体存储的信息有：该容器镜像的元数据，容器镜像的大小信息，以及该容器镜像所代表的具体rootfs。
+
+
+
+
+
+## 8、driver
+
+
+
+
+
+Driver是Docker架构中的驱动模块。通过Driver驱动，Docker可以实现对Docker容器执行环境的定制。由于Docker运行的生命周期中，并非用户所有的操作都是针对Docker容器的管理，另外还有关于Docker运行信息的获取，Graph的存储与记录等。因此，为了将Docker容器的管理从Docker Daemon内部业务逻辑中区分开来，设计了Driver层驱动来接管所有这部分请求。
+
+
+
+
+
+在Docker Driver的实现中，可以分为以下三类驱动：graphdriver、networkdriver和execdriver。
+
+
+
+
+
+graphdriver主要用于完成容器镜像的管理，包括存储与获取。即当用户需要下载指定的容器镜像时，graphdriver将容器镜像存储在本地的指定目录；同时当用户需要使用指定的容器镜像来创建容器的rootfs时，graphdriver从本地镜像存储目录中获取指定的容器镜像。
+
+
+
+
+
+在graphdriver的初始化过程之前，有4种文件系统或类文件系统在其内部注册，它们分别是aufs、btrfs、vfs和devmapper。而Docker在初始化之时，通过获取系统环境变量”DOCKER_DRIVER”来提取所使用driver的指定类型。而之后所有的graph操作，都使用该driver来执行。
+
+
+
+
+
+graphdriver的架构如下：
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408120634.png)
+
+
+
+
+
+networkdriver的用途是完成Docker容器网络环境的配置，其中包括Docker启动时为Docker环境创建网桥；Docker容器创建时为其创建专属虚拟网卡设备；以及为Docker容器分配IP、端口并与宿主机做端口映射，设置容器防火墙策略等。networkdriver的架构如下：
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408120642.png)
+
+
+
+
+
+execdriver作为Docker容器的执行驱动，负责创建容器运行命名空间，负责容器资源使用的统计与限制，负责容器内部进程的真正运行等。在execdriver的实现过程中，原先可以使用LXC驱动调用LXC的接口，来操纵容器的配置以及生命周期，而现在execdriver默认使用native驱动，不依赖于LXC。具体体现在Daemon启动过程中加载的ExecDriverflag参数，该参数在配置文件已经被设为”native”。这可以认为是Docker在1.2版本上一个很大的改变，或者说Docker实现跨平台的一个先兆。execdriver架构如下：
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408120652.png)
+
+
+
+
+
+## 9、libcontainer
+
+
+
+
+
+libcontainer是Docker架构中一个使用Go语言设计实现的库，设计初衷是希望该库可以不依靠任何依赖，直接访问内核中与容器相关的API。
+
+
+
+
+
+正是由于libcontainer的存在，Docker可以直接调用libcontainer，而最终操纵容器的namespace、cgroups、apparmor、网络设备以及防火墙规则等。这一系列操作的完成都不需要依赖LXC或者其他包。libcontainer架构如下：
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408120659.png)
+
+
+
+
+
+另外，libcontainer提供了一整套标准的接口来满足上层对容器管理的需求。或者说，libcontainer屏蔽了Docker上层对容器的直接管理。又由于libcontainer使用Go这种跨平台的语言开发实现，且本身又可以被上层多种不同的编程语言访问，因此很难说，未来的Docker就一定会紧紧地和Linux捆绑在一起。而于此同时，Microsoft在其著名云计算平台Azure中，也添加了对Docker的支持，可见Docker的开放程度与业界的火热度。
+
+
+
+
+
+暂不谈Docker，由于libcontainer的功能以及其本身与系统的松耦合特性，很有可能会在其他以容器为原型的平台出现，同时也很有可能催生出云计算领域全新的项目。
+
+
+
+
+
+## 10、docker container
+
+
+
+
+
+Docker container（Docker容器）是Docker架构中服务交付的最终体现形式。Docker按照用户的需求与指令，订制相应的Docker容器：
+
+
+
+
+
+*   用户通过指定容器镜像，使得Docker容器可以自定义rootfs等文件系统；
+
+*   用户通过指定计算资源的配额，使得Docker容器使用指定的计算资源；
+
+*   用户通过配置网络及其安全策略，使得Docker容器拥有独立且安全的网络环境；
+
+*   用户通过指定运行的命令，使得Docker容器执行指定的工作。
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408120710.png)
diff --git "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\21011\357\274\232\345\215\201\345\210\206\351\222\237\347\220\206\350\247\243Kubernetes\346\240\270\345\277\203\346\246\202\345\277\265.md" "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\345\215\201\345\210\206\351\222\237\347\220\206\350\247\243Kubernetes\346\240\270\345\277\203\346\246\202\345\277\265.md"
similarity index 86%
rename from "docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\21011\357\274\232\345\215\201\345\210\206\351\222\237\347\220\206\350\247\243Kubernetes\346\240\270\345\277\203\346\246\202\345\277\265.md"
rename to "docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\345\215\201\345\210\206\351\222\237\347\220\206\350\247\243Kubernetes\346\240\270\345\277\203\346\246\202\345\277\265.md"
index 68f03f1..ef5a9ff 100644
--- "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\21011\357\274\232\345\215\201\345\210\206\351\222\237\347\220\206\350\247\243Kubernetes\346\240\270\345\277\203\346\246\202\345\277\265.md"
+++ "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\345\215\201\345\210\206\351\222\237\347\220\206\350\247\243Kubernetes\346\240\270\345\277\203\346\246\202\345\277\265.md"
@@ -1,17 +1,18 @@
-# Table of Contents
+# 目录
 
 * [十分钟带你理解Kubernetes核心概念](#十分钟带你理解kubernetes核心概念)
-    * [什么是Kubernetes？](#什么是kubernetes？)
-    * [集群](#集群)
-    * [Pod](#pod)
-    * [Lable](#lable)
-    * [Replication Controller](#replication-controller)
-    * [Service](#service)
-    * [Node](#node)
-    * [Kubernetes Master](#kubernetes-master)
-    * [下一步](#下一步)
-
-
+  * [什么是Kubernetes？](#什么是kubernetes？)
+  * [集群](#集群)
+  * [Pod](#pod)
+  * [Label](#label)
+  * [Replication Controller](#replication-controller)
+  * [Service](#service)
+  * [Node](#node)
+  * [Kubernetes Master](#kubernetes-master)
+  * [下一步](#下一步)
+
+
+[toc]
 本文转自互联网，侵删
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -22,13 +23,13 @@
 本系列文章将整理到我的个人博客
 > www.how2playlife.com
 
-更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注
+更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注  
 该系列博文会介绍常见的后端技术，这对后端工程师来说是一种综合能力，我们会逐步了解搜索技术，云计算相关技术、大数据研发等常见的技术喜提，以便让你更完整地了解后端技术栈的全貌，为后续参与分布式应用的开发和学习做好准备。
 
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系我，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 
 # 十分钟带你理解Kubernetes核心概念
 
@@ -38,9 +39,9 @@
 
 这就开始吧。
 
-### 什么是Kubernetes？
+## 什么是Kubernetes？
 
-Kubernetes（k8s）是自动化容器操作的开源平台，这些操作包括部署，调度和节点集群间扩展。如果你曾经用过Docker容器技术部署容器，那么可以将Docker看成Kubernetes内部使用的低级别组件。Kubernetes不仅仅支持Docker，还支持Rocket，这是另一种容器技术。
+Kubernetes（k8s）是自动化容器操作的开源平台，这些操作包括部署，调度和节点集群间扩展。如果你曾经用过Docker容器技术部署容器，那么可以将Docker看成Kubernetes内部使用的低级别组件。Kubernetes不仅仅支持Docker，还支持Rocket，这是另一种容器技术。  
 使用Kubernetes可以：
 
 *   自动化容器的部署和复制
@@ -51,14 +52,14 @@ Kubernetes（k8s）是自动化容器操作的开源平台，这些操作包括
 
 实际上，使用Kubernetes只需一个[部署文件](https://github.com/kubernetes/kubernetes/blob/master/examples/guestbook/all-in-one/guestbook-all-in-one.yaml)，使用一条命令就可以部署多层容器（前端，后台等）的完整集群：
 
-```
-$ kubectl create -f single-config-file.yaml
-
-```
+```  
+$ kubectl create -f single-config-file.yaml  
+  
+```  
 
 kubectl是和Kubernetes API交互的命令行程序。现在介绍一些核心概念。
 
-### 集群
+## 集群
 
 集群是一组节点，这些节点可以是物理服务器或者虚拟机，之上安装了Kubernetes平台。下图展示这样的集群。注意该图为了强调核心概念有所简化。[这里](http://kubernetes.io/v1.1/docs/design/architecture.html)可以看到一个典型的Kubernetes架构图。
 
@@ -68,11 +69,11 @@ kubectl是和Kubernetes API交互的命令行程序。现在介绍一些核心
 
 
 
-![](https://upload-images.jianshu.io/upload_images/1233356-838c13e9241040b4.png?imageMogr2/auto-orient/strip|imageView2/2/w/803/format/webp)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1233356-838c13e9241040b4.png)
 
 
 
- [1.png](http://dockone.io/uploads/article/20151230/d56441427680948fb56a00af57bda690.png) 
+[1.png](http://dockone.io/uploads/article/20151230/d56441427680948fb56a00af57bda690.png)
 
 上图可以看到如下组件，使用特别的图标表示Service和Label：
 
@@ -84,7 +85,7 @@ kubectl是和Kubernetes API交互的命令行程序。现在介绍一些核心
 *   Node（节点）
 *   Kubernetes Master（Kubernetes主节点）
 
-### Pod
+## Pod
 
 [Pod](http://kubernetes.io/v1.1/docs/user-guide/pods.html)（上图绿色方框）安排在节点上，包含一组容器和卷。同一个Pod里的容器共享同一个网络命名空间，可以使用localhost互相通信。Pod是短暂的，不是持续性实体。你可能会有这些问题：
 
@@ -92,11 +93,11 @@ kubectl是和Kubernetes API交互的命令行程序。现在介绍一些核心
 *   是否手动创建Pod，如果想要创建同一个容器的多份拷贝，需要一个个分别创建出来么？可以手动创建单个Pod，但是也可以使用Replication Controller使用Pod模板创建出多份拷贝，下文会详细介绍。
 *   如果Pod是短暂的，那么重启时IP地址可能会改变，那么怎么才能从前端容器正确可靠地指向后台容器呢？这时可以使用Service，下文会详细介绍。
 
-### Lable
+## Label
 
 正如图所示，一些Pod有Label。一个Label是attach到Pod的一对键/值对，用来传递用户定义的属性。比如，你可能创建了一个"tier"和“app”标签，通过Label（**tier=frontend, app=myapp**）来标记前端Pod容器，使用Label（**tier=backend, app=myapp**）标记后台Pod。然后可以使用[Selectors](http://kubernetes.io/v1.1/docs/user-guide/labels.html#label-selectors)选择带有特定Label的Pod，并且将Service或者Replication Controller应用到上面。
 
-### Replication Controller
+## Replication Controller
 
 _是否手动创建Pod，如果想要创建同一个容器的多份拷贝，需要一个个分别创建出来么，能否将Pods划到逻辑组里？_
 
@@ -108,11 +109,10 @@ Replication Controller确保任意时间都有指定数量的Pod“副本”在
 
 
 
-![](https://upload-images.jianshu.io/upload_images/1233356-5f5b425bb2705525.gif?imageMogr2/auto-orient/strip|imageView2/2/w/797/format/webp)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1233356-5f5b425bb2705525.gif)
 
 
 
- [2.gif](http://dockone.io/uploads/article/20151230/5e2bad1a25e33e2d155da81da1d3a54b.gif) 
 
 如果之前不响应的Pod恢复了，现在就有4个Pod了，那么Replication Controller会将其中一个终止保持总数为3。如果在运行中将副本总数改为5，Replication Controller会立刻启动2个新Pod，保证总数为5。还可以按照这样的方式缩小Pod，这个特性在执行滚动[升级](https://cloud.google.com/container-engine/docs/replicationcontrollers/#rolling_updates)时很有用。
 
@@ -123,13 +123,13 @@ Replication Controller确保任意时间都有指定数量的Pod“副本”在
 
 现在已经创建了Pod的一些副本，那么在这些副本上如何均衡负载呢？我们需要的是Service。
 
-### Service
+## Service
 
 _如果Pods是短暂的，那么重启时IP地址可能会改变，怎么才能从前端容器正确可靠地指向后台容器呢？_
 
 [Service](http://kubernetes.io/v1.1/docs/user-guide/services.html)是定义一系列Pod以及访问这些Pod的策略的一层**抽象**。Service通过Label找到Pod组。因为Service是抽象的，所以在图表里通常看不到它们的存在，这也就让这一概念更难以理解。
 
-现在，假定有2个后台Pod，并且定义后台Service的名称为‘backend-service’，lable选择器为（**tier=backend, app=myapp**）。_backend-service_ 的Service会完成如下两件重要的事情：
+现在，假定有2个后台Pod，并且定义后台Service的名称为‘backend-service’，lable选择器为（**tier=backend, app=myapp**）。_backend-service_##的Service会完成如下两件重要的事情：
 
 *   会为Service创建一个本地集群的DNS入口，因此前端Pod只需要DNS查找主机名为 ‘backend-service’，就能够解析出前端应用程序可用的IP地址。
 *   现在前端已经得到了后台服务的IP地址，但是它应该访问2个后台Pod的哪一个呢？Service在这2个后台Pod之间提供透明的负载均衡，会将请求分发给其中的任意一个（如下面的动画所示）。通过每个Node上运行的代理（kube-proxy）完成。[这里](http://kubernetes.io/v1.1/docs/user-guide/services.html#virtual-ips-and-service-proxies)有更多技术细节。
@@ -142,15 +142,15 @@ _如果Pods是短暂的，那么重启时IP地址可能会改变，怎么才能
 
 
 
-![](https://upload-images.jianshu.io/upload_images/1233356-d12e172a195f74cd.gif?imageMogr2/auto-orient/strip|imageView2/2/w/797/format/webp)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1233356-d12e172a195f74cd.gif)
 
 
 
- [3.gif](http://dockone.io/uploads/article/20151230/125bbccce0b3bbf42abab0e520d9250b.gif) 
+[3.gif](http://dockone.io/uploads/article/20151230/125bbccce0b3bbf42abab0e520d9250b.gif)
 
 有一个特别类型的Kubernetes Service，称为'[LoadBalancer](http://kubernetes.io/v1.1/docs/user-guide/services.html#type-loadbalancer)'，作为外部负载均衡器使用，在一定数量的Pod之间均衡流量。比如，对于负载均衡Web流量很有用。
 
-### Node
+## Node
 
 节点（上图橘色方框）是物理或者虚拟机器，作为Kubernetes worker，通常称为Minion。每个节点都运行如下Kubernetes关键组件：
 
@@ -158,16 +158,16 @@ _如果Pods是短暂的，那么重启时IP地址可能会改变，怎么才能
 *   Kube-proxy：Service使用其将链接路由到Pod，如上文所述。
 *   Docker或Rocket：Kubernetes使用的容器技术来创建容器。
 
-### Kubernetes Master
+## Kubernetes Master
 
 集群拥有一个Kubernetes Master（紫色方框）。Kubernetes Master提供集群的独特视角，并且拥有一系列组件，比如Kubernetes API Server。API Server提供可以用来和集群交互的REST端点。master节点包括用来创建和复制Pod的Replication Controller。
 
-### 下一步
+## 下一步
 
-现在我们已经了解了Kubernetes核心概念的基本知识，你可以进一步阅读Kubernetes [用户手册](http://kubernetes.io/v1.1/docs/user-guide/README.html)。用户手册提供了快速并且完备的学习文档。
+现在我们已经了解了Kubernetes核心概念的基本知识，你可以进一步阅读Kubernetes##[用户手册](http://kubernetes.io/v1.1/docs/user-guide/README.html)。用户手册提供了快速并且完备的学习文档。  
 如果迫不及待想要试试Kubernetes，可以使用[Google Container Engine](https://cloud.google.com/container-engine/docs/)。Google Container Engine是托管的Kubernetes容器环境。简单注册/登录之后就可以在上面尝试示例了。
 
-**原文链接：[Learn the Kubernetes Key Concepts in 10 Minutes](http://omerio.com/2015/12/18/learn-the-kubernetes-key-concepts-in-10-minutes/)（翻译：崔婧雯）**
-＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
-译者介绍
+**原文链接：[Learn the Kubernetes Key Concepts in 10 Minutes](http://omerio.com/2015/12/18/learn-the-kubernetes-key-concepts-in-10-minutes/)（翻译：崔婧雯）**  
+＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝  
+译者介绍  
 崔婧雯，现就职于IBM，高级软件工程师，负责IBM WebSphere业务流程管理软件的系统测试工作。曾就职于VMware从事桌面虚拟化产品的质量保证工作。对虚拟化，中间件技术，业务流程管理有浓厚的兴趣。
diff --git "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\21012\357\274\232\346\215\213\344\270\200\346\215\213\345\244\247\346\225\260\346\215\256\347\240\224\345\217\221\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md" "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\346\215\213\344\270\200\346\215\213\345\244\247\346\225\260\346\215\256\347\240\224\345\217\221\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md"
similarity index 98%
rename from "docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\21012\357\274\232\346\215\213\344\270\200\346\215\213\345\244\247\346\225\260\346\215\256\347\240\224\345\217\221\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md"
rename to "docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\346\215\213\344\270\200\346\215\213\345\244\247\346\225\260\346\215\256\347\240\224\345\217\221\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md"
index d4b83ff..186eadb 100644
--- "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\21012\357\274\232\346\215\213\344\270\200\346\215\213\345\244\247\346\225\260\346\215\256\347\240\224\345\217\221\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md"
+++ "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\346\215\213\344\270\200\346\215\213\345\244\247\346\225\260\346\215\256\347\240\224\345\217\221\347\232\204\345\237\272\346\234\254\346\246\202\345\277\265.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [0x00 前言](#0x00-前言)
   * [0x01 数据？数据！](#0x01-数据？数据！)
@@ -7,9 +7,11 @@
   * [0xFF 总结](#0xff-总结)
 
 
+[toc]
+
 本文作者：[**木东居士**]
 
-转自个人主页：[http://www.mdjs.info](https://link.jianshu.com/?t=http%3A%2F%2Fwww.mdjs.info)
+转自：[http://www.mdjs.info](https://link.jianshu.com/?t=http%3A%2F%2Fwww.mdjs.info)
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
diff --git "a/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\346\220\234\347\264\242\345\274\225\346\223\216\345\237\272\347\241\200\345\200\222\346\216\222\347\264\242\345\274\225.md" "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\346\220\234\347\264\242\345\274\225\346\223\216\345\237\272\347\241\200\345\200\222\346\216\222\347\264\242\345\274\225.md"
new file mode 100644
index 0000000..d93e497
--- /dev/null
+++ "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\346\220\234\347\264\242\345\274\225\346\223\216\345\237\272\347\241\200\345\200\222\346\216\222\347\264\242\345\274\225.md"
@@ -0,0 +1,165 @@
+# 目录
+
+  * [什么是倒排索引？](#什么是倒排索引？)
+    * [1.单词——文档矩阵](#1单词文档矩阵)
+    * [2.倒排索引基本概念](#2倒排索引基本概念)
+    * [3.倒排索引简单实例](#3倒排索引简单实例)
+    * [4. 单词词典](#4-单词词典)
+
+
+[toc]
+本文转载自 https://www.cnblogs.com/zlslch/p/6440114.html
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+本系列文章将整理到我的个人博客
+> www.how2playlife.com
+
+更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注  
+该系列博文会介绍常见的后端技术，这对后端工程师来说是一种综合能力，我们会逐步了解搜索技术，云计算相关技术、大数据研发等常见的技术喜提，以便让你更完整地了解后端技术栈的全貌，为后续参与分布式应用的开发和学习做好准备。
+
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系我，欢迎你参与本系列博文的创作和修订。
+
+<!-- more -->  
+
+## 什么是倒排索引？
+
+见其名知其意，有倒排索引，对应肯定，有正向索引。  
+  正向索引（forward index），反向索引（inverted index）更熟悉的名字是倒排索引。
+
+在搜索引擎中每个文件都对应一个文件ID，文件内容被表示为一系列关键词的集合（实际上在搜索引擎索引库中，关键词也已经转换为关键词ID）。例如“文档1”经过分词，提取了20个关键词，每个关键词都会记录它在文档中的出现次数和出现位置。
+
+得到正向索引的结构如下：
+
+“文档1”的ID >单词1：出现次数，出现位置列表；单词2：出现次数，出现位置列表；…………。
+
+“文档2”的ID >此文档出现的关键词列表。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/855959-20170706154309815-1724421988.png)
+
+一般是通过key，去找value。
+
+当用户在主页上搜索关键词“华为手机”时，假设只存在正向索引（forward index），那么就需要扫描索引库中的所有文档，找出所有包含关键词“华为手机”的文档，再根据打分模型进行打分，排出名次后呈现给用户。因为互联网上收录在搜索引擎中的文档的数目是个天文数字，这样的索引结构根本无法满足实时返回排名结果的要求。
+
+所以，搜索引擎会将正向索引重新构建为倒排索引，即把文件ID对应到关键词的映射转换为关键词到文件ID的映射，每个关键词都对应着一系列的文件，这些文件中都出现这个关键词。
+
+得到倒排索引的结构如下：
+
+“关键词1”：“文档1”的ID，“文档2”的ID，…………。
+
+“关键词2”：带有此关键词的文档ID列表。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/855959-20170706154505378-610589524.png)
+
+从词的关键字，去找文档。
+### 1.单词——文档矩阵
+
+单词-文档矩阵是表达两者之间所具有的一种包含关系的概念模型，图1展示了其含义。图3-1的每列代表一个文档，每行代表一个单词，打对勾的位置代表包含关系。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/855959-20170224195649726-238255448.png)
+
+图1 单词-文档矩阵
+
+从纵向即文档这个维度来看，每列代表文档包含了哪些单词，比如文档1包含了词汇1和词汇4，而不包含其它单词。从横向即单词这个维度来看，每行代表了哪些文档包含了某个单词。比如对于词汇1来说，文档1和文档4中出现过单词1，而其它文档不包含词汇1。矩阵中其它的行列也可作此种解读。
+
+搜索引擎的索引其实就是实现“单词-文档矩阵”的具体[数据结构](http://lib.csdn.net/base/datastructure "算法与数据结构知识库")。可以有不同的方式来实现上述概念模型，比如“倒排索引”、“签名文件”、“后缀树”等方式。但是各项实验数据表明，“倒排索引”是实现单词到文档映射关系的最佳实现方式，所以本博文主要介绍“倒排索引”的技术细节。
+
+### 2.倒排索引基本概念
+
+文档(Document)：一般搜索引擎的处理对象是互联网网页，而文档这个概念要更宽泛些，代表以文本形式存在的存储对象，相比网页来说，涵盖更多种形式，比如Word，PDF，html，XML等不同格式的文件都可以称之为文档。再比如一封邮件，一条短信，一条微博也可以称之为文档。在本书后续内容，很多情况下会使用文档来表征文本信息。
+
+文档集合(Document Collection)：由若干文档构成的集合称之为文档集合。比如海量的互联网网页或者说大量的电子邮件都是文档集合的具体例子。
+
+文档编号(Document ID)：在搜索引擎内部，会将文档集合内每个文档赋予一个唯一的内部编号，以此编号来作为这个文档的唯一标识，这样方便内部处理，每个文档的内部编号即称之为“文档编号”，后文有时会用DocID来便捷地代表文档编号。
+
+单词编号(Word ID)：与文档编号类似，搜索引擎内部以唯一的编号来表征某个单词，单词编号可以作为某个单词的唯一表征。
+
+倒排索引(Inverted Index)：倒排索引是实现“单词-文档矩阵”的一种具体存储形式，通过倒排索引，可以根据单词快速获取包含这个单词的文档列表。倒排索引主要由两个部分组成：“单词词典”和“倒排文件”。
+
+单词词典(Lexicon)：搜索引擎的通常索引单位是单词，单词词典是由文档集合中出现过的所有单词构成的字符串集合，单词词典内每条索引项记载单词本身的一些信息以及指向“倒排列表”的指针。
+
+倒排列表(PostingList)：倒排列表记载了出现过某个单词的所有文档的文档列表及单词在该文档中出现的位置信息，每条记录称为一个倒排项(Posting)。根据倒排列表，即可获知哪些文档包含某个单词。
+
+倒排文件(Inverted File)：所有单词的倒排列表往往顺序地存储在磁盘的某个文件里，这个文件即被称之为倒排文件，倒排文件是存储倒排索引的物理文件。
+
+关于这些概念之间的关系，通过图2可以比较清晰的看出来。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/855959-20170224200237991-592489046.png)
+
+### 3.倒排索引简单实例
+
+倒排索引从逻辑结构和基本思路上来讲非常简单。下面我们通过具体实例来进行说明，使得读者能够对倒排索引有一个宏观而直接的感受。
+
+假设文档集合包含五个文档，每个文档内容如图3所示，在图中最左端一栏是每个文档对应的文档编号。我们的任务就是对这个文档集合建立倒排索引。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/855959-20170224200300601-1967186316.png)
+
+图3  文档集合
+
+中文和英文等语言不同，单词之间没有明确分隔符号，所以首先要用分词系统将文档自动切分成单词序列。这样每个文档就转换为由单词序列构成的数据流，为了系统后续处理方便，需要对每个不同的单词赋予唯一的单词编号，同时记录下哪些文档包含这个单词，在如此处理结束后，我们可以得到最简单的倒排索引（参考图3-4）。在图4中，“单词ID”一栏记录了每个单词的单词编号，第二栏是对应的单词，第三栏即每个单词对应的倒排列表。比如单词“谷歌”，其单词编号为1，倒排列表为{1,2,3,4,5}，说明文档集合中每个文档都包含了这个单词。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/855959-20170224200334195-2052728227.png)
+
+图4  简单的倒排索引
+
+之所以说图4所示倒排索引是最简单的，是因为这个索引系统只记载了哪些文档包含某个单词，而事实上，索引系统还可以记录除此之外的更多信息。图5是一个相对复杂些的倒排索引，与图4的基本索引系统比，在单词对应的倒排列表中不仅记录了文档编号，还记载了单词频率信息（TF），即这个单词在某个文档中的出现次数，之所以要记录这个信息，是因为词频信息在搜索结果排序时，计算查询和文档相似度是很重要的一个计算因子，所以将其记录在倒排列表中，以方便后续排序时进行分值计算。在图5的例子里，单词“创始人”的单词编号为7，对应的倒排列表内容为：（3:1），其中的3代表文档编号为3的文档包含这个单词，数字1代表词频信息，即这个单词在3号文档中只出现过1次，其它单词对应的倒排列表所代表含义与此相同。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/855959-20170224200417070-899412746.png)
+
+图 5 带有单词频率信息的倒排索引
+
+实用的倒排索引还可以记载更多的信息，图6所示索引系统除了记录文档编号和单词频率信息外，额外记载了两类信息，即每个单词对应的“文档频率信息”（对应图6的第三栏）以及在倒排列表中记录单词在某个文档出现的位置信息。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/855959-20170224200448148-924219280.png)
+
+图6  带有单词频率、文档频率和出现位置信息的倒排索引
+
+“文档频率信息”代表了在文档集合中有多少个文档包含某个单词，之所以要记录这个信息，其原因与单词频率信息一样，这个信息在搜索结果排序计算中是非常重要的一个因子。而单词在某个文档中出现的位置信息并非索引系统一定要记录的，在实际的索引系统里可以包含，也可以选择不包含这个信息，之所以如此，因为这个信息对于搜索系统来说并非必需的，位置信息只有在支持“短语查询”的时候才能够派上用场。
+
+以单词“拉斯”为例，其单词编号为8，文档频率为2，代表整个文档集合中有两个文档包含这个单词，对应的倒排列表为：{(3;1;<4>)，(5;1;<4>)},其含义为在文档3和文档5出现过这个单词，单词频率都为1，单词“拉斯”在两个文档中的出现位置都是4，即文档中第四个单词是“拉斯”。
+
+图6所示倒排索引已经是一个非常完备的索引系统，实际搜索系统的索引结构基本如此，区别无非是采取哪些具体的数据结构来实现上述逻辑结构。
+
+有了这个索引系统，搜索引擎可以很方便地响应用户的查询，比如用户输入查询词“Facebook”，搜索系统查找倒排索引，从中可以读出包含这个单词的文档，这些文档就是提供给用户的搜索结果，而利用单词频率信息、文档频率信息即可以对这些候选搜索结果进行排序，计算文档和查询的相似性，按照相似性得分由高到低排序输出，此即为搜索系统的部分内部流程，具体实现方案本书第五章会做详细描述。
+
+### 4. 单词词典
+
+单词词典是倒排索引中非常重要的组成部分，它用来维护文档集合中出现过的所有单词的相关信息，同时用来记载某个单词对应的倒排列表在倒排文件中的位置信息。在支持搜索时，根据用户的查询词，去单词词典里查询，就能够获得相应的倒排列表，并以此作为后续排序的基础。 对于一个规模很大的文档集合来说，可能包含几十万甚至上百万的不同单词，能否快速定位某个单词，这直接影响搜索时的响应速度，所以需要高效的数据结构来对单词词典进行构建和查找，常用的数据结构包括哈希加链表结构和树形词典结构。  
+4.1 哈希加链表  
+ 图7是这种词典结构的示意图。这种词典结构主要由两个部分构成：
+
+主体部分是哈希表，每个哈希表项保存一个指针，指针指向冲突链表，在冲突链表里，相同哈希值的单词形成链表结构。之所以会有冲突链表，是因为两个不同单词获得相同的哈希值，如果是这样，在哈希方法里被称做是一次冲突，可以将相同哈希值的单词存储在链表里，以供后续查找。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/855959-20170224200556085-1266490265.png)
+
+在建立索引的过程中，词典结构也会相应地被构建出来。比如在解析一个新文档的时候，对于某个在文档中出现的单词T，首先利用哈希函数获得其哈希值，之后根据哈希值对应的哈希表项读取其中保存的指针，就找到了对应的冲突链表。如果冲突链表里已经存在这个单词，说明单词在之前解析的文档里已经出现过。如果在冲突链表里没有发现这个单词，说明该单词是首次碰到，则将其加入冲突链表里。通过这种方式，当文档集合内所有文档解析完毕时，相应的词典结构也就建立起来了。
+
+在响应用户查询请求时，其过程与建立词典类似，不同点在于即使词典里没出现过某个单词，也不会添加到词典内。以图7为例，假设用户输入的查询请求为单词3，对这个单词进行哈希，定位到哈希表内的2号槽，从其保留的指针可以获得冲突链表，依次将单词3和冲突链表内的单词比较，发现单词3在冲突链表内，于是找到这个单词，之后可以读出这个单词对应的倒排列表来进行后续的工作，如果没有找到这个单词，说明文档集合内没有任何文档包含单词，则搜索结果为空。
+
+4.2 树形结构  
+ B树（或者B+树）是另外一种高效查找结构，图8是一个 B树结构示意图。B树与哈希方式查找不同，需要字典项能够按照大小排序（数字或者字符序），而哈希方式则无须数据满足此项要求。  
+ B树形成了层级查找结构，中间节点用于指出一定顺序范围的词典项目存储在哪个子树中，起到根据词典项比较大小进行导航的作用，最底层的叶子节点存储单词的地址信息，根据这个地址就可以提取出单词字符串。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/855959-20170224200636976-342112863.png)
+
+图8  B树查找结构  
+  
+总结
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/855959-20170224200716070-76147588.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/855959-20170224200724179-596243521.png)
+
+单词ID：记录每个单词的单词编号；  
+单词：对应的单词；  
+文档频率：代表文档集合中有多少个文档包含某个单词  
+倒排列表：包含单词ID及其他必要信息  
+DocId：单词出现的文档id  
+TF：单词在某个文档中出现的次数  
+POS：单词在文档中出现的位置  
+  以单词“加盟”为例，其单词编号为6，文档频率为3，代表整个文档集合中有三个文档包含这个单词，对应的倒排列表为{(2;1;<4>),(3;1;<7>),(5;1;<5>)}，含义是在文档2，3，5出现过这个单词，在每个文档的出现过1次，单词“加盟”在第一个文档的POS是4，即文档的第四个单词是“加盟”，其他的类似。  
+这个倒排索引已经是一个非常完备的索引系统，实际搜索系统的索引结构基本如此。
diff --git "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2102\357\274\232\346\220\234\347\264\242\345\274\225\346\223\216\345\267\245\344\275\234\345\216\237\347\220\206.md" "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\346\220\234\347\264\242\345\274\225\346\223\216\345\267\245\344\275\234\345\216\237\347\220\206.md"
similarity index 93%
rename from "docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2102\357\274\232\346\220\234\347\264\242\345\274\225\346\223\216\345\267\245\344\275\234\345\216\237\347\220\206.md"
rename to "docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\346\220\234\347\264\242\345\274\225\346\223\216\345\267\245\344\275\234\345\216\237\347\220\206.md"
index f962101..e74ad9e 100644
--- "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2102\357\274\232\346\220\234\347\264\242\345\274\225\346\223\216\345\267\245\344\275\234\345\216\237\347\220\206.md"
+++ "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\346\220\234\347\264\242\345\274\225\346\223\216\345\267\245\344\275\234\345\216\237\347\220\206.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [写在前面](#写在前面)
   * [搜索引擎发展过程](#搜索引擎发展过程)
@@ -8,9 +8,11 @@
   * [搜索引擎解决方案](#搜索引擎解决方案)
 
 
-本文作者：顿炖
-链接：https://www.zhihu.com/question/19937854/answer/98791215
-来源：知乎
+[toc]
+
+本文作者：顿炖  
+链接：https://www.zhihu.com/question/19937854/answer/98791215  
+来源：知乎  
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
 
@@ -19,13 +21,13 @@
 本系列文章将整理到我的个人博客
 > www.how2playlife.com
 
-更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注
+更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注  
 该系列博文会介绍常见的后端技术，这对后端工程师来说是一种综合能力，我们会逐步了解搜索技术，云计算相关技术、大数据研发等常见的技术喜提，以便让你更完整地了解后端技术栈的全貌，为后续参与分布式应用的开发和学习做好准备。
 
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系我，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 ## 写在前面
 
 Max Grigorev最近写了一篇文章，题目是[《What every software engineer should know about search》](https://link.juejin.im/?target=https%3A%2F%2Fmedium.com%2Fstartup-grind%2Fwhat-every-software-engineer-should-know-about-search-27d1df99f80d)，这篇文章里指出了现在一些软件工程师的问题，他们认为开发一个搜索引擎功能就是搭建一个ElasticSearch集群，而没有深究背后的技术，以及技术发展趋势。Max认为，除了搜索引擎自身的搜索问题解决、人类使用方式等之外，也需要解决索引、分词、权限控制、国际化等等的技术点，看了他的文章，勾起了我多年前的想法。
@@ -72,7 +74,7 @@ Max Grigorev最近写了一篇文章，题目是[《What every software engineer
 
 一个完整的网络爬虫基础框架如下图所示：
 
-![](https://ww2.sinaimg.cn/large/006tKfTcly1fkrzrfk7trj30pl0grjt9.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/006tKfTcly1fkrzrfk7trj30pl0grjt9.jpg)
 
 整个架构共有如下几个过程：
 
@@ -93,10 +95,10 @@ Lucene是一个高性能的java全文检索工具包，它使用的是倒排文
 
 全文检索大体分两个过程，索引创建 (Indexing) 和搜索索引 (Search) 。
 
-索引创建：将现实世界中所有的结构化和非结构化数据提取信息，创建索引的过程。
+索引创建：将现实世界中所有的结构化和非结构化数据提取信息，创建索引的过程。  
 搜索索引：就是得到用户的查询请求，搜索创建的索引，然后返回结果的过程。
 
-![](https://ww2.sinaimg.cn/large/006tKfTcly1fkrzrpvzm1j30f40db755.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/006tKfTcly1fkrzrpvzm1j30f40db755.jpg)
 
 非结构化数据中所存储的信息是每个文件包含哪些字符串，也即已知文件，欲求字符串相对容易，也即是从文件到字符串的映射。而我们想搜索的信息是哪些文件包含此字符串，也即已知字符串，欲求文件，也即从字符串到文件的映射。两者恰恰相反。于是如果索引总能够保存从字符串到文件的映射，则会大大提高搜索速度。
 
@@ -106,7 +108,7 @@ Lucene是一个高性能的java全文检索工具包，它使用的是倒排文
 
 假设我的文档集合里面有100篇文档，为了方便表示，我们为文档编号从1到100，得到下面的结构
 
-![](https://ww1.sinaimg.cn/large/006tKfTcly1fkrzrz05rqj30f4049gmb.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/006tKfTcly1fkrzrz05rqj30f4049gmb.jpg)
 
 每个字符串都指向包含此字符串的文档(Document)链表，此文档链表称为倒排表 (Posting List)。
 
@@ -122,7 +124,7 @@ Solr是一个基于Lucene的搜索引擎服务器。Solr 提供了层面搜索
 
 谷歌公司发布的一系列技术白皮书导致了Hadoop的诞生。Hadoop是一系列大数据处理工具，可以被用在大规模集群里。Hadoop目前已经发展为一个生态体系，包括了很多组件，如图所示。
 
-![](https://ww4.sinaimg.cn/large/006tKfTcly1fkrzs6lbs1j31hm10x466.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/006tKfTcly1fkrzs6lbs1j31hm10x466.jpg)
 
 Cloudera是一家将Hadoop技术用于搜索引擎的公司，用户可以采用全文搜索方式检索存储在HDFS（Hadoop分布式文件系统）和Apache HBase里面的数据，再加上开源的搜索引擎Apache Solr，Cloudera提供了搜索功能，并结合Apache ZooKeeper进行分布式处理的管理、索引切分以及高性能检索。
 
@@ -139,7 +141,7 @@ Cloudera是一家将Hadoop技术用于搜索引擎的公司，用户可以采用
 
 如果我们想要实现搜索引擎，最重要的是索引模块和搜索模块。索引模块在不同的机器上各自进行对资源的索引，并把索引文件统一传输到同一个地方（可以是在远程服务器上，也可以是在本地）。搜索模块则利用这些从多个索引模块收集到的数据完成用户的搜索请求。因此，我们可以理解两个模块之间相对是独立的，它们之间的关联不是通过代码，而是通过索引和元数据，如下图所示。
 
-![](https://ww1.sinaimg.cn/large/006tKfTcly1fkrzshq4cbj30ga05874m.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/006tKfTcly1fkrzshq4cbj30ga05874m.jpg)
 
 对于索引的建立，我们需要注意性能问题。当需要进行索引的资源数目不多时，隔一定的时间进行一次完全索引，不会占用很长时间。但在大型应用中，资源的容量是巨大的，如果每次都进行完整的索引，耗费的时间会很惊人。我们可以通过跳过已经索引的资源内容，删除已不存在的资源内容的索引，并进行增量索引来解决这个问题。这可能会涉及文件校验和索引删除等。另一方面，框架可以提供查询缓存功能，提高查询效率。框架可以在内存中建立一级缓存，并使用如 OSCache或 EHCache缓存框架，实现磁盘上的二级缓存。当索引的内容变化不频繁时，使用查询缓存更会明显地提高查询速度、降低资源消耗。
 
@@ -151,7 +153,7 @@ Cloudera是一家将Hadoop技术用于搜索引擎的公司，用户可以采用
 
 *   OmniFind
 
-OmniFind 是 IBM 公司推出的企业级搜索解决方案。基于 UIMA (Unstructured Information Management Architecture) 技术，它提供了强大的索引和获取信息功能，支持巨大数量、多种类型的文档资源（无论是结构化还是非结构化），并为 Lotus®Domino®和 WebSphere®Portal 专门进行了优化。
+OmniFind 是 IBM 公司推出的企业级搜索解决方案。基于 UIMA (Unstructured Information Management Architecture) 技术，它提供了强大的索引和获取信息功能，支持巨大数量、多种类型的文档资源（无论是结构化还是非结构化），并为 Lotus®Domino®和 WebSphere®Portal 专门进行了优化。  
 下一代搜索引擎
 
 从技术和产品层面来看，接下来的几年，甚至于更长时间，应该没有哪一家搜索引擎可以撼动谷歌的技术领先优势和产品地位。但是我们也可以发现一些现象，例如搜索假期租房的时候，人们更喜欢使用Airbub，而不是Google，这就是针对匿名/个性化搜索需求，这些需求是谷歌所不能完全覆盖到的，毕竟原始数据并不在谷歌。我们可以看一个例子：DuckDuckGo。这是一款有别于大众理解的搜索引擎，DuckDuckGo强调的是最佳答案，而不是更多的结果，所以每个人搜索相同关键词时，返回的结果是不一样的。
@@ -162,8 +164,7 @@ OmniFind 是 IBM 公司推出的企业级搜索解决方案。基于 UIMA (Unstr
 
 贴个图，自己感受下。
 
-![](https://pic3.zhimg.com/5b981a1b36b15a5a82c8f4e65a718afa_b.jpg)![](https://pic3.zhimg.com/80/5b981a1b36b15a5a82c8f4e65a718afa_hd.jpg)
-
-**详细点的 ：**
-![](https://pic4.zhimg.com/6e7fd609f7de41c35f5587a1ceb42523_b.jpg)![](https://pic4.zhimg.com/80/6e7fd609f7de41c35f5587a1ceb42523_hd.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/5b981a1b36b15a5a82c8f4e65a718afa_b.jpg)![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/5b981a1b36b15a5a82c8f4e65a718afa_hd.jpg)
 
+**详细点的 ：**  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/6e7fd609f7de41c35f5587a1ceb42523_b.jpg)![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/6e7fd609f7de41c35f5587a1ceb42523_hd.jpg)
diff --git "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2106\357\274\232\347\231\275\350\257\235\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257.md" "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\347\231\275\350\257\235\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257.md"
similarity index 95%
rename from "docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2106\357\274\232\347\231\275\350\257\235\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257.md"
rename to "docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\347\231\275\350\257\235\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257.md"
index 6a38c85..7896eb0 100644
--- "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2106\357\274\232\347\231\275\350\257\235\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257.md"
+++ "b/docs/backend/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\210\357\274\232\347\231\275\350\257\235\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257.md"
@@ -1,15 +1,14 @@
-# Table of Contents
-
-
 
 本文转自互联网，侵删
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本系列文章将整理到我的个人博客
+
 > www.how2playlife.com
 
 更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注
@@ -24,7 +23,7 @@
 
 所有的操作系统都有内核，无论是Windows还是Linux，都管理着三个重要的资源：计算，网络，存储。
 
-![](https://img-blog.csdn.net/20180306202405696)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408115530.png)
 
 计算指CPU和内存，网络即网络设备，存储即硬盘之类的。
 
@@ -34,7 +33,7 @@
 
 为了区分内核态和用户态，CPU专门设置四个特权等级0,1,2,3 来做这个事情。
 
-![](https://img-blog.csdn.net/20180306202427394)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408115543.png)
 
 当时写Linux内核的时候，估计大牛们还不知道将来虚拟机会大放异彩，大牛们想，一共两级特权，一个内核态，一个用户态，却有四个等级，好奢侈，好富裕，就敞开了用，内核态运行在第0等级，用户态运行在第3等级，占了两头，太不会过日子了。
 
@@ -104,7 +103,7 @@
 
 对于虚拟机内核来讲，只要将标志位设为虚拟机状态，则可以直接在CPU上执行大部分的指令，不需要虚拟化软件在中间转述，除非遇到特别敏感的指令，才需要将标志位设为物理机内核态运行，这样大大提高了效率。
 
-所以安装虚拟机的时候，务必要将物理CPU的这个标志位打开，是否打开对于Intel可以查看grep "vmx" /proc/cpuinfo，对于AMD可以查看grep "svm" /proc/cpuinfo
+所以安装虚拟机的时候，务必要将物理CPU的这个标志位打开，是否打开对于Intel可以查看grep"vmx" /proc/cpuinfo，对于AMD可以查看grep "svm" /proc/cpuinfo
 
 这叫做硬件辅助虚拟化。
 
@@ -116,4 +115,4 @@
 
 如果您想更技术的了解本文背后的原理，请看书《系统虚拟化——原理与实现》
 
-![](https://img-blog.csdn.net/20180306202439418)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230408115552.png)
diff --git "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2101\357\274\232\346\220\234\347\264\242\345\274\225\346\223\216\345\237\272\347\241\200\345\200\222\346\216\222\347\264\242\345\274\225.md" "b/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2101\357\274\232\346\220\234\347\264\242\345\274\225\346\223\216\345\237\272\347\241\200\345\200\222\346\216\222\347\264\242\345\274\225.md"
deleted file mode 100644
index 56081a3..0000000
--- "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2101\357\274\232\346\220\234\347\264\242\345\274\225\346\223\216\345\237\272\347\241\200\345\200\222\346\216\222\347\264\242\345\274\225.md"
+++ /dev/null
@@ -1,174 +0,0 @@
-# Table of Contents
-
-* [[什么是倒排索引？](https://www.cnblogs.com/zlslch/p/6440114.html)](#[什么是倒排索引？]httpswwwcnblogscomzlslchp6440114html)
-  * [1.单词——文档矩阵](#1单词文档矩阵)
-  * [2.倒排索引基本概念](#2倒排索引基本概念)
-  * [3.倒排索引简单实例](#3倒排索引简单实例)
-  * [4\. 单词词典](#4-单词词典)
-
-
-本文转载自 https://www.cnblogs.com/zlslch/p/6440114.html
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-本系列文章将整理到我的个人博客
-> www.how2playlife.com
-
-更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注
-该系列博文会介绍常见的后端技术，这对后端工程师来说是一种综合能力，我们会逐步了解搜索技术，云计算相关技术、大数据研发等常见的技术喜提，以便让你更完整地了解后端技术栈的全貌，为后续参与分布式应用的开发和学习做好准备。
-
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系我，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-# [什么是倒排索引？](https://www.cnblogs.com/zlslch/p/6440114.html)
-
-
-
-
-
-　　见其名知其意，有倒排索引，对应肯定，有正向索引。
-
-     正向索引（forward index），反向索引（inverted index）更熟悉的名字是倒排索引。
-
-     在搜索引擎中每个文件都对应一个文件ID，文件内容被表示为一系列关键词的集合（实际上在搜索引擎索引库中，关键词也已经转换为关键词ID）。例如“文档1”经过分词，提取了20个关键词，每个关键词都会记录它在文档中的出现次数和出现位置。
-
-     得到正向索引的结构如下：
-
-       “文档1”的ID > 单词1：出现次数，出现位置列表；单词2：出现次数，出现位置列表；…………。
-
-       “文档2”的ID > 此文档出现的关键词列表。
-
- ![](https://images2015.cnblogs.com/blog/855959/201707/855959-20170706154309815-1724421988.png)
-
-　　一般是通过key，去找value。
-
-      当用户在主页上搜索关键词“华为手机”时，假设只存在正向索引（forward index），那么就需要扫描索引库中的所有文档，找出所有包含关键词“华为手机”的文档，再根据打分模型进行打分，排出名次后呈现给用户。因为互联网上收录在搜索引擎中的文档的数目是个天文数字，这样的索引结构根本无法满足实时返回排名结果的要求。
-
-       所以，搜索引擎会将正向索引重新构建为倒排索引，即把文件ID对应到关键词的映射转换为关键词到文件ID的映射，每个关键词都对应着一系列的文件，这些文件中都出现这个关键词。
-
-       得到倒排索引的结构如下：
-
-       “关键词1”：“文档1”的ID，“文档2”的ID，…………。
-
-       “关键词2”：带有此关键词的文档ID列表。
-
- ![](https://images2015.cnblogs.com/blog/855959/201707/855959-20170706154505378-610589524.png)
-
-　　从词的关键字，去找文档。
-
-## 1.单词——文档矩阵
-
-      单词-文档矩阵是表达两者之间所具有的一种包含关系的概念模型，图1展示了其含义。图3-1的每列代表一个文档，每行代表一个单词，打对勾的位置代表包含关系。
-
-　　　　　　　　　　　　![](https://images2015.cnblogs.com/blog/855959/201702/855959-20170224195649726-238255448.png)
-
-　　　　　　　　  　　　　　　　　　　　　　　　　图1 单词-文档矩阵
-
-     从纵向即文档这个维度来看，每列代表文档包含了哪些单词，比如文档1包含了词汇1和词汇4，而不包含其它单词。从横向即单词这个维度来看，每行代表了哪些文档包含了某个单词。比如对于词汇1来说，文档1和文档4中出现过单词1，而其它文档不包含词汇1。矩阵中其它的行列也可作此种解读。
-
-    搜索引擎的索引其实就是实现“单词-文档矩阵”的具体[数据结构](http://lib.csdn.net/base/datastructure "算法与数据结构知识库")。可以有不同的方式来实现上述概念模型，比如“倒排索引”、“签名文件”、“后缀树”等方式。但是各项实验数据表明，“倒排索引”是实现单词到文档映射关系的最佳实现方式，所以本博文主要介绍“倒排索引”的技术细节。
-
-## 2.倒排索引基本概念
-
-       文档(Document)：一般搜索引擎的处理对象是互联网网页，而文档这个概念要更宽泛些，代表以文本形式存在的存储对象，相比网页来说，涵盖更多种形式，比如Word，PDF，html，XML等不同格式的文件都可以称之为文档。再比如一封邮件，一条短信，一条微博也可以称之为文档。在本书后续内容，很多情况下会使用文档来表征文本信息。
-
-       文档集合(Document Collection)：由若干文档构成的集合称之为文档集合。比如海量的互联网网页或者说大量的电子邮件都是文档集合的具体例子。
-
-       文档编号(Document ID)：在搜索引擎内部，会将文档集合内每个文档赋予一个唯一的内部编号，以此编号来作为这个文档的唯一标识，这样方便内部处理，每个文档的内部编号即称之为“文档编号”，后文有时会用DocID来便捷地代表文档编号。
-
-       单词编号(Word ID)：与文档编号类似，搜索引擎内部以唯一的编号来表征某个单词，单词编号可以作为某个单词的唯一表征。
-
-       倒排索引(Inverted Index)：倒排索引是实现“单词-文档矩阵”的一种具体存储形式，通过倒排索引，可以根据单词快速获取包含这个单词的文档列表。倒排索引主要由两个部分组成：“单词词典”和“倒排文件”。
-
-       单词词典(Lexicon)：搜索引擎的通常索引单位是单词，单词词典是由文档集合中出现过的所有单词构成的字符串集合，单词词典内每条索引项记载单词本身的一些信息以及指向“倒排列表”的指针。
-
-       倒排列表(PostingList)：倒排列表记载了出现过某个单词的所有文档的文档列表及单词在该文档中出现的位置信息，每条记录称为一个倒排项(Posting)。根据倒排列表，即可获知哪些文档包含某个单词。
-
-       倒排文件(Inverted File)：所有单词的倒排列表往往顺序地存储在磁盘的某个文件里，这个文件即被称之为倒排文件，倒排文件是存储倒排索引的物理文件。
-
-     关于这些概念之间的关系，通过图2可以比较清晰的看出来。
-
-　　　　　　　　　　　　　　![](https://images2015.cnblogs.com/blog/855959/201702/855959-20170224200237991-592489046.png)
-
-## 3.倒排索引简单实例
-
-      倒排索引从逻辑结构和基本思路上来讲非常简单。下面我们通过具体实例来进行说明，使得读者能够对倒排索引有一个宏观而直接的感受。
-
-      假设文档集合包含五个文档，每个文档内容如图3所示，在图中最左端一栏是每个文档对应的文档编号。我们的任务就是对这个文档集合建立倒排索引。
-
-　　　　　　　　　　　　　　![](https://images2015.cnblogs.com/blog/855959/201702/855959-20170224200300601-1967186316.png)
-
- 　　　　　　　　　　　　　　　　　　　　　　　　　　图3   文档集合
-
-　　中文和英文等语言不同，单词之间没有明确分隔符号，所以首先要用分词系统将文档自动切分成单词序列。这样每个文档就转换为由单词序列构成的数据流，为了系统后续处理方便，需要对每个不同的单词赋予唯一的单词编号，同时记录下哪些文档包含这个单词，在如此处理结束后，我们可以得到最简单的倒排索引（参考图3-4）。在图4中，“单词ID”一栏记录了每个单词的单词编号，第二栏是对应的单词，第三栏即每个单词对应的倒排列表。比如单词“谷歌”，其单词编号为1，倒排列表为{1,2,3,4,5}，说明文档集合中每个文档都包含了这个单词。
-
-　　　　　　　　　　　　　　![](https://images2015.cnblogs.com/blog/855959/201702/855959-20170224200334195-2052728227.png)
-
-　　　　　　　　　　　　　　　　　　　　　　　　　　　　图4   简单的倒排索引
-
-　　之所以说图4所示倒排索引是最简单的，是因为这个索引系统只记载了哪些文档包含某个单词，而事实上，索引系统还可以记录除此之外的更多信息。图5是一个相对复杂些的倒排索引，与图4的基本索引系统比，在单词对应的倒排列表中不仅记录了文档编号，还记载了单词频率信息（TF），即这个单词在某个文档中的出现次数，之所以要记录这个信息，是因为词频信息在搜索结果排序时，计算查询和文档相似度是很重要的一个计算因子，所以将其记录在倒排列表中，以方便后续排序时进行分值计算。在图5的例子里，单词“创始人”的单词编号为7，对应的倒排列表内容为：（3:1），其中的3代表文档编号为3的文档包含这个单词，数字1代表词频信息，即这个单词在3号文档中只出现过1次，其它单词对应的倒排列表所代表含义与此相同。
-
-　　　　　　　　　　　　　　![](https://images2015.cnblogs.com/blog/855959/201702/855959-20170224200417070-899412746.png)
-
-　　　　　　　　　　　　　　　　　　　　　　　　　　　　图 5 带有单词频率信息的倒排索引
-
- 　　实用的倒排索引还可以记载更多的信息，图6所示索引系统除了记录文档编号和单词频率信息外，额外记载了两类信息，即每个单词对应的“文档频率信息”（对应图6的第三栏）以及在倒排列表中记录单词在某个文档出现的位置信息。
-
-　　　　　　　　　　　　　　　　　　![](https://images2015.cnblogs.com/blog/855959/201702/855959-20170224200448148-924219280.png)
-
- 　　　　　　　　　　　　　　　　　　　　　　图6   带有单词频率、文档频率和出现位置信息的倒排索引
-
-   “文档频率信息”代表了在文档集合中有多少个文档包含某个单词，之所以要记录这个信息，其原因与单词频率信息一样，这个信息在搜索结果排序计算中是非常重要的一个因子。而单词在某个文档中出现的位置信息并非索引系统一定要记录的，在实际的索引系统里可以包含，也可以选择不包含这个信息，之所以如此，因为这个信息对于搜索系统来说并非必需的，位置信息只有在支持“短语查询”的时候才能够派上用场。
-
-     以单词“拉斯”为例，其单词编号为8，文档频率为2，代表整个文档集合中有两个文档包含这个单词，对应的倒排列表为：{(3;1;<4>)，(5;1;<4>)},其含义为在文档3和文档5出现过这个单词，单词频率都为1，单词“拉斯”在两个文档中的出现位置都是4，即文档中第四个单词是“拉斯”。
-
-     图6所示倒排索引已经是一个非常完备的索引系统，实际搜索系统的索引结构基本如此，区别无非是采取哪些具体的数据结构来实现上述逻辑结构。
-
-     有了这个索引系统，搜索引擎可以很方便地响应用户的查询，比如用户输入查询词“Facebook”，搜索系统查找倒排索引，从中可以读出包含这个单词的文档，这些文档就是提供给用户的搜索结果，而利用单词频率信息、文档频率信息即可以对这些候选搜索结果进行排序，计算文档和查询的相似性，按照相似性得分由高到低排序输出，此即为搜索系统的部分内部流程，具体实现方案本书第五章会做详细描述。
-
-## 4\. 单词词典
-
-　　单词词典是倒排索引中非常重要的组成部分，它用来维护文档集合中出现过的所有单词的相关信息，同时用来记载某个单词对应的倒排列表在倒排文件中的位置信息。在支持搜索时，根据用户的查询词，去单词词典里查询，就能够获得相应的倒排列表，并以此作为后续排序的基础。
-       对于一个规模很大的文档集合来说，可能包含几十万甚至上百万的不同单词，能否快速定位某个单词，这直接影响搜索时的响应速度，所以需要高效的数据结构来对单词词典进行构建和查找，常用的数据结构包括哈希加链表结构和树形词典结构。
-4.1   哈希加链表
-       图7是这种词典结构的示意图。这种词典结构主要由两个部分构成：
-
-        主体部分是哈希表，每个哈希表项保存一个指针，指针指向冲突链表，在冲突链表里，相同哈希值的单词形成链表结构。之所以会有冲突链表，是因为两个不同单词获得相同的哈希值，如果是这样，在哈希方法里被称做是一次冲突，可以将相同哈希值的单词存储在链表里，以供后续查找。
-
-　　　　　　　　　　　　　　　　　　　　　　![](https://images2015.cnblogs.com/blog/855959/201702/855959-20170224200556085-1266490265.png)
-
-　　在建立索引的过程中，词典结构也会相应地被构建出来。比如在解析一个新文档的时候，对于某个在文档中出现的单词T，首先利用哈希函数获得其哈希值，之后根据哈希值对应的哈希表项读取其中保存的指针，就找到了对应的冲突链表。如果冲突链表里已经存在这个单词，说明单词在之前解析的文档里已经出现过。如果在冲突链表里没有发现这个单词，说明该单词是首次碰到，则将其加入冲突链表里。通过这种方式，当文档集合内所有文档解析完毕时，相应的词典结构也就建立起来了。
-
-       在响应用户查询请求时，其过程与建立词典类似，不同点在于即使词典里没出现过某个单词，也不会添加到词典内。以图7为例，假设用户输入的查询请求为单词3，对这个单词进行哈希，定位到哈希表内的2号槽，从其保留的指针可以获得冲突链表，依次将单词3和冲突链表内的单词比较，发现单词3在冲突链表内，于是找到这个单词，之后可以读出这个单词对应的倒排列表来进行后续的工作，如果没有找到这个单词，说明文档集合内没有任何文档包含单词，则搜索结果为空。
-
-4.2   树形结构
-       B树（或者B+树）是另外一种高效查找结构，图8是一个 B树结构示意图。B树与哈希方式查找不同，需要字典项能够按照大小排序（数字或者字符序），而哈希方式则无须数据满足此项要求。
-       B树形成了层级查找结构，中间节点用于指出一定顺序范围的词典项目存储在哪个子树中，起到根据词典项比较大小进行导航的作用，最底层的叶子节点存储单词的地址信息，根据这个地址就可以提取出单词字符串。
-
-　　　　　　　　　　　　　　　　![](https://images2015.cnblogs.com/blog/855959/201702/855959-20170224200636976-342112863.png)
-
- 　　　　　　　　　　　　　　　　　　　　　　　　　　图8   B树查找结构 
-
-总结
-
-![](https://images2015.cnblogs.com/blog/855959/201702/855959-20170224200716070-76147588.png)
-
-![](https://images2015.cnblogs.com/blog/855959/201702/855959-20170224200724179-596243521.png)
-
-单词ID：记录每个单词的单词编号；
-单词：对应的单词；
-文档频率：代表文档集合中有多少个文档包含某个单词
-倒排列表：包含单词ID及其他必要信息
-DocId：单词出现的文档id
-TF：单词在某个文档中出现的次数
-POS：单词在文档中出现的位置
-     以单词“加盟”为例，其单词编号为6，文档频率为3，代表整个文档集合中有三个文档包含这个单词，对应的倒排列表为{(2;1;<4>),(3;1;<7>),(5;1;<5>)}，含义是在文档2，3，5出现过这个单词，在每个文档的出现过1次，单词“加盟”在第一个文档的POS是4，即文档的第四个单词是“加盟”，其他的类似。
-这个倒排索引已经是一个非常完备的索引系统，实际搜索系统的索引结构基本如此。
-
-
-
diff --git "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2109\357\274\232\345\205\210\346\220\236\346\207\202Docker\346\240\270\345\277\203\346\246\202\345\277\265\345\220\247.md" "b/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2109\357\274\232\345\205\210\346\220\236\346\207\202Docker\346\240\270\345\277\203\346\246\202\345\277\265\345\220\247.md"
deleted file mode 100644
index edf38ec..0000000
--- "a/docs/big-backEnd/\345\220\216\347\253\257\346\212\200\346\234\257\346\235\202\350\260\2109\357\274\232\345\205\210\346\220\236\346\207\202Docker\346\240\270\345\277\203\346\246\202\345\277\265\345\220\247.md"
+++ /dev/null
@@ -1,249 +0,0 @@
-# Table of Contents
-
-* [可能是把Docker的概念讲的最清楚的一篇文章](#可能是把docker的概念讲的最清楚的一篇文章)
-  * [一 先从认识容器开始](#一-先从认识容器开始)
-    * [1.1 什么是容器？](#11-什么是容器？)
-      * [先来看看容器较为官方的解释](#先来看看容器较为官方的解释)
-      * [再来看看容器较为通俗的解释](#再来看看容器较为通俗的解释)
-    * [1.2 图解物理机、虚拟机与容器](#12-图解物理机、虚拟机与容器)
-  * [二 再来谈谈Docker的一些概念](#二-再来谈谈docker的一些概念)
-    * [2.1 什么是Docker？](#21-什么是docker？)
-    * [2.2 Docker思想](#22-docker思想)
-    * [2.3 Docker容器的特点](#23-docker容器的特点)
-    * [2.4 为什么要用Docker](#24-为什么要用docker)
-  * [三 容器 VS 虚拟机](#三-容器-vs-虚拟机)
-    * [3.1 两者对比图](#31-两者对比图)
-    * [3.2 容器与虚拟机 (VM) 总结](#32-容器与虚拟机-vm-总结)
-    * [3.3 容器与虚拟机 (VM)两者是可以共存的](#33-容器与虚拟机-vm两者是可以共存的)
-  * [四 Docker基本概念](#四-docker基本概念)
-    * [4.1 镜像（Image）——一个特殊的文件系统](#41-镜像（image）一个特殊的文件系统)
-    * [4.2 容器（Container)——镜像运行时的实体](#42-容器（container镜像运行时的实体)
-    * [4.3 仓库（Repository）——集中存放镜像文件的地方](#43-仓库（repository）集中存放镜像文件的地方)
-  * [五 最后谈谈：Build, Ship, and Run](#五-最后谈谈：build-ship-and-run)
-  * [六 总结](#六-总结)
-
-
-本文转载自互联网，侵删
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-本系列文章将整理到我的个人博客
-> www.how2playlife.com
-
-更多Java技术文章会更新在我的微信公众号【Java技术江湖】上，欢迎关注
-该系列博文会介绍常见的后端技术，这对后端工程师来说是一种综合能力，我们会逐步了解搜索技术，云计算相关技术、大数据研发等常见的技术喜提，以便让你更完整地了解后端技术栈的全貌，为后续参与分布式应用的开发和学习做好准备。
-
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系我，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-# 可能是把Docker的概念讲的最清楚的一篇文章
-
-
-
-本文只是对Docker的概念做了较为详细的介绍，并不涉及一些像Docker环境的安装以及Docker的一些常见操作和命令。
-
-阅读本文大概需要15分钟，通过阅读本文你将知道一下概念：
-
-*   容器
-*   什么是Docker？
-*   Docker思想、特点
-*   Docker容器主要解决什么问题
-*   容器 VS 虚拟机
-*   Docker基本概念： 镜像（Image），容器（Container），仓库（Repository）
-
-* * *
-
-> Docker 是世界领先的软件容器平台，所以想要搞懂Docker的概念我们必须先从容器开始说起。
-
-## 一 先从认识容器开始
-
-### 1.1 什么是容器？
-
-#### 先来看看容器较为官方的解释
-
-一句话概括容器：容器就是将软件打包成标准化单元，以用于开发、交付和部署。
-
-*   容器镜像是轻量的、可执行的独立软件包 ，包含软件运行所需的所有内容：代码、运行时环境、系统工具、系统库和设置。
-*   容器化软件适用于基于Linux和Windows的应用，在任何环境中都能够始终如一地运行。
-*   容器赋予了软件独立性 ，使其免受外在环境差异（例如，开发和预演环境的差异）的影响，从而有助于减少团队间在相同基础设施上运行不同软件时的冲突。
-
-#### 再来看看容器较为通俗的解释
-
-如果需要通俗的描述容器的话，我觉得容器就是一个存放东西的地方，就像书包可以装各种文具、衣柜可以放各种衣服、鞋架可以放各种鞋子一样。我们现在所说的容器存放的东西可能更偏向于应用比如网站、程序甚至是系统环境。
-
-![认识容器](https://user-gold-cdn.xitu.io/2018/6/17/1640cae21c18e404?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-### 1.2 图解物理机、虚拟机与容器
-
-关于虚拟机与容器的对比在后面会详细介绍到，这里只是通过网上的图片加深大家对于物理机、虚拟机与容器这三者的理解。
-
-物理机
-
-![物理机](https://user-gold-cdn.xitu.io/2018/6/18/1641129f0ecdf8ff?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-虚拟机：
-
-![虚拟机](https://user-gold-cdn.xitu.io/2018/6/18/164112a72a917f4a?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-容器：
-
-![容器](https://user-gold-cdn.xitu.io/2018/6/18/164112ac76e6f693?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-通过上面这三张抽象图，我们可以大概可以通过类比概括出： 容器虚拟化的是操作系统而不是硬件，容器之间是共享同一套操作系统资源的。虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统。因此容器的隔离级别会稍低一些。
-
-* * *
-
-> 相信通过上面的解释大家对于容器这个既陌生又熟悉的概念有了一个初步的认识，下面我们就来谈谈Docker的一些概念。
-
-## 二 再来谈谈Docker的一些概念
-
-![Docker的一些概念](https://user-gold-cdn.xitu.io/2018/6/18/16410734eb1ed373?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-### 2.1 什么是Docker？
-
-说实话关于Docker是什么并太好说，下面我通过四点向你说明Docker到底是个什么东西。
-
-*   Docker 是世界领先的软件容器平台。
-*   Docker 使用 Google 公司推出的 Go 语言 进行开发实现，基于 Linux 内核 的cgroup，namespace，以及AUFS类的UnionFS等技术，对进程进行封装隔离，属于操作系统层面的虚拟化技术。 由于隔离的进程独立于宿主和其它的隔离的进 程，因此也称其为容器。Docke最初实现是基于 LXC.
-*   Docker 能够自动执行重复性任务，例如搭建和配置开发环境，从而解放了开发人员以便他们专注在真正重要的事情上：构建杰出的软件。
-*   用户可以方便地创建和使用容器，把自己的应用放入容器。容器还可以进行版本管理、复制、分享、修改，就像管理普通的代码一样。
-
-![什么是Docker](https://user-gold-cdn.xitu.io/2018/6/18/16411c3946dda762?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-### 2.2 Docker思想
-
-*   集装箱
-*   标准化： ①运输方式 ② 存储方式 ③ API接口
-*   隔离
-
-### 2.3 Docker容器的特点
-
-*   #### 轻量
-
-    在一台机器上运行的多个 Docker 容器可以共享这台机器的操作系统内核；它们能够迅速启动，只需占用很少的计算和内存资源。镜像是通过文件系统层进行构造的，并共享一些公共文件。这样就能尽量降低磁盘用量，并能更快地下载镜像。
-
-*   #### 标准
-
-    Docker 容器基于开放式标准，能够在所有主流 Linux 版本、Microsoft Windows 以及包括 VM、裸机服务器和云在内的任何基础设施上运行。
-
-*   #### 安全
-
-    Docker 赋予应用的隔离性不仅限于彼此隔离，还独立于底层的基础设施。Docker 默认提供最强的隔离，因此应用出现问题，也只是单个容器的问题，而不会波及到整台机器。
-
-### 2.4 为什么要用Docker
-
-*   Docker 的镜像提供了除内核外完整的运行时环境，确保了应用运行环境一致性，从而不会再出现 “这段代码在我机器上没问题啊” 这类问题；——一致的运行环境
-*   可以做到秒级、甚至毫秒级的启动时间。大大的节约了开发、测试、部署的时间。——更快速的启动时间
-*   避免公用的服务器，资源会容易受到其他用户的影响。——隔离性
-*   善于处理集中爆发的服务器使用压力；——弹性伸缩，快速扩展
-*   可以很轻易的将在一个平台上运行的应用，迁移到另一个平台上，而不用担心运行环境的变化导致应用无法正常运行的情况。——迁移方便
-*   使用 Docker 可以通过定制应用镜像来实现持续集成、持续交付、部署。——持续交付和部署
-
-* * *
-
-> 每当说起容器，我们不得不将其与虚拟机做一个比较。就我而言，对于两者无所谓谁会取代谁，而是两者可以和谐共存。
-
-## 三 容器 VS 虚拟机
-
-  简单来说： 容器和虚拟机具有相似的资源隔离和分配优势，但功能有所不同，因为容器虚拟化的是操作系统，而不是硬件，因此容器更容易移植，效率也更高。
-
-### 3.1 两者对比图
-
-  传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便.
-
-![容器 VS 虚拟机](https://user-gold-cdn.xitu.io/2018/6/17/1640cb4abec9e902?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-### 3.2 容器与虚拟机 (VM) 总结
-
-![容器与虚拟机 (VM) 总结](https://user-gold-cdn.xitu.io/2018/6/18/16410aa3b89ae481?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-*   容器是一个应用层抽象，用于将代码和依赖资源打包在一起。 多个容器可以在同一台机器上运行，共享操作系统内核，但各自作为独立的进程在用户空间中运行 。与虚拟机相比， 容器占用的空间较少（容器镜像大小通常只有几十兆），瞬间就能完成启动 。
-
-*   虚拟机 (VM) 是一个物理硬件层抽象，用于将一台服务器变成多台服务器。 管理程序允许多个 VM 在一台机器上运行。每个VM都包含一整套操作系统、一个或多个应用、必要的二进制文件和库资源，因此 占用大量空间 。而且 VM 启动也十分缓慢 。
-
-  通过Docker官网，我们知道了这么多Docker的优势，但是大家也没有必要完全否定虚拟机技术，因为两者有不同的使用场景。虚拟机更擅长于彻底隔离整个运行环境。例如，云服务提供商通常采用虚拟机技术隔离不同的用户。而 Docker通常用于隔离不同的应用 ，例如前端，后端以及数据库。
-
-### 3.3 容器与虚拟机 (VM)两者是可以共存的
-
-就我而言，对于两者无所谓谁会取代谁，而是两者可以和谐共存。
-
-![两者是可以共存的](https://user-gold-cdn.xitu.io/2018/6/17/1640cca26fc38f9e?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-* * *
-
-> Docker中非常重要的三个基本概念，理解了这三个概念，就理解了 Docker 的整个生命周期。
-
-## 四 Docker基本概念
-
-Docker 包括三个基本概念
-
-*   镜像（Image）
-*   容器（Container）
-*   仓库（Repository）
-
-理解了这三个概念，就理解了 Docker 的整个生命周期
-
-![Docker 包括三个基本概念](https://user-gold-cdn.xitu.io/2018/6/18/164109e4900357a9?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-### 4.1 镜像（Image）——一个特殊的文件系统
-
-  操作系统分为内核和用户空间。对于 Linux 而言，内核启动后，会挂载 root 文件系统为其提供用户空间支持。而Docker 镜像（Image），就相当于是一个 root 文件系统。
-
-  Docker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。 镜像不包含任何动态数据，其内容在构建之后也不会被改变。
-
-  Docker 设计时，就充分利用 Union FS的技术，将其设计为 分层存储的架构 。 镜像实际是由多层文件系统联合组成。
-
-  镜像构建时，会一层层构建，前一层是后一层的基础。每一层构建完就不会再发生改变，后一层上的任何改变只发生在自己这一层。 比如，删除前一层文件的操作，实际不是真的删除前一层的文件，而是仅在当前层标记为该文件已删除。在最终容器运行的时候，虽然不会看到这个文件，但是实际上该文件会一直跟随镜像。因此，在构建镜像的时候，需要额外小心，每一层尽量只包含该层需要添加的东西，任何额外的东西应该在该层构建结束前清理掉。
-
-  分层存储的特征还使得镜像的复用、定制变的更为容易。甚至可以用之前构建好的镜像作为基础层，然后进一步添加新的层，以定制自己所需的内容，构建新的镜像。
-
-### 4.2 容器（Container)——镜像运行时的实体
-
-  镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的 类 和 实例 一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
-
-  容器的实质是进程，但与直接在宿主执行的进程不同，容器进程运行于属于自己的独立的 命名空间。前面讲过镜像使用的是分层存储，容器也是如此。
-
-  容器存储层的生存周期和容器一样，容器消亡时，容器存储层也随之消亡。因此，任何保存于容器存储层的信息都会随容器删除而丢失。
-
-  按照 Docker 最佳实践的要求，容器不应该向其存储层内写入任何数据 ，容器存储层要保持无状态化。所有的文件写入操作，都应该使用数据卷（Volume）、或者绑定宿主目录，在这些位置的读写会跳过容器存储层，直接对宿主(或网络存储)发生读写，其性能和稳定性更高。数据卷的生存周期独立于容器，容器消亡，数据卷不会消亡。因此， 使用数据卷后，容器可以随意删除、重新 run ，数据却不会丢失。
-
-### 4.3 仓库（Repository）——集中存放镜像文件的地方
-
-  镜像构建完成后，可以很容易的在当前宿主上运行，但是， 如果需要在其它服务器上使用这个镜像，我们就需要一个集中的存储、分发镜像的服务，Docker Registry就是这样的服务。
-
-  一个 Docker Registry中可以包含多个仓库（Repository）；每个仓库可以包含多个标签（Tag）；每个标签对应一个镜像。所以说：镜像仓库是Docker用来集中存放镜像文件的地方类似于我们之前常用的代码仓库。
-
-  通常，一个仓库会包含同一个软件不同版本的镜像，而标签就常用于对应该软件的各个版本 。我们可以通过`<仓库名>:<标签>`的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 latest 作为默认标签.。
-
-这里补充一下Docker Registry 公开服务和私有 Docker Registry的概念：
-
-  Docker Registry 公开服务 是开放给用户使用、允许用户管理镜像的 Registry 服务。一般这类公开服务允许用户免费上传、下载公开的镜像，并可能提供收费服务供用户管理私有镜像。
-
-  最常使用的 Registry 公开服务是官方的 Docker Hub ，这也是默认的 Registry，并拥有大量的高质量的官方镜像，网址为：[hub.docker.com/](https://link.juejin.im/?target=https%3A%2F%2Fhub.docker.com%2F) 。在国内访问Docker Hub 可能会比较慢国内也有一些云服务商提供类似于 Docker Hub 的公开服务。比如 [时速云镜像库](https://link.juejin.im/?target=https%3A%2F%2Fhub.tenxcloud.com%2F)、[网易云镜像服务](https://link.juejin.im/?target=https%3A%2F%2Fwww.163yun.com%2Fproduct%2Frepo)、[DaoCloud 镜像市场](https://link.juejin.im/?target=https%3A%2F%2Fwww.daocloud.io%2F)、[阿里云镜像库](https://link.juejin.im/?target=https%3A%2F%2Fwww.aliyun.com%2Fproduct%2Fcontainerservice%3Futm_content%3Dse_1292836)等。
-
-  除了使用公开服务外，用户还可以在 本地搭建私有 Docker Registry 。Docker 官方提供了 Docker Registry 镜像，可以直接使用做为私有 Registry 服务。开源的 Docker Registry 镜像只提供了 Docker Registry API 的服务端实现，足以支持 docker 命令，不影响使用。但不包含图形界面，以及镜像维护、用户管理、访问控制等高级功能。
-
-* * *
-
-> Docker的概念基本上已经讲完，最后我们谈谈：Build, Ship, and Run。
-
-## 五 最后谈谈：Build, Ship, and Run
-
-如果你搜索Docker官网，会发现如下的字样：“Docker - Build, Ship, and Run Any App, Anywhere”。那么Build, Ship, and Run到底是在干什么呢？
-
-![build ship run](https://user-gold-cdn.xitu.io/2018/6/18/16411c521e79bd82?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-*   Build（构建镜像） ： 镜像就像是集装箱包括文件以及运行环境等等资源。
-*   Ship（运输镜像） ：主机和仓库间运输，这里的仓库就像是超级码头一样。
-*   Run （运行镜像） ：运行的镜像就是一个容器，容器就是运行程序的地方。
-
-Docker 运行过程也就是去仓库把镜像拉到本地，然后用一条命令把镜像运行起来变成容器。所以，我们也常常将Docker称为码头工人或码头装卸工，这和Docker的中文翻译搬运工人如出一辙。
-
-## 六 总结
-
-本文主要把Docker中的一些常见概念做了详细的阐述，但是并不涉及Docker的安装、镜像的使用、容器的操作等内容。这部分东西，希望读者自己可以通过阅读书籍与官方文档的形式掌握。如果觉得官方文档阅读起来很费力的话，这里推荐一本书籍《Docker技术入门与实战第二版》。
-
diff --git "a/docs/cache/Redis\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265\346\200\273\347\273\223.md" "b/docs/cache/Redis\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265\346\200\273\347\273\223.md"
index 4a2131b..6c9a602 100644
--- "a/docs/cache/Redis\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265\346\200\273\347\273\223.md"
+++ "b/docs/cache/Redis\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265\346\200\273\347\273\223.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [使用和基础数据结构（外观）](#使用和基础数据结构（外观）)
   * [底层数据结构](#底层数据结构)
   * [redis server结构和数据库redisDb](#redis-server结构和数据库redisdb)
@@ -21,15 +20,8 @@
     * [个人公众号：黄小斜](#个人公众号：黄小斜)
 
 
----
-title: Redis原理与实践总结
-date: 2018-07-08 22:15:12
-tags:
-	- Redis
-categories:
-	- 后端
-	- 技术总结
----
+[toc]
+
 
 本文主要对Redis的设计和实现原理做了一个介绍很总结，有些东西我也介绍的不是很详细准确，尽量在自己的理解范围内把一些知识点和关键性技术做一个描述。如有错误，还望见谅，欢迎指出。
 这篇文章主要还是参考我之前的技术专栏总结而来的。欢迎查看：
@@ -84,11 +76,6 @@ REDIS_ZSET (有序集)是ZADD 、ZCOUNT 等命令的操作对象
 
 集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)
 
-下图说明了，外部数据结构和底层实际数据结构是通过realobject来连接的。一个外观类型里面必然存着一个realobject，通过它来访问底层数据结构。
-
-![image](https://user-gold-cdn.xitu.io/2017/9/17/2c71cff03efc96d2280d12602cc2aa92?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-
 ## 底层数据结构
 
 下面讨论redis底层数据结构
@@ -110,7 +97,7 @@ dict字典与Java中的哈希表实现简直如出一辙，首先都是数组+
 
 其中dict同时保存两个entry数组，当需要扩容时，把节点转移到第二个数组即可，平时只使用一个数组。
 
-![image](http://zhangtielei.com/assets/photos_redis/redis_dict_structure.png)
+![image](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/redis_dict_structure.png)
 
 3 压缩链表ziplist
 
@@ -140,7 +127,7 @@ quicklist的结构为什么这样设计呢？总结起来，大概又是一个
 
 但是，它不利于修改操作，每次数据变动都会引发一次内存的realloc。特别是当ziplist长度很长的时候，一次realloc可能会导致大批量的数据拷贝，进一步降低性能。
 
-![image](http://zhangtielei.com/assets/photos_redis/redis_quicklist_structure.png)
+![image](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/redis_quicklist_structure.png)
 
 5 zset
 zset其实是两种结构的合并。也就是dict和skiplist结合而成的。dict负责保存数据对分数的映射，而skiplist用于根据分数进行数据的查询（相辅相成）
@@ -158,9 +145,9 @@ sortedset是由skiplist，dict和ziplist组成的。
 
 set是由一个叫zset的数据结构来实现的，这个zset包含一个dict + 一个skiplist。dict用来查询数据到分数(score)的对应关系，而skiplist用来根据分数查询数据（可能是范围查找）。
 
- 在本系列前面关于ziplist的文章里，我们介绍过，ziplist就是由很多数据项组成的一大块连续内存。由于sorted set的每一项元素都由数据和score组成，因此，当使用zadd命令插入一个(数据, score)对的时候，底层在相应的ziplist上就插入两个数据项：数据在前，score在后。
+在本系列前面关于ziplist的文章里，我们介绍过，ziplist就是由很多数据项组成的一大块连续内存。由于sorted set的每一项元素都由数据和score组成，因此，当使用zadd命令插入一个(数据, score)对的时候，底层在相应的ziplist上就插入两个数据项：数据在前，score在后。
 
-![image](http://zhangtielei.com/assets/photos_redis/skiplist/redis_skiplist_example.png)
+![image](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/redis_skiplist_example.png)
 
 skiplist的节点中存着节点值和分数。并且跳表是根据节点的分数进行排序的，所以可以根据节点分数进行范围查找。
 
@@ -168,7 +155,7 @@ skiplist的节点中存着节点值和分数。并且跳表是根据节点的分
 
 inset是一个数字结合，他使用灵活的数据类型来保持数字。
 
-![image](http://zhangtielei.com/assets/photos_redis/intset/redis_intset_add_example.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230406202310.png)
 
 新创建的intset只有一个header，总共8个字节。其中encoding = 2, length = 0。
 添加13, 5两个元素之后，因为它们是比较小的整数，都能使用2个字节表示，所以encoding不变，值还是2。
@@ -200,14 +187,12 @@ hash表由dict实现
 
 集合由inset实现。
 
-![image](https://user-gold-cdn.xitu.io/2017/9/17/2c71cff03efc96d2280d12602cc2aa92?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
 
 ## redis server结构和数据库redisDb
 
 1 redis服务器中维护着一个数据库名为redisdb，实际上他是一个dict结构。
 
-Redis的数据库使用字典作为底层实现，数据库的增、删、查、改都是构建在字典的操作之上的。 
+Redis的数据库使用字典作为底层实现，数据库的增、删、查、改都是构建在字典的操作之上的。
 
 2 redis服务器将所有数据库都保存在服务器状态结构redisServer(redis.h/redisServer)的db数组（应该是一个链表）里：
 
@@ -232,18 +217,18 @@ Redis的数据库使用字典作为底层实现，数据库的增、删、查、
 大的dict数组中有多个小的dict字典，他们共同负责存储redisdb的所有键值对。
 
 同时，对应的expire字典则负责存储这些键的过期时间
-![image](https://img-blog.csdn.net/20180701224321524?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MjQ4ODg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230406201529.png)
 
 4 过期键的删除策略
 
 2、过期键删除策略
-通过前面的介绍，大家应该都知道数据库键的过期时间都保存在过期字典里，那假如一个键过期了，那么这个过期键是什么时候被删除的呢？现在来看看redis的过期键的删除策略： 
+通过前面的介绍，大家应该都知道数据库键的过期时间都保存在过期字典里，那假如一个键过期了，那么这个过期键是什么时候被删除的呢？现在来看看redis的过期键的删除策略：
 
-a、定时删除：在设置键的过期时间的同时，创建一个定时器，在定时结束的时候，将该键删除； 
+a、定时删除：在设置键的过期时间的同时，创建一个定时器，在定时结束的时候，将该键删除；
 
-b、惰性删除：放任键过期不管，在访问该键的时候，判断该键的过期时间是否已经到了，如果过期时间已经到了，就执行删除操作； 
+b、惰性删除：放任键过期不管，在访问该键的时候，判断该键的过期时间是否已经到了，如果过期时间已经到了，就执行删除操作；
 
-c、定期删除：每隔一段时间，对数据库中的键进行一次遍历，删除过期的键。 
+c、定期删除：每隔一段时间，对数据库中的键进行一次遍历，删除过期的键。
 
 ## redis的事件模型
 
@@ -275,7 +260,7 @@ redis处理请求的方式基于reactor线程模型，即一个线程处理连
 
 appendfsync同步频率的区别如下图：
 
-![这里写图片描述](https://img-blog.csdn.net/20170313210401173?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveGxnZW4xNTczODc=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230406201549.png)
 
 ## redis主从复制
 
@@ -297,7 +282,7 @@ master增量的把写命令发给slave。
 
 ### 使用setnx加expire实现加锁和时限
 
-  加锁时使用setnx设置key为1并设置超时时间，解锁时删除键
+加锁时使用setnx设置key为1并设置超时时间，解锁时删除键
 
     tryLock(){  
         SETNX Key 1
@@ -312,7 +297,8 @@ master增量的把写命令发给slave。
 ### 使用getset加锁和获取过期时间
 
 针对锁无法释放问题的一个解决方案基于GETSET命令来实现
-    
+
+
     思路：
     
     SETNX(Key,ExpireTime)获取锁
@@ -326,7 +312,8 @@ master增量的把写命令发给slave。
     注意：这个版本去掉了EXPIRE命令，改为通过Value时间戳值来判断过期
 
 
-​    
+
+
 ### 2.0的setnx可以配置过期时间。
 
     V2.0 基于SETNX
@@ -337,11 +324,10 @@ master增量的把写命令发给slave。
     release(){  
       DELETE Key
     }
-Redis 2.6.12版本后SETNX增加过期时间参数，这样就解决了两条命令无法保证原子性的问题。但是设想下面一个场景： 
-1. C1成功获取到了锁，之后C1因为GC进入等待或者未知原因导致任务执行过长，最后在锁失效前C1没有主动释放锁 2. C2在C1的锁超时后获取到锁，并且开始执行，这个时候C1和C2都同时在执行，会因重复执行造成数据不一致等未知情况 3. C1如果先执行完毕，则会释放C2的锁，此时可能导致另外一个C3进程获取到了锁
 
-流程图如下
-![2.](http://tech.dianwoda.com/content/images/2018/04/unsafe-lock.png)
+Redis 2.6.12版本后SETNX增加过期时间参数，这样就解决了两条命令无法保证原子性的问题。但是设想下面一个场景：
+
+1. C1成功获取到了锁，之后C1因为GC进入等待或者未知原因导致任务执行过长，最后在锁失效前C1没有主动释放锁 2. C2在C1的锁超时后获取到锁，并且开始执行，这个时候C1和C2都同时在执行，会因重复执行造成数据不一致等未知情况 3. C1如果先执行完毕，则会释放C2的锁，此时可能导致另外一个C3进程获取到了锁
 
 ### 使用sentx将值设为时间戳，通过lua脚本进行cas比较和删除操作
 
@@ -359,9 +345,10 @@ Redis 2.6.12版本后SETNX增加过期时间参数，这样就解决了两条命
           end
         )
     }
+
 这个方案通过指定Value为时间戳，并在释放锁的时候检查锁的Value是否为获取锁的Value，避免了V2.0版本中提到的C1释放了C2持有的锁的问题；另外在释放锁的时候因为涉及到多个Redis操作，并且考虑到Check And Set 模型的并发问题，所以使用Lua脚本来避免并发问题。
 
-  如果在并发极高的场景下，比如抢红包场景，可能存在UnixTimestamp重复问题，另外由于不能保证分布式环境下的物理时钟一致性，也可能存在UnixTimestamp重复问题，只不过极少情况下会遇到。
+如果在并发极高的场景下，比如抢红包场景，可能存在UnixTimestamp重复问题，另外由于不能保证分布式环境下的物理时钟一致性，也可能存在UnixTimestamp重复问题，只不过极少情况下会遇到。
 
 ### 分布式Redis锁：Redlock
 
@@ -370,13 +357,15 @@ redlock的思想就是要求一个节点获取集群中N/2 + 1个节点
 
 
 ### 总结
+
 不论是基于SETNX版本的Redis单实例分布式锁，还是Redlock分布式锁，都是为了保证下特性
 
-  1. 安全性：在同一时间不允许多个Client同时持有锁
-  2. 活性
+    1. 安全性：在同一时间不允许多个Client同时持有锁
+    2. 活性
 
     死锁：锁最终应该能够被释放，即使Client端crash或者出现网络分区（通常基于超时机制）
     容错性：只要超过半数Redis节点可用，锁都能被正确获取和释放
+
 ## 分布式方案
 
 1 主从复制，优点是备份简易使用。缺点是不能故障切换，并且不易扩展。
@@ -397,9 +386,7 @@ Redis cluster是一个去中心化、多实例Redis间进行数据共享的集
 
 每个节点上都保存着其他节点的信息，通过任一节点可以访问正常工作的节点数据，因为每台机器上的保留着完整的分片信息，某些机器不正常工作不影响整体集群的工作。并且每一台redis主机都会配备slave，通过sentinel自动切换。
 
-![image](http://7xivgs.com1.z0.glb.clouddn.com/codis02.png)
-
-## redis事务    
+## redis事务
 
 事务
 MULTI 、 EXEC 、 DISCARD 和 WATCH 是 Redis 事务相关的命令。事务可以一次执行多个命令， 并且带有以下两个重要的保证：
@@ -421,7 +408,8 @@ redis事务有一个特点，那就是在2.6以前，事务的一系列操作，
     因为不需要对回滚进行支持，所以 Redis 的内部可以保持简单且快速。
 
 
-​    
+
+
 ### redis脚本事务
 
 Redis 脚本和事务
@@ -443,32 +431,16 @@ redis事务的ACID特性
 
     事务具有一致性指的是,如果数据库在执行事务之前是一致的,那么在事务执行之后,无论事务是否执行成功,数据库也应该仍然一致的。
     ”一致“指的是数据符合数据库本身的定义和要求,没有包含非法或者无效的错误数据。redis通过谨慎的错误检测和简单的设计来保证事务一致性。
+
 ③隔离性
 
     事务的隔离性指的是,即使数据库中有多个事务并发在执行,各个事务之间也不会互相影响,并且在并发状态下执行的事务和串行执行的事务产生的结果完全
     相同。
     因为redis使用单线程的方式来执行事务(以及事务队列中的命令),并且服务器保证,在执行事务期间不会对事物进行中断,因此,redis的事务总是以串行
     的方式运行的,并且事务也总是具有隔离性的
+
 ④持久性
 
     事务的耐久性指的是,当一个事务执行完毕时,执行这个事务所得的结果已经被保持到永久存储介质里面。
     因为redis事务不过是简单的用队列包裹起来一组redis命令,redis并没有为事务提供任何额外的持久化功能,所以redis事务的耐久性由redis使用的模式
     决定
-
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26010\357\274\232Redis\347\232\204\344\272\213\344\273\266\351\251\261\345\212\250\346\250\241\345\236\213\344\270\216\345\221\275\344\273\244\346\211\247\350\241\214\350\277\207\347\250\213.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26010\357\274\232Redis\347\232\204\344\272\213\344\273\266\351\251\261\345\212\250\346\250\241\345\236\213\344\270\216\345\221\275\344\273\244\346\211\247\350\241\214\350\277\207\347\250\213.md"
deleted file mode 100644
index b7abc28..0000000
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26010\357\274\232Redis\347\232\204\344\272\213\344\273\266\351\251\261\345\212\250\346\250\241\345\236\213\344\270\216\345\221\275\344\273\244\346\211\247\350\241\214\350\277\207\347\250\213.md"
+++ /dev/null
@@ -1,302 +0,0 @@
-本文转自https://www.xilidou.com/2018/03/12/redis-data/
-作者：犀利豆
-本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从入门到进阶，Redis基本的使用方法，Redis的基本数据结构，以及一些进阶的使用方法，同时也需要进一步了解Redis的底层数据结构，再接着，还会带来Redis主从复制、集群、分布式锁等方面的相关内容，以及作为缓存的一些使用方法和注意事项，以便让你更完整地了解整个Redis相关的技术体系，形成自己的知识框架。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-原文地址：https://www.xilidou.com/2018/03/22/redis-event/
-
-Redis 是一个事件驱动的内存数据库，服务器需要处理两种类型的事件。
-
-文件事件
-时间事件
-下面就会介绍这两种事件的实现原理。
-
-文件事件
-Redis 服务器通过 socket 实现与客户端（或其他redis服务器）的交互,文件事件就是服务器对 socket 操作的抽象。 Redis 服务器，通过监听这些 socket 产生的文件事件并处理这些事件，实现对客户端调用的响应。
-
-Reactor
-Redis 基于 Reactor 模式开发了自己的事件处理器。
-
-这里就先展开讲一讲 Reactor 模式。看下图：
-![image](https://img.xilidou.com/img/Reactor.jpg)
-reactor
-
-“I/O 多路复用模块”会监听多个 FD ，当这些FD产生，accept，read，write 或 close 的文件事件。会向“文件事件分发器（dispatcher）”传送事件。
-
-文件事件分发器（dispatcher）在收到事件之后，会根据事件的类型将事件分发给对应的 handler。
-
-我们顺着图，从上到下的逐一讲解 Redis 是怎么实现这个 Reactor 模型的。
-
-I/O 多路复用模块
-Redis 的 I/O 多路复用模块，其实是封装了操作系统提供的 select，epoll，avport 和 kqueue 这些基础函数。向上层提供了一个统一的接口，屏蔽了底层实现的细节。
-
-一般而言 Redis 都是部署到 Linux 系统上，所以我们就看看使用 Redis 是怎么利用 linux 提供的 epoll 实现I/O 多路复用。
-
-首先看看 epoll 提供的三个方法：
-    
-    /*
-     * 创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大
-     */
-    int epoll_create(int size)；
-    
-    /*
-     * 可以理解为，增删改 fd 需要监听的事件
-     * epfd 是 epoll_create() 创建的句柄。
-     * op 表示 增删改
-     * epoll_event 表示需要监听的事件，Redis 只用到了可读，可写，错误，挂断 四个状态
-     */
-    int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
-    
-    /*
-     * 可以理解为查询符合条件的事件
-     * epfd 是 epoll_create() 创建的句柄。
-     * epoll_event 用来存放从内核得到事件的集合
-     * maxevents 获取的最大事件数
-     * timeout 等待超时时间
-     */
-    int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
-    再看 Redis 对文件事件，封装epoll向上提供的接口：
-    
-    
-    /*
-     * 事件状态
-     */
-    typedef struct aeApiState {
-    
-        // epoll_event 实例描述符
-        int epfd;
-    
-        // 事件槽
-        struct epoll_event *events;
-    
-    } aeApiState;
-    
-    /*
-     * 创建一个新的 epoll 
-     */
-    static int  aeApiCreate(aeEventLoop *eventLoop)
-    /*
-     * 调整事件槽的大小
-     */
-    static int  aeApiResize(aeEventLoop *eventLoop, int setsize)
-    /*
-     * 释放 epoll 实例和事件槽
-     */
-    static void aeApiFree(aeEventLoop *eventLoop)
-    /*
-     * 关联给定事件到 fd
-     */
-    static int  aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask)
-    /*
-     * 从 fd 中删除给定事件
-     */
-    static void aeApiDelEvent(aeEventLoop *eventLoop, int fd, int mask)
-    /*
-     * 获取可执行事件
-     */
-    static int  aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp)
-所以看看这个ae_peoll.c 如何对 epoll 进行封装的：
-
-aeApiCreate() 是对 epoll.epoll_create() 的封装。
-aeApiAddEvent()和aeApiDelEvent() 是对 epoll.epoll_ctl()的封装。
-aeApiPoll() 是对 epoll_wait()的封装。
-这样 Redis 的利用 epoll 实现的 I/O 复用器就比较清晰了。
-
-再往上一层次我们需要看看 ea.c 是怎么封装的？
-
-首先需要关注的是事件处理器的数据结构：
-
-
-    typedef struct aeFileEvent {
-    
-        // 监听事件类型掩码，
-        // 值可以是 AE_READABLE 或 AE_WRITABLE ，
-        // 或者 AE_READABLE | AE_WRITABLE
-        int mask; /* one of AE_(READABLE|WRITABLE) */
-    
-        // 读事件处理器
-        aeFileProc *rfileProc;
-    
-        // 写事件处理器
-        aeFileProc *wfileProc;
-    
-        // 多路复用库的私有数据
-        void *clientData;
-    
-    } aeFileEvent;
-mask 就是可以理解为事件的类型。
-
-除了使用 ae_peoll.c 提供的方法外,ae.c 还增加 “增删查” 的几个 API。
-
-增:aeCreateFileEvent
-删:aeDeleteFileEvent
-查: 查包括两个维度 aeGetFileEvents 获取某个 fd 的监听类型和aeWait等待某个fd 直到超时或者达到某个状态。
-事件分发器（dispatcher）
-Redis 的事件分发器 ae.c/aeProcessEvents 不但处理文件事件还处理时间事件，所以这里只贴与文件分发相关的出部分代码，dispather 根据 mask 调用不同的事件处理器。
-
-    //从 epoll 中获关注的事件
-    numevents = aeApiPoll(eventLoop, tvp);
-    for (j = 0; j < numevents; j++) {
-        // 从已就绪数组中获取事件
-        aeFileEvent *fe = &eventLoop->events[eventLoop->fired[j].fd];
-    
-        int mask = eventLoop->fired[j].mask;
-        int fd = eventLoop->fired[j].fd;
-        int rfired = 0;
-    
-        // 读事件
-        if (fe->mask & mask & AE_READABLE) {
-            // rfired 确保读/写事件只能执行其中一个
-            rfired = 1;
-            fe->rfileProc(eventLoop,fd,fe->clientData,mask);
-        }
-        // 写事件
-        if (fe->mask & mask & AE_WRITABLE) {
-            if (!rfired || fe->wfileProc != fe->rfileProc)
-                fe->wfileProc(eventLoop,fd,fe->clientData,mask);
-        }
-    
-        processed++;
-    }
-可以看到这个分发器，根据 mask 的不同将事件分别分发给了读事件和写事件。
-
-文件事件处理器的类型
-Redis 有大量的事件处理器类型，我们就讲解处理一个简单命令涉及到的三个处理器：
-
-acceptTcpHandler 连接应答处理器，负责处理连接相关的事件，当有client 连接到Redis的时候们就会产生 AE_READABLE 事件。引发它执行。
-readQueryFromClinet 命令请求处理器，负责读取通过 sokect 发送来的命令。
-sendReplyToClient 命令回复处理器，当Redis处理完命令，就会产生 AE_WRITEABLE 事件，将数据回复给 client。
-文件事件实现总结
-我们按照开始给出的 Reactor 模型，从上到下讲解了文件事件处理器的实现，下面将会介绍时间时间的实现。
-
-时间事件
-Reids 有很多操作需要在给定的时间点进行处理，时间事件就是对这类定时任务的抽象。
-
-先看时间事件的数据结构：
-
-    /* Time event structure
-     *
-     * 时间事件结构
-     */
-    typedef struct aeTimeEvent {
-    
-        // 时间事件的唯一标识符
-        long long id; /* time event identifier. */
-    
-        // 事件的到达时间
-        long when_sec; /* seconds */
-        long when_ms; /* milliseconds */
-    
-        // 事件处理函数
-        aeTimeProc *timeProc;
-    
-        // 事件释放函数
-        aeEventFinalizerProc *finalizerProc;
-    
-        // 多路复用库的私有数据
-        void *clientData;
-    
-        // 指向下个时间事件结构，形成链表
-        struct aeTimeEvent *next;
-    
-    } aeTimeEvent;
-看见 next 我们就知道这个 aeTimeEvent 是一个链表结构。看图：
-![image](https://img.xilidou.com/img/timeEvent.jpg)
-
-timeEvent
-
-注意这是一个按照id倒序排列的链表，并没有按照事件顺序排序。
-
-processTimeEvent
-Redis 使用这个函数处理所有的时间事件，我们整理一下执行思路：
-
-记录最新一次执行这个函数的时间，用于处理系统时间被修改产生的问题。
-遍历链表找出所有 when_sec 和 when_ms 小于现在时间的事件。
-执行事件对应的处理函数。
-检查事件类型，如果是周期事件则刷新该事件下一次的执行事件。
-否则从列表中删除事件。
-综合调度器（aeProcessEvents）
-综合调度器是 Redis 统一处理所有事件的地方。我们梳理一下这个函数的简单逻辑：
-
-    // 1. 获取离当前时间最近的时间事件
-    shortest = aeSearchNearestTimer(eventLoop);
-    
-    // 2. 获取间隔时间
-    timeval = shortest - nowTime;
-    
-    // 如果timeval 小于 0，说明已经有需要执行的时间事件了。
-    if(timeval < 0){
-        timeval = 0
-    }
-    
-    // 3. 在 timeval 时间内，取出文件事件。
-    numevents = aeApiPoll(eventLoop, timeval);
-    
-    // 4.根据文件事件的类型指定不同的文件处理器
-    if (AE_READABLE) {
-        // 读事件
-        rfileProc(eventLoop,fd,fe->clientData,mask);
-    }
-        // 写事件
-    if (AE_WRITABLE) {
-        wfileProc(eventLoop,fd,fe->clientData,mask);
-    }
-以上的伪代码就是整个 Redis 事件处理器的逻辑。
-
-我们可以再看看谁执行了这个 aeProcessEvents:
-
-
-    void aeMain(aeEventLoop *eventLoop) {
-    
-        eventLoop->stop = 0;
-    
-        while (!eventLoop->stop) {
-    
-            // 如果有需要在事件处理前执行的函数，那么运行它
-            if (eventLoop->beforesleep != NULL)
-                eventLoop->beforesleep(eventLoop);
-    
-            // 开始处理事件
-            aeProcessEvents(eventLoop, AE_ALL_EVENTS);
-        }
-    }
-然后我们再看看是谁调用了 eaMain:
-
-    int main(int argc, char **argv) {
-        //一些配置和准备
-        ...
-        aeMain(server.el);
-        
-        //结束后的回收工作
-        ...
-    }
-我们在 Redis 的 main 方法中找个了它。
-
-这个时候我们整理出的思路就是:
-
-Redis 的 main() 方法执行了一些配置和准备以后就调用 eaMain() 方法。
-
-eaMain() while(true) 的调用 aeProcessEvents()。
-
-所以我们说 Redis 是一个事件驱动的程序，期间我们发现，Redis 没有 fork 过任何线程。所以也可以说 Redis 是一个基于事件驱动的单线程应用。
-
-总结
-在后端的面试中 Redis 总是一个或多或少会问到的问题。
-
-读完这篇文章你也许就能回答这几个问题：
-
-为什么 Redis 是一个单线程应用？
-为什么 Redis 是一个单线程应用，却有如此高的性能？
-如果你用本文提供的知识点回答这两个问题，一定会在面试官心中留下一个高大的形象。
-
-大家还可以阅读我的 Redis 相关的文章：
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\345\274\200\347\257\207\357\274\232\344\273\200\344\271\210\346\230\257Redis.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\345\274\200\347\257\207\357\274\232\344\273\200\344\271\210\346\230\257Redis.md"
index 4f58639..51ba773 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\345\274\200\347\257\207\357\274\232\344\273\200\344\271\210\346\230\257Redis.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\345\274\200\347\257\207\357\274\232\344\273\200\344\271\210\346\230\257Redis.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [redis 学习笔记](#redis-学习笔记)
     * [redis 是什么?](#redis-是什么)
@@ -10,6 +10,8 @@
   * [天下无难试之Redis面试刁难大全](#天下无难试之redis面试刁难大全)
 
 
+[toc]
+
 本文转自互联网
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2601\357\274\232Redis \347\232\204\345\237\272\347\241\200\346\225\260\346\215\256\347\273\223\346\236\204\346\246\202\350\247\210.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis \347\232\204\345\237\272\347\241\200\346\225\260\346\215\256\347\273\223\346\236\204\346\246\202\350\247\210.md"
similarity index 56%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2601\357\274\232Redis \347\232\204\345\237\272\347\241\200\346\225\260\346\215\256\347\273\223\346\236\204\346\246\202\350\247\210.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis \347\232\204\345\237\272\347\241\200\346\225\260\346\215\256\347\273\223\346\236\204\346\246\202\350\247\210.md"
index 6b59545..9d78bed 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2601\357\274\232Redis \347\232\204\345\237\272\347\241\200\346\225\260\346\215\256\347\273\223\346\236\204\346\246\202\350\247\210.md"	
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis \347\232\204\345\237\272\347\241\200\346\225\260\346\215\256\347\273\223\346\236\204\346\246\202\350\247\210.md"	
@@ -1,10 +1,14 @@
-# Table of Contents
+# 目录
 
-* [[](https://www.xilidou.com/2018/03/12/redis-data/#SDS "SDS")SDS](#[]httpswwwxilidoucom20180312redis-datasds-sdssds)
-* [[](https://www.xilidou.com/2018/03/12/redis-data/#%E9%93%BE%E8%A1%A8 "链表")链表](#[]httpswwwxilidoucom20180312redis-datae993bee8a1a8-链表链表)
-* [[](https://www.xilidou.com/2018/03/12/redis-data/#%E5%AD%97%E5%85%B8 "字典")字典](#[]httpswwwxilidoucom20180312redis-datae5ad97e585b8-字典字典)
+  * [SDS](#sds)
+  * [链表](#链表)
+  * [字典](#字典)
+
+
+[toc]
+
+本文转自https://www.xilidou.com/2018/03/22/redis-event/  
 
-本文转自https://www.xilidou.com/2018/03/22/redis-event/
 作者：犀利豆
 
 本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -18,7 +22,7 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 
 
 这周开始学习 Redis，看看Redis是怎么实现的。所以会写一系列关于 Redis的文章。这篇文章关于 Redis 的基础数据。阅读这篇文章你可以了解：
@@ -31,84 +35,67 @@
 
 
 
-# [](https://www.xilidou.com/2018/03/12/redis-data/#SDS "SDS")SDS
+## SDS
 
 SDS （Simple Dynamic String）是 Redis 最基础的数据结构。直译过来就是”简单的动态字符串“。Redis 自己实现了一个动态的字符串，而不是直接使用了 C 语言中的字符串。
 
 sds 的数据结构：
 
+````
+    struct sdshdr {// buf 中已占用空间的长度 int len;// buf 中剩余可用空间的长度 int free;// 数据空间   
+    char buf[];  
+            }  
 
-    struct sdshdr {   
-    // buf 中已占用空间的长度 int len; 
-    // buf 中剩余可用空间的长度 int free; 
-    // 数据空间 
-    char buf[];
-        
-    }
-
-
+````
 
 所以一个 SDS 的就如下图：
 
-![sds](https://img.xilidou.com/img/2019-04-25-022158.jpg)
+![sds](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2019-04-25-022158.jpg)
 
 所以我们看到，sds 包含3个参数。buf 的长度 len，buf 的剩余长度，以及buf。
 
 为什么这么设计呢？
 
-*   可以直接获取字符串长度。
+*   可以直接获取字符串长度。  
     C 语言中，获取字符串的长度需要用指针遍历字符串，时间复杂度为 O(n)，而 SDS 的长度，直接从len 获取复杂度为 O(1)。
 
-*   杜绝缓冲区溢出。
+*   杜绝缓冲区溢出。  
     由于C 语言不记录字符串长度，如果增加一个字符传的长度，如果没有注意就可能溢出，覆盖了紧挨着这个字符的数据。对于SDS 而言增加字符串长度需要验证 free的长度，如果free 不够就会扩容整个 buf，防止溢出。
 
-*   减少修改字符串长度时造成的内存再次分配。
+*   减少修改字符串长度时造成的内存再次分配。  
     redis 作为高性能的内存数据库，需要较高的相应速度。字符串也很大概率的频繁修改。 SDS 通过未使用空间这个参数，将字符串的长度和底层buf的长度之间的额关系解除了。buf的长度也不是字符串的长度。基于这个分设计 SDS 实现了空间的预分配和惰性释放。
 
-    1.  预分配
-        如果对 SDS 修改后，如果 len 小于 1MB 那 len = 2 * len + 1byte。 这个 1 是用于保存空字节。
+    1.  预分配  
+        如果对 SDS 修改后，如果 len 小于 1MB 那 len = 2 * len + 1byte。 这个 1 是用于保存空字节。  
         如果 SDS 修改后 len 大于 1MB 那么 len = 1MB + len + 1byte。
-    2.  惰性释放
+    2.  惰性释放  
         如果缩短 SDS 的字符串长度，redis并不是马上减少 SDS 所占内存。只是增加 free 的长度。同时向外提供 API 。真正需要释放的时候，才去重新缩小 SDS 所占的内存
-*   二进制安全。
+*   二进制安全。  
     C 语言中的字符串是以 ”\0“ 作为字符串的结束标记。而 SDS 是使用 len 的长度来标记字符串的结束。所以SDS 可以存储字符串之外的任意二进制流。因为有可能有的二进制流在流中就包含了”\0“造成字符串提前结束。也就是说 SDS 不依赖 “\0” 作为结束的依据。
 
-*   兼容C语言
+*   兼容C语言  
     SDS 按照惯例使用 ”\0“ 作为结尾的管理。部分普通C 语言的字符串 API 也可以使用。
 
-# [](https://www.xilidou.com/2018/03/12/redis-data/#%E9%93%BE%E8%A1%A8 "链表")链表
+## 链表
 
 C语言中并没有链表这个数据结构所以 Redis 自己实现了一个。Redis 中的链表是：
-
-    typedef struct listNode { 
-    // 前置节点 struct listNode *prev; 
-    // 后置节点 struct listNode *next; 
-    // 节点的值 void *value;} listNode;
-
-
+````
+    typedef struct listNode {// 前置节点 struct listNode *prev;// 后置节点 struct listNode *next;// 节点的值 void *value;} listNode;  
+````
 非常典型的双向链表的数据结构。
 
 同时为双向链表提供了如下操作的函数：
-
-
-    /* * 双端链表迭代器 */typedef struct listIter { 
-    // 当前迭代到的节点 listNode *next; 
-    // 迭代的方向 int direction;} listIter;
-    
-    /* * 双端链表结构 
-    
-    */typedef struct list { 
-    // 表头节点 listNode *head; 
-    // 表尾节点 listNode *tail; 
-    // 节点值复制函数 void *(*dup)(void *ptr); 
-    // 节点值释放函数 void (*free)(void *ptr); 
-    // 节点值对比函数 int (*match)(void *ptr, void *key); 
-    // 链表所包含的节点数量 unsigned long len;} list;
-
-
+````
+
+    /* * 双端链表迭代器 */typedef struct listIter {// 当前迭代到的节点 listNode *next;// 迭代的方向 int direction;} listIter;    /* * 双端链表结构   
+      
+    */typedef struct list {   
+// 表头节点 listNode *head;// 表尾节点 listNode *tail;// 节点值复制函数 void *(*dup)(void *ptr);// 节点值释放函数 void (*free)(void *ptr);// 节点值对比函数 int (*match)(void *ptr, void *key);// 链表所包含的节点数量 unsigned long len;
+} list;
+````
 链表的结构比较简单，数据结构如下：
 
-![list](https://img.xilidou.com/img/2019-04-25-22159.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2019-04-25-22159.jpg)
 
 总结一下性质：
 
@@ -116,130 +103,85 @@ C语言中并没有链表这个数据结构所以 Redis 自己实现了一个。
 *   list 记录了 head 和 tail，寻找 head 和 tail 的时间复杂度为 O(1)。
 *   获取链表的长度 len 时间复杂度 O(1)。
 
-# [](https://www.xilidou.com/2018/03/12/redis-data/#%E5%AD%97%E5%85%B8 "字典")字典
+## 字典
 
 字典数据结构极其类似 java 中的 Hashmap。
 
 Redis的字典由三个基础的数据结构组成。最底层的单位是哈希表节点。结构如下：
-
-    typedef struct dictEntry {
-        
-        // 键
-        void *key;
-    
-        // 值
-        union {
-            void *val;
-            uint64_t u64;
-            int64_t s64;
-        } v;
-    
-        // 指向下个哈希表节点，形成链表
-        struct dictEntry *next;
-    
-    } dictEntry;
-
-实际上哈希表节点就是一个单项列表的节点。保存了一下下一个节点的指针。 key 就是节点的键，v是这个节点的值。这个 v 既可以是一个指针，也可以是一个 `uint64_t`或者 `int64_t` 整数。*next 指向下一个节点。
-
-通过一个哈希表的数组把各个节点链接起来：
-    typedef struct dictht {
-        
-        // 哈希表数组
-        dictEntry **table;
-    
-        // 哈希表大小
-        unsigned long size;
-        
-        // 哈希表大小掩码，用于计算索引值
-        // 总是等于 size - 1
-        unsigned long sizemask;
-    
-        // 该哈希表已有节点的数量
-        unsigned long used;
-    
-    } dictht;
-dictht
-
+````
+    typedef struct dictEntry {        // 键  
+        void *key;    // 值  
+        union {            void *val;            uint64_t u64;            int64_t s64;        } v;    // 指向下个哈希表节点，形成链表  
+        struct dictEntry *next;        } dictEntry;  
+````
+实际上哈希表节点就是一个单项列表的节点。保存了一下下一个节点的指针。 key 就是节点的键，v是这个节点的值。这个 v 既可以是一个指针，也可以是一个`uint64_t`或者`int64_t`整数。*next 指向下一个节点。
+
+通过一个哈希表的数组把各个节点链接起来：  
+````
+typedef struct dictht {
+
+        // 哈希表数组  
+        dictEntry **table;    // 哈希表大小  
+        unsigned long size;        // 哈希表大小掩码，用于计算索引值  
+        // 总是等于 size - 1        unsigned long sizemask;    // 该哈希表已有节点的数量  
+        unsigned long used;        
+}
+````
 通过图示我们观察：
 
-![dictht.png](https://img.xilidou.com/img/2019-04-25-022159.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2019-04-25-022159.jpg)
 
 实际上，如果对java 的基本数据结构了解的同学就会发现，这个数据结构和 java 中的 HashMap 是很类似的，就是数组加链表的结构。
 
 字典的数据结构：
-
-    typedef struct dict {
-    
-        // 类型特定函数
-        dictType *type;
-    
-        // 私有数据
-        void *privdata;
-    
-        // 哈希表
-        dictht ht[2];
-    
-        // rehash 索引
-        // 当 rehash 不在进行时，值为 -1
-        int rehashidx; /* rehashing not in progress if rehashidx == -1 */
-    
-        // 目前正在运行的安全迭代器的数量
-        int iterators; /* number of iterators currently running */
-    
-    } dict;
-
+````
+    typedef struct dict {    // 类型特定函数  
+        dictType *type;    // 私有数据  
+        void *privdata;    // 哈希表  
+        dictht ht[2];    // rehash 索引  
+        // 当 rehash 不在进行时，值为 -1        int rehashidx; /* rehashing not in progress if rehashidx == -1 */    // 目前正在运行的安全迭代器的数量  
+        int iterators; /* number of iterators currently running */        } dict;  
+````
 其中的dictType 是一组方法，代码如下：
 
-<figure>
-
-    /*
-     * 字典类型特定函数
-     */
-    typedef struct dictType {
-    
-        // 计算哈希值的函数
-        unsigned int (*hashFunction)(const void *key);
-    
-        // 复制键的函数
-        void *(*keyDup)(void *privdata, const void *key);
-    
-        // 复制值的函数
-        void *(*valDup)(void *privdata, const void *obj);
-    
-        // 对比键的函数
-        int (*keyCompare)(void *privdata, const void *key1, const void *key2);
-    
-        // 销毁键的函数
-        void (*keyDestructor)(void *privdata, void *key);
-        
-        // 销毁值的函数
-        void (*valDestructor)(void *privdata, void *obj);
-    
-    } dictType;
-
+````
+
+/*     
+ * 字典类型特定函数  
+ */    
+typedef struct dictType {    // 计算哈希值的函数  
+    unsigned int (*hashFunction)(const void *key);    // 复制键的函数  
+    void *(*keyDup)(void *privdata, const void *key);    // 复制值的函数  
+    void *(*valDup)(void *privdata, const void *obj);    // 对比键的函数  
+    int (*keyCompare)(void *privdata, const void *key1, const void *key2);    // 销毁键的函数  
+    void (*keyDestructor)(void *privdata, void *key);        // 销毁值的函数  
+    void (*valDestructor)(void *privdata, void *obj);       
+   
+} 
+````
 字典的数据结构如下图：
 
-![dict](https://img.xilidou.com/img/2019-04-25-022200.jpg)
+![dict](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2019-04-25-022200.jpg)
 
-这里我们可以看到一个dict 拥有两个 dictht。一般来说只使用 ht[0],当扩容的时候发生了rehash的时候，ht[1]才会被使用。
+这里我们可以看到一个dict 拥有两个 dictht。一般来说只使用 ht[0],当扩容的时候发生了rehash的时候，ht[1]才会被使用。
 
 当我们观察或者研究一个hash结构的时候偶我们首先要考虑的这个 dict 如何插入一个数据？
 
 我们梳理一下插入数据的逻辑。
 
-*   计算Key 的 hash 值。找到 hash 映射到 table 数组的位置。
+*   计算Key 的 hash 值。找到 hash 映射到 table 数组的位置。
 
-*   如果数据已经有一个 key 存在了。那就意味着发生了 hash 碰撞。新加入的节点，就会作为链表的一个节点接到之前节点的 next 指针上。
+*   如果数据已经有一个 key 存在了。那就意味着发生了 hash 碰撞。新加入的节点，就会作为链表的一个节点接到之前节点的 next 指针上。
 
-*   如果 key 发生了多次碰撞，造成链表的长度越来越长。会使得字典的查询速度下降。为了维持正常的负载。Redis 会对 字典进行 rehash 操作。来增加 table 数组的长度。所以我们要着重了解一下 Redis 的 rehash。步骤如下：
+*   如果 key 发生了多次碰撞，造成链表的长度越来越长。会使得字典的查询速度下降。为了维持正常的负载。Redis 会对 字典进行 rehash 操作。来增加 table 数组的长度。所以我们要着重了解一下 Redis 的 rehash。步骤如下：
 
-    1.  根据ht[0] 的数据和操作的类型（扩大或缩小），分配 ht[1] 的大小。
+    1.  根据ht[0] 的数据和操作的类型（扩大或缩小），分配 ht[1] 的大小。
     2.  将 ht[0] 的数据 rehash 到 ht[1] 上。
     3.  rehash 完成以后，将ht[1] 设置为 ht[0]，生成一个新的ht[1]备用。
-*   渐进式的 rehash 。
+*   渐进式的 rehash 。  
     其实如果字典的 key 数量很大，达到千万级以上，rehash 就会是一个相对较长的时间。所以为了字典能够在 rehash 的时候能够继续提供服务。Redis 提供了一个渐进式的 rehash 实现，rehash的步骤如下：
 
-    1.  分配 ht[1] 的空间，让字典同时持有 ht[1] 和 ht[0]。
+    1.  分配 ht[1] 的空间，让字典同时持有 ht[1] 和 ht[0]。
     2.  在字典中维护一个 rehashidx，设置为 0 ，表示字典正在 rehash。
     3.  在rehash期间，每次对字典的操作除了进行指定的操作以外，都会根据 ht[0] 在 rehashidx 上对应的键值对 rehash 到 ht[1]上。
     4.  随着操作进行， ht[0] 的数据就会全部 rehash 到 ht[1] 。设置ht[0] 的 rehashidx 为 -1，渐进的 rehash 结束。
@@ -247,4 +189,3 @@ dictht
 这样保证数据能够平滑的进行 rehash。防止 rehash 时间过久阻塞线程。
 
 *   在进行 rehash 的过程中，如果进行了 delete 和 update 等操作，会在两个哈希表上进行。如果是 find 的话优先在ht[0] 上进行，如果没有找到，再去 ht[1] 中查找。如果是 insert 的话那就只会在 ht[1]中插入数据。这样就会保证了 ht[1] 的数据只增不减，ht[0]的数据只减不增。
-
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26014\357\274\232Redis\344\272\213\345\212\241\346\265\205\346\236\220\344\270\216ACID\347\211\271\346\200\247\344\273\213\347\273\215.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\344\272\213\345\212\241\346\265\205\346\236\220\344\270\216ACID\347\211\271\346\200\247\344\273\213\347\273\215.md"
similarity index 62%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26014\357\274\232Redis\344\272\213\345\212\241\346\265\205\346\236\220\344\270\216ACID\347\211\271\346\200\247\344\273\213\347\273\215.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\344\272\213\345\212\241\346\265\205\346\236\220\344\270\216ACID\347\211\271\346\200\247\344\273\213\347\273\215.md"
index a24f1b9..f9aef55 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26014\357\274\232Redis\344\272\213\345\212\241\346\265\205\346\236\220\344\270\216ACID\347\211\271\346\200\247\344\273\213\347\273\215.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\344\272\213\345\212\241\346\265\205\346\236\220\344\270\216ACID\347\211\271\346\200\247\344\273\213\347\273\215.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
 * [事务](#事务)
   * [用法](#用法)
@@ -6,12 +6,13 @@
   * [为什么 Redis 不支持回滚（roll back）](#为什么-redis-不支持回滚（roll-back）)
   * [放弃事务](#放弃事务)
   * [使用 check-and-set 操作实现乐观锁](#使用-check-and-set-操作实现乐观锁)
-  * [了解 `WATCH`](#了解 `watch`)
+  * [了解`WATCH`](#了解`watch`)
     * [使用 WATCH 实现 ZPOP](#使用-watch-实现-zpop)
   * [Redis 脚本和事务](#redis-脚本和事务)
 * [redis事务的ACID特性](#redis事务的acid特性)
 
 
+[toc]
 
 本文转自互联网
 本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -28,28 +29,18 @@
 <!-- more -->
 
 
-
-
-
-
-
-
-
-
-
-
 # 事务
 
-[MULTI](http://www.redis.cn/commands/multi.html) 、 [EXEC](http://www.redis.cn/commands/exec.html) 、 [DISCARD](http://www.redis.cn/commands/discard.html) 和 [WATCH](http://www.redis.cn/commands/watch.html) 是 Redis 事务相关的命令。事务可以一次执行多个命令， 并且带有以下两个重要的保证：
+[MULTI](http://www.redis.cn/commands/multi.html)、[EXEC](http://www.redis.cn/commands/exec.html)、[DISCARD](http://www.redis.cn/commands/discard.html)和[WATCH](http://www.redis.cn/commands/watch.html)是 Redis 事务相关的命令。事务可以一次执行多个命令， 并且带有以下两个重要的保证：
 
 *   事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
 
 *   事务是一个原子操作：事务中的命令要么全部被执行，要么全部都不执行。
 
-[EXEC](http://www.redis.cn/commands/exec.html) 命令负责触发并执行事务中的所有命令：
+[EXEC](http://www.redis.cn/commands/exec.html)命令负责触发并执行事务中的所有命令：
 
-*   如果客户端在使用 [MULTI](http://www.redis.cn/commands/multi.html) 开启了一个事务之后，却因为断线而没有成功执行 [EXEC](http://www.redis.cn/commands/exec.html) ，那么事务中的所有命令都不会被执行。
-*   另一方面，如果客户端成功在开启事务之后执行 [EXEC](http://www.redis.cn/commands/exec.html) ，那么事务中的所有命令都会被执行。
+*   如果客户端在使用[MULTI](http://www.redis.cn/commands/multi.html)开启了一个事务之后，却因为断线而没有成功执行[EXEC](http://www.redis.cn/commands/exec.html)，那么事务中的所有命令都不会被执行。
+*   另一方面，如果客户端成功在开启事务之后执行[EXEC](http://www.redis.cn/commands/exec.html)，那么事务中的所有命令都会被执行。
 
 当使用 AOF 方式做持久化的时候， Redis 会使用单个 write(2) 命令将事务写入到磁盘中。
 
@@ -63,11 +54,11 @@
 
 ## 用法
 
-[MULTI](http://www.redis.cn/commands/multi.html) 命令用于开启一个事务，它总是返回 `OK` 。 [MULTI](http://www.redis.cn/commands/multi.html) 执行之后， 客户端可以继续向服务器发送任意多条命令， 这些命令不会立即被执行， 而是被放到一个队列中， 当 [EXEC](http://www.redis.cn/commands/exec.html)命令被调用时， 所有队列中的命令才会被执行。
+[MULTI](http://www.redis.cn/commands/multi.html)命令用于开启一个事务，它总是返回`OK`。[MULTI](http://www.redis.cn/commands/multi.html)执行之后， 客户端可以继续向服务器发送任意多条命令， 这些命令不会立即被执行， 而是被放到一个队列中， 当[EXEC](http://www.redis.cn/commands/exec.html)命令被调用时， 所有队列中的命令才会被执行。
 
-另一方面， 通过调用 [DISCARD](http://www.redis.cn/commands/discard.html) ， 客户端可以清空事务队列， 并放弃执行事务。
+另一方面， 通过调用[DISCARD](http://www.redis.cn/commands/discard.html)， 客户端可以清空事务队列， 并放弃执行事务。
 
-以下是一个事务例子， 它原子地增加了 `foo` 和 `bar` 两个键的值：
+以下是一个事务例子， 它原子地增加了`foo`和`bar`两个键的值：
 
 
 
@@ -77,26 +68,26 @@
 
 
 
-[EXEC](http://www.redis.cn/commands/exec.html) 命令的回复是一个数组， 数组中的每个元素都是执行事务中的命令所产生的回复。 其中， 回复元素的先后顺序和命令发送的先后顺序一致。
+[EXEC](http://www.redis.cn/commands/exec.html)命令的回复是一个数组， 数组中的每个元素都是执行事务中的命令所产生的回复。 其中， 回复元素的先后顺序和命令发送的先后顺序一致。
 
-当客户端处于事务状态时， 所有传入的命令都会返回一个内容为 `QUEUED` 的状态回复（status reply）， 这些被入队的命令将在 EXEC 命令被调用时执行。
+当客户端处于事务状态时， 所有传入的命令都会返回一个内容为`QUEUED`的状态回复（status reply）， 这些被入队的命令将在 EXEC 命令被调用时执行。
 
 ## 事务中的错误
 
 使用事务时可能会遇上以下两种错误：
 
-*   事务在执行 [EXEC](http://www.redis.cn/commands/exec.html) 之前，入队的命令可能会出错。比如说，命令可能会产生语法错误（参数数量错误，参数名错误，等等），或者其他更严重的错误，比如内存不足（如果服务器使用 `maxmemory` 设置了最大内存限制的话）。
-*   命令可能在 [EXEC](http://www.redis.cn/commands/exec.html) 调用之后失败。举个例子，事务中的命令可能处理了错误类型的键，比如将列表命令用在了字符串键上面，诸如此类。
+*   事务在执行[EXEC](http://www.redis.cn/commands/exec.html)之前，入队的命令可能会出错。比如说，命令可能会产生语法错误（参数数量错误，参数名错误，等等），或者其他更严重的错误，比如内存不足（如果服务器使用`maxmemory`设置了最大内存限制的话）。
+*   命令可能在[EXEC](http://www.redis.cn/commands/exec.html)调用之后失败。举个例子，事务中的命令可能处理了错误类型的键，比如将列表命令用在了字符串键上面，诸如此类。
 
-对于发生在 [EXEC](http://www.redis.cn/commands/exec.html) 执行之前的错误，客户端以前的做法是检查命令入队所得的返回值：如果命令入队时返回 `QUEUED` ，那么入队成功；否则，就是入队失败。如果有命令在入队时失败，那么大部分客户端都会停止并取消这个事务。
+对于发生在[EXEC](http://www.redis.cn/commands/exec.html)执行之前的错误，客户端以前的做法是检查命令入队所得的返回值：如果命令入队时返回`QUEUED`，那么入队成功；否则，就是入队失败。如果有命令在入队时失败，那么大部分客户端都会停止并取消这个事务。
 
-不过，从 Redis 2.6.5 开始，服务器会对命令入队失败的情况进行记录，并在客户端调用 [EXEC](http://www.redis.cn/commands/exec.html) 命令时，拒绝执行并自动放弃这个事务。
+不过，从 Redis 2.6.5 开始，服务器会对命令入队失败的情况进行记录，并在客户端调用[EXEC](http://www.redis.cn/commands/exec.html)命令时，拒绝执行并自动放弃这个事务。
 
 在 Redis 2.6.5 以前， Redis 只执行事务中那些入队成功的命令，而忽略那些入队失败的命令。 而新的处理方式则使得在流水线（pipeline）中包含事务变得简单，因为发送事务和读取事务的回复都只需要和服务器进行一次通讯。
 
-至于那些在 [EXEC](http://www.redis.cn/commands/exec.html) 命令执行之后所产生的错误， 并没有对它们进行特别处理： 即使事务中有某个/某些命令在执行时产生了错误， 事务中的其他命令仍然会继续执行。
+至于那些在[EXEC](http://www.redis.cn/commands/exec.html)命令执行之后所产生的错误， 并没有对它们进行特别处理： 即使事务中有某个/某些命令在执行时产生了错误， 事务中的其他命令仍然会继续执行。
 
-从协议的角度来看这个问题，会更容易理解一些。 以下例子中， [LPOP](http://www.redis.cn/commands/lpop.html) 命令的执行将出错， 尽管调用它的语法是正确的：
+从协议的角度来看这个问题，会更容易理解一些。 以下例子中，[LPOP](http://www.redis.cn/commands/lpop.html)命令的执行将出错， 尽管调用它的语法是正确的：
 
 
 
@@ -106,7 +97,7 @@ Trying 127.0.0.1...Connected to localhost.Escape character is '^]'.MULTI+OKSET a
 
 
 
-[EXEC](http://www.redis.cn/commands/exec.html) 返回两条[bulk-string-reply](http://www.redis.cn/topics/protocol.html#bulk-string-reply)： 第一条是 `OK` ，而第二条是 `-ERR` 。 至于怎样用合适的方法来表示事务中的错误， 则是由客户端自己决定的。
+[EXEC](http://www.redis.cn/commands/exec.html)返回两条[bulk-string-reply](http://www.redis.cn/topics/protocol.html#bulk-string-reply)： 第一条是`OK`，而第二条是`-ERR`。 至于怎样用合适的方法来表示事务中的错误， 则是由客户端自己决定的。
 
 最重要的是记住这样一条， 即使事务中有某条/某些命令执行失败了， 事务队列中的其他命令仍然会继续执行 —— Redis 不会停止执行事务中的命令。
 
@@ -120,7 +111,7 @@ MULTI+OKINCR a b c-ERR wrong number of arguments for 'incr' command
 
 
 
-因为调用 [INCR](http://www.redis.cn/commands/incr.html) 命令的参数格式不正确， 所以这个 [INCR](http://www.redis.cn/commands/incr.html) 命令入队失败。
+因为调用[INCR](http://www.redis.cn/commands/incr.html)命令的参数格式不正确， 所以这个[INCR](http://www.redis.cn/commands/incr.html)命令入队失败。
 
 ## 为什么 Redis 不支持回滚（roll back）
 
@@ -131,11 +122,11 @@ MULTI+OKINCR a b c-ERR wrong number of arguments for 'incr' command
 *   Redis 命令只会因为错误的语法而失败（并且这些问题不能在入队时发现），或是命令用在了错误类型的键上面：这也就是说，从实用性的角度来说，失败的命令是由编程错误造成的，而这些错误应该在开发的过程中被发现，而不应该出现在生产环境中。
 *   因为不需要对回滚进行支持，所以 Redis 的内部可以保持简单且快速。
 
-有种观点认为 Redis 处理事务的做法会产生 bug ， 然而需要注意的是， 在通常情况下， 回滚并不能解决编程错误带来的问题。 举个例子， 如果你本来想通过 [INCR](http://www.redis.cn/commands/incr.html) 命令将键的值加上 1 ， 却不小心加上了 2 ， 又或者对错误类型的键执行了 [INCR](http://www.redis.cn/commands/incr.html)， 回滚是没有办法处理这些情况的。
+有种观点认为 Redis 处理事务的做法会产生 bug ， 然而需要注意的是， 在通常情况下， 回滚并不能解决编程错误带来的问题。 举个例子， 如果你本来想通过[INCR](http://www.redis.cn/commands/incr.html)命令将键的值加上 1 ， 却不小心加上了 2 ， 又或者对错误类型的键执行了[INCR](http://www.redis.cn/commands/incr.html)， 回滚是没有办法处理这些情况的。
 
 ## 放弃事务
 
-当执行 [DISCARD](http://www.redis.cn/commands/discard.html) 命令时， 事务会被放弃， 事务队列会被清空， 并且客户端会从事务状态中退出：
+当执行[DISCARD](http://www.redis.cn/commands/discard.html)命令时， 事务会被放弃， 事务队列会被清空， 并且客户端会从事务状态中退出：
 
 
 
@@ -147,11 +138,11 @@ MULTI+OKINCR a b c-ERR wrong number of arguments for 'incr' command
 
 ## 使用 check-and-set 操作实现乐观锁
 
-[WATCH](http://www.redis.cn/commands/watch.html) 命令可以为 Redis 事务提供 check-and-set （CAS）行为。
+[WATCH](http://www.redis.cn/commands/watch.html)命令可以为 Redis 事务提供 check-and-set （CAS）行为。
 
-被 [WATCH](http://www.redis.cn/commands/watch.html) 的键会被监视，并会发觉这些键是否被改动过了。 如果有至少一个被监视的键在 [EXEC](http://www.redis.cn/commands/exec.html) 执行之前被修改了， 那么整个事务都会被取消， [EXEC](http://www.redis.cn/commands/exec.html) 返回[nil-reply](http://www.redis.cn/topics/protocol.html#nil-reply)来表示事务已经失败。
+被[WATCH](http://www.redis.cn/commands/watch.html)的键会被监视，并会发觉这些键是否被改动过了。 如果有至少一个被监视的键在[EXEC](http://www.redis.cn/commands/exec.html)执行之前被修改了， 那么整个事务都会被取消，[EXEC](http://www.redis.cn/commands/exec.html)返回[nil-reply](http://www.redis.cn/topics/protocol.html#nil-reply)来表示事务已经失败。
 
-举个例子， 假设我们需要原子性地为某个值进行增 1 操作（假设 [INCR](http://www.redis.cn/commands/incr.html) 不存在）。
+举个例子， 假设我们需要原子性地为某个值进行增 1 操作（假设[INCR](http://www.redis.cn/commands/incr.html)不存在）。
 
 首先我们可能会这样做：
 
@@ -165,7 +156,7 @@ val = GET mykeyval = val + 1SET mykey $val
 
 上面的这个实现在只有一个客户端的时候可以执行得很好。 但是， 当多个客户端同时对同一个键进行这样的操作时， 就会产生竞争条件。举个例子， 如果客户端 A 和 B 都读取了键原来的值， 比如 10 ， 那么两个客户端都会将键的值设为 11 ， 但正确的结果应该是 12 才对。
 
-有了 [WATCH](http://www.redis.cn/commands/watch.html) ， 我们就可以轻松地解决这类问题了：
+有了[WATCH](http://www.redis.cn/commands/watch.html)， 我们就可以轻松地解决这类问题了：
 
 
 
@@ -175,17 +166,17 @@ WATCH mykeyval = GET mykeyval = val + 1MULTISET mykey $valEXEC
 
 
 
-使用上面的代码， 如果在 [WATCH](http://www.redis.cn/commands/watch.html) 执行之后， [EXEC](http://www.redis.cn/commands/exec.html) 执行之前， 有其他客户端修改了 `mykey` 的值， 那么当前客户端的事务就会失败。 程序需要做的， 就是不断重试这个操作， 直到没有发生碰撞为止。
+使用上面的代码， 如果在[WATCH](http://www.redis.cn/commands/watch.html)执行之后，[EXEC](http://www.redis.cn/commands/exec.html)执行之前， 有其他客户端修改了`mykey`的值， 那么当前客户端的事务就会失败。 程序需要做的， 就是不断重试这个操作， 直到没有发生碰撞为止。
 
 这种形式的锁被称作乐观锁， 它是一种非常强大的锁机制。 并且因为大多数情况下， 不同的客户端会访问不同的键， 碰撞的情况一般都很少， 所以通常并不需要进行重试。
 
-## 了解 `WATCH`
+## 了解`WATCH`
 
-[WATCH](http://www.redis.cn/commands/watch.html) 使得 [EXEC](http://www.redis.cn/commands/exec.html) 命令需要有条件地执行： 事务只能在所有被监视键都没有被修改的前提下执行， 如果这个前提不能满足的话，事务就不会被执行。 [了解更多->](http://code.google.com/p/redis/issues/detail?id=270)
+[WATCH](http://www.redis.cn/commands/watch.html)使得[EXEC](http://www.redis.cn/commands/exec.html)命令需要有条件地执行： 事务只能在所有被监视键都没有被修改的前提下执行， 如果这个前提不能满足的话，事务就不会被执行。[了解更多->](http://code.google.com/p/redis/issues/detail?id=270)
 
-[WATCH](http://www.redis.cn/commands/watch.html) 命令可以被调用多次。 对键的监视从 [WATCH](http://www.redis.cn/commands/watch.html) 执行之后开始生效， 直到调用 [EXEC](http://www.redis.cn/commands/exec.html) 为止。
+[WATCH](http://www.redis.cn/commands/watch.html)命令可以被调用多次。 对键的监视从[WATCH](http://www.redis.cn/commands/watch.html)执行之后开始生效， 直到调用[EXEC](http://www.redis.cn/commands/exec.html)为止。
 
-用户还可以在单个 [WATCH](http://www.redis.cn/commands/watch.html) 命令中监视任意多个键， 就像这样：
+用户还可以在单个[WATCH](http://www.redis.cn/commands/watch.html)命令中监视任意多个键， 就像这样：
 
 
 
@@ -195,15 +186,15 @@ redis> WATCH key1 key2 key3OK
 
 
 
-当 [EXEC](http://www.redis.cn/commands/exec.html) 被调用时， 不管事务是否成功执行， 对所有键的监视都会被取消。
+当[EXEC](http://www.redis.cn/commands/exec.html)被调用时， 不管事务是否成功执行， 对所有键的监视都会被取消。
 
 另外， 当客户端断开连接时， 该客户端对键的监视也会被取消。
 
-使用无参数的 [UNWATCH](http://www.redis.cn/commands/unwatch.html) 命令可以手动取消对所有键的监视。 对于一些需要改动多个键的事务， 有时候程序需要同时对多个键进行加锁， 然后检查这些键的当前值是否符合程序的要求。 当值达不到要求时， 就可以使用 [UNWATCH](http://www.redis.cn/commands/unwatch.html) 命令来取消目前对键的监视， 中途放弃这个事务， 并等待事务的下次尝试。
+使用无参数的[UNWATCH](http://www.redis.cn/commands/unwatch.html)命令可以手动取消对所有键的监视。 对于一些需要改动多个键的事务， 有时候程序需要同时对多个键进行加锁， 然后检查这些键的当前值是否符合程序的要求。 当值达不到要求时， 就可以使用[UNWATCH](http://www.redis.cn/commands/unwatch.html)命令来取消目前对键的监视， 中途放弃这个事务， 并等待事务的下次尝试。
 
 ### 使用 WATCH 实现 ZPOP
 
-[WATCH](http://www.redis.cn/commands/watch.html) 可以用于创建 Redis 没有内置的原子操作。举个例子， 以下代码实现了原创的 [ZPOP](http://www.redis.cn/commands/zpop.html) 命令， 它可以原子地弹出有序集合中分值（score）最小的元素：
+[WATCH](http://www.redis.cn/commands/watch.html)可以用于创建 Redis 没有内置的原子操作。举个例子， 以下代码实现了原创的[ZPOP](http://www.redis.cn/commands/zpop.html)命令， 它可以原子地弹出有序集合中分值（score）最小的元素：
 
 
 
@@ -213,7 +204,7 @@ WATCH zsetelement = ZRANGE zset 0 0MULTIZREM zset elementEXEC
 
 
 
-程序只要重复执行这段代码， 直到 [EXEC](http://www.redis.cn/commands/exec.html) 的返回值不是[nil-reply](http://www.redis.cn/topics/protocol.html#nil-reply)回复即可。
+程序只要重复执行这段代码， 直到[EXEC](http://www.redis.cn/commands/exec.html)的返回值不是[nil-reply](http://www.redis.cn/topics/protocol.html#nil-reply)回复即可。
 
 ## Redis 脚本和事务
 
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2602\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224dict.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224dict.md"
similarity index 94%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2602\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224dict.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224dict.md"
index f79f1bd..97fbd0e 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2602\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224dict.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224dict.md"
@@ -1,14 +1,18 @@
-# Table of Contents
-
-      * [dict的数据结构定义](#dict的数据结构定义)
-      * [dict的创建（dictCreate）](#dict的创建（dictcreate）)
-      * [dict的查找（dictFind）](#dict的查找（dictfind）)
-            * [dictIsRehashing(d) ((d)->rehashidx != -1)](#dictisrehashingd-d-rehashidx---1)
-      * [dict的插入（dictAdd和dictReplace）](#dict的插入（dictadd和dictreplace）)
-      * [dict的删除（dictDelete）](#dict的删除（dictdelete）)
+# 目录
+
+  * [dict的数据结构定义](#dict的数据结构定义)
+  * [dict的创建（dictCreate）](#dict的创建（dictcreate）)
+  * [dict的查找（dictFind）](#dict的查找（dictfind）)
+  * [dict的插入（dictAdd和dictReplace）](#dict的插入（dictadd和dictreplace）)
+  * [dict的删除（dictDelete）](#dict的删除（dictdelete）)
+
+
+[toc]
+
 本文转自互联网
 
 本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
@@ -61,12 +65,13 @@ dict本质上是为了解决算法中的查找问题（Searching），一般查
 
 下面进行详细介绍。
 
-#### dict的数据结构定义
+## dict的数据结构定义
 
 为了实现增量式重哈希（incremental rehashing），dict的数据结构里包含两个哈希表。在重哈希期间，数据从第一个哈希表向第二个哈希表迁移。
 
 dict的C代码定义如下（出自Redis源码dict.h）：
-    
+
+````
     typedef struct dictEntry {
         void *key;
         union {
@@ -104,10 +109,10 @@ dict的C代码定义如下（出自Redis源码dict.h）：
         int iterators; /* number of iterators currently running */
     } dict;
 
-
+````
 为了能更清楚地展示dict的数据结构定义，我们用一张结构图来表示它。如下。
 
-[![Redis dict结构图](http://zhangtielei.com/assets/photos_redis/redis_dict_structure.png)](http://zhangtielei.com/assets/photos_redis/redis_dict_structure.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230406203512.png)
 
 结合上面的代码和结构图，可以很清楚地看出dict的结构。一个dict由如下若干项组成：
 
@@ -135,8 +140,8 @@ dictType结构包含若干函数指针，用于dict的调用者对涉及key和va
 
 dictEntry结构中包含k, v和指向链表下一项的next指针。k是void指针，这意味着它可以指向任何类型。v是个union，当它的值是uint64_t、int64_t或double类型时，就不再需要额外的存储，这有利于减少内存碎片。当然，v也可以是void指针，以便能存储任何类型的数据。
 
-#### dict的创建（dictCreate）
-
+## dict的创建（dictCreate）
+````
     dict *dictCreate(dictType *type,
             void *privDataPtr)
     {
@@ -166,12 +171,12 @@ dictEntry结构中包含k, v和指向链表下一项的next指针。k是void指
         ht->used = 0;
     }
 
-
+````
 dictCreate为dict的数据结构分配空间并为各个变量赋初值。其中两个哈希表ht[0]和ht[1]起始都没有分配空间，table指针都赋为NULL。这意味着要等第一个数据插入时才会真正分配空间。
 
-#### dict的查找（dictFind）
-    
-    #define dictIsRehashing(d) ((d)->rehashidx != -1)
+## dict的查找（dictFind）
+````
+    //define dictIsRehashing(d) ((d)->rehashidx != -1)
     
     dictEntry *dictFind(dict *d, const void *key)
     {
@@ -193,7 +198,7 @@ dictCreate为dict的数据结构分配空间并为各个变量赋初值。其中
         }
         return NULL;
     }
-
+````
 
 上述dictFind的源码，根据dict当前是否正在重哈希，依次做了这么几件事：
 
@@ -204,7 +209,7 @@ dictCreate为dict的数据结构分配空间并为各个变量赋初值。其中
 
 下面我们有必要看一下增量式重哈希的_dictRehashStep的实现。
 
-    
+````
     static void _dictRehashStep(dict *d) {
         if (d->iterators == 0) dictRehash(d,1);
     }
@@ -253,7 +258,7 @@ dictCreate为dict的数据结构分配空间并为各个变量赋初值。其中
         /* More to rehash... */
         return 1;
     }
-
+````
 dictRehash每次将重哈希至少向前推进n步（除非不到n步整个重哈希就结束了），每一步都将ht[0]上某一个bucket（即一个dictEntry链表）上的每一个dictEntry移动到ht[1]上，它在ht[1]上的新位置根据ht[1]的sizemask进行重新计算。rehashidx记录了当前尚未迁移（有待迁移）的ht[0]的bucket位置。
 
 如果dictRehash被调用的时候，rehashidx指向的bucket里一个dictEntry也没有，那么它就没有可迁移的数据。这时它尝试在ht[0].table数组中不断向后遍历，直到找到下一个存有数据的bucket位置。如果一直找不到，则最多走n*10步，本次重哈希暂告结束。
@@ -262,13 +267,13 @@ dictRehash每次将重哈希至少向前推进n步（除非不到n步整个重
 
 根据以上对于重哈希过程的分析，我们容易看出，本文前面的dict结构图中所展示的正是rehashidx=2时的情况，前面两个bucket（ht[0].table[0]和ht[0].table[1]）都已经迁移到ht[1]上去了。
 
-#### dict的插入（dictAdd和dictReplace）
+## dict的插入（dictAdd和dictReplace）
 
 dictAdd插入新的一对key和value，如果key已经存在，则插入失败。
 
 dictReplace也是插入一对key和value，不过在key存在的时候，它会更新value。
 
-    
+````
     int dictAdd(dict *d, void *key, void *val)
     {
         dictEntry *entry = dictAddRaw(d,key);
@@ -329,7 +334,7 @@ dictReplace也是插入一对key和value，不过在key存在的时候，它会
         }
         return idx;
     }
-
+````
 以上是dictAdd的关键实现代码。我们主要需要注意以下几点：
 
 *   它也会触发推进一步重哈希（_dictRehashStep）。
@@ -340,7 +345,7 @@ dictReplace也是插入一对key和value，不过在key存在的时候，它会
 
 dictReplace在dictAdd基础上实现，如下：
 
-    
+````
     int dictReplace(dict *d, void *key, void *val)
     {
         dictEntry *entry, auxentry;
@@ -361,10 +366,10 @@ dictReplace在dictAdd基础上实现，如下：
         dictFreeVal(d, &auxentry);
         return 0;
     }
-
+````
 在key已经存在的情况下，dictReplace会同时调用dictAdd和dictFind，这其实相当于两次查找过程。这里Redis的代码不够优化。
 
-#### dict的删除（dictDelete）
+## dict的删除（dictDelete）
 
 dictDelete的源码这里忽略，具体请参考dict.c。需要稍加注意的是：
 
@@ -376,7 +381,3 @@ dictDelete的源码这里忽略，具体请参考dict.c。需要稍加注意的
 
 dict的实现相对来说比较简单，本文就介绍到这。在下一篇中我们将会介绍Redis中动态字符串的实现——sds，敬请期待。
 
-**原创文章，转载请注明出处，并包含下面的二维码！否则拒绝转载！**
-**本文链接：**[http://zhangtielei.com/posts/blog-redis-dict.html](http://zhangtielei.com/posts/blog-redis-dict.html)
-
-![我的微信公众号: tielei-blog (张铁蕾)](http://zhangtielei.com/assets/my_weixin_sign_sf_840.jpg)
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2607\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224intset.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224intset.md"
similarity index 94%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2607\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224intset.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224intset.md"
index 5baa446..b8ffc6e 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2607\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224intset.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224intset.md"
@@ -1,17 +1,16 @@
-# Table of Contents
+# 目录
 
-    * [intset数据结构简介](#intset数据结构简介)
-            * [INTSET_ENC_INT16 (sizeof(int16_t))](#intset_enc_int16-sizeofint16_t)
-            * [INTSET_ENC_INT32 (sizeof(int32_t))](#intset_enc_int32-sizeofint32_t)
-            * [INTSET_ENC_INT64 (sizeof(int64_t))](#intset_enc_int64-sizeofint64_t)
-    * [intset的查找和添加操作](#intset的查找和添加操作)
-    * [Redis的set](#redis的set)
-    * [Redis set的并、交、差算法](#redis-set的并、交、差算法)
-      * [交集](#交集)
-      * [并集](#并集)
-      * [差集](#差集)
+  * [intset数据结构简介](#intset数据结构简介)
+  * [intset的查找和添加操作](#intset的查找和添加操作)
+  * [Redis的set](#redis的set)
+  * [Redis set的并、交、差算法](#redis-set的并、交、差算法)
+    * [交集](#交集)
+    * [并集](#并集)
+    * [差集](#差集)
 
 
+[toc]
+
 本文转自互联网
 
 本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -54,7 +53,7 @@ set-max-intset-entries 512
 
 注：本文讨论的代码实现基于Redis源码的3.2分支。
 
-### intset数据结构简介
+## intset数据结构简介
 
 intset顾名思义，是由整数组成的集合。实际上，intset是一个由整数组成的有序集合，从而便于在上面进行二分查找，用于快速地判断一个元素是否属于这个集合。它在内存分配上与[ziplist](http://zhangtielei.com/posts/blog-redis-ziplist.html)有些类似，是连续的一整块内存空间，而且对于大整数和小整数（按绝对值）采取了不同的编码，尽量对内存的使用进行了优化。
 
@@ -85,7 +84,7 @@ typedef struct intset {
 
 *   `encoding`: 数据编码，表示intset中的每个数据元素用几个字节来存储。它有三种可能的取值：INTSET_ENC_INT16表示每个元素用2个字节存储，INTSET_ENC_INT32表示每个元素用4个字节存储，INTSET_ENC_INT64表示每个元素用8个字节存储。因此，intset中存储的整数最多只能占用64bit。
 *   `length`: 表示intset中的元素个数。`encoding`和`length`两个字段构成了intset的头部（header）。
-*   `contents`: 是一个柔性数组（[flexible array member](https://en.wikipedia.org/wiki/Flexible_array_member)），表示intset的header后面紧跟着数据元素。这个数组的总长度（即总字节数）等于`encoding * length`。柔性数组在Redis的很多数据结构的定义中都出现过（例如[sds](http://zhangtielei.com/posts/blog-redis-sds.html), [quicklist](http://zhangtielei.com/posts/blog-redis-quicklist.html), [skiplist](http://zhangtielei.com/posts/blog-redis-skiplist.html)），用于表达一个偏移量。`contents`需要单独为其分配空间，这部分内存不包含在intset结构当中。
+*   `contents`: 是一个柔性数组（[flexible array member](https://en.wikipedia.org/wiki/Flexible_array_member)），表示intset的header后面紧跟着数据元素。这个数组的总长度（即总字节数）等于`encoding * length`。柔性数组在Redis的很多数据结构的定义中都出现过（例如[sds](http://zhangtielei.com/posts/blog-redis-sds.html),[quicklist](http://zhangtielei.com/posts/blog-redis-quicklist.html),[skiplist](http://zhangtielei.com/posts/blog-redis-skiplist.html)），用于表达一个偏移量。`contents`需要单独为其分配空间，这部分内存不包含在intset结构当中。
 
 其中需要注意的是，intset可能会随着数据的添加而改变它的数据编码：
 
@@ -98,7 +97,7 @@ typedef struct intset {
 
 在上图中：
 
-*   新创建的intset只有一个header，总共8个字节。其中`encoding` = 2, `length` = 0。
+*   新创建的intset只有一个header，总共8个字节。其中`encoding`= 2,`length`= 0。
 *   添加13, 5两个元素之后，因为它们是比较小的整数，都能使用2个字节表示，所以`encoding`不变，值还是2。
 *   当添加32768的时候，它不再能用2个字节来表示了（2个字节能表达的数据范围是-2<sup>15</sup>~2<sup>15</sup>-1，而32768等于2<sup>15</sup>，超出范围了），因此`encoding`必须升级到INTSET_ENC_INT32（值为4），即用4个字节表示一个元素。
 *   在添加每个元素的过程中，intset始终保持从小到大有序。
@@ -110,7 +109,7 @@ intset与[ziplist](http://zhangtielei.com/posts/blog-redis-ziplist.html)相比
 *   ziplist是无序的，而intset是从小到大有序的。因此，在ziplist上查找只能遍历，而在intset上可以进行二分查找，性能更高。
 *   ziplist可以对每个数据项进行不同的变长编码（每个数据项前面都有数据长度字段`len`），而intset只能整体使用一个统一的编码（`encoding`）。
 
-### intset的查找和添加操作
+## intset的查找和添加操作
 
 要理解intset的一些实现细节，只需要关注intset的两个关键操作基本就可以了：查找（`intsetFind`）和添加（`intsetAdd`）元素。
 
@@ -238,7 +237,7 @@ intset *intsetAdd(intset *is, int64_t value, uint8_t *success) {
 *   注意一下`intsetAdd`的返回值，它返回一个新的intset指针。它可能与传入的intset指针`is`相同，也可能不同。调用方必须用这里返回的新的intset，替换之前传进来的旧的intset变量。类似这种接口使用模式，在Redis的实现代码中是很常见的，比如我们之前在介绍[sds](http://zhangtielei.com/posts/blog-redis-sds.html)和[ziplist](http://zhangtielei.com/posts/blog-redis-ziplist.html)的时候都碰到过类似的情况。
 *   显然，这个`intsetAdd`算法总的时间复杂度为O(n)。
 
-### Redis的set
+## Redis的set
 
 为了更好地理解Redis对外暴露的set数据结构，我们先看一下set的一些关键的命令。下面是一些命令举例：
 
@@ -248,11 +247,11 @@ intset *intsetAdd(intset *is, int64_t value, uint8_t *success) {
 
 *   `sadd`用于分别向集合`s1`和`s2`中添加元素。添加的元素既有数字，也有非数字（”a”和”b”）。
 *   `sismember`用于判断指定的元素是否在集合内存在。
-*   `sinter`, `sunion`和`sdiff`分别用于计算集合的交集、并集和差集。
+*   `sinter`,`sunion`和`sdiff`分别用于计算集合的交集、并集和差集。
 
 我们前面提到过，set的底层实现，随着元素类型是否是整型以及添加的元素的数目多少，而有所变化。例如，具体到上述命令的执行过程中，集合`s1`的底层数据结构会发生如下变化：
 
-*   在开始执行完`sadd s1 13 5`之后，由于添加的都是比较小的整数，所以`s1`底层是一个intset，其数据编码`encoding` = 2。
+*   在开始执行完`sadd s1 13 5`之后，由于添加的都是比较小的整数，所以`s1`底层是一个intset，其数据编码`encoding`= 2。
 *   在执行完`sadd s1 32768 10 100000`之后，`s1`底层仍然是一个intset，但其数据编码`encoding`从2升级到了4。
 *   在执行完`sadd s1 a b`之后，由于添加的元素不再是数字，`s1`底层的实现会转成一个dict。
 
@@ -267,13 +266,13 @@ intset *intsetAdd(intset *is, int64_t value, uint8_t *success) {
 
 实际上，从时间复杂度上比较，intset的平均情况是没有dict性能高的。以查找为例，intset是O(log n)的，而dict可以认为是O(1)的。但是，由于使用intset的时候集合元素个数比较少，所以这个影响不大。
 
-### Redis set的并、交、差算法
+## Redis set的并、交、差算法
 
 Redis set的并、交、差算法的实现代码，在t_set.c中。其中计算交集调用的是`sinterGenericCommand`，计算并集和差集调用的是`sunionDiffGenericCommand`。它们都能同时对多个（可以多于2个）集合进行运算。当对多个集合进行差集运算时，它表达的含义是：用第一个集合与第二个集合做差集，所得结果再与第三个集合做差集，依次向后类推。
 
 我们在这里简要介绍一下三个算法的实现思路。
 
-#### 交集
+### 交集
 
 计算交集的过程大概可以分为三部分：
 
@@ -285,7 +284,7 @@ Redis set的并、交、差算法的实现代码，在t_set.c中。其中计算
 
 > O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
 
-#### 并集
+### 并集
 
 计算并集最简单，只需要遍历所有集合，将每一个元素都添加到最后的结果集合中。向集合中添加元素会自动去重。
 
@@ -295,7 +294,7 @@ Redis set的并、交、差算法的实现代码，在t_set.c中。其中计算
 
 注意，这里同前面讨论交集计算一样，将元素插入到结果集合的过程，忽略intset的情况，认为时间复杂度为O(1)。
 
-#### 差集
+### 差集
 
 计算差集有两种可能的算法，它们的时间复杂度有所区别。
 
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2605\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224quicklist.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224quicklist.md"
similarity index 77%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2605\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224quicklist.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224quicklist.md"
index fb47b21..80bba2e 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2605\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224quicklist.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224quicklist.md"
@@ -1,15 +1,18 @@
-# Table of Contents
+# 目录
 
-      * [quicklist概述](#quicklist概述)
-      * [quicklist的数据结构定义](#quicklist的数据结构定义)
-      * [quicklist的创建](#quicklist的创建)
-      * [quicklist的push操作](#quicklist的push操作)
-      * [quicklist的其它操作](#quicklist的其它操作)
+  * [quicklist概述](#quicklist概述)
+  * [quicklist的数据结构定义](#quicklist的数据结构定义)
+  * [quicklist的创建](#quicklist的创建)
+  * [quicklist的push操作](#quicklist的push操作)
+  * [quicklist的其它操作](#quicklist的其它操作)
 
 
+[toc]
+
 本文转自互联网
 
 本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
@@ -20,7 +23,7 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 
 本文是《[Redis内部数据结构详解](http://zhangtielei.com/posts/blog-redis-dict.html)》系列的第五篇。在本文中，我们介绍一个Redis内部数据结构——quicklist。Redis对外暴露的list数据类型，它底层实现所依赖的内部数据结构就是quicklist。
 
@@ -30,10 +33,10 @@
 
 
 
-```
-list-max-ziplist-size -2
-list-compress-depth 0
-
+```  
+list-max-ziplist-size -2  
+list-compress-depth 0  
+  
 ```
 
 
@@ -44,7 +47,7 @@ list-compress-depth 0
 
 注：本文讨论的quicklist实现基于Redis源码的3.2分支。
 
-#### quicklist概述
+## quicklist概述
 
 Redis对外暴露的上层list数据类型，经常被用作队列使用。比如它支持的如下一些操作：
 
@@ -91,9 +94,9 @@ quicklist的结构为什么这样设计呢？总结起来，大概又是一个
 
 
 
-```
-list-max-ziplist-size -2
-
+```  
+list-max-ziplist-size -2  
+  
 ```
 
 
@@ -120,9 +123,9 @@ list-max-ziplist-size -2
 
 
 
-```
-list-compress-depth 0
-
+```  
+list-compress-depth 0  
+  
 ```
 
 
@@ -143,7 +146,7 @@ list-compress-depth 0
 
 Redis对于quicklist内部节点的压缩算法，采用的[LZF](http://oldhome.schmorp.de/marc/liblzf.html)——一种无损压缩算法。
 
-#### quicklist的数据结构定义
+## quicklist的数据结构定义
 
 quicklist相关的数据结构定义可以在quicklist.h中找到：
 
@@ -151,34 +154,16 @@ quicklist相关的数据结构定义可以在quicklist.h中找到：
 
 
 
-```
-typedef struct quicklistNode {
-    struct quicklistNode *prev;
-    struct quicklistNode *next;
-    unsigned char *zl;
-    unsigned int sz;             /* ziplist size in bytes */
-    unsigned int count : 16;     /* count of items in ziplist */
-    unsigned int encoding : 2;   /* RAW==1 or LZF==2 */
-    unsigned int container : 2;  /* NONE==1 or ZIPLIST==2 */
-    unsigned int recompress : 1; /* was this node previous compressed? */
-    unsigned int attempted_compress : 1; /* node can't compress; too small */
-    unsigned int extra : 10; /* more bits to steal for future usage */
-} quicklistNode;
-
-typedef struct quicklistLZF {
-    unsigned int sz; /* LZF size in bytes*/
-    char compressed[];
-} quicklistLZF;
-
-typedef struct quicklist {
-    quicklistNode *head;
-    quicklistNode *tail;
-    unsigned long count;        /* total count of all entries in all ziplists */
-    unsigned int len;           /* number of quicklistNodes */
-    int fill : 16;              /* fill factor for individual nodes */
-    unsigned int compress : 16; /* depth of end nodes not to compress;0=off */
-} quicklist;
-
+```  
+typedef struct quicklistNode {  
+    struct quicklistNode *prev;    struct quicklistNode *next;    unsigned char *zl;    unsigned int sz;             /* ziplist size in bytes */    unsigned int count : 16;     /* count of items in ziplist */    unsigned int encoding : 2;   /* RAW==1 or LZF==2 */    unsigned int container : 2;  /* NONE==1 or ZIPLIST==2 */    unsigned int recompress : 1; /* was this node previous compressed? */    unsigned int attempted_compress : 1; /* node can't compress; too small */    unsigned int extra : 10; /* more bits to steal for future usage */} quicklistNode;  
+  
+typedef struct quicklistLZF {  
+    unsigned int sz; /* LZF size in bytes*/    char compressed[];} quicklistLZF;  
+  
+typedef struct quicklist {  
+    quicklistNode *head;    quicklistNode *tail;    unsigned long count;        /* total count of all entries in all ziplists */    unsigned int len;           /* number of quicklistNodes */    int fill : 16;              /* fill factor for individual nodes */    unsigned int compress : 16; /* depth of end nodes not to compress;0=off */} quicklist;  
+  
 ```
 
 
@@ -190,7 +175,7 @@ quicklistNode结构代表quicklist的一个节点，其中各个字段的含义
 *   prev: 指向链表前一个节点的指针。
 *   next: 指向链表后一个节点的指针。
 *   zl: 数据指针。如果当前节点的数据没有压缩，那么它指向一个ziplist结构；否则，它指向一个quicklistLZF结构。
-*   sz: 表示zl指向的ziplist的总大小（包括`zlbytes`, `zltail`, `zllen`, `zlend`和各个数据项）。需要注意的是：如果ziplist被压缩了，那么这个sz的值仍然是压缩前的ziplist大小。
+*   sz: 表示zl指向的ziplist的总大小（包括`zlbytes`, `zltail`, `zllen`, `zlend`和各个数据项）。需要注意的是：如果ziplist被压缩了，那么这个sz的值仍然是压缩前的ziplist大小。
 *   count: 表示ziplist里面包含的数据项个数。这个字段只有16bit。稍后我们会一起计算一下这16bit是否够用。
 *   encoding: 表示ziplist是否压缩了（以及用了哪个压缩算法）。目前只有两种取值：2表示被压缩了（而且用的是[LZF](http://oldhome.schmorp.de/marc/liblzf.html)压缩算法），1表示没有压缩。
 *   container: 是一个预留字段。本来设计是用来表明一个quicklist节点下面是直接存数据，还是使用ziplist存数据，或者用其它的结构来存数据（用作一个数据容器，所以叫container）。但是，在目前的实现中，这个值是一个固定的值2，表示使用ziplist作为数据容器。
@@ -212,7 +197,7 @@ quicklistLZF结构表示一个被压缩过的ziplist。其中：
 *   fill: 16bit，ziplist大小设置，存放`list-max-ziplist-size`参数的值。
 *   compress: 16bit，节点压缩深度设置，存放`list-compress-depth`参数的值。
 
-[![Redis quicklist 结构图](http://zhangtielei.com/assets/photos_redis/redis_quicklist_structure.png)](http://zhangtielei.com/assets/photos_redis/redis_quicklist_structure.png)
+[![Redis quicklist 结构图](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/redis_quicklist_structure.png)](http://zhangtielei.com/assets/photos_redis/redis_quicklist_structure.png)
 
 上图是一个quicklist的结构图举例。图中例子对应的ziplist大小配置和节点压缩深度配置，如下：
 
@@ -220,10 +205,10 @@ quicklistLZF结构表示一个被压缩过的ziplist。其中：
 
 
 
-```
-list-max-ziplist-size 3
-list-compress-depth 2
-
+```  
+list-max-ziplist-size 3  
+list-compress-depth 2  
+  
 ```
 
 
@@ -246,7 +231,7 @@ list-compress-depth 2
 
 下面进入代码分析阶段。
 
-#### quicklist的创建
+## quicklist的创建
 
 当我们使用`lpush`或`rpush`命令第一次向一个不存在的list里面插入数据的时候，Redis会首先调用`quicklistCreate`接口创建一个空的quicklist。
 
@@ -254,19 +239,11 @@ list-compress-depth 2
 
 
 
-```
-quicklist *quicklistCreate(void) {
-    struct quicklist *quicklist;
-
-    quicklist = zmalloc(sizeof(*quicklist));
-    quicklist->head = quicklist->tail = NULL;
-    quicklist->len = 0;
-    quicklist->count = 0;
-    quicklist->compress = 0;
-    quicklist->fill = -2;
-    return quicklist;
-}
-
+```  
+quicklist *quicklistCreate(void) {  
+    struct quicklist *quicklist;  
+    quicklist = zmalloc(sizeof(*quicklist));    quicklist->head = quicklist->tail = NULL;    quicklist->len = 0;    quicklist->count = 0;    quicklist->compress = 0;    quicklist->fill = -2;    return quicklist;}  
+  
 ```
 
 
@@ -275,7 +252,7 @@ quicklist *quicklistCreate(void) {
 
 在很多介绍数据结构的书上，实现双向链表的时候经常会多增加一个空余的头节点，主要是为了插入和删除操作的方便。从上面`quicklistCreate`的代码可以看出，quicklist是一个不包含空余头节点的双向链表（`head`和`tail`都初始化为NULL）。
 
-#### quicklist的push操作
+## quicklist的push操作
 
 quicklist的push操作是调用`quicklistPush`来实现的。
 
@@ -283,62 +260,20 @@ quicklist的push操作是调用`quicklistPush`来实现的。
 
 
 
-```
-void quicklistPush(quicklist *quicklist, void *value, const size_t sz,
-                   int where) {
-    if (where == QUICKLIST_HEAD) {
-        quicklistPushHead(quicklist, value, sz);
-    } else if (where == QUICKLIST_TAIL) {
-        quicklistPushTail(quicklist, value, sz);
-    }
-}
-
-/* Add new entry to head node of quicklist.
- *
- * Returns 0 if used existing head.
- * Returns 1 if new head created. */
-int quicklistPushHead(quicklist *quicklist, void *value, size_t sz) {
-    quicklistNode *orig_head = quicklist->head;
-    if (likely(
-            _quicklistNodeAllowInsert(quicklist->head, quicklist->fill, sz))) {
-        quicklist->head->zl =
-            ziplistPush(quicklist->head->zl, value, sz, ZIPLIST_HEAD);
-        quicklistNodeUpdateSz(quicklist->head);
-    } else {
-        quicklistNode *node = quicklistCreateNode();
-        node->zl = ziplistPush(ziplistNew(), value, sz, ZIPLIST_HEAD);
-
-        quicklistNodeUpdateSz(node);
-        _quicklistInsertNodeBefore(quicklist, quicklist->head, node);
-    }
-    quicklist->count++;
-    quicklist->head->count++;
-    return (orig_head != quicklist->head);
-}
-
-/* Add new entry to tail node of quicklist.
- *
- * Returns 0 if used existing tail.
- * Returns 1 if new tail created. */
-int quicklistPushTail(quicklist *quicklist, void *value, size_t sz) {
-    quicklistNode *orig_tail = quicklist->tail;
-    if (likely(
-            _quicklistNodeAllowInsert(quicklist->tail, quicklist->fill, sz))) {
-        quicklist->tail->zl =
-            ziplistPush(quicklist->tail->zl, value, sz, ZIPLIST_TAIL);
-        quicklistNodeUpdateSz(quicklist->tail);
-    } else {
-        quicklistNode *node = quicklistCreateNode();
-        node->zl = ziplistPush(ziplistNew(), value, sz, ZIPLIST_TAIL);
-
-        quicklistNodeUpdateSz(node);
-        _quicklistInsertNodeAfter(quicklist, quicklist->tail, node);
-    }
-    quicklist->count++;
-    quicklist->tail->count++;
-    return (orig_tail != quicklist->tail);
-}
-
+```  
+void quicklistPush(quicklist *quicklist, void *value, const size_t sz,  
+                   int where) {    if (where == QUICKLIST_HEAD) {        quicklistPushHead(quicklist, value, sz);    } else if (where == QUICKLIST_TAIL) {        quicklistPushTail(quicklist, value, sz);    }}  
+  
+/* Add new entry to head node of quicklist.  
+ * * Returns 0 if used existing head. * Returns 1 if new head created. */int quicklistPushHead(quicklist *quicklist, void *value, size_t sz) {  
+    quicklistNode *orig_head = quicklist->head;    if (likely(            _quicklistNodeAllowInsert(quicklist->head, quicklist->fill, sz))) {        quicklist->head->zl =            ziplistPush(quicklist->head->zl, value, sz, ZIPLIST_HEAD);        quicklistNodeUpdateSz(quicklist->head);    } else {        quicklistNode *node = quicklistCreateNode();        node->zl = ziplistPush(ziplistNew(), value, sz, ZIPLIST_HEAD);  
+        quicklistNodeUpdateSz(node);        _quicklistInsertNodeBefore(quicklist, quicklist->head, node);    }    quicklist->count++;    quicklist->head->count++;    return (orig_head != quicklist->head);}  
+  
+/* Add new entry to tail node of quicklist.  
+ * * Returns 0 if used existing tail. * Returns 1 if new tail created. */int quicklistPushTail(quicklist *quicklist, void *value, size_t sz) {  
+    quicklistNode *orig_tail = quicklist->tail;    if (likely(            _quicklistNodeAllowInsert(quicklist->tail, quicklist->fill, sz))) {        quicklist->tail->zl =            ziplistPush(quicklist->tail->zl, value, sz, ZIPLIST_TAIL);        quicklistNodeUpdateSz(quicklist->tail);    } else {        quicklistNode *node = quicklistCreateNode();        node->zl = ziplistPush(ziplistNew(), value, sz, ZIPLIST_TAIL);  
+        quicklistNodeUpdateSz(node);        _quicklistInsertNodeAfter(quicklist, quicklist->tail, node);    }    quicklist->count++;    quicklist->tail->count++;    return (orig_tail != quicklist->tail);}  
+  
 ```
 
 
@@ -352,7 +287,7 @@ int quicklistPushTail(quicklist *quicklist, void *value, size_t sz) {
 
 在`_quicklistInsertNodeAfter`的实现中，还会根据`list-compress-depth`的配置将里面的节点进行压缩。它的实现比较繁琐，我们这里就不展开讨论了。
 
-#### quicklist的其它操作
+## quicklist的其它操作
 
 quicklist的操作较多，且实现细节都比较繁杂，这里就不一一分析源码了，我们简单介绍一些比较重要的操作。
 
@@ -371,7 +306,7 @@ quicklist不仅实现了从头部或尾部插入，也实现了从任意指定
 
 下一篇我们将介绍skiplist和它所支撑的Redis数据类型sorted set，敬请期待。
 
-**原创文章，转载请注明出处，并包含下面的二维码！否则拒绝转载！**
+**原创文章，转载请注明出处，并包含下面的二维码！否则拒绝转载！**  
 **本文链接：**[http://zhangtielei.com/posts/blog-redis-quicklist.html](http://zhangtielei.com/posts/blog-redis-quicklist.html)
 
-![我的微信公众号: tielei-blog (张铁蕾)](http://zhangtielei.com/assets/my_weixin_sign_sf_840.jpg)
+![我的微信公众号: tielei-blog (张铁蕾)](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/my_weixin_sign_sf_840.jpg)
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2603\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224sds.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224sds.md"
similarity index 59%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2603\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224sds.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224sds.md"
index 2d094b4..f9d1726 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2603\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224sds.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224sds.md"
@@ -1,23 +1,15 @@
-# Table of Contents
+# 目录
 
   * [前言](#前言)
   * [sds的数据结构定义](#sds的数据结构定义)
-            * [SDS_TYPE_5  0](#sds_type_5--0)
-            * [SDS_TYPE_8  1](#sds_type_8--1)
-            * [SDS_TYPE_16 2](#sds_type_16-2)
-            * [SDS_TYPE_32 3](#sds_type_32-3)
-            * [SDS_TYPE_64 4](#sds_type_64-4)
   * [Redis dict结构举例](#redis-dict结构举例)
-            * [SDS_TYPE_MASK 7](#sds_type_mask-7)
-            * [SDS_TYPE_BITS 3](#sds_type_bits-3)
-            * [SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));](#sds_hdr_varts-struct-sdshdrt-sh--voids-sizeofstruct-sdshdrt)
-            * [SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))](#sds_hdrts-struct-sdshdrt-s-sizeofstruct-sdshdrt)
-            * [SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)](#sds_type_5_lenf-fsds_type_bits)
   * [sds的创建和销毁](#sds的创建和销毁)
   * [sds的连接（追加）操作](#sds的连接（追加）操作)
   * [浅谈sds与string的关系](#浅谈sds与string的关系)
 
 
+[toc]
+
 本文转自互联网
 
 本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -31,31 +23,31 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 ## 前言
 
 本文是《Redis内部数据结构详解》系列的第二篇，讲述Redis中使用最多的一个基础数据结构：sds。
 
 不管在哪门编程语言当中，字符串都几乎是使用最多的数据结构。sds正是在Redis中被广泛使用的字符串结构，它的全称是Simple Dynamic String。与其它语言环境中出现的字符串相比，它具有如下显著的特点：
 
-可动态扩展内存。sds表示的字符串其内容可以修改，也可以追加。在很多语言中字符串会分为mutable和immutable两种，显然sds属于mutable类型的。
-二进制安全（Binary Safe）。sds能存储任意二进制数据，而不仅仅是可打印字符。
-与传统的C语言字符串类型兼容。这个的含义接下来马上会讨论。
+可动态扩展内存。sds表示的字符串其内容可以修改，也可以追加。在很多语言中字符串会分为mutable和immutable两种，显然sds属于mutable类型的。  
+二进制安全（Binary Safe）。sds能存储任意二进制数据，而不仅仅是可打印字符。  
+与传统的C语言字符串类型兼容。这个的含义接下来马上会讨论。  
 看到这里，很多对Redis有所了解的同学可能已经产生了一个疑问：Redis已经对外暴露了一个字符串结构，叫做string，那这里所说的sds到底和string是什么关系呢？可能有人会猜：string是基于sds实现的。这个猜想已经非常接近事实，但在描述上还不太准确。有关string和sds之间关系的详细分析，我们放在后面再讲。现在为了方便讨论，让我们先暂时简单地认为，string的底层实现就是sds。
 
 在讨论sds的具体实现之前，我们先站在Redis使用者的角度，来观察一下string所支持的一些主要操作。下面是一个操作示例：
 
-![image](http://zhangtielei.com/assets/photos_redis/redis_string_op_examples.png)
+![image](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/redis_string_op_examples.png)  
 Redis string操作示例
 
 
 
 以上这些操作都比较简单，我们简单解释一下：
 
-初始的字符串的值设为”tielei”。
-第3步通过append命令对字符串进行了追加，变成了”tielei zhang”。
-然后通过setbit命令将第53个bit设置成了1。bit的偏移量从左边开始算，从0开始。其中第48～55bit是中间的空格那个字符，它的ASCII码是0x20。将第53个bit设置成1之后，它的ASCII码变成了0x24，打印出来就是’$’。因此，现在字符串的值变成了”tielei$zhang”。
-最后通过getrange取从倒数第5个字节到倒数第1个字节的内容，得到”zhang”。
+初始的字符串的值设为”tielei”。  
+第3步通过append命令对字符串进行了追加，变成了”tielei zhang”。  
+然后通过setbit命令将第53个bit设置成了1。bit的偏移量从左边开始算，从0开始。其中第48～55bit是中间的空格那个字符，它的ASCII码是0x20。将第53个bit设置成1之后，它的ASCII码变成了0x24，打印出来就是’$’。因此，现在字符串的值变成了”tielei$zhang”。  
+最后通过getrange取从倒数第5个字节到倒数第1个字节的内容，得到”zhang”。  
 这些命令的实现，有一部分是和sds的实现有关的。下面我们开始详细讨论。
 
 ## sds的数据结构定义
@@ -63,76 +55,38 @@ Redis string操作示例
 
 我们可以在sds.h中找到sds的类型定义：
 
-typedef char *sds;
+typedef char *sds;  
 肯定有人感到困惑了，竟然sds就等同于char *？我们前面提到过，sds和传统的C语言字符串保持类型兼容，因此它们的类型定义是一样的，都是char *。在有些情况下，需要传入一个C语言字符串的地方，也确实可以传入一个sds。但是，sds和char *并不等同。sds是Binary Safe的，它可以存储任意二进制数据，不能像C语言字符串那样以字符’\0’来标识字符串的结束，因此它必然有个长度字段。但这个长度字段在哪里呢？实际上sds还包含一个header结构：
-
-    struct __attribute__ ((__packed__)) sdshdr5 {
-        unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
-        char buf[];
-    };
-    struct __attribute__ ((__packed__)) sdshdr8 {
-        uint8_t len; /* used */
-        uint8_t alloc; /* excluding the header and null terminator */
-        unsigned char flags; /* 3 lsb of type, 5 unused bits */
-        char buf[];
-    };
-    struct __attribute__ ((__packed__)) sdshdr16 {
-        uint16_t len; /* used */
-        uint16_t alloc; /* excluding the header and null terminator */
-        unsigned char flags; /* 3 lsb of type, 5 unused bits */
-        char buf[];
-    };
-    struct __attribute__ ((__packed__)) sdshdr32 {
-        uint32_t len; /* used */
-        uint32_t alloc; /* excluding the header and null terminator */
-        unsigned char flags; /* 3 lsb of type, 5 unused bits */
-        char buf[];
-    };
-    struct __attribute__ ((__packed__)) sdshdr64 {
-        uint64_t len; /* used */
-        uint64_t alloc; /* excluding the header and null terminator */
-        unsigned char flags; /* 3 lsb of type, 5 unused bits */
-        char buf[];
-    };
-sds一共有5种类型的header。之所以有5种，是为了能让不同长度的字符串可以使用不同大小的header。这样，短字符串就能使用较小的header，从而节省内存。
-
+````
+    struct __attribute__ ((__packed__)) sdshdr5 {        unsigned char flags; /* 3 lsb of type, and 5 msb of string length */        char buf[];    };    struct __attribute__ ((__packed__)) sdshdr8 {        uint8_t len; /* used */        uint8_t alloc; /* excluding the header and null terminator */        unsigned char flags; /* 3 lsb of type, 5 unused bits */        char buf[];    };    struct __attribute__ ((__packed__)) sdshdr16 {        uint16_t len; /* used */        uint16_t alloc; /* excluding the header and null terminator */        unsigned char flags; /* 3 lsb of type, 5 unused bits */        char buf[];    };    struct __attribute__ ((__packed__)) sdshdr32 {        uint32_t len; /* used */        uint32_t alloc; /* excluding the header and null terminator */        unsigned char flags; /* 3 lsb of type, 5 unused bits */        char buf[];    };    struct __attribute__ ((__packed__)) sdshdr64 {        uint64_t len; /* used */        uint64_t alloc; /* excluding the header and null terminator */        unsigned char flags; /* 3 lsb of type, 5 unused bits */        char buf[];    };sds一共有5种类型的header。之所以有5种，是为了能让不同长度的字符串可以使用不同大小的header。这样，短字符串就能使用较小的header，从而节省内存。  
+````
 一个sds字符串的完整结构，由在内存地址上前后相邻的两部分组成：
 
-一个header。通常包含字符串的长度(len)、最大容量(alloc)和flags。sdshdr5有所不同。
-一个字符数组。这个字符数组的长度等于最大容量+1。真正有效的字符串数据，其长度通常小于最大容量。在真正的字符串数据之后，是空余未用的字节（一般以字节0填充），允许在不重新分配内存的前提下让字符串数据向后做有限的扩展。在真正的字符串数据之后，还有一个NULL结束符，即ASCII码为0的’\0’字符。这是为了和传统C字符串兼容。之所以字符数组的长度比最大容量多1个字节，就是为了在字符串长度达到最大容量时仍然有1个字节存放NULL结束符。
+一个header。通常包含字符串的长度(len)、最大容量(alloc)和flags。sdshdr5有所不同。  
+一个字符数组。这个字符数组的长度等于最大容量+1。真正有效的字符串数据，其长度通常小于最大容量。在真正的字符串数据之后，是空余未用的字节（一般以字节0填充），允许在不重新分配内存的前提下让字符串数据向后做有限的扩展。在真正的字符串数据之后，还有一个NULL结束符，即ASCII码为0的’\0’字符。这是为了和传统C字符串兼容。之所以字符数组的长度比最大容量多1个字节，就是为了在字符串长度达到最大容量时仍然有1个字节存放NULL结束符。  
 除了sdshdr5之外，其它4个header的结构都包含3个字段：
 
-    len: 表示字符串的真正长度（不包含NULL结束符在内）。
-    alloc: 表示字符串的最大容量（不包含最后多余的那个字节）。
-    flags: 总是占用一个字节。其中的最低3个bit用来表示header的类型。header的类型共有5种，在sds.h中有常量定义。
-    #define SDS_TYPE_5  0
-    #define SDS_TYPE_8  1
-    #define SDS_TYPE_16 2
-    #define SDS_TYPE_32 3
-    #define SDS_TYPE_64 4
-sds的数据结构，我们有必要非常仔细地去解析它。
+    len: 表示字符串的真正长度（不包含NULL结束符在内）。  
+    alloc: 表示字符串的最大容量（不包含最后多余的那个字节）。  
+    flags: 总是占用一个字节。其中的最低3个bit用来表示header的类型。header的类型共有5种，在sds.h中有常量定义。  
+    #define SDS_TYPE_5  0    #define SDS_TYPE_8  1    #define SDS_TYPE_16 2    #define SDS_TYPE_32 3    #define SDS_TYPE_64 4sds的数据结构，我们有必要非常仔细地去解析它。  
 
 ## Redis dict结构举例
 
 上图是sds的一个内部结构的例子。图中展示了两个sds字符串s1和s2的内存结构，一个使用sdshdr8类型的header，另一个使用sdshdr16类型的header。但它们都表达了同样的一个长度为6的字符串的值：”tielei”。下面我们结合代码，来解释每一部分的组成。
 
 sds的字符指针（s1和s2）就是指向真正的数据（字符数组）开始的位置，而header位于内存地址较低的方向。在sds.h中有一些跟解析header有关的宏定义：
-
-    #define SDS_TYPE_MASK 7
-    #define SDS_TYPE_BITS 3
-    #define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));
-    #define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
-    #define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)
-其中SDS_HDR用来从sds字符串获得header起始位置的指针，比如SDS_HDR(8, s1)表示s1的header指针，SDS_HDR(16, s2)表示s2的header指针。
-
+````
+    #define SDS_TYPE_MASK 7    #define SDS_TYPE_BITS 3    #define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));    #define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))    #define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)其中SDS_HDR用来从sds字符串获得header起始位置的指针，比如SDS_HDR(8, s1)表示s1的header指针，SDS_HDR(16, s2)表示s2的header指针。  
+````
 当然，使用SDS_HDR之前我们必须先知道到底是哪一种header，这样我们才知道SDS_HDR第1个参数应该传什么。由sds字符指针获得header类型的方法是，先向低地址方向偏移1个字节的位置，得到flags字段。比如，s1[-1]和s2[-1]分别获得了s1和s2的flags的值。然后取flags的最低3个bit得到header的类型。
 
-由于s1[-1] == 0x01 == SDS_TYPE_8，因此s1的header类型是sdshdr8。
-由于s2[-1] == 0x02 == SDS_TYPE_16，因此s2的header类型是sdshdr16。
+由于s1[-1] == 0x01 == SDS_TYPE_8，因此s1的header类型是sdshdr8。  
+由于s2[-1] == 0x02 == SDS_TYPE_16，因此s2的header类型是sdshdr16。  
 有了header指针，就能很快定位到它的len和alloc字段：
 
-s1的header中，len的值为0x06，表示字符串数据长度为6；alloc的值为0x80，表示字符数组最大容量为128。
-s2的header中，len的值为0x0006，表示字符串数据长度为6；alloc的值为0x03E8，表示字符数组最大容量为1000。（注意：图中是按小端地址构成）
+s1的header中，len的值为0x06，表示字符串数据长度为6；alloc的值为0x80，表示字符数组最大容量为128。  
+s2的header中，len的值为0x0006，表示字符串数据长度为6；alloc的值为0x03E8，表示字符数组最大容量为1000。（注意：图中是按小端地址构成）  
 在各个header的类型定义中，还有几个需要我们注意的地方：
 
 在各个header的定义中使用了__attribute__ ((packed))，是为了让编译器以紧凑模式来分配内存。如果没有这个属性，编译器可能会为struct的字段做优化对齐，在其中填充空字节。那样的话，就不能保证header和sds的数据部分紧紧前后相邻，也不能按照固定向低地址方向偏移1个字节的方式来获取flags字段了。
@@ -141,7 +95,7 @@ s2的header中，len的值为0x0006，表示字符串数据长度为6；alloc的
 
 它在这里只是起到一个标记的作用，表示在flags字段后面就是一个字符数组，或者说，它指明了紧跟在flags字段后面的这个字符数组在结构体中的偏移位置。而程序在为header分配的内存的时候，它并不占用内存空间。
 
-如果计算sizeof(struct sdshdr16)的值，那么结果是5个字节，其中没有buf字段。
+如果计算sizeof(struct sdshdr16)的值，那么结果是5个字节，其中没有buf字段。  
 sdshdr5与其它几个header结构不同，它不包含alloc字段，而长度使用flags的高5位来存储。
 
 因此，它不能为字符串分配空余空间。如果字符串需要动态增长，那么它就必然要重新分配内存才行。所以说，这种类型的sds字符串更适合存储静态的短字符串（长度小于32）。
@@ -152,208 +106,61 @@ header和数据相邻，而不用分成两块内存空间来单独分配。这
 
 虽然header有多个类型，但sds可以用统一的char *来表达。且它与传统的C语言字符串保持类型兼容。
 
-如果一个sds里面存储的是可打印字符串，那么我们可以直接把它传给C函数，比如使用strcmp比较字符串大小，或者使用printf进行打印。
+如果一个sds里面存储的是可打印字符串，那么我们可以直接把它传给C函数，比如使用strcmp比较字符串大小，或者使用printf进行打印。  
 弄清了sds的数据结构，它的具体操作函数就比较好理解了。
 
-    sds的一些基础函数
-    sdslen(const sds s): 获取sds字符串长度。
-    sdssetlen(sds s, size_t newlen): 设置sds字符串长度。
-    sdsinclen(sds s, size_t inc): 增加sds字符串长度。
-    sdsalloc(const sds s): 获取sds字符串容量。
-    sdssetalloc(sds s, size_t newlen): 设置sds字符串容量。
-    sdsavail(const sds s): 获取sds字符串空余空间（即alloc - len）。
-    sdsHdrSize(char type): 根据header类型得到header大小。
-    sdsReqType(size_t string_size):
-
-根据字符串数据长度计算所需要的header类型。
+    sds的一些基础函数  
+    sdslen(const sds s): 获取sds字符串长度。  
+    sdssetlen(sds s, size_t newlen): 设置sds字符串长度。  
+    sdsinclen(sds s, size_t inc): 增加sds字符串长度。  
+    sdsalloc(const sds s): 获取sds字符串容量。  
+    sdssetalloc(sds s, size_t newlen): 设置sds字符串容量。  
+    sdsavail(const sds s): 获取sds字符串空余空间（即alloc - len）。  
+    sdsHdrSize(char type): 根据header类型得到header大小。  
+    sdsReqType(size_t string_size):  
+根据字符串数据长度计算所需要的header类型。  
 这里我们挑选sdslen和sdsReqType的代码，察看一下。
-
-    static inline size_t sdslen(const sds s) {
-        unsigned char flags = s[-1];
-        switch(flags&SDS_TYPE_MASK) {
-            case SDS_TYPE_5:
-                return SDS_TYPE_5_LEN(flags);
-            case SDS_TYPE_8:
-                return SDS_HDR(8,s)->len;
-            case SDS_TYPE_16:
-                return SDS_HDR(16,s)->len;
-            case SDS_TYPE_32:
-                return SDS_HDR(32,s)->len;
-            case SDS_TYPE_64:
-                return SDS_HDR(64,s)->len;
-        }
-        return 0;
-    }
- 
-    static inline char sdsReqType(size_t string_size) {
-        if (string_size < 1<<5)
-            return SDS_TYPE_5;
-        if (string_size < 1<<8)
-            return SDS_TYPE_8;
-        if (string_size < 1<<16)
-            return SDS_TYPE_16;
-        if (string_size < 1ll<<32)
-            return SDS_TYPE_32;
-        return SDS_TYPE_64;
-    }
-    
-跟前面的分析类似，sdslen先用s[-1]向低地址方向偏移1个字节，得到flags；然后与SDS_TYPE_MASK进行按位与，得到header类型；然后根据不同的header类型，调用SDS_HDR得到header起始指针，进而获得len字段。
-
+````
+    static inline size_t sdslen(const sds s) {        unsigned char flags = s[-1];        switch(flags&SDS_TYPE_MASK) {            case SDS_TYPE_5:                return SDS_TYPE_5_LEN(flags);            case SDS_TYPE_8:                return SDS_HDR(8,s)->len;            case SDS_TYPE_16:                return SDS_HDR(16,s)->len;            case SDS_TYPE_32:                return SDS_HDR(32,s)->len;            case SDS_TYPE_64:                return SDS_HDR(64,s)->len;        }        return 0;    }     static inline char sdsReqType(size_t string_size) {  
+        if (string_size < 1<<5)            return SDS_TYPE_5;        if (string_size < 1<<8)            return SDS_TYPE_8;        if (string_size < 1<<16)            return SDS_TYPE_16;        if (string_size < 1ll<<32)            return SDS_TYPE_32;        return SDS_TYPE_64;    }    跟前面的分析类似，sdslen先用s[-1]向低地址方向偏移1个字节，得到flags；然后与SDS_TYPE_MASK进行按位与，得到header类型；然后根据不同的header类型，调用SDS_HDR得到header起始指针，进而获得len字段。  
+````
 通过sdsReqType的代码，很容易看到：
 
-长度在0和2^5-1之间，选用SDS_TYPE_5类型的header。
-长度在2^5和2^8-1之间，选用SDS_TYPE_8类型的header。
-长度在2^8和2^16-1之间，选用SDS_TYPE_16类型的header。
-长度在2^16和2^32-1之间，选用SDS_TYPE_32类型的header。
-长度大于2^32的，选用SDS_TYPE_64类型的header。能表示的最大长度为2^64-1。
+长度在0和2^5-1之间，选用SDS_TYPE_5类型的header。  
+长度在2^5和2^8-1之间，选用SDS_TYPE_8类型的header。  
+长度在2^8和2^16-1之间，选用SDS_TYPE_16类型的header。  
+长度在2^16和2^32-1之间，选用SDS_TYPE_32类型的header。  
+长度大于2^32的，选用SDS_TYPE_64类型的header。能表示的最大长度为2^64-1。  
 注：sdsReqType的实现代码，直到3.2.0，它在长度边界值上都一直存在问题，直到最近3.2 branch上的commit 6032340才修复。
 
 ## sds的创建和销毁
-    sds sdsnewlen(const void *init, size_t initlen) {
-        void *sh;
-        sds s;
-        char type = sdsReqType(initlen);
-        /* Empty strings are usually created in order to append. Use type 8
-         * since type 5 is not good at this. */
-        if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
-        int hdrlen = sdsHdrSize(type);
-        unsigned char *fp; /* flags pointer. */
-     
-        sh = s_malloc(hdrlen+initlen+1);
-        if (!init)
-            memset(sh, 0, hdrlen+initlen+1);
-        if (sh == NULL) return NULL;
-        s = (char*)sh+hdrlen;
-        fp = ((unsigned char*)s)-1;
-        switch(type) {
-            case SDS_TYPE_5: {
-                *fp = type | (initlen << SDS_TYPE_BITS);
-                break;
-            }
-            case SDS_TYPE_8: {
-                SDS_HDR_VAR(8,s);
-                sh->len = initlen;
-                sh->alloc = initlen;
-                *fp = type;
-                break;
-            }
-            case SDS_TYPE_16: {
-                SDS_HDR_VAR(16,s);
-                sh->len = initlen;
-                sh->alloc = initlen;
-                *fp = type;
-                break;
-            }
-            case SDS_TYPE_32: {
-                SDS_HDR_VAR(32,s);
-                sh->len = initlen;
-                sh->alloc = initlen;
-                *fp = type;
-                break;
-            }
-            case SDS_TYPE_64: {
-                SDS_HDR_VAR(64,s);
-                sh->len = initlen;
-                sh->alloc = initlen;
-                *fp = type;
-                break;
-            }
-        }
-        if (initlen && init)
-            memcpy(s, init, initlen);
-        s[initlen] = '\0';
-        return s;
-    }
-     
-    sds sdsempty(void) {
-        return sdsnewlen("",0);
-    }
-     
-    sds sdsnew(const char *init) {
-        size_t initlen = (init == NULL) ? 0 : strlen(init);
-        return sdsnewlen(init, initlen);
-    }
-     
-    void sdsfree(sds s) {
-        if (s == NULL) return;
-        s_free((char*)s-sdsHdrSize(s[-1]));
-    }
-    
-    
+````
+    sds sdsnewlen(const void *init, size_t initlen) {        void *sh;        sds s;        char type = sdsReqType(initlen);        /* Empty strings are usually created in order to append. Use type 8         * since type 5 is not good at this. */        if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;        int hdrlen = sdsHdrSize(type);        unsigned char *fp; /* flags pointer. */             sh = s_malloc(hdrlen+initlen+1);  
+        if (!init)            memset(sh, 0, hdrlen+initlen+1);        if (sh == NULL) return NULL;        s = (char*)sh+hdrlen;        fp = ((unsigned char*)s)-1;        switch(type) {            case SDS_TYPE_5: {                *fp = type | (initlen << SDS_TYPE_BITS);                break;            }            case SDS_TYPE_8: {                SDS_HDR_VAR(8,s);                sh->len = initlen;                sh->alloc = initlen;                *fp = type;                break;            }            case SDS_TYPE_16: {                SDS_HDR_VAR(16,s);                sh->len = initlen;                sh->alloc = initlen;                *fp = type;                break;            }            case SDS_TYPE_32: {                SDS_HDR_VAR(32,s);                sh->len = initlen;                sh->alloc = initlen;                *fp = type;                break;            }            case SDS_TYPE_64: {                SDS_HDR_VAR(64,s);                sh->len = initlen;                sh->alloc = initlen;                *fp = type;                break;            }        }        if (initlen && init)            memcpy(s, init, initlen);        s[initlen] = '\0';        return s;    }         sds sdsempty(void) {  
+        return sdsnewlen("",0);    }         sds sdsnew(const char *init) {  
+        size_t initlen = (init == NULL) ? 0 : strlen(init);        return sdsnewlen(init, initlen);    }         void sdsfree(sds s) {  
+        if (s == NULL) return;        s_free((char*)s-sdsHdrSize(s[-1]));    }          
+````
 sdsnewlen创建一个长度为initlen的sds字符串，并使用init指向的字符数组（任意二进制数据）来初始化数据。如果init为NULL，那么使用全0来初始化数据。它的实现中，我们需要注意的是：
 
-如果要创建一个长度为0的空字符串，那么不使用SDS_TYPE_5类型的header，而是转而使用SDS_TYPE_8类型的header。这是因为创建的空字符串一般接下来的操作很可能是追加数据，但SDS_TYPE_5类型的sds字符串不适合追加数据（会引发内存重新分配）。
-需要的内存空间一次性进行分配，其中包含三部分：header、数据、最后的多余字节（hdrlen+initlen+1）。
-初始化的sds字符串数据最后会追加一个NULL结束符（s[initlen] = ‘\0’）。
+如果要创建一个长度为0的空字符串，那么不使用SDS_TYPE_5类型的header，而是转而使用SDS_TYPE_8类型的header。这是因为创建的空字符串一般接下来的操作很可能是追加数据，但SDS_TYPE_5类型的sds字符串不适合追加数据（会引发内存重新分配）。  
+需要的内存空间一次性进行分配，其中包含三部分：header、数据、最后的多余字节（hdrlen+initlen+1）。  
+初始化的sds字符串数据最后会追加一个NULL结束符（s[initlen] = ‘\0’）。  
 关于sdsfree，需要注意的是：内存要整体释放，所以要先计算出header起始指针，把它传给s_free函数。这个指针也正是在sdsnewlen中调用s_malloc返回的那个地址。
 
 ## sds的连接（追加）操作
-    sds sdscatlen(sds s, const void *t, size_t len) {
-        size_t curlen = sdslen(s);
-     
-        s = sdsMakeRoomFor(s,len);
-        if (s == NULL) return NULL;
-        memcpy(s+curlen, t, len);
-        sdssetlen(s, curlen+len);
-        s[curlen+len] = '\0';
-        return s;
-    }
-     
-    sds sdscat(sds s, const char *t) {
-        return sdscatlen(s, t, strlen(t));
-    }
-     
-    sds sdscatsds(sds s, const sds t) {
-        return sdscatlen(s, t, sdslen(t));
-    }
-     
-    sds sdsMakeRoomFor(sds s, size_t addlen) {
-        void *sh, *newsh;
-        size_t avail = sdsavail(s);
-        size_t len, newlen;
-        char type, oldtype = s[-1] & SDS_TYPE_MASK;
-        int hdrlen;
-     
-        /* Return ASAP if there is enough space left. */
-        if (avail >= addlen) return s;
-     
-        len = sdslen(s);
-        sh = (char*)s-sdsHdrSize(oldtype);
-        newlen = (len+addlen);
-        if (newlen < SDS_MAX_PREALLOC)
-            newlen *= 2;
-        else
-            newlen += SDS_MAX_PREALLOC;
-     
-        type = sdsReqType(newlen);
-     
-        /* Don't use type 5: the user is appending to the string and type 5 is
-         * not able to remember empty space, so sdsMakeRoomFor() must be called
-         * at every appending operation. */
-        if (type == SDS_TYPE_5) type = SDS_TYPE_8;
-     
-        hdrlen = sdsHdrSize(type);
-        if (oldtype==type) {
-            newsh = s_realloc(sh, hdrlen+newlen+1);
-            if (newsh == NULL) return NULL;
-            s = (char*)newsh+hdrlen;
-        } else {
-            /* Since the header size changes, need to move the string forward,
-             * and can't use realloc */
-            newsh = s_malloc(hdrlen+newlen+1);
-            if (newsh == NULL) return NULL;
-            memcpy((char*)newsh+hdrlen, s, len+1);
-            s_free(sh);
-            s = (char*)newsh+hdrlen;
-            s[-1] = type;
-            sdssetlen(s, len);
-        }
-        sdssetalloc(s, newlen);
-        return s;
-    }
-    
-sdscatlen将t指向的长度为len的任意二进制数据追加到sds字符串s的后面。本文开头演示的string的append命令，内部就是调用sdscatlen来实现的。
-
+````
+    sds sdscatlen(sds s, const void *t, size_t len) {        size_t curlen = sdslen(s);             s = sdsMakeRoomFor(s,len);  
+        if (s == NULL) return NULL;        memcpy(s+curlen, t, len);        sdssetlen(s, curlen+len);        s[curlen+len] = '\0';        return s;    }         sds sdscat(sds s, const char *t) {  
+        return sdscatlen(s, t, strlen(t));    }         sds sdscatsds(sds s, const sds t) {  
+        return sdscatlen(s, t, sdslen(t));    }         sds sdsMakeRoomFor(sds s, size_t addlen) {  
+        void *sh, *newsh;        size_t avail = sdsavail(s);        size_t len, newlen;        char type, oldtype = s[-1] & SDS_TYPE_MASK;        int hdrlen;             /* Return ASAP if there is enough space left. */  
+        if (avail >= addlen) return s;             len = sdslen(s);  
+        sh = (char*)s-sdsHdrSize(oldtype);        newlen = (len+addlen);        if (newlen < SDS_MAX_PREALLOC)            newlen *= 2;        else            newlen += SDS_MAX_PREALLOC;             type = sdsReqType(newlen);  
+             /* Don't use type 5: the user is appending to the string and type 5 is  
+         * not able to remember empty space, so sdsMakeRoomFor() must be called         * at every appending operation. */        if (type == SDS_TYPE_5) type = SDS_TYPE_8;             hdrlen = sdsHdrSize(type);  
+        if (oldtype==type) {            newsh = s_realloc(sh, hdrlen+newlen+1);            if (newsh == NULL) return NULL;            s = (char*)newsh+hdrlen;        } else {            /* Since the header size changes, need to move the string forward,             * and can't use realloc */            newsh = s_malloc(hdrlen+newlen+1);            if (newsh == NULL) return NULL;            memcpy((char*)newsh+hdrlen, s, len+1);            s_free(sh);            s = (char*)newsh+hdrlen;            s[-1] = type;            sdssetlen(s, len);        }        sdssetalloc(s, newlen);        return s;    }    sdscatlen将t指向的长度为len的任意二进制数据追加到sds字符串s的后面。本文开头演示的string的append命令，内部就是调用sdscatlen来实现的。  
+````
 在sdscatlen的实现中，先调用sdsMakeRoomFor来保证字符串s有足够的空间来追加长度为len的数据。sdsMakeRoomFor可能会分配新的内存，也可能不会。
 
 sdsMakeRoomFor是sds实现中很重要的一个函数。关于它的实现代码，我们需要注意的是：
@@ -383,4 +190,3 @@ setbit和getrange都是先根据key取到整个sds字符串，然后再从字符
 但是，string除了支持这些操作之外，当它存储的值是个数字的时候，它还支持incr、decr等操作。那么，当string存储数字值的时候，它的内部存储还是sds吗？
 
 实际上，不是了。而且，这种情况下，setbit和getrange的实现也会有所不同。这些细节，我们放在下一篇介绍robj的时候再进行系统地讨论。
-
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2606\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224skiplist.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224skiplist.md"
similarity index 90%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2606\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224skiplist.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224skiplist.md"
index 5133967..d419a09 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2606\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224skiplist.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224skiplist.md"
@@ -1,21 +1,23 @@
-# Table of Contents
+# 目录
 
-    * [skiplist数据结构简介](#skiplist数据结构简介)
-    * [skiplist的算法性能分析](#skiplist的算法性能分析)
-    * [skiplist与平衡树、哈希表的比较](#skiplist与平衡树、哈希表的比较)
-    * [Redis中的skiplist实现](#redis中的skiplist实现)
-      * [sorted set的命令举例](#sorted-set的命令举例)
-      * [Redis中skiplist实现的特殊性](#redis中skiplist实现的特殊性)
-      * [skiplist的数据结构定义](#skiplist的数据结构定义)
-            * [ZSKIPLIST_MAXLEVEL 32](#zskiplist_maxlevel-32)
-            * [ZSKIPLIST_P 0.25](#zskiplist_p-025)
-    * [Redis中的sorted set](#redis中的sorted-set)
-    * [Redis为什么用skiplist而不用平衡树？](#redis为什么用skiplist而不用平衡树？)
+  * [skiplist数据结构简介](#skiplist数据结构简介)
+  * [skiplist的算法性能分析](#skiplist的算法性能分析)
+  * [skiplist与平衡树、哈希表的比较](#skiplist与平衡树、哈希表的比较)
+  * [Redis中的skiplist实现](#redis中的skiplist实现)
+    * [sorted set的命令举例](#sorted-set的命令举例)
+    * [Redis中skiplist实现的特殊性](#redis中skiplist实现的特殊性)
+    * [skiplist的数据结构定义](#skiplist的数据结构定义)
+  * [Redis中的sorted set](#redis中的sorted-set)
+  * [Redis为什么用skiplist而不用平衡树？](#redis为什么用skiplist而不用平衡树？)
+
+
+[toc]
 
 
 本文转自互联网
 
 本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
@@ -58,7 +60,7 @@ zset-max-ziplist-value 64
 
 注：本文讨论的代码实现基于Redis源码的3.2分支。
 
-### skiplist数据结构简介
+## skiplist数据结构简介
 
 skiplist本质上也是一种查找结构，用于解决算法中的查找问题（Searching），即根据给定的key，快速查到它所在的位置（或者对应的value）。
 
@@ -70,17 +72,17 @@ skiplist，顾名思义，首先它是一个list。实际上，它是在有序
 
 我们先来看一个有序链表，如下图（最左侧的灰色节点表示一个空的头结点）：
 
-[![有序链表结构图](http://zhangtielei.com/assets/photos_redis/skiplist/sorted_linked_list.png)](http://zhangtielei.com/assets/photos_redis/skiplist/sorted_linked_list.png)
+![[有序链表结构图](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/sorted_linked_list.png)](http://zhangtielei.com/assets/photos_redis/skiplist/sorted_linked_list.png)
 
 在这样一个链表中，如果我们要查找某个数据，那么需要从头开始逐个进行比较，直到找到包含数据的那个节点，或者找到第一个比给定数据大的节点为止（没找到）。也就是说，时间复杂度为O(n)。同样，当我们要插入新数据的时候，也要经历同样的查找过程，从而确定插入位置。
 
 假如我们每相邻两个节点增加一个指针，让指针指向下下个节点，如下图：
 
-[![每两个节点增加一个跳跃指针的有序链表](http://zhangtielei.com/assets/photos_redis/skiplist/skip2node_linked_list.png)](http://zhangtielei.com/assets/photos_redis/skiplist/skip2node_linked_list.png)
+[![每两个节点增加一个跳跃指针的有序链表](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/skip2node_linked_list.png)](http://zhangtielei.com/assets/photos_redis/skiplist/skip2node_linked_list.png)
 
 这样所有新增加的指针连成了一个新的链表，但它包含的节点个数只有原来的一半（上图中是7, 19, 26）。现在当我们想查找数据的时候，可以先沿着这个新链表进行查找。当碰到比待查数据大的节点时，再回到原来的链表中进行查找。比如，我们想查找23，查找的路径是沿着下图中标红的指针所指向的方向进行的：
 
-[![一个搜索路径的例子](http://zhangtielei.com/assets/photos_redis/skiplist/search_path_on_skip2node_list.png)](http://zhangtielei.com/assets/photos_redis/skiplist/search_path_on_skip2node_list.png)
+[![一个搜索路径的例子](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/search_path_on_skip2node_list.png)](http://zhangtielei.com/assets/photos_redis/skiplist/search_path_on_skip2node_list.png)
 
 *   23首先和7比较，再和19比较，比它们都大，继续向后比较。
 *   但23和26比较的时候，比26要小，因此回到下面的链表（原链表），与22比较。
@@ -90,7 +92,7 @@ skiplist，顾名思义，首先它是一个list。实际上，它是在有序
 
 利用同样的方式，我们可以在上层新产生的链表上，继续为每相邻的两个节点增加一个指针，从而产生第三层链表。如下图：
 
-[![两层跳跃指针](http://zhangtielei.com/assets/photos_redis/skiplist/skip2node_level3_linked_list.png)](http://zhangtielei.com/assets/photos_redis/skiplist/skip2node_level3_linked_list.png)
+[![两层跳跃指针](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/skip2node_level3_linked_list.png)](http://zhangtielei.com/assets/photos_redis/skiplist/skip2node_level3_linked_list.png)
 
 在这个新的三层链表结构上，如果我们还是查找23，那么沿着最上层链表首先要比较的是19，发现23比19大，接下来我们就知道只需要到19的后面去继续查找，从而一下子跳过了19前面的所有节点。可以想象，当链表足够长的时候，这种多层链表的查找方式能让我们跳过很多下层节点，大大加快查找的速度。
 
@@ -98,7 +100,7 @@ skiplist正是受这种多层链表的想法的启发而设计出来的。实际
 
 skiplist为了避免这一问题，它不要求上下相邻两层链表之间的节点个数有严格的对应关系，而是为每个节点随机出一个层数(level)。比如，一个节点随机出的层数是3，那么就把它链入到第1层到第3层这三层链表中。为了表达清楚，下图展示了如何通过一步步的插入操作从而形成一个skiplist的过程：
 
-[![skiplist插入形成过程](http://zhangtielei.com/assets/photos_redis/skiplist/skiplist_insertions.png)](http://zhangtielei.com/assets/photos_redis/skiplist/skiplist_insertions.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230406205225.png)
 
 从上面skiplist的创建和插入过程可以看出，每一个节点的层数（level）是随机出来的，而且新插入一个节点不会影响其它节点的层数。因此，插入操作只需要修改插入节点前后的指针，而不需要对很多节点都进行调整。这就降低了插入操作的复杂度。实际上，这是skiplist的一个很重要的特性，这让它在插入性能上明显优于平衡树的方案。这在后面我们还会提到。
 
@@ -106,7 +108,7 @@ skiplist为了避免这一问题，它不要求上下相邻两层链表之间的
 
 刚刚创建的这个skiplist总共包含4层链表，现在假设我们在它里面依然查找23，下图给出了查找路径：
 
-[![skiplist上的查找路径展示](http://zhangtielei.com/assets/photos_redis/skiplist/search_path_on_skiplist.png)](http://zhangtielei.com/assets/photos_redis/skiplist/search_path_on_skiplist.png)
+[![skiplist上的查找路径展示](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/search_path_on_skiplist.png)](http://zhangtielei.com/assets/photos_redis/skiplist/search_path_on_skiplist.png)
 
 需要注意的是，前面演示的各个节点的插入过程，实际上在插入之前也要先经历一个类似的查找过程，在确定插入位置后，再完成插入操作。
 
@@ -158,7 +160,7 @@ MaxLevel = 32
 
 
 
-### skiplist的算法性能分析
+## skiplist的算法性能分析
 
 在这一部分，我们来简单分析一下skiplist的时间复杂度和空间复杂度，以便对于skiplist的性能有一个直观的了解。如果你不是特别偏执于算法的性能分析，那么可以暂时跳过这一小节的内容。
 
@@ -175,7 +177,7 @@ MaxLevel = 32
 
 因此，一个节点的平均层数（也即包含的平均指针数目），计算如下：
 
-[![skiplist平均层数计算](http://zhangtielei.com/assets/photos_redis/skiplist/skiplist_avg_level.png)](http://zhangtielei.com/assets/photos_redis/skiplist/skiplist_avg_level.png)
+[![skiplist平均层数计算](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/skiplist_avg_level.png)](http://zhangtielei.com/assets/photos_redis/skiplist/skiplist_avg_level.png)
 
 现在很容易计算出：
 
@@ -195,7 +197,7 @@ MaxLevel = 32
 
 这两种情形如下图所示：
 
-[![skiplist沿查找路径回溯](http://zhangtielei.com/assets/photos_redis/skiplist/skiplist_backwards.png)](http://zhangtielei.com/assets/photos_redis/skiplist/skiplist_backwards.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230406205314.png)
 
 用C(k)表示向上攀爬k个层级所需要走过的平均查找路径长度（概率期望），那么：
 
@@ -249,7 +251,7 @@ C(k)=k/p
 
 当然，这里的时间复杂度分析还是比较粗略的。比如，沿着查找路径向左向上回溯的时候，可能先到达左侧头结点，然后沿头结点一路向上；还可能先到达最高层的节点，然后沿着最高层链表一路向左。但这些细节不影响平均时间复杂度的最后结果。另外，这里给出的时间复杂度只是一个概率平均值，但实际上计算一个精细的概率分布也是有可能的。详情还请参见[William Pugh](https://en.wikipedia.org/wiki/William_Pugh)的论文《[Skip Lists: A Probabilistic Alternative to Balanced Trees](ftp://ftp.cs.umd.edu/pub/skipLists/skiplists.pdf)》。
 
-### skiplist与平衡树、哈希表的比较
+## skiplist与平衡树、哈希表的比较
 
 *   skiplist和各种平衡树（如AVL、红黑树等）的元素是有序排列的，而哈希表不是有序的。因此，在哈希表上只能做单个key的查找，不适宜做范围查找。所谓范围查找，指的是查找那些大小在指定的两个值之间的所有节点。
 *   在做范围查找的时候，平衡树比skiplist操作要复杂。在平衡树上，我们找到指定范围的小值之后，还需要以中序遍历的顺序继续寻找其它不超过大值的节点。如果不对平衡树进行一定的改造，这里的中序遍历并不容易实现。而在skiplist上进行范围查找就非常简单，只需要在找到小值之后，对第1层链表进行若干步的遍历就可以实现。
@@ -258,13 +260,13 @@ C(k)=k/p
 *   查找单个key，skiplist和平衡树的时间复杂度都为O(log n)，大体相当；而哈希表在保持较低的哈希值冲突概率的前提下，查找时间复杂度接近O(1)，性能更高一些。所以我们平常使用的各种Map或dictionary结构，大都是基于哈希表实现的。
 *   从算法实现难度上来比较，skiplist比平衡树要简单得多。
 
-### Redis中的skiplist实现
+## Redis中的skiplist实现
 
 在这一部分，我们讨论Redis中的skiplist实现。
 
 在Redis中，skiplist被用于实现暴露给外部的一个数据结构：sorted set。准确地说，sorted set底层不仅仅使用了skiplist，还使用了ziplist和dict。这几个数据结构的关系，我们下一章再讨论。现在，我们先花点时间把sorted set的关键命令看一下。这些命令对于Redis里skiplist的实现，有重要的影响。
 
-#### sorted set的命令举例
+### sorted set的命令举例
 
 sorted set是一个有序的数据集合，对于像类似排行榜这样的应用场景特别适合。
 
@@ -279,7 +281,7 @@ sorted set是一个有序的数据集合，对于像类似排行榜这样的应
 
 这份数据给出了每位同学的名字和分数。下面我们将这份数据存储到sorted set里面去：
 
-[![sorted set命令举例](http://zhangtielei.com/assets/photos_redis/skiplist/sorted_set_cmd_examples.png)](http://zhangtielei.com/assets/photos_redis/skiplist/sorted_set_cmd_examples.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230406205334.png)
 
 对于上面的这些命令，我们需要的注意的地方包括：
 
@@ -295,7 +297,7 @@ sorted set是一个有序的数据集合，对于像类似排行榜这样的应
 *   每个数据对应一个分数(score)。
 *   根据分数大小和数据本身的字典排序，每个数据会产生一个排名(rank)。可以按正序或倒序。
 
-#### Redis中skiplist实现的特殊性
+### Redis中skiplist实现的特殊性
 
 我们简单分析一下前面出现的几个查询命令：
 
@@ -328,7 +330,7 @@ sorted set是一个有序的数据集合，对于像类似排行榜这样的应
 *   第1层链表不是一个单向链表，而是一个双向链表。这是为了方便以倒序方式获取一个范围内的元素。
 *   在skiplist中可以很方便地计算出每个元素的排名(rank)。
 
-#### skiplist的数据结构定义
+### skiplist的数据结构定义
 
 
 
@@ -375,7 +377,7 @@ typedef struct zskiplist {
 
 下图以前面插入的代数课成绩表为例，展示了Redis中一个skiplist的可能结构：
 
-[![Redis skiplist结构举例](http://zhangtielei.com/assets/photos_redis/skiplist/redis_skiplist_example.png)](http://zhangtielei.com/assets/photos_redis/skiplist/redis_skiplist_example.png)
+[![Redis skiplist结构举例](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/redis_skiplist_example.png)](http://zhangtielei.com/assets/photos_redis/skiplist/redis_skiplist_example.png)
 
 注意：图中前向指针上面括号中的数字，表示对应的span的值。即当前指针跨越了多少个节点，这个计数不包括指针的起点节点，但包括指针的终点节点。
 
@@ -383,7 +385,7 @@ typedef struct zskiplist {
 
 可见，在查找skiplist的过程中，通过累加span值的方式，我们就能很容易算出排名。相反，如果指定排名来查找数据（类似zrange和zrevrange那样），也可以不断累加span并时刻保持累加值不超过指定的排名，通过这种方式就能得到一条O(log n)的查找路径。
 
-### Redis中的sorted set
+## Redis中的sorted set
 
 我们前面提到过，Redis中的sorted set，是在skiplist, dict和ziplist基础上构建起来的:
 
@@ -435,16 +437,16 @@ typedef struct zset {
 
 
 
-### Redis为什么用skiplist而不用平衡树？
+## Redis为什么用skiplist而不用平衡树？
 
 在前面我们对于skiplist和平衡树、哈希表的比较中，其实已经不难看出Redis里使用skiplist而不用平衡树的原因了。现在我们看看，对于这个问题，Redis的作者 @antirez 是怎么说的：
 
 > There are a few reasons:
-> 
+>
 > 1) They are not very memory intensive. It’s up to you basically. Changing parameters about the probability of a node to have a given number of levels will make then less memory intensive than btrees.
-> 
+>
 > 2) A sorted set is often target of many ZRANGE or ZREVRANGE operations, that is, traversing the skip list as a linked list. With this operation the cache locality of skip lists is at least as good as with other kind of balanced trees.
-> 
+>
 > 3) They are simpler to implement, debug, and so forth. For instance thanks to the skip list simplicity I received a patch (already in Redis master) with augmented skip lists implementing ZRANK in O(log(N)). It required little changes to the code.
 
 这段话原文出处：
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2604\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224ziplist.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224ziplist.md"
similarity index 80%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2604\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224ziplist.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224ziplist.md"
index 85ebd5e..85e3de6 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2604\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224ziplist.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\206\205\351\203\250\346\225\260\346\215\256\347\273\223\346\236\204\350\257\246\350\247\243\342\200\224\342\200\224ziplist.md"
@@ -1,12 +1,14 @@
-# Table of Contents
+# 目录
 
-      * [什么是ziplist](#什么是ziplist)
-      * [ziplist的数据结构定义](#ziplist的数据结构定义)
-      * [ziplist的接口](#ziplist的接口)
-      * [ziplist的插入逻辑解析](#ziplist的插入逻辑解析)
-      * [hash与ziplist](#hash与ziplist)
+  * [什么是ziplist](#什么是ziplist)
+  * [ziplist的数据结构定义](#ziplist的数据结构定义)
+  * [ziplist的接口](#ziplist的接口)
+  * [ziplist的插入逻辑解析](#ziplist的插入逻辑解析)
+  * [hash与ziplist](#hash与ziplist)
 
 
+[toc]
+
 本文转自互联网
 
 本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -20,7 +22,7 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 
 
 本文是《[Redis内部数据结构详解](http://zhangtielei.com/posts/blog-redis-dict.html)》系列的第四篇。在本文中，我们首先介绍一个新的Redis内部数据结构——ziplist，然后在文章后半部分我们会讨论一下在robj, dict和ziplist的基础上，Redis对外暴露的hash结构是怎样构建起来的。
@@ -28,22 +30,16 @@
 我们在讨论中还会涉及到两个Redis配置（在redis.conf中的ADVANCED CONFIG部分）：
 
 
-
-
-
-```
-hash-max-ziplist-entries 512
-hash-max-ziplist-value 64
-
+```  
+hash-max-ziplist-entries 512  
+hash-max-ziplist-value 64  
+  
 ```
 
 
-
-
-
 本文的后半部分会对这两个配置做详细的解释。
 
-#### 什么是ziplist
+## 什么是ziplist
 
 Redis官方对于ziplist的定义是（出自ziplist.c的文件头部注释）：
 
@@ -55,7 +51,7 @@ Redis官方对于ziplist的定义是（出自ziplist.c的文件头部注释）
 
 另外，ziplist为了在细节上节省内存，对于值的存储采用了变长的编码方式，大概意思是说，对于大的整数，就多用一些字节来存储，而对于小的整数，就少用一些字节来存储。我们接下来很快就会讨论到这些实现细节。
 
-#### ziplist的数据结构定义
+## ziplist的数据结构定义
 
 ziplist的数据结构组成是本文要讨论的重点。实际上，ziplist还是稍微有点复杂的，它复杂的地方就在于它的数据结构定义。一旦理解了数据结构，它的一些操作也就比较容易理解了。
 
@@ -73,7 +69,7 @@ ziplist的数据结构组成是本文要讨论的重点。实际上，ziplist还
 *   `<entry>`: 表示真正存放数据的数据项，长度不定。一个数据项（entry）也有它自己的内部结构，这个稍后再解释。
 *   `<zlend>`: ziplist最后1个字节，是一个结束标记，值固定等于255。
 
-上面的定义中还值得注意的一点是：`<zlbytes>`, `<zltail>`, `<zllen>`既然占据多个字节，那么在存储的时候就有大端（big endian）和小端（little endian）的区别。ziplist采取的是小端模式来存储，这在下面我们介绍具体例子的时候还会再详细解释。
+上面的定义中还值得注意的一点是：`<zlbytes>`,`<zltail>`,`<zllen>`既然占据多个字节，那么在存储的时候就有大端（big endian）和小端（little endian）的区别。ziplist采取的是小端模式来存储，这在下面我们介绍具体例子的时候还会再详细解释。
 
 我们再来看一下每一个数据项`<entry>`的构成：
 
@@ -109,7 +105,7 @@ ziplist的数据结构组成是本文要讨论的重点。实际上，ziplist还
 
 好了，ziplist的数据结构定义，我们介绍完了，现在我们看一个具体的例子。
 
-[![Redis Ziplist Sample](http://zhangtielei.com/assets/photos_redis/redis_ziplist_sample.png)](http://zhangtielei.com/assets/photos_redis/redis_ziplist_sample.png)
+[![Redis Ziplist Sample](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/redis_ziplist_sample.png)
 
 上图是一份真实的ziplist数据。我们逐项解读一下：
 
@@ -138,7 +134,7 @@ ziplist的数据结构组成是本文要讨论的重点。实际上，ziplist还
 
 接下来我要贴一些代码了。
 
-#### ziplist的接口
+## ziplist的接口
 
 我们先不着急看实现，先来挑几个ziplist的重要的接口，看看它们长什么样子：
 
@@ -146,19 +142,19 @@ ziplist的数据结构组成是本文要讨论的重点。实际上，ziplist还
 
 
 
-```
-unsigned char *ziplistNew(void);
-unsigned char *ziplistMerge(unsigned char **first, unsigned char **second);
-unsigned char *ziplistPush(unsigned char *zl, unsigned char *s, unsigned int slen, int where);
-unsigned char *ziplistIndex(unsigned char *zl, int index);
-unsigned char *ziplistNext(unsigned char *zl, unsigned char *p);
-unsigned char *ziplistPrev(unsigned char *zl, unsigned char *p);
-unsigned char *ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen);
-unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p);
-unsigned char *ziplistFind(unsigned char *p, unsigned char *vstr, unsigned int vlen, unsigned int skip);
-unsigned int ziplistLen(unsigned char *zl);
-
-```
+```  
+unsigned char *ziplistNew(void);  
+unsigned char *ziplistMerge(unsigned char **first, unsigned char **second);  
+unsigned char *ziplistPush(unsigned char *zl, unsigned char *s, unsigned int slen, int where);  
+unsigned char *ziplistIndex(unsigned char *zl, int index);  
+unsigned char *ziplistNext(unsigned char *zl, unsigned char *p);  
+unsigned char *ziplistPrev(unsigned char *zl, unsigned char *p);  
+unsigned char *ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen);  
+unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p);  
+unsigned char *ziplistFind(unsigned char *p, unsigned char *vstr, unsigned int vlen, unsigned int skip);  
+unsigned int ziplistLen(unsigned char *zl);  
+  
+```  
 
 
 
@@ -177,7 +173,7 @@ unsigned int ziplistLen(unsigned char *zl);
 *   ziplistFind: 查找给定的数据（由vstr和vlen指定）。注意它有一个skip参数，表示查找的时候每次比较之间要跳过几个数据项。为什么会有这么一个参数呢？其实这个参数的主要用途是当用ziplist表示hash结构的时候，是按照一个field，一个value来依次存入ziplist的。也就是说，偶数索引的数据项存field，奇数索引的数据项存value。当按照field的值进行查找的时候，就需要把奇数项跳过去。
 *   ziplistLen: 计算ziplist的长度（即包含数据项的个数）。
 
-#### ziplist的插入逻辑解析
+## ziplist的插入逻辑解析
 
 ziplist的相关接口的具体实现，还是有些复杂的，限于篇幅的原因，我们这里只结合代码来讲解插入的逻辑。插入是很有代表性的操作，通过这部分来一窥ziplist内部的实现，其它部分的实现我们也就会很容易理解了。
 
@@ -187,98 +183,21 @@ ziplistPush和ziplistInsert都是插入，只是对于插入位置的限定不
 
 
 
-```
-static unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {
-    size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), reqlen;
-    unsigned int prevlensize, prevlen = 0;
-    size_t offset;
-    int nextdiff = 0;
-    unsigned char encoding = 0;
-    long long value = 123456789; /* initialized to avoid warning. Using a value
-                                    that is easy to see if for some reason
-                                    we use it uninitialized. */
-    zlentry tail;
-
-    /* Find out prevlen for the entry that is inserted. */
-    if (p[0] != ZIP_END) {
-        ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
-    } else {
-        unsigned char *ptail = ZIPLIST_ENTRY_TAIL(zl);
-        if (ptail[0] != ZIP_END) {
-            prevlen = zipRawEntryLength(ptail);
-        }
-    }
-
-    /* See if the entry can be encoded */
-    if (zipTryEncoding(s,slen,&value,&encoding)) {
-        /* 'encoding' is set to the appropriate integer encoding */
-        reqlen = zipIntSize(encoding);
-    } else {
-        /* 'encoding' is untouched, however zipEncodeLength will use the
-         * string length to figure out how to encode it. */
-        reqlen = slen;
-    }
-    /* We need space for both the length of the previous entry and
-     * the length of the payload. */
-    reqlen += zipPrevEncodeLength(NULL,prevlen);
-    reqlen += zipEncodeLength(NULL,encoding,slen);
-
-    /* When the insert position is not equal to the tail, we need to
-     * make sure that the next entry can hold this entry's length in
-     * its prevlen field. */
-    nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0;
-
-    /* Store offset because a realloc may change the address of zl. */
-    offset = p-zl;
-    zl = ziplistResize(zl,curlen+reqlen+nextdiff);
-    p = zl+offset;
-
-    /* Apply memory move when necessary and update tail offset. */
-    if (p[0] != ZIP_END) {
-        /* Subtract one because of the ZIP_END bytes */
-        memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);
-
-        /* Encode this entry's raw length in the next entry. */
-        zipPrevEncodeLength(p+reqlen,reqlen);
-
-        /* Update offset for tail */
-        ZIPLIST_TAIL_OFFSET(zl) =
-            intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+reqlen);
-
-        /* When the tail contains more than one entry, we need to take
-         * "nextdiff" in account as well. Otherwise, a change in the
-         * size of prevlen doesn't have an effect on the *tail* offset. */
-        zipEntry(p+reqlen, &tail);
-        if (p[reqlen+tail.headersize+tail.len] != ZIP_END) {
-            ZIPLIST_TAIL_OFFSET(zl) =
-                intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);
-        }
-    } else {
-        /* This element will be the new tail. */
-        ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(p-zl);
-    }
-
-    /* When nextdiff != 0, the raw length of the next entry has changed, so
-     * we need to cascade the update throughout the ziplist */
-    if (nextdiff != 0) {
-        offset = p-zl;
-        zl = __ziplistCascadeUpdate(zl,p+reqlen);
-        p = zl+offset;
-    }
-
-    /* Write the entry */
-    p += zipPrevEncodeLength(p,prevlen);
-    p += zipEncodeLength(p,encoding,slen);
-    if (ZIP_IS_STR(encoding)) {
-        memcpy(p,s,slen);
-    } else {
-        zipSaveInteger(p,value,encoding);
-    }
-    ZIPLIST_INCR_LENGTH(zl,1);
-    return zl;
-}
-
-```
+```  
+static unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {  
+    size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), reqlen;    unsigned int prevlensize, prevlen = 0;    size_t offset;    int nextdiff = 0;    unsigned char encoding = 0;    long long value = 123456789; /* initialized to avoid warning. Using a value                                    that is easy to see if for some reason                                    we use it uninitialized. */    zlentry tail;  
+    /* Find out prevlen for the entry that is inserted. */    if (p[0] != ZIP_END) {        ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);    } else {        unsigned char *ptail = ZIPLIST_ENTRY_TAIL(zl);        if (ptail[0] != ZIP_END) {            prevlen = zipRawEntryLength(ptail);        }    }  
+    /* See if the entry can be encoded */    if (zipTryEncoding(s,slen,&value,&encoding)) {        /* 'encoding' is set to the appropriate integer encoding */        reqlen = zipIntSize(encoding);    } else {        /* 'encoding' is untouched, however zipEncodeLength will use the         * string length to figure out how to encode it. */        reqlen = slen;    }    /* We need space for both the length of the previous entry and     * the length of the payload. */    reqlen += zipPrevEncodeLength(NULL,prevlen);    reqlen += zipEncodeLength(NULL,encoding,slen);  
+    /* When the insert position is not equal to the tail, we need to     * make sure that the next entry can hold this entry's length in     * its prevlen field. */    nextdiff = (p[0] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : 0;  
+    /* Store offset because a realloc may change the address of zl. */    offset = p-zl;    zl = ziplistResize(zl,curlen+reqlen+nextdiff);    p = zl+offset;  
+    /* Apply memory move when necessary and update tail offset. */    if (p[0] != ZIP_END) {        /* Subtract one because of the ZIP_END bytes */        memmove(p+reqlen,p-nextdiff,curlen-offset-1+nextdiff);  
+        /* Encode this entry's raw length in the next entry. */        zipPrevEncodeLength(p+reqlen,reqlen);  
+        /* Update offset for tail */        ZIPLIST_TAIL_OFFSET(zl) =            intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+reqlen);  
+        /* When the tail contains more than one entry, we need to take         * "nextdiff" in account as well. Otherwise, a change in the         * size of prevlen doesn't have an effect on the *tail* offset. */        zipEntry(p+reqlen, &tail);        if (p[reqlen+tail.headersize+tail.len] != ZIP_END) {            ZIPLIST_TAIL_OFFSET(zl) =                intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);        }    } else {        /* This element will be the new tail. */        ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(p-zl);    }  
+    /* When nextdiff != 0, the raw length of the next entry has changed, so     * we need to cascade the update throughout the ziplist */    if (nextdiff != 0) {        offset = p-zl;        zl = __ziplistCascadeUpdate(zl,p+reqlen);        p = zl+offset;    }  
+    /* Write the entry */    p += zipPrevEncodeLength(p,prevlen);    p += zipEncodeLength(p,encoding,slen);    if (ZIP_IS_STR(encoding)) {        memcpy(p,s,slen);    } else {        zipSaveInteger(p,value,encoding);    }    ZIPLIST_INCR_LENGTH(zl,1);    return zl;}  
+  
+```  
 
 
 
@@ -288,13 +207,13 @@ static unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsig
 
 *   这个函数是在指定的位置p插入一段新的数据，待插入数据的地址指针是s，长度为slen。插入后形成一个新的数据项，占据原来p的配置，原来位于p位置的数据项以及后面的所有数据项，需要统一向后移动，给新插入的数据项留出空间。参数p指向的是ziplist中某一个数据项的起始位置，或者在向尾端插入的时候，它指向ziplist的结束标记`<zlend>`。
 *   函数开始先计算出待插入位置前一个数据项的长度`prevlen`。这个长度要存入新插入的数据项的`<prevrawlen>`字段。
-*   然后计算当前数据项占用的总字节数`reqlen`，它包含三部分：`<prevrawlen>`, `<len>`和真正的数据。其中的数据部分会通过调用`zipTryEncoding`先来尝试转成整数。
+*   然后计算当前数据项占用的总字节数`reqlen`，它包含三部分：`<prevrawlen>`,`<len>`和真正的数据。其中的数据部分会通过调用`zipTryEncoding`先来尝试转成整数。
 *   由于插入导致的ziplist对于内存的新增需求，除了待插入数据项占用的`reqlen`之外，还要考虑原来p位置的数据项（现在要排在待插入数据项之后）的`<prevrawlen>`字段的变化。本来它保存的是前一项的总长度，现在变成了保存当前插入的数据项的总长度。这样它的`<prevrawlen>`字段本身需要的存储空间也可能发生变化，这个变化可能是变大也可能是变小。这个变化了多少的值`nextdiff`，是调用`zipPrevLenByteDiff`计算出来的。如果变大了，`nextdiff`是正值，否则是负值。
 *   现在很容易算出来插入后新的ziplist需要多少字节了，然后调用`ziplistResize`来重新调整大小。ziplistResize的实现里会调用allocator的`zrealloc`，它有可能会造成数据拷贝。
 *   现在额外的空间有了，接下来就是将原来p位置的数据项以及后面的所有数据都向后挪动，并为它设置新的`<prevrawlen>`字段。此外，还可能需要调整ziplist的`<zltail>`字段。
 *   最后，组装新的待插入数据项，放在位置p。
 
-#### hash与ziplist
+## hash与ziplist
 
 hash是Redis中可以用来存储一个对象结构的比较理想的数据类型。一个对象的各个属性，正好对应一个hash结构的各个field。
 
@@ -304,21 +223,17 @@ hash是Redis中可以用来存储一个对象结构的比较理想的数据类
 
 实际上，hash随着数据的增大，其底层数据结构的实现是会发生变化的，当然存储效率也就不同。在field比较少，各个value值也比较小的时候，hash采用ziplist来实现；而随着field增多和value值增大，hash可能会变成dict来实现。当hash底层变成dict来实现的时候，它的存储效率就没法跟那些序列化方式相比了。
 
-当我们为某个key第一次执行 `hset key field value` 命令的时候，Redis会创建一个hash结构，这个新创建的hash底层就是一个ziplist。
+当我们为某个key第一次执行`hset key field value`命令的时候，Redis会创建一个hash结构，这个新创建的hash底层就是一个ziplist。
 
 
 
 
 
-```
-robj *createHashObject(void) {
-    unsigned char *zl = ziplistNew();
-    robj *o = createObject(OBJ_HASH, zl);
-    o->encoding = OBJ_ENCODING_ZIPLIST;
-    return o;
-}
-
-```
+```  
+robj *createHashObject(void) {  
+    unsigned char *zl = ziplistNew();    robj *o = createObject(OBJ_HASH, zl);    o->encoding = OBJ_ENCODING_ZIPLIST;    return o;}  
+  
+```  
 
 
 
@@ -332,11 +247,11 @@ robj *createHashObject(void) {
 
 
 
-```
-hset user:100 name tielei
-hset user:100 age 20
-
-```
+```  
+hset user:100 name tielei  
+hset user:100 age 20  
+  
+```  
 
 
 
@@ -352,11 +267,11 @@ hset user:100 age 20
 
 
 
-```
-hash-max-ziplist-entries 512
-hash-max-ziplist-value 64
-
-```
+```  
+hash-max-ziplist-entries 512  
+hash-max-ziplist-value 64  
+  
+```  
 
 
 
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26015\357\274\232Redis\345\210\206\345\270\203\345\274\217\351\224\201\350\277\233\345\214\226\345\217\262.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\210\206\345\270\203\345\274\217\351\224\201\350\277\233\345\214\226\345\217\262.md"
similarity index 95%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26015\357\274\232Redis\345\210\206\345\270\203\345\274\217\351\224\201\350\277\233\345\214\226\345\217\262.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\210\206\345\270\203\345\274\217\351\224\201\350\277\233\345\214\226\345\217\262.md"
index 9f3d353..4a2ea7d 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26015\357\274\232Redis\345\210\206\345\270\203\345\274\217\351\224\201\350\277\233\345\214\226\345\217\262.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\345\210\206\345\270\203\345\274\217\351\224\201\350\277\233\345\214\226\345\217\262.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [Redis分布式锁进化史](#redis分布式锁进化史)
     * [各个版本的Redis分布式锁](#各个版本的redis分布式锁)
@@ -101,7 +101,7 @@ release(){
 tryLock(){      SETNX Key 1 Seconds}release(){    DELETE Key}
 ```
 
-Redis 2.6.12版本后SETNX增加过期时间参数，这样就解决了两条命令无法保证原子性的问题。但是设想下面一个场景： 
+Redis 2.6.12版本后SETNX增加过期时间参数，这样就解决了两条命令无法保证原子性的问题。但是设想下面一个场景：
 
 1\. C1成功获取到了锁，之后C1因为GC进入等待或者未知原因导致任务执行过长，最后在锁失效前C1没有主动释放锁 
 
@@ -167,7 +167,7 @@ release(){
 
 ```
 
-Redis 2.6.12后[SET](https://redis.io/commands/set)同样提供了一个NX参数，等同于SETNX命令，官方文档上提醒后面的版本有可能去掉[SETNX](https://redis.io/commands/setnx), [SETEX](https://redis.io/commands/setex), [PSETEX](https://redis.io/commands/psetex),并用SET命令代替，另外一个优化是使用一个自增的唯一UniqId代替时间戳来规避V3.0提到的时钟问题。
+Redis 2.6.12后[SET](https://redis.io/commands/set)同样提供了一个NX参数，等同于SETNX命令，官方文档上提醒后面的版本有可能去掉[SETNX](https://redis.io/commands/setnx),[SETEX](https://redis.io/commands/setex),[PSETEX](https://redis.io/commands/psetex),并用SET命令代替，另外一个优化是使用一个自增的唯一UniqId代替时间戳来规避V3.0提到的时钟问题。
 
 这个方案是目前最优的分布式锁方案，但是如果在Redis集群环境下依然存在问题：
 
@@ -175,7 +175,7 @@ Redis 2.6.12后[SET](https://redis.io/commands/set)同样提供了一个NX参数
 
 ### 分布式Redis锁：Redlock
 
-V3.1的版本仅在单实例的场景下是安全的，针对如何实现分布式Redis的锁，国外的分布式专家有过激烈的讨论， antirez提出了分布式锁算法Redlock，在[distlock](https://redis.io/topics/distlock)话题下可以看到对Redlock的详细说明，下面是Redlock算法的一个中文说明（引用）
+V3.1的版本仅在单实例的场景下是安全的，针对如何实现分布式Redis的锁，国外的分布式专家有过激烈的讨论，antirez提出了分布式锁算法Redlock，在[distlock](https://redis.io/topics/distlock)话题下可以看到对Redlock的详细说明，下面是Redlock算法的一个中文说明（引用）
 
 假设有N个独立的Redis节点
 
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\347\232\204\344\272\213\344\273\266\351\251\261\345\212\250\346\250\241\345\236\213\344\270\216\345\221\275\344\273\244\346\211\247\350\241\214\350\277\207\347\250\213.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\347\232\204\344\272\213\344\273\266\351\251\261\345\212\250\346\250\241\345\236\213\344\270\216\345\221\275\344\273\244\346\211\247\350\241\214\350\277\207\347\250\213.md"
new file mode 100644
index 0000000..b755863
--- /dev/null
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\347\232\204\344\272\213\344\273\266\351\251\261\345\212\250\346\250\241\345\236\213\344\270\216\345\221\275\344\273\244\346\211\247\350\241\214\350\277\207\347\250\213.md"
@@ -0,0 +1,192 @@
+[toc]
+
+本文转自https://www.xilidou.com/2018/03/12/redis-data/  
+作者：犀利豆  
+本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+
+该系列博文会告诉你如何从入门到进阶，Redis基本的使用方法，Redis的基本数据结构，以及一些进阶的使用方法，同时也需要进一步了解Redis的底层数据结构，再接着，还会带来Redis主从复制、集群、分布式锁等方面的相关内容，以及作为缓存的一些使用方法和注意事项，以便让你更完整地了解整个Redis相关的技术体系，形成自己的知识框架。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+<!-- more -->  
+
+原文地址：https://www.xilidou.com/2018/03/22/redis-event/
+
+Redis 是一个事件驱动的内存数据库，服务器需要处理两种类型的事件。
+
+文件事件  
+时间事件  
+下面就会介绍这两种事件的实现原理。
+
+文件事件  
+Redis 服务器通过 socket 实现与客户端（或其他redis服务器）的交互,文件事件就是服务器对 socket 操作的抽象。 Redis 服务器，通过监听这些 socket 产生的文件事件并处理这些事件，实现对客户端调用的响应。
+
+Reactor  
+Redis 基于 Reactor 模式开发了自己的事件处理器。
+
+这里就先展开讲一讲 Reactor 模式。看下图：  
+![image](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/Reactor.jpg)  
+reactor
+
+“I/O 多路复用模块”会监听多个 FD ，当这些FD产生，accept，read，write 或 close 的文件事件。会向“文件事件分发器（dispatcher）”传送事件。
+
+文件事件分发器（dispatcher）在收到事件之后，会根据事件的类型将事件分发给对应的 handler。
+
+我们顺着图，从上到下的逐一讲解 Redis 是怎么实现这个 Reactor 模型的。
+
+I/O 多路复用模块  
+Redis 的 I/O 多路复用模块，其实是封装了操作系统提供的 select，epoll，avport 和 kqueue 这些基础函数。向上层提供了一个统一的接口，屏蔽了底层实现的细节。
+
+一般而言 Redis 都是部署到 Linux 系统上，所以我们就看看使用 Redis 是怎么利用 linux 提供的 epoll 实现I/O 多路复用。
+
+首先看看 epoll 提供的三个方法：
+````
+    /*     * 创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大  
+     */    int epoll_create(int size)；  
+        /*  
+     * 可以理解为，增删改 fd 需要监听的事件  
+     * epfd 是 epoll_create() 创建的句柄。  
+     * op 表示 增删改  
+     * epoll_event 表示需要监听的事件，Redis 只用到了可读，可写，错误，挂断 四个状态  
+     */    int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；  
+        /*  
+     * 可以理解为查询符合条件的事件  
+     * epfd 是 epoll_create() 创建的句柄。  
+     * epoll_event 用来存放从内核得到事件的集合  
+     * maxevents 获取的最大事件数  
+     * timeout 等待超时时间  
+     */    int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);    再看 Redis 对文件事件，封装epoll向上提供的接口：  
+          
+    /*  
+     * 事件状态  
+     */    typedef struct aeApiState {    // epoll_event 实例描述符  
+        int epfd;    // 事件槽  
+        struct epoll_event *events;        } aeApiState;  
+        /*  
+     * 创建一个新的 epoll     */  
+    static int  aeApiCreate(aeEventLoop *eventLoop)    /*     * 调整事件槽的大小  
+     */    static int  aeApiResize(aeEventLoop *eventLoop, int setsize)    /*     * 释放 epoll 实例和事件槽  
+     */    static void aeApiFree(aeEventLoop *eventLoop)    /*     * 关联给定事件到 fd     */    static int  aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask)    /*     * 从 fd 中删除给定事件  
+     */    static void aeApiDelEvent(aeEventLoop *eventLoop, int fd, int mask)    /*     * 获取可执行事件  
+     */    static int  aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp)所以看看这个ae_peoll.c 如何对 epoll 进行封装的：  
+````
+aeApiCreate() 是对 epoll.epoll_create() 的封装。  
+aeApiAddEvent()和aeApiDelEvent() 是对 epoll.epoll_ctl()的封装。  
+aeApiPoll() 是对 epoll_wait()的封装。  
+这样 Redis 的利用 epoll 实现的 I/O 复用器就比较清晰了。
+
+再往上一层次我们需要看看 ea.c 是怎么封装的？
+
+首先需要关注的是事件处理器的数据结构：
+
+````
+    typedef struct aeFileEvent {    // 监听事件类型掩码，  
+        // 值可以是 AE_READABLE 或 AE_WRITABLE ，  
+        // 或者 AE_READABLE | AE_WRITABLE        int mask; /* one of AE_(READABLE|WRITABLE) */    // 读事件处理器  
+        aeFileProc *rfileProc;    // 写事件处理器  
+        aeFileProc *wfileProc;    // 多路复用库的私有数据  
+        void *clientData;        } aeFileEvent;  
+````
+mask 就是可以理解为事件的类型。
+
+除了使用 ae_peoll.c 提供的方法外,ae.c 还增加 “增删查” 的几个 API。
+
+增:aeCreateFileEvent  
+删:aeDeleteFileEvent  
+查: 查包括两个维度 aeGetFileEvents 获取某个 fd 的监听类型和aeWait等待某个fd 直到超时或者达到某个状态。  
+事件分发器（dispatcher）  
+Redis 的事件分发器 ae.c/aeProcessEvents 不但处理文件事件还处理时间事件，所以这里只贴与文件分发相关的出部分代码，dispather 根据 mask 调用不同的事件处理器。
+````
+    //从 epoll 中获关注的事件  
+    numevents = aeApiPoll(eventLoop, tvp);    for (j = 0; j < numevents; j++) {        // 从已就绪数组中获取事件  
+        aeFileEvent *fe = &eventLoop->events[eventLoop->fired[j].fd];            int mask = eventLoop->fired[j].mask;  
+        int fd = eventLoop->fired[j].fd;        int rfired = 0;    // 读事件  
+        if (fe->mask & mask & AE_READABLE) {            // rfired 确保读/写事件只能执行其中一个  
+            rfired = 1;            fe->rfileProc(eventLoop,fd,fe->clientData,mask);        }        // 写事件  
+        if (fe->mask & mask & AE_WRITABLE) {            if (!rfired || fe->wfileProc != fe->rfileProc)                fe->wfileProc(eventLoop,fd,fe->clientData,mask);        }            processed++;  
+    }可以看到这个分发器，根据 mask 的不同将事件分别分发给了读事件和写事件。  
+````
+文件事件处理器的类型  
+Redis 有大量的事件处理器类型，我们就讲解处理一个简单命令涉及到的三个处理器：
+
+acceptTcpHandler 连接应答处理器，负责处理连接相关的事件，当有client 连接到Redis的时候们就会产生 AE_READABLE 事件。引发它执行。  
+readQueryFromClinet 命令请求处理器，负责读取通过 sokect 发送来的命令。  
+sendReplyToClient 命令回复处理器，当Redis处理完命令，就会产生 AE_WRITEABLE 事件，将数据回复给 client。  
+文件事件实现总结  
+我们按照开始给出的 Reactor 模型，从上到下讲解了文件事件处理器的实现，下面将会介绍时间时间的实现。
+
+时间事件  
+Reids 有很多操作需要在给定的时间点进行处理，时间事件就是对这类定时任务的抽象。
+
+先看时间事件的数据结构：
+````
+    /* Time event structure     *     * 时间事件结构  
+     */    typedef struct aeTimeEvent {    // 时间事件的唯一标识符  
+        long long id; /* time event identifier. */    // 事件的到达时间  
+        long when_sec; /* seconds */        long when_ms; /* milliseconds */    // 事件处理函数  
+        aeTimeProc *timeProc;    // 事件释放函数  
+        aeEventFinalizerProc *finalizerProc;    // 多路复用库的私有数据  
+        void *clientData;    // 指向下个时间事件结构，形成链表  
+        struct aeTimeEvent *next;        } aeTimeEvent;  
+````
+看见 next 我们就知道这个 aeTimeEvent 是一个链表结构。看图：  
+![image](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/timeEvent.jpg)
+
+timeEvent
+
+注意这是一个按照id倒序排列的链表，并没有按照事件顺序排序。
+
+processTimeEvent  
+Redis 使用这个函数处理所有的时间事件，我们整理一下执行思路：
+
+记录最新一次执行这个函数的时间，用于处理系统时间被修改产生的问题。  
+遍历链表找出所有 when_sec 和 when_ms 小于现在时间的事件。  
+执行事件对应的处理函数。  
+检查事件类型，如果是周期事件则刷新该事件下一次的执行事件。  
+否则从列表中删除事件。  
+综合调度器（aeProcessEvents）  
+综合调度器是 Redis 统一处理所有事件的地方。我们梳理一下这个函数的简单逻辑：
+````
+    // 1. 获取离当前时间最近的时间事件  
+    shortest = aeSearchNearestTimer(eventLoop);    // 2. 获取间隔时间  
+    timeval = shortest - nowTime;    // 如果timeval 小于 0，说明已经有需要执行的时间事件了。  
+    if(timeval < 0){        timeval = 0    }    // 3. 在 timeval 时间内，取出文件事件。  
+    numevents = aeApiPoll(eventLoop, timeval);        // 4.根据文件事件的类型指定不同的文件处理器  
+    if (AE_READABLE) {        // 读事件  
+        rfileProc(eventLoop,fd,fe->clientData,mask);    }        // 写事件  
+    if (AE_WRITABLE) {        wfileProc(eventLoop,fd,fe->clientData,mask);    }以上的伪代码就是整个 Redis 事件处理器的逻辑。  
+````
+我们可以再看看谁执行了这个 aeProcessEvents:
+````
+    void aeMain(aeEventLoop *eventLoop) {            eventLoop->stop = 0;  
+            while (!eventLoop->stop) {  
+    // 如果有需要在事件处理前执行的函数，那么运行它  
+            if (eventLoop->beforesleep != NULL)                eventLoop->beforesleep(eventLoop);    // 开始处理事件  
+            aeProcessEvents(eventLoop, AE_ALL_EVENTS);        }    }然后我们再看看是谁调用了 eaMain:  
+    int main(int argc, char **argv) {        //一些配置和准备  
+        ...        aeMain(server.el);                //结束后的回收工作  
+        ...    }我们在 Redis 的 main 方法中找个了它。  
+````
+这个时候我们整理出的思路就是:
+
+Redis 的 main() 方法执行了一些配置和准备以后就调用 eaMain() 方法。
+
+eaMain() while(true) 的调用 aeProcessEvents()。
+
+所以我们说 Redis 是一个事件驱动的程序，期间我们发现，Redis 没有 fork 过任何线程。所以也可以说 Redis 是一个基于事件驱动的单线程应用。
+
+总结  
+在后端的面试中 Redis 总是一个或多或少会问到的问题。
+
+读完这篇文章你也许就能回答这几个问题：
+
+为什么 Redis 是一个单线程应用？  
+为什么 Redis 是一个单线程应用，却有如此高的性能？  
+如果你用本文提供的知识点回答这两个问题，一定会在面试官心中留下一个高大的形象。
+
+大家还可以阅读我的 Redis 相关的文章：
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26013\357\274\232Redis\351\233\206\347\276\244\346\234\272\345\210\266\345\217\212\344\270\200\344\270\252Redis\346\236\266\346\236\204\346\274\224\350\277\233\345\256\236\344\276\213.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\351\233\206\347\276\244\346\234\272\345\210\266\345\217\212\344\270\200\344\270\252Redis\346\236\266\346\236\204\346\274\224\350\277\233\345\256\236\344\276\213.md"
similarity index 61%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26013\357\274\232Redis\351\233\206\347\276\244\346\234\272\345\210\266\345\217\212\344\270\200\344\270\252Redis\346\236\266\346\236\204\346\274\224\350\277\233\345\256\236\344\276\213.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\351\233\206\347\276\244\346\234\272\345\210\266\345\217\212\344\270\200\344\270\252Redis\346\236\266\346\236\204\346\274\224\350\277\233\345\256\236\344\276\213.md"
index e487e83..5d84b69 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26013\357\274\232Redis\351\233\206\347\276\244\346\234\272\345\210\266\345\217\212\344\270\200\344\270\252Redis\346\236\266\346\236\204\346\274\224\350\277\233\345\256\236\344\276\213.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232Redis\351\233\206\347\276\244\346\234\272\345\210\266\345\217\212\344\270\200\344\270\252Redis\346\236\266\346\236\204\346\274\224\350\277\233\345\256\236\344\276\213.md"
@@ -1,97 +1,81 @@
-# Table of Contents
-
-  * [[](http://blog.720ui.com/2016/redis_action_04_cluster/#Replication%EF%BC%88%E4%B8%BB%E4%BB%8E%E5%A4%8D%E5%88%B6%EF%BC%89 "Replication（主从复制）")Replication（主从复制）](#[]httpblog720uicom2016redis_action_04_clusterreplicationefbc88e4b8bbe4bb8ee5a48de588b6efbc89-replication（主从复制）replication（主从复制）)
-    * [[](http://blog.720ui.com/2016/redis_action_04_cluster/#%E9%85%8D%E7%BD%AE%E4%B8%BB%E6%9C%8D%E5%8A%A1%E5%99%A8 "配置主服务器")配置主服务器](#[]httpblog720uicom2016redis_action_04_clustere9858de7bdaee4b8bbe69c8de58aa1e599a8-配置主服务器配置主服务器)
-    * [[](http://blog.720ui.com/2016/redis_action_04_cluster/#%E9%85%8D%E7%BD%AE%E4%BB%8E%E6%9C%8D%E5%8A%A1%E5%99%A8 "配置从服务器")配置从服务器](#[]httpblog720uicom2016redis_action_04_clustere9858de7bdaee4bb8ee69c8de58aa1e599a8-配置从服务器配置从服务器)
-    * [[](http://blog.720ui.com/2016/redis_action_04_cluster/#%E6%B5%8B%E8%AF%95 "测试")测试](#[]httpblog720uicom2016redis_action_04_clustere6b58be8af95-测试测试)
-  * [[](http://blog.720ui.com/2016/redis_action_04_cluster/#Sentinel%EF%BC%88%E5%93%A8%E5%85%B5%EF%BC%89 "Sentinel（哨兵）")Sentinel（哨兵）](#[]httpblog720uicom2016redis_action_04_clustersentinelefbc88e593a8e585b5efbc89-sentinel（哨兵）sentinel（哨兵）)
-    * [[](http://blog.720ui.com/2016/redis_action_04_cluster/#%E9%85%8D%E7%BD%AESentinel "配置Sentinel")配置Sentinel](#[]httpblog720uicom2016redis_action_04_clustere9858de7bdaesentinel-配置sentinel配置sentinel)
-    * [[](http://blog.720ui.com/2016/redis_action_04_cluster/#%E5%90%AF%E5%8A%A8-Sentinel "启动 Sentinel")启动 Sentinel](#[]httpblog720uicom2016redis_action_04_clustere590afe58aa8-sentinel-启动-sentinel启动-sentinel)
-    * [[](http://blog.720ui.com/2016/redis_action_04_cluster/#%E6%B5%8B%E8%AF%95-1 "测试")测试](#[]httpblog720uicom2016redis_action_04_clustere6b58be8af95-1-测试测试)
-  * [[](http://blog.720ui.com/2016/redis_action_04_cluster/#Twemproxy "Twemproxy")Twemproxy](#[]httpblog720uicom2016redis_action_04_clustertwemproxy-twemproxytwemproxy)
-  * [[](http://blog.720ui.com/2016/redis_action_04_cluster/#Codis "Codis")Codis](#[]httpblog720uicom2016redis_action_04_clustercodis-codiscodis)
-  * [[](http://blog.720ui.com/2016/redis_action_04_cluster/#Redis-3-0%E9%9B%86%E7%BE%A4 "Redis 3.0集群")Redis 3.0集群](#[]httpblog720uicom2016redis_action_04_clusterredis-3-0e99b86e7bea4-redis-30集群redis-30集群)
-    * [[](http://blog.720ui.com/2016/redis_action_04_cluster/#%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA "环境搭建")环境搭建](#[]httpblog720uicom2016redis_action_04_clustere78eafe5a283e690ade5bbba-环境搭建环境搭建)
-    * [[](http://blog.720ui.com/2016/redis_action_04_cluster/#%E5%88%9B%E5%BB%BA%E9%9B%86%E7%BE%A4 "创建集群")创建集群](#[]httpblog720uicom2016redis_action_04_clustere5889be5bbbae99b86e7bea4-创建集群创建集群)
-
-
-本文转自互联网
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从入门到进阶，Redis基本的使用方法，Redis的基本数据结构，以及一些进阶的使用方法，同时也需要进一步了解Redis的底层数据结构，再接着，还会带来Redis主从复制、集群、分布式锁等方面的相关内容，以及作为缓存的一些使用方法和注意事项，以便让你更完整地了解整个Redis相关的技术体系，形成自己的知识框架。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-转自http://blog.720ui.com/2016/redis_action_04_cluster/#Replication%EF%BC%88%E4%B8%BB%E4%BB%8E%E5%A4%8D%E5%88%B6%EF%BC%89
-
-下面介绍Redis的集群方案。
-
-
-
-## [](http://blog.720ui.com/2016/redis_action_04_cluster/#Replication%EF%BC%88%E4%B8%BB%E4%BB%8E%E5%A4%8D%E5%88%B6%EF%BC%89 "Replication（主从复制）")Replication（主从复制）
+# 目录
+
+  * [Replication（主从复制）](#replication（主从复制）)
+    * [配置主服务器](#配置主服务器)
+    * [配置从服务器](#配置从服务器)
+    * [测试](#测试)
+  * [Sentinel（哨兵）](#sentinel（哨兵）)
+    * [配置Sentinel](#配置sentinel)
+    * [启动 Sentinel](#启动-sentinel)
+    * [测试](#测试-1)
+  * [Twemproxy](#twemproxy)
+  * [Codis](#codis)
+  * [Redis 3.0集群](#redis-30集群)
+    * [环境搭建](#环境搭建)
+* [根据实际情况修改](#根据实际情况修改)
+* [允许redis支持集群模式](#允许redis支持集群模式)
+* [节点配置文件，由redis自动维护](#节点配置文件，由redis自动维护)
+* [节点超时毫秒](#节点超时毫秒)
+* [开启AOF同步模式](#开启aof同步模式)
+    * [创建集群](#创建集群)
+
+
+## Replication（主从复制）
 
 Redis的replication机制允许slave从master那里通过网络传输拷贝到完整的数据备份，从而达到主从机制。为了实现主从复制，我们准备三个redis服务，依次命名为master，slave1，slave2。
 
-### [](http://blog.720ui.com/2016/redis_action_04_cluster/#%E9%85%8D%E7%BD%AE%E4%B8%BB%E6%9C%8D%E5%8A%A1%E5%99%A8 "配置主服务器")配置主服务器
+### 配置主服务器
 
 为了测试效果，我们先修改主服务器的配置文件redis.conf的端口信息
 
-<pre>
+
 
 1.  port 6300
 
-</pre>
 
-### [](http://blog.720ui.com/2016/redis_action_04_cluster/#%E9%85%8D%E7%BD%AE%E4%BB%8E%E6%9C%8D%E5%8A%A1%E5%99%A8 "配置从服务器")配置从服务器
+### 配置从服务器
 
 replication相关的配置比较简单，只需要把下面一行加到slave的配置文件中。你只需要把ip地址和端口号改一下。
 
-<pre>
-
 1.  slaveof 192.168.1.1  6379
 
-</pre>
+
 
 我们先修改从服务器1的配置文件redis.conf的端口信息和从服务器配置。
 
-<pre>
+
+
 
 1.  port 6301
 2.  slaveof 127.0.0.1  6300
 
-</pre>
+
 
 我们再修改从服务器2的配置文件redis.conf的端口信息和从服务器配置。
 
-<pre>
+
+
 
 1.  port 6302
 2.  slaveof 127.0.0.1  6300
 
-</pre>
+
 
 值得注意的是，从redis2.6版本开始，slave支持只读模式，而且是默认的。可以通过配置项slave-read-only来进行配置。
 此外，如果master通过requirepass配置项设置了密码，slave每次同步操作都需要验证密码，可以通过在slave的配置文件中添加以下配置项
 
-<pre>
+
+
 
 1.  masterauth <password>
 
-</pre>
 
-### [](http://blog.720ui.com/2016/redis_action_04_cluster/#%E6%B5%8B%E8%AF%95 "测试")测试
+
+### 测试
 
 分别启动主服务器，从服务器，我们来验证下主从复制。我们在主服务器写入一条消息，然后再其他从服务器查看是否成功复制了。
 
-## [](http://blog.720ui.com/2016/redis_action_04_cluster/#Sentinel%EF%BC%88%E5%93%A8%E5%85%B5%EF%BC%89 "Sentinel（哨兵）")Sentinel（哨兵）
+## Sentinel（哨兵）
 
 主从机制，上面的方案中主服务器可能存在单点故障，万一主服务器宕机，这是个麻烦事情，所以Redis提供了Redis-Sentinel，以此来实现主从切换的功能，类似与zookeeper。
 
@@ -105,32 +89,34 @@ Redis-Sentinel是Redis官方推荐的高可用性(HA)解决方案，当用Redis
 
 Redis Sentinel 兼容 Redis 2.4.16 或以上版本， 推荐使用 Redis 2.8.0 或以上的版本。
 
-### [](http://blog.720ui.com/2016/redis_action_04_cluster/#%E9%85%8D%E7%BD%AESentinel "配置Sentinel")配置Sentinel
+### 配置Sentinel
 
 必须指定一个sentinel的配置文件sentinel.conf，如果不指定将无法启动sentinel。首先，我们先创建一个配置文件sentinel.conf
 
-<pre>
 
-1.  port 26379
-2.  sentinel monitor mymaster 127.0.0.1  6300  2
+````
+
+port 26379
+sentinel monitor mymaster 127.0.0.1  6300  2
+````
 
-</pre>
 
 官方典型的配置如下
 
-<pre>
 
-1.  sentinel monitor mymaster 127.0.0.1  6379  2
-2.  sentinel down-after-milliseconds mymaster 60000
-3.  sentinel failover-timeout mymaster 180000
-4.  sentinel parallel-syncs mymaster 1
-5.   
-6.  sentinel monitor resque 192.168.1.3  6380  4
-7.  sentinel down-after-milliseconds resque 10000
-8.  sentinel failover-timeout resque 180000
-9.  sentinel parallel-syncs resque 5
+````
+
+sentinel monitor mymaster 127.0.0.1  6379  2
+sentinel down-after-milliseconds mymaster 60000
+sentinel failover-timeout mymaster 180000
+sentinel parallel-syncs mymaster 1
+
+sentinel monitor resque 192.168.1.3  6380  4
+sentinel down-after-milliseconds resque 10000
+sentinel failover-timeout resque 180000
+sentinel parallel-syncs resque 5
+````
 
-</pre>
 
 配置文件只需要配置master的信息就好啦，不用配置slave的信息，因为slave能够被自动检测到(master节点会有关于slave的消息)。
 
@@ -138,11 +124,12 @@ Redis Sentinel 兼容 Redis 2.4.16 或以上版本， 推荐使用 Redis 2.8.0 
 
 接下来我们将一行一行地解释上面的配置项：
 
-<pre>
 
-1.  sentinel monitor mymaster 127.0.0.1  6379  2
+````
+
+sentinel monitor mymaster 127.0.0.1  6379  2
+````
 
-</pre>
 
 这行配置指示 Sentinel 去监视一个名为 mymaster 的主服务器， 这个主服务器的 IP 地址为 127.0.0.1 ， 端口号为 6300， 而将这个主服务器判断为失效至少需要 2 个 Sentinel 同意，只要同意 Sentinel 的数量不达标，自动故障迁移就不会执行。
 
@@ -150,57 +137,60 @@ Redis Sentinel 兼容 Redis 2.4.16 或以上版本， 推荐使用 Redis 2.8.0 
 
 除了第一行配置，我们发现剩下的配置都有一个统一的格式:
 
-<pre>
 
-1.  sentinel <option_name>  <master_name>  <option_value>
 
-</pre>
+````
+sentinel <option_name>  <master_name>  <option_value>
+````
+
 
 接下来我们根据上面格式中的option_name一个一个来解释这些配置项：
 
 *   down-after-milliseconds 选项指定了 Sentinel 认为服务器已经断线所需的毫秒数。
 *   parallel-syncs 选项指定了在执行故障转移时， 最多可以有多少个从服务器同时对新的主服务器进行同步， 这个数字越小， 完成故障转移所需的时间就越长。
 
-### [](http://blog.720ui.com/2016/redis_action_04_cluster/#%E5%90%AF%E5%8A%A8-Sentinel "启动 Sentinel")启动 Sentinel
+### 启动 Sentinel
 
 对于 redis-sentinel 程序， 你可以用以下命令来启动 Sentinel 系统
 
-<pre>
 
-1.  redis-sentinel sentinel.conf
+````
+
+redis-sentinel sentinel.conf
+````
 
-</pre>
 
 对于 redis-server 程序， 你可以用以下命令来启动一个运行在 Sentinel 模式下的 Redis 服务器
 
-<pre>
 
-1.  redis-server sentinel.conf --sentinel
 
-</pre>
+````
+redis-server sentinel.conf --sentinel
+````
+
 
 以上两种方式，都必须指定一个sentinel的配置文件sentinel.conf， 如果不指定将无法启动sentinel。sentinel默认监听26379端口，所以运行前必须确定该端口没有被别的进程占用。
-![](http://image.chenyongjun.vip/sentinel01.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/sentinel01.png)
 
-### [](http://blog.720ui.com/2016/redis_action_04_cluster/#%E6%B5%8B%E8%AF%95-1 "测试")测试
+### 测试
 
 此时，我们开启两个Sentinel，关闭主服务器，我们来验证下Sentinel。发现，服务器发生切换了。
-![](http://image.chenyongjun.vip/sentinel02.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/sentinel02.png)
 当6300端口的这个服务重启的时候，他会变成6301端口服务的slave。
 
-## [](http://blog.720ui.com/2016/redis_action_04_cluster/#Twemproxy "Twemproxy")Twemproxy
+## Twemproxy
 
 Twemproxy是由Twitter开源的Redis代理， Redis客户端把请求发送到Twemproxy，Twemproxy根据路由规则发送到正确的Redis实例，最后Twemproxy把结果汇集返回给客户端。
 
 Twemproxy通过引入一个代理层，将多个Redis实例进行统一管理，使Redis客户端只需要在Twemproxy上进行操作，而不需要关心后面有多少个Redis实例，从而实现了Redis集群。
-![](http://image.chenyongjun.vip/twemproxy01.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/twemproxy01.png)
 Twemproxy本身也是单点，需要用Keepalived做高可用方案。
 
 这么些年来，Twenproxy作为应用范围最广、稳定性最高、最久经考验的分布式中间件，在业界广泛使用。
 
 但是，Twemproxy存在诸多不方便之处，最主要的是，Twemproxy无法平滑地增加Redis实例，业务量突增，需增加Redis服务器；业务量萎缩，需要减少Redis服务器。但对Twemproxy而言，基本上都很难操作。其次，没有友好的监控管理后台界面，不利于运维监控。
 
-## [](http://blog.720ui.com/2016/redis_action_04_cluster/#Codis "Codis")Codis
+## Codis
 
 Codis解决了Twemproxy的这两大痛点，由豌豆荚于2014年11月开源，基于Go和C开发、现已广泛用于豌豆荚的各种Redis业务场景。
 
@@ -213,13 +203,14 @@ Codis 3.x 由以下组件组成：
 *   Codis FE：集群管理界面。多个集群实例共享可以共享同一个前端展示页面；通过配置文件管理后端 codis-dashboard 列表，配置文件可自动更新。
 *   Codis HA：为集群提供高可用。依赖 codis-dashboard 实例，自动抓取集群各个组件的状态；会根据当前集群状态自动生成主从切换策略，并在需要时通过 codis-dashboard 完成主从切换。
 *   Storage：为集群状态提供外部存储。提供 Namespace 概念，不同集群的会按照不同 product name 进行组织；目前仅提供了 Zookeeper 和 Etcd 两种实现，但是提供了抽象的 interface 可自行扩展。
-    ![](http://image.chenyongjun.vip/codis02.png)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/codis02.png)
 
 Codis引入了Group的概念，每个Group包括1个Redis Master及一个或多个Redis Slave，这是和Twemproxy的区别之一，实现了Redis集群的高可用。当1个Redis Master挂掉时，Codis不会自动把一个Slave提升为Master，这涉及数据的一致性问题，Redis本身的数据同步是采用主从异步复制，当数据在Maste写入成功时，Slave是否已读入这个数据是没法保证的，需要管理员在管理界面上手动把Slave提升为Master。
 
 Codis使用，可以参考官方文档[https://github.com/CodisLabs/codis/blob/release3.0/doc/tutorial_zh.md](https://github.com/CodisLabs/codis/blob/release3.0/doc/tutorial_zh.md)
 
-## [](http://blog.720ui.com/2016/redis_action_04_cluster/#Redis-3-0%E9%9B%86%E7%BE%A4 "Redis 3.0集群")Redis 3.0集群
+## Redis 3.0集群
 
 Redis 3.0集群采用了P2P的模式，完全去中心化。支持多节点数据集自动分片，提供一定程度的分区可用性，部分节点挂掉或者无法连接其他节点后，服务可以正常运行。Redis 3.0集群采用Hash Slot方案，而不是一致性哈希。Redis把所有的Key分成了16384个slot，每个Redis实例负责其中一部分slot。集群中的所有信息（节点、端口、slot等），都通过节点之间定期的数据交换而更新。
 
@@ -233,52 +224,65 @@ Redis 3.0集群，目前支持的cluster特性
 *   集群管理:cluster xxx
 *   基于配置(nodes-port.conf)的集群管理
 *   ASK 转向/MOVED 转向机制
-    ![](http://image.chenyongjun.vip/redis3-cluster01.png)
+
+* ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/redis3-cluster01.png)
 
 如上图所示，所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽。节点的fail是通过集群中超过半数的节点检测失效时才生效。客户端与redis节点直连，不需要中间proxy层。客户端不需要连接集群所有节点，连接集群中任何一个可用节点即可。redis-cluster把所有的物理节点映射到[0-16383]slot上cluster负责维护node<->slot<->value。
 
-![](http://image.chenyongjun.vip/redis3-cluster02.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/redis3-cluster02.png)
+
 选举过程是集群中所有master参与，如果半数以上master节点与master节点通信超时，认为当前master节点挂掉。
 
 当集群不可用时，所有对集群的操作做都不可用，收到((error) CLUSTERDOWN The cluster is down)错误。如果集群任意master挂掉，且当前master没有slave，集群进入fail状态，也可以理解成进群的slot映射[0-16383]不完成时进入fail状态。如果进群超过半数以上master挂掉，无论是否有slave集群进入fail状态。
 
-### [](http://blog.720ui.com/2016/redis_action_04_cluster/#%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA "环境搭建")环境搭建
+### 环境搭建
 
 现在，我们进行集群环境搭建。集群环境至少需要3个主服务器节点。本次测试，使用另外3个节点作为从服务器的节点，即3个主服务器，3个从服务器。
 
 修改配置文件，其它的保持默认即可。
 
-<pre>
 
-1.  # 根据实际情况修改
-2.  port 7000  
-3.  # 允许redis支持集群模式
-4.  cluster-enabled yes 
-5.  # 节点配置文件，由redis自动维护
-6.  cluster-config-file nodes.conf 
-7.  # 节点超时毫秒
-8.  cluster-node-timeout 5000  
-9.  # 开启AOF同步模式
-10.  appendonly yes
 
-</pre>
+````
+# 根据实际情况修改
+
+port 7000  
 
-### [](http://blog.720ui.com/2016/redis_action_04_cluster/#%E5%88%9B%E5%BB%BA%E9%9B%86%E7%BE%A4 "创建集群")创建集群
+# 允许redis支持集群模式
+
+cluster-enabled yes 
+
+# 节点配置文件，由redis自动维护
+
+cluster-config-file nodes.conf 
+
+# 节点超时毫秒
+
+cluster-node-timeout 5000  
+
+# 开启AOF同步模式
+
+appendonly yes
+
+````
+
+### 创建集群
 
 目前这些实例虽然都开启了cluster模式，但是彼此还不认识对方，接下来可以通过Redis集群的命令行工具redis-trib.rb来完成集群创建。
-首先，下载 [https://raw.githubusercontent.com/antirez/redis/unstable/src/redis-trib.rb](https://raw.githubusercontent.com/antirez/redis/unstable/src/redis-trib.rb "redis-trib.rb")。
+首先，下载 [https://raw.githubusercontent.com/antirez/redis/unstable/src/redis-trib.rb](https://raw.githubusercontent.com/antirez/redis/unstable/src/redis-trib.rb "redis-trib.rb")。
 
 然后，搭建Redis 的 Ruby 支持环境。这里，不进行扩展，参考相关文档。
 
 现在，接下来运行以下命令。这个命令在这里用于创建一个新的集群, 选项–replicas 1 表示我们希望为集群中的每个主节点创建一个从节点。
 
-<pre>
-
 1.  redis-trib.rb create --replicas 1  127.0.0.1:7001  127.0.0.1:7002  127.0.0.1:7003  127.0.0.1:7004  127.0.0.1:7005  127.0.0.1:7006
 
-</pre>
-
-![](http://image.chenyongjun.vip/redis3-cluster03.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/redis3-cluster03.png)
 
 5.3、测试
-![](http://image.chenyongjun.vip/redis3-cluster04.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/redis3-cluster04.png)
+
+*   版权声明：本文由 **梁桂钊** 发表于 [梁桂钊的博客](http://blog.720ui.com/)
+*   转载声明：转载请联系公众号【服务端思维】。
+*   文章标题：[Redis实战（四） 集群机制 | 梁桂钊的博客](http://blog.720ui.com/2016/redis_action_04_cluster/)
+*   文章链接：[http://blog.720ui.com/2016/redis_action_04_cluster/](http://blog.720ui.com/2016/redis_action_04_cluster/)
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26011\357\274\232\344\275\277\347\224\250\345\277\253\347\205\247\345\222\214AOF\345\260\206Redis\346\225\260\346\215\256\346\214\201\344\271\205\345\214\226\345\210\260\347\241\254\347\233\230\344\270\255.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232\344\275\277\347\224\250\345\277\253\347\205\247\345\222\214AOF\345\260\206Redis\346\225\260\346\215\256\346\214\201\344\271\205\345\214\226\345\210\260\347\241\254\347\233\230\344\270\255.md"
similarity index 87%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26011\357\274\232\344\275\277\347\224\250\345\277\253\347\205\247\345\222\214AOF\345\260\206Redis\346\225\260\346\215\256\346\214\201\344\271\205\345\214\226\345\210\260\347\241\254\347\233\230\344\270\255.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232\344\275\277\347\224\250\345\277\253\347\205\247\345\222\214AOF\345\260\206Redis\346\225\260\346\215\256\346\214\201\344\271\205\345\214\226\345\210\260\347\241\254\347\233\230\344\270\255.md"
index 058e6b8..b239d06 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26011\357\274\232\344\275\277\347\224\250\345\277\253\347\205\247\345\222\214AOF\345\260\206Redis\346\225\260\346\215\256\346\214\201\344\271\205\345\214\226\345\210\260\347\241\254\347\233\230\344\270\255.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232\344\275\277\347\224\250\345\277\253\347\205\247\345\222\214AOF\345\260\206Redis\346\225\260\346\215\256\346\214\201\344\271\205\345\214\226\345\210\260\347\241\254\347\233\230\344\270\255.md"
@@ -1,6 +1,5 @@
-# Table of Contents
+# 目录
 
-* [转自https://blog.csdn.net/xlgen157387/article/details/61925524](#转自httpsblogcsdnnetxlgen157387articledetails61925524)
 * [前言](#前言)
   * [快照持久化](#快照持久化)
   * [AOF持久化](#aof持久化)
@@ -8,8 +7,11 @@
   * [总结](#总结)
 
 
+[toc]
+
 本文转自互联网
 本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
@@ -22,16 +24,10 @@
 
 <!-- more -->
 
-# 转自https://blog.csdn.net/xlgen157387/article/details/61925524
+转自https://blog.csdn.net/xlgen157387/article/details/61925524
 
 # 前言
 
-
-
-
-
-
-
 我们知道Redis是一款内存服务器，就算我们对自己的服务器足够的信任，不会出现任何软件或者硬件的故障，但也会有可能出现突然断电等情况，造成Redis服务器中的数据失效。因此，我们需要向传统的关系型数据库一样对数据进行备份，将Redis在内存中的数据持久化到硬盘等非易失性介质中，来保证数据的可靠性。
 
 将Redis内存服务器中的数据持久化到硬盘等介质中的一个好处就是，使得我们的服务器在重启之后还可以重用以前的数据，或者是为了防止系统出现故障而将数据备份到一个远程的位置。
@@ -43,7 +39,7 @@
 ```
 
 
-Redis给我们提供了两种不同方式的持久化方法：快照（Snapshotting） 和 只追加文件（append-only-file）。
+Redis给我们提供了两种不同方式的持久化方法：快照（Snapshotting）和只追加文件（append-only-file）。
 
 （1）名词简介
 
@@ -75,17 +71,17 @@ appendonly no  #是否使用AOF持久化appendfsync everysec  #多久执行一
 
 一、创建快照的方式：
 
-（1）客户端通过向Redis发送`BGSAVE` 命令来创建快照。
+（1）客户端通过向Redis发送`BGSAVE`命令来创建快照。
 
 使用BGSAVE的时候，Redis会调用fork来创建一个子进程，然后子进程负责将快照写到硬盘中，而父进程则继续处理命令请求。
 
 使用场景：
 
-如果用户使用了save设置，例如：`save 60 1000` ,那么从Redis最近一次创建快照之后开始计算，当“60秒之内有1000次写入操作”这个条件满足的时候，Redis就会自动触发BGSAVE命令。
+如果用户使用了save设置，例如：`save 60 1000`,那么从Redis最近一次创建快照之后开始计算，当“60秒之内有1000次写入操作”这个条件满足的时候，Redis就会自动触发BGSAVE命令。
 
 如果用户使用了多个save设置，那么当任意一个save配置满足条件的时候，Redis都会触发一次BGSAVE命令。
 
-（2）客户端通过向Redis发送`SAVE` 命令来创建快照。
+（2）客户端通过向Redis发送`SAVE`命令来创建快照。
 
 接收到SAVE命令的Redis服务器在快照创建完毕之前将不再响应任何其他命令的请求。SAVE命令并不常用，我们通常只在没有足够的内存去执行BGSAVE命令的时候才会使用SAVE命令，或者即使等待持久化操作执行完毕也无所谓的情况下，才会使用这个命令；
 
@@ -101,7 +97,7 @@ appendonly no  #是否使用AOF持久化appendfsync everysec  #多久执行一
 
 各虚拟机类别，创建子线程所耗时间：
 
-![这里写图片描述](https://img-blog.csdn.net/20170313204830337?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveGxnZW4xNTczODc=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230406210020.png)
 
 因此，为了防止Redis因为创建子进程的时候出现停顿，我们可以考虑关闭自动保存，转而通过手动的方式发送BGSAVE或者SAVE来进行持久化，
 
@@ -135,7 +131,7 @@ appendfsync everysec/always/no
 
 appendfsync同步频率的区别如下图：
 
-![这里写图片描述](https://img-blog.csdn.net/20170313210401173?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveGxnZW4xNTczODc=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230406210035.png)
 
 （1）always的方式固然可以对没一条数据进行很好的保存，但是这种同步策略需要对硬盘进行大量的写操作，所以Redis处理命令的速度会受到硬盘性能的限制。
 
@@ -153,7 +149,7 @@ Redis以每秒同步一次AOF文件的性能和不使用任何持久化特性时
 
 三、重写/压缩AOF文件
 
-随着数据量的增大，AOF的文件可能会很大，这样在每次进行数据恢复的时候就会进行很长的时间，为了解决日益增大的AOF文件，用户可以向Redis发送`BGREWRITEAOF` 命令，这个命令会通过移除AOF文件中的冗余命令来重写AOF文件，是AOF文件的体检变得尽可能的小。
+随着数据量的增大，AOF的文件可能会很大，这样在每次进行数据恢复的时候就会进行很长的时间，为了解决日益增大的AOF文件，用户可以向Redis发送`BGREWRITEAOF`命令，这个命令会通过移除AOF文件中的冗余命令来重写AOF文件，是AOF文件的体检变得尽可能的小。
 
 BGREWRITEAOF的工作原理和BGSAVE的原理很像：Redis会创建一个子进程，然后由子进程负责对AOF文件的重写操作。
 
@@ -161,7 +157,7 @@ BGREWRITEAOF的工作原理和BGSAVE的原理很像：Redis会创建一个子进
 
 四、触发重写/压缩AOF文件条件设定
 
-AOF通过设置`auto-aof-rewrite-percentage` 和 `auto-aof-rewrite-min-size` 选项来自动执行BGREWRITEAOF。
+AOF通过设置`auto-aof-rewrite-percentage`和`auto-aof-rewrite-min-size`选项来自动执行BGREWRITEAOF。
 
 其具体含义，通过实例可以看出，如下配置：
 
@@ -171,7 +167,7 @@ auto-aof-rewrite-percentage 100 auto-aof-rewrite-min-size 64mb
 
 表示当前AOF的文件体积大于64MB，并且AOF文件的体积比上一次重写之后的体积变大了至少一倍（100%）的时候，Redis将执行重写BGREWRITEAOF命令。
 
-如果AOF重写执行的过于频繁的话，可以将`auto-aof-rewrite-percentage` 选项的值设置为100以上，这种最偶发就可以让Redis在AOF文件的体积变得更大之后才执行重写操作，不过，这也使得在进行数据恢复的时候执行的时间变得更加长一些。
+如果AOF重写执行的过于频繁的话，可以将`auto-aof-rewrite-percentage`选项的值设置为100以上，这种最偶发就可以让Redis在AOF文件的体积变得更大之后才执行重写操作，不过，这也使得在进行数据恢复的时候执行的时间变得更加长一些。
 
 ## 验证快照文件和AOF文件
 
@@ -183,7 +179,7 @@ redis-check-aofredis-check-dump
 
 他们可以再系统发生故障的时候，检查快照和AOF文件的状态，并对有需要的情况对文件进行修复。
 
-如果用户在运行redis-check-aof命令的时候，指定了`--fix` 参数，那么程序将对AOF文件进行修复。
+如果用户在运行redis-check-aof命令的时候，指定了`--fix`参数，那么程序将对AOF文件进行修复。
 
 程序修复AOF文件的方法很简单：他会扫描给定的AOF文件，寻找不正确或者不完整的命令，当发现第一个出现错误命令的时候，程序会删除出错命令以及出错命令之后的所有命令，只保留那些位于出错命令之前的正确命令。大部分情况，被删除的都是AOF文件末尾的不完整的写命令。
 
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2609\357\274\232\346\225\260\346\215\256\345\272\223redisDb\344\270\216\351\224\256\350\277\207\346\234\237\345\210\240\351\231\244\347\255\226\347\225\245.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232\346\225\260\346\215\256\345\272\223redisDb\344\270\216\351\224\256\350\277\207\346\234\237\345\210\240\351\231\244\347\255\226\347\225\245.md"
similarity index 93%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2609\357\274\232\346\225\260\346\215\256\345\272\223redisDb\344\270\216\351\224\256\350\277\207\346\234\237\345\210\240\351\231\244\347\255\226\347\225\245.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232\346\225\260\346\215\256\345\272\223redisDb\344\270\216\351\224\256\350\277\207\346\234\237\345\210\240\351\231\244\347\255\226\347\225\245.md"
index 769c091..3f14892 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2609\357\274\232\346\225\260\346\215\256\345\272\223redisDb\344\270\216\351\224\256\350\277\207\346\234\237\345\210\240\351\231\244\347\255\226\347\225\245.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232\346\225\260\346\215\256\345\272\223redisDb\344\270\216\351\224\256\350\277\207\346\234\237\345\210\240\351\231\244\347\255\226\347\225\245.md"
@@ -1,7 +1,18 @@
-# Table of Contents
+# 目录
 
+  * [一. 数据库](#一-数据库)
+  * [二、切换数据库原理](#二、切换数据库原理)
+  * [三、数据库的键空间](#三、数据库的键空间)
+    * [1、数据库的结构（我们只分析键空间和键过期时间）](#1、数据库的结构（我们只分析键空间和键过期时间）)
+    * [2、键空间的初始化](#2、键空间的初始化)
+    * [3、键空间的操作](#3、键空间的操作)
+  * [四、数据库的过期键操作](#四、数据库的过期键操作)
+    * [1、过期键处理函数](#1、过期键处理函数)
+    * [2、过期键删除策略](#2、过期键删除策略)
 
 
+[toc]
+
 本文转自互联网
 本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -16,31 +27,31 @@
 
 <!-- more -->
 
-一. 数据库
+## 一. 数据库
 Redis的数据库使用字典作为底层实现，数据库的增、删、查、改都是构建在字典的操作之上的。
 redis服务器将所有数据库都保存在服务器状态结构redisServer(redis.h/redisServer)的db数组（应该是一个链表）里：
-
+````
     struct redisServer {
       //..
       // 数据库数组，保存着服务器中所有的数据库
         redisDb *db;
       //..
     }
-
+````
 在初始化服务器时，程序会根据服务器状态的dbnum属性来决定应该创建多少个数据库：
-
+````
     struct redisServer {
         // ..
         //服务器中数据库的数量
         int dbnum;
         //..
     }
-
+````
 dbnum属性的值是由服务器配置的database选项决定的，默认值为16；
 
-二、切换数据库原理
+## 二、切换数据库原理
 每个Redis客户端都有自己的目标数据库，每当客户端执行数据库的读写命令时，目标数据库就会成为这些命令的操作对象。
-
+````
     127.0.0.1:6379> set msg 'Hello world'
     OK
     127.0.0.1:6379> get msg
@@ -50,20 +61,20 @@ dbnum属性的值是由服务器配置的database选项决定的，默认值为1
     127.0.0.1:6379[2]> get msg
     (nil)
     127.0.0.1:6379[2]>
-
+````
 在服务器内部，客户端状态redisClient结构(redis.h/redisClient)的db属性记录了客户端当前的目标数据库，这个属性是一个指向redisDb结构(redis.h/redisDb)的指针：
-
+````
     typedef struct redisClient {
         //..
         // 客户端当前正在使用的数据库
         redisDb *db;
         //..
     } redisClient;
-
+````
 redisClient.db指针指向redisServer.db数组中的一个元素，而被指向的元素就是当前客户端的目标数据库。
 我们就可以通过修改redisClient指针，让他指向服务器中的不同数据库，从而实现切换数据库的功能–这就是select命令的实现原理。
 实现代码：
-
+````
     int selectDb(redisClient *c, int id) {
         // 确保 id 在正确范围内
         if (id < 0 || id >= server.dbnum)
@@ -72,9 +83,10 @@ redisClient.db指针指向redisServer.db数组中的一个元素，而被指向
         c->db = &server.db[id];
         return REDIS_OK;
     }
-
-三、数据库的键空间
-1、数据库的结构（我们只分析键空间和键过期时间）
+````
+## 三、数据库的键空间
+### 1、数据库的结构（我们只分析键空间和键过期时间）
+````
     typedef struct redisDb {
         // 数据库键空间，保存着数据库中的所有键值对
         dict *dict;                 /* The keyspace for this DB */
@@ -87,7 +99,7 @@ redisClient.db指针指向redisServer.db数组中的一个元素，而被指向
         //..
     } redisDb
 
-
+````
 上图是一个RedisDb的示例，该数据库存放有五个键值对，分别是sRedis，INums，hBooks，SortNum和sNums，它们各自都有自己的值对象，另外，其中有三个键设置了过期时间，当前数据库是服务器的第0号数据库。现在，我们就从源码角度分析这个数据库结构：
 我们知道，Redis是一个键值对数据库服务器，服务器中的每一个数据库都是一个redis.h/redisDb结构，其中，结构中的dict字典保存了数据库中所有的键值对，我们就将这个字典成为键空间。
 Redis数据库的数据都是以键值对的形式存在，其充分利用了字典高效索引的特点。
@@ -95,9 +107,9 @@ a、键空间的键就是数据库中的键，一般都是字符串对象；
 b、键空间的值就是数据库中的值，可以是5种类型对象（字符串、列表、哈希、集合和有序集合）之一。
 数据库的键空间结构分析完了，我们先看看数据库的初始化。
 
-2、键空间的初始化
+### 2、键空间的初始化
 在redis.c中，我们可以找到键空间的初始化操作：
-
+````
     //创建并初始化数据库结构
      for (j = 0; j < server.dbnum; j++) {
         // 创建每个数据库的键空间
@@ -106,12 +118,12 @@ b、键空间的值就是数据库中的值，可以是5种类型对象（字符
         // 设定当前数据库的编号
         server.db[j].id = j;
     }
-
+````
 初始化之后就是对键空间的操作了。
 
-3、键空间的操作
+### 3、键空间的操作
 我先把一些常见的键空间操作函数列出来：
-
+````
     // 从数据库中取出键key的值对象，若不存在就返回NULL
     robj *lookupKey(redisDb *db, robj *key);
     
@@ -152,10 +164,11 @@ b、键空间的值就是数据库中的值，可以是5种类型对象（字符
     int dbDelete(redisDb *db, robj *key);
     /* 清空所有数据库，返回键值对的个数 */
     long long emptyDb(void(callback)(void*));
-
+````
 下面我选取几个比较典型的操作函数分析一下：
 
 查找键值对函数–lookupKey
+````
 robj *lookupKey(redisDb *db, robj *key) {
     // 查找键空间
     dictEntry *de = dictFind(db->dict,key->ptr);
@@ -173,10 +186,10 @@ robj *lookupKey(redisDb *db, robj *key) {
         return NULL;
     }
 }
-
+````
 添加键值对–dbAdd
 添加键值对使我们经常使用到的函数，底层由dbAdd()函数实现，传入的参数是待添加的数据库，键对象和值对象，源码如下：
-
+````
 void dbAdd(redisDb *db, robj *key, robj *val) {
     // 复制键名
     sds copy = sdsdup(key->ptr);
@@ -187,13 +200,13 @@ void dbAdd(redisDb *db, robj *key, robj *val) {
     // 如果开启了集群模式，那么将键保存到槽里面
     if (server.cluster_enabled) slotToKeyAdd(key);
  }
-
+````
 好了，关于键空间操作函数就分析到这，其他函数(在文件db.c中)大家可以自己去分析，有问题的话可以回帖，我们可以一起讨论！
 
-四、数据库的过期键操作
+## 四、数据库的过期键操作
 在前面我们说到，redisDb结构中有一个expires指针（概况图可以看上图），该指针指向一个字典结构，字典中保存了所有键的过期时间，该字典称为过期字典。
 过期字典的初始化：
-
+````
 // 创建并初始化数据库结构
  for (j = 0; j < server.dbnum; j++) {
         // 创建每个数据库的过期时间字典
@@ -202,13 +215,15 @@ void dbAdd(redisDb *db, robj *key, robj *val) {
         server.db[j].id = j;
         // ..
     }
-
+````
 a、过期字典的键是一个指针，指向键空间中的某一个键对象（就是某一个数据库键）；
 b、过期字典的值是一个long long类型的整数，这个整数保存了键所指向的数据库键的时间戳–一个毫秒精度的unix时间戳。
 下面我们就来分析过期键的处理函数：
 
-1、过期键处理函数
+### 1、过期键处理函数
+
 设置键的过期时间–setExpire()
+````
 /*
  * 将键 key 的过期时间设为 when
  */
@@ -224,8 +239,9 @@ void setExpire(redisDb *db, robj *key, long long when) {
     // 这里是直接使用整数值来保存过期时间，不是用 INT 编码的 String 对象
     dictSetSignedIntegerVal(de,when);
 }
-
+````
 获取键的过期时间–getExpire()
+````
 long long getExpire(redisDb *db, robj *key) {
     dictEntry *de;
     // 如果过期键不存在，那么直接返回
@@ -235,8 +251,9 @@ long long getExpire(redisDb *db, robj *key) {
     // 返回过期时间
     return dictGetSignedIntegerVal(de);
 }
-
+````
 删除键的过期时间–removeExpire()
+````
 // 移除键 key 的过期时间
 int removeExpire(redisDb *db, robj *key) {
     // 确保键带有过期时间
@@ -244,8 +261,8 @@ int removeExpire(redisDb *db, robj *key) {
     // 删除过期时间
     return dictDelete(db->expires,key->ptr) == DICT_OK;
 }
-
-2、过期键删除策略
+````
+### 2、过期键删除策略
 通过前面的介绍，大家应该都知道数据库键的过期时间都保存在过期字典里，那假如一个键过期了，那么这个过期键是什么时候被删除的呢？现在来看看redis的过期键的删除策略：
 a、定时删除：在设置键的过期时间的同时，创建一个定时器，在定时结束的时候，将该键删除；
 b、惰性删除：放任键过期不管，在访问该键的时候，判断该键的过期时间是否已经到了，如果过期时间已经到了，就执行删除操作；
@@ -257,7 +274,7 @@ c、定期删除：每隔一段时间，对数据库中的键进行一次遍历
 
 惰性删除函数–expireIfNeeded()
 源码如下：
-
+````
 /* 检查key是否已经过期，如果是的话，将它从数据库中删除 
  * 并将删除命令写入AOF文件以及附属节点(主从复制和AOF持久化相关)
  * 返回0代表该键还没有过期，或者没有设置过期时间
@@ -287,11 +304,12 @@ int expireIfNeeded(redisDb *db, robj *key) {
     // 将该键从数据库中删除
     return dbDelete(db,key);
 }
-
+````
 定期删除策略
 过期键的定期删除策略由redis.c/activeExpireCycle()函数实现，服务器周期性地操作redis.c/serverCron()（每隔100ms执行一次）时，会调用activeExpireCycle()函数，分多次遍历服务器中的各个数据库，从数据库中的expires字典中随机检查一部分键的过期时间，并删除其中的过期键。
 删除过期键的操作由activeExpireCycleTryExpire函数(activeExpireCycle()调用了该函数)执行，其源码如下：
 
+````
 /* 检查键的过期时间，如过期直接删除*/
 int activeExpireCycleTryExpire(redisDb *db, dictEntry *de, long long now) {
     // 获取过期时间
@@ -318,6 +336,6 @@ int activeExpireCycleTryExpire(redisDb *db, dictEntry *de, long long now) {
         return 0;
     }
 }
-
+````
 删除过期键对AOF、RDB和主从复制都有影响，等到了介绍相关功能时再讨论。
 今天就先到这里~
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26012\357\274\232\346\265\205\346\236\220Redis\344\270\273\344\273\216\345\244\215\345\210\266.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232\346\265\205\346\236\220Redis\344\270\273\344\273\216\345\244\215\345\210\266.md"
similarity index 79%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26012\357\274\232\346\265\205\346\236\220Redis\344\270\273\344\273\216\345\244\215\345\210\266.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232\346\265\205\346\236\220Redis\344\270\273\344\273\216\345\244\215\345\210\266.md"
index 0d23887..393e8ac 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\26012\357\274\232\346\265\205\346\236\220Redis\344\270\273\344\273\216\345\244\215\345\210\266.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232\346\265\205\346\236\220Redis\344\270\273\344\273\216\345\244\215\345\210\266.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
 * [Redis复制概论](#redis复制概论)
   * [Redis复制方式](#redis复制方式)
@@ -18,7 +18,10 @@
 * [总结](#总结)
 
 
-本文转自互联网
+[toc]
+
+
+本文转自互联网  
 本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
 
@@ -30,7 +33,7 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 
 转自网络，侵删
 
@@ -42,7 +45,7 @@
 
 数据库复制指的是发生在不同数据库实例之间，单向的信息传播的行为，通常由被复制方和复制方组成，被复制方和复制方之间建立网络连接，复制方式通常为被复制方主动将数据发送到复制方，复制方接收到数据存储在当前实例，最终目的是为了保证双方的数据一致、同步。
 
-![](http://static.oschina.net/uploads/space/2016/0529/130324_yGmz_1759553.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/130324_yGmz_1759553.png)
 
 复制示意图
 
@@ -52,7 +55,7 @@
 
 Redis的复制方式有两种，一种是主（master）-从（slave）模式，一种是从（slave）-从（slave）模式，因此Redis的复制拓扑图会丰富一些，可以像星型拓扑，也可以像个有向无环：
 
-![](http://static.oschina.net/uploads/space/2016/0529/131412_Ak0S_1759553.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/131412_Ak0S_1759553.png)
 
 Redis集群复制结构图
 
@@ -109,127 +112,126 @@ Redis提供了提高数据一致性的解决方案，本文后面会进行介绍
 
 举个例子，我们有四台redis实例，M1，R1、R2、R3，其中M1为master，R1、R2、R3分别为三台slave redis实例。在M1启动如下：
 
-```
-./redis-server ../redis8000.conf --port 8000
-
-```
+```  
+./redis-server ../redis8000.conf --port 8000  
+  
+```  
 
 下面分别为R1、R2、R3的启动命令：
 
-```
- ./redis-server ../redis8001.conf --port 8001 --slaveof 127.0.0.1 8000 ./redis-server ../redis8002.conf --port 8002 --slaveof 127.0.0.1 8000 ./redis-server ../redis8003.conf --port 8003 --slaveof 127.0.0.1 8000
-```
-
-这样，我们就成功的启动了四台Redis实例，master实例的服务端口为8000，R1、R2、R3的服务端口分别为8001、8002、8003，集群图如下：
-
-![](http://static.oschina.net/uploads/space/2016/0529/135124_AfX5_1759553.png)
-
-Redis集群复制拓扑
-
-上面的命令在slave启动的时候就指定了master机器，我们也可以在slave运行的时候通过slaveof命令来指定master机器。
-
-
-
-## 复制过程
-
-Redis复制主要由SYNC命令实现，复制过程如下图：
-
-![](http://static.oschina.net/uploads/space/2016/0529/142921_LCDS_1759553.png)
-
-Redis复制过程
-
-上图为Redis复制工作过程：
-
-1.  slave向master发送sync命令。
-2.  master开启子进程来讲dataset写入rdb文件，同时将子进程完成之前接收到的写命令缓存起来。
-3.  子进程写完，父进程得知，开始将RDB文件发送给slave。
-4.  master发送完RDB文件，将缓存的命令也发给slave。
-5.  master增量的把写命令发给slave。
-
-值得注意的是，当slave跟master的连接断开时，slave可以自动的重新连接master，在redis2.8版本之前，每当slave进程挂掉重新连接master的时候都会开始新的一轮全量复制。如果master同时接收到多个slave的同步请求，则master只需要备份一次RDB文件。
-
-
-
-## 增量复制
-
-上面复制过程介绍的最后提到，slave和master断开了、当slave和master重新连接上之后需要全量复制，这个策略是很不友好的，从Redis2.8开始，Redis提供了增量复制的机制：
-
-![](http://static.oschina.net/uploads/space/2016/0529/150147_XvpH_1759553.png)
-
-增量复制机制
-
-master除了备份RDB文件之外还会维护者一个环形队列，以及环形队列的写索引和slave同步的全局offset，环形队列用于存储最新的操作数据，当slave和maste断开重连之后，会把slave维护的offset，也就是上一次同步到哪里的这个值告诉master，同时会告诉master上次和当前slave连接的master的runid，满足下面两个条件，Redis不会全量复制：
-
-1.  slave传递的run id和master的run id一致。
-2.  master在环形队列上可以找到对呀offset的值。
-
-满足上面两个条件，Redis就不会全量复制，这样的好处是大大的提高的性能，不做无效的功。
-
-增量复制是由psync命令实现的，slave可以通过psync命令来让Redis进行增量复制，当然最终是否能够增量复制取决于环形队列的大小和slave的断线时间长短和重连的这个master是否是之前的master。
-
-环形队列大小配置参数：
-
-```
+```  
+ ./redis-server ../redis8001.conf --port 8001 --slaveof 127.0.0.1 8000 ./redis-server ../redis8002.conf --port 8002 --slaveof 127.0.0.1 8000 ./redis-server ../redis8003.conf --port 8003 --slaveof 127.0.0.1 8000```  
+  
+这样，我们就成功的启动了四台Redis实例，master实例的服务端口为8000，R1、R2、R3的服务端口分别为8001、8002、8003，集群图如下：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/135124_AfX5_1759553.png)  
+  
+Redis集群复制拓扑  
+  
+上面的命令在slave启动的时候就指定了master机器，我们也可以在slave运行的时候通过slaveof命令来指定master机器。  
+  
+  
+  
+## 复制过程  
+  
+Redis复制主要由SYNC命令实现，复制过程如下图：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/142921_LCDS_1759553.png)  
+  
+Redis复制过程  
+  
+上图为Redis复制工作过程：  
+  
+1.  slave向master发送sync命令。  
+2.  master开启子进程来讲dataset写入rdb文件，同时将子进程完成之前接收到的写命令缓存起来。  
+3.  子进程写完，父进程得知，开始将RDB文件发送给slave。  
+4.  master发送完RDB文件，将缓存的命令也发给slave。  
+5.  master增量的把写命令发给slave。  
+  
+值得注意的是，当slave跟master的连接断开时，slave可以自动的重新连接master，在redis2.8版本之前，每当slave进程挂掉重新连接master的时候都会开始新的一轮全量复制。如果master同时接收到多个slave的同步请求，则master只需要备份一次RDB文件。  
+  
+  
+  
+## 增量复制  
+  
+上面复制过程介绍的最后提到，slave和master断开了、当slave和master重新连接上之后需要全量复制，这个策略是很不友好的，从Redis2.8开始，Redis提供了增量复制的机制：  
+  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/150147_XvpH_1759553.png)  
+  
+增量复制机制  
+  
+master除了备份RDB文件之外还会维护者一个环形队列，以及环形队列的写索引和slave同步的全局offset，环形队列用于存储最新的操作数据，当slave和maste断开重连之后，会把slave维护的offset，也就是上一次同步到哪里的这个值告诉master，同时会告诉master上次和当前slave连接的master的runid，满足下面两个条件，Redis不会全量复制：  
+  
+1.  slave传递的run id和master的run id一致。  
+2.  master在环形队列上可以找到对呀offset的值。  
+  
+满足上面两个条件，Redis就不会全量复制，这样的好处是大大的提高的性能，不做无效的功。  
+  
+增量复制是由psync命令实现的，slave可以通过psync命令来让Redis进行增量复制，当然最终是否能够增量复制取决于环形队列的大小和slave的断线时间长短和重连的这个master是否是之前的master。  
+  
+环形队列大小配置参数：  
+  
+```  
 repl-backlog-size 1mb
-```
-
-Redis同时也提供了当没有slave需要同步的时候，多久可以释放环形队列：
-
-```
+```  
+  
+Redis同时也提供了当没有slave需要同步的时候，多久可以释放环形队列：  
+  
+```  
 repl-backlog-ttl 3600
-```
-
-
-
-## 免持久化复制
-
-免持久化机制官方叫做Diskless Replication，前面基于RDB文件写磁盘的方式可以看出，Redis必须要先将RDB文件写入磁盘，才进行网络传输，那么为什么不能直接通过网络把RDB文件传送给slave呢？免持久化复制就是做这个事情的，而且在Redis2.8.18版本开始支持，当然目前还是实验阶段。
-
-值得注意的是，一旦基于Diskless Replication的复制传送开始，新的slave请求需要等待这次传输完毕才能够得到服务。
-
-是否开启Diskless Replication的开关配置为：
-
-```
+```  
+  
+  
+  
+## 免持久化复制  
+  
+免持久化机制官方叫做Diskless Replication，前面基于RDB文件写磁盘的方式可以看出，Redis必须要先将RDB文件写入磁盘，才进行网络传输，那么为什么不能直接通过网络把RDB文件传送给slave呢？免持久化复制就是做这个事情的，而且在Redis2.8.18版本开始支持，当然目前还是实验阶段。  
+  
+值得注意的是，一旦基于Diskless Replication的复制传送开始，新的slave请求需要等待这次传输完毕才能够得到服务。  
+  
+是否开启Diskless Replication的开关配置为：  
+  
+```  
 repo-diskless-sync no
-```
-
-为了让后续的slave能够尽量赶上本次复制，Redis提供了一个参数配置指定复制开始的时间延迟：
-
-```
+```  
+  
+为了让后续的slave能够尽量赶上本次复制，Redis提供了一个参数配置指定复制开始的时间延迟：  
+  
+```  
 repl-diskless-sync-delay 5
-```
-
-
-
-## slave只读模式
-
-自从Redis2.6版本开始，支持对slave的只读模式的配置，默认对slave的配置也是只读。只读模式的slave将会拒绝客户端的写请求，从而避免因为从slave写入而导致的数据不一致问题。
-
-
-
-## 半同步复制
-
-和MySQL复制策略有点类似，Redis复制本身是异步的，但也提供了半同步的复制策略，半同步复制策略在Redis复制中的语义是这样的：
-
-```
+```  
+  
+  
+  
+## slave只读模式  
+  
+自从Redis2.6版本开始，支持对slave的只读模式的配置，默认对slave的配置也是只读。只读模式的slave将会拒绝客户端的写请求，从而避免因为从slave写入而导致的数据不一致问题。  
+  
+  
+  
+## 半同步复制  
+  
+和MySQL复制策略有点类似，Redis复制本身是异步的，但也提供了半同步的复制策略，半同步复制策略在Redis复制中的语义是这样的：  
+  
+```  
 允许用户给出这样的配置：在maste接受写操作的时候，只有当一定时间间隔内，至少有N台slave在线，否则写入无效。
-```
-
-上面功能的实现基于Redis下面特性：
-
-1.  Redis slaves每秒钟会ping一次master，告诉master当前slave复制到哪里了。
-2.  Redis master会记住每个slave复制到哪里了。
-
-我们可以通过下面配置来指定时间间隔和N这个值：
-
-```
+```  
+  
+上面功能的实现基于Redis下面特性：  
+  
+1.  Redis slaves每秒钟会ping一次master，告诉master当前slave复制到哪里了。  
+2.  Redis master会记住每个slave复制到哪里了。  
+  
+我们可以通过下面配置来指定时间间隔和N这个值：  
+  
+```  
 min-slaves-to-write <number of slaves>min-slaves-max-lag <number of seconds>
-```
-
-当配置了上面两个参数之后，一旦对于一个写操作没有满足上面的两个条件，则master会报错，并且将本次写操作视为无效。这有点像CAP理论中的“C”，即一致性实现，虽然半同步策略不能够完全保证master和slave的数据一致性，但是相对减少了不一致性的窗口期。
-
-
-
-# 总结
-
+```  
+  
+当配置了上面两个参数之后，一旦对于一个写操作没有满足上面的两个条件，则master会报错，并且将本次写操作视为无效。这有点像CAP理论中的“C”，即一致性实现，虽然半同步策略不能够完全保证master和slave的数据一致性，但是相对减少了不一致性的窗口期。  
+  
+  
+  
+# 总结  
+  
 本文在理解Redis复制概念和复制的优缺点的基础之上介绍了当前Redis复制工作原理以及主要特性，希望能够帮助大家。
diff --git "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2608\357\274\232\350\277\236\346\216\245\345\272\225\345\261\202\344\270\216\350\241\250\351\235\242\347\232\204\346\225\260\346\215\256\347\273\223\346\236\204robj.md" "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232\350\277\236\346\216\245\345\272\225\345\261\202\344\270\216\350\241\250\351\235\242\347\232\204\346\225\260\346\215\256\347\273\223\346\236\204robj.md"
similarity index 90%
rename from "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2608\357\274\232\350\277\236\346\216\245\345\272\225\345\261\202\344\270\216\350\241\250\351\235\242\347\232\204\346\225\260\346\215\256\347\273\223\346\236\204robj.md"
rename to "docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232\350\277\236\346\216\245\345\272\225\345\261\202\344\270\216\350\241\250\351\235\242\347\232\204\346\225\260\346\215\256\347\273\223\346\236\204robj.md"
index 3dd96d6..e8823f6 100644
--- "a/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\2608\357\274\232\350\277\236\346\216\245\345\272\225\345\261\202\344\270\216\350\241\250\351\235\242\347\232\204\346\225\260\346\215\256\347\273\223\346\236\204robj.md"
+++ "b/docs/cache/\346\216\242\347\264\242Redis\350\256\276\350\256\241\344\270\216\345\256\236\347\216\260\357\274\232\350\277\236\346\216\245\345\272\225\345\261\202\344\270\216\350\241\250\351\235\242\347\232\204\346\225\260\346\215\256\347\273\223\346\236\204robj.md"
@@ -1,29 +1,13 @@
-# Table of Contents
-
-      * [robj的数据结构定义](#robj的数据结构定义)
-            * [OBJ_STRING 0](#obj_string-0)
-            * [OBJ_LIST 1](#obj_list-1)
-            * [OBJ_SET 2](#obj_set-2)
-            * [OBJ_ZSET 3](#obj_zset-3)
-            * [OBJ_HASH 4](#obj_hash-4)
-            * [OBJ_ENCODING_RAW 0     /* Raw representation */](#obj_encoding_raw-0------raw-representation-)
-            * [OBJ_ENCODING_INT 1     /* Encoded as integer */](#obj_encoding_int-1------encoded-as-integer-)
-            * [OBJ_ENCODING_HT 2      /* Encoded as hash table */](#obj_encoding_ht-2-------encoded-as-hash-table-)
-            * [OBJ_ENCODING_ZIPMAP 3  /* Encoded as zipmap */](#obj_encoding_zipmap-3---encoded-as-zipmap-)
-            * [OBJ_ENCODING_LINKEDLIST 4 /* Encoded as regular linked list */](#obj_encoding_linkedlist-4--encoded-as-regular-linked-list-)
-            * [OBJ_ENCODING_ZIPLIST 5 /* Encoded as ziplist */](#obj_encoding_ziplist-5--encoded-as-ziplist-)
-            * [OBJ_ENCODING_INTSET 6  /* Encoded as intset */](#obj_encoding_intset-6---encoded-as-intset-)
-            * [OBJ_ENCODING_SKIPLIST 7  /* Encoded as skiplist */](#obj_encoding_skiplist-7---encoded-as-skiplist-)
-            * [OBJ_ENCODING_EMBSTR 8  /* Embedded sds string encoding */](#obj_encoding_embstr-8---embedded-sds-string-encoding-)
-            * [OBJ_ENCODING_QUICKLIST 9 /* Encoded as linked list of ziplists */](#obj_encoding_quicklist-9--encoded-as-linked-list-of-ziplists-)
-            * [LRU_BITS 24](#lru_bits-24)
-      * [string robj的编码过程](#string-robj的编码过程)
-            * [sdsEncodedObject(objptr) (objptr->encoding == OBJ_ENCODING_RAW || objptr->encoding == OBJ_ENCODING_EMBSTR)](#sdsencodedobjectobjptr-objptr-encoding--obj_encoding_raw--objptr-encoding--obj_encoding_embstr)
-      * [string robj的解码过程](#string-robj的解码过程)
-      * [再谈sds与string的关系](#再谈sds与string的关系)
-      * [robj的引用计数操作](#robj的引用计数操作)
+# 目录
 
+  * [robj的数据结构定义](#robj的数据结构定义)
+  * [string robj的编码过程](#string-robj的编码过程)
+  * [string robj的解码过程](#string-robj的解码过程)
+  * [再谈sds与string的关系](#再谈sds与string的关系)
+  * [robj的引用计数操作](#robj的引用计数操作)
 
+
+[toc]
 本文转自互联网
 本文将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
 > https://github.com/h2pl/Java-Tutorial
@@ -46,10 +30,10 @@
 
 而从Redis内部实现的角度来看，在前面第一篇文章中，我们已经提到过，一个database内的这个映射关系是用一个dict来维护的。dict的key固定用一种数据结构来表达就够了，这就是动态字符串sds。而value则比较复杂，为了在同一个dict内能够存储不同类型的value，这就需要一个通用的数据结构，这个通用的数据结构就是robj（全名是redisObject）。举个例子：如果value是一个list，那么它的内部存储结构是一个quicklist（quicklist的具体实现我们放在后面的文章讨论）；如果value是一个string，那么它的内部存储结构一般情况下是一个sds。当然实际情况更复杂一点，比如一个string类型的value，如果它的值是一个数字，那么Redis内部还会把它转成long型来存储，从而减小内存使用。而一个robj既能表示一个sds，也能表示一个quicklist，甚至还能表示一个long型。
 
-#### robj的数据结构定义
+## robj的数据结构定义
 
 在server.h中我们找到跟robj定义相关的代码，如下（注意，本系列文章中的代码片段全部来源于Redis源码的3.2分支）：
-
+````
     /* Object types */
     #define OBJ_STRING 0
     #define OBJ_LIST 1
@@ -79,7 +63,7 @@
         int refcount;
         void *ptr;
     } robj;
-    
+````    
 
 一个robj包含如下5个字段：
 
@@ -121,10 +105,10 @@
 *   允许同一类型的数据采用不同的内部表示，从而在某些情况下尽量节省内存。
 *   支持对象共享和引用计数。当对象被共享的时候，只占用一份内存拷贝，进一步节省内存。
 
-#### string robj的编码过程
+## string robj的编码过程
 
 当我们执行Redis的set命令的时候，Redis首先将接收到的value值（string类型）表示成一个type = OBJ_STRING并且encoding = OBJ_ENCODING_RAW的robj对象，然后在存入内部存储之前先执行一个编码过程，试图将它表示成另一种更节省内存的encoding方式。这一过程的核心代码，是object.c中的tryObjectEncoding函数。
-
+````
     robj *tryObjectEncoding(robj *o) {
         long value;
         sds s = o->ptr;
@@ -203,16 +187,16 @@
         /* Return the original object. */
         return o;
     }
-
+````
 
 这段代码执行的操作比较复杂，我们有必要仔细看一下每一步的操作：
 
 *   第1步检查，检查type。确保只对string类型的对象进行操作。
 *   第2步检查，检查encoding。sdsEncodedObject是定义在server.h中的一个宏，确保只对OBJ_ENCODING_RAW和OBJ_ENCODING_EMBSTR编码的string对象进行操作。这两种编码的string都采用sds来存储，可以尝试进一步编码处理。
 
-
+````
     #define sdsEncodedObject(objptr) (objptr->encoding == OBJ_ENCODING_RAW || objptr->encoding == OBJ_ENCODING_EMBSTR)
-
+````
 *   第3步检查，检查refcount。引用计数大于1的共享对象，在多处被引用。由于编码过程结束后robj的对象指针可能会变化（我们在前一篇介绍sdscatlen函数的时候提到过类似这种接口使用模式），这样对于引用计数大于1的对象，就需要更新所有地方的引用，这不容易做到。因此，对于计数大于1的对象不做编码处理。
 *   试图将字符串转成64位的long。64位的long所能表达的数据范围是-2^63到2^63-1，用十进制表达出来最长是20位数（包括负号）。这里判断小于等于21，似乎是写多了，实际判断小于等于20就够了（如果我算错了请一定告诉我哦）。string2l如果将字符串转成long转成功了，那么会返回1并且将转好的long存到value变量里。
 *   在转成long成功时，又分为两种情况。
@@ -223,7 +207,7 @@
     *   如果前面所有的编码尝试都没有成功（仍然是OBJ_ENCODING_RAW），且sds里空余字节过多，那么做最后一次努力，调用sds的sdsRemoveFreeSpace接口来释放空余字节。
 
 其中调用的createEmbeddedStringObject，我们有必要看一下它的代码：
-
+````
     robj *createEmbeddedStringObject(const char *ptr, size_t len) {
         robj *o = zmalloc(sizeof(robj)+sizeof(struct sdshdr8)+len+1);
         struct sdshdr8 *sh = (void*)(o+1);
@@ -245,7 +229,7 @@
         }
         return o;
     }
-
+````
 createEmbeddedStringObject对sds重新分配内存，将robj和sds放在一个连续的内存块中分配，这样对于短字符串的存储有利于减少内存碎片。这个连续的内存块包含如下几部分：
 
 *   16个字节的robj结构。
@@ -255,12 +239,12 @@ createEmbeddedStringObject对sds重新分配内存，将robj和sds放在一个
 
 加起来一共不超过64字节（16+3+44+1），因此这样的一个短字符串可以完全分配在一个64字节长度的内存块中。
 
-#### string robj的解码过程
+## string robj的解码过程
 
 当我们需要获取字符串的值，比如执行get命令的时候，我们需要执行与前面讲的编码过程相反的操作——解码。
 
 这一解码过程的核心代码，是object.c中的getDecodedObject函数。
-
+````
     robj *getDecodedObject(robj *o) {
         robj *dec;
     
@@ -278,7 +262,7 @@ createEmbeddedStringObject对sds重新分配内存，将robj和sds放在一个
             serverPanic("Unknown encoding type");
         }
     }
-
+````
 
 这个过程比较简单，需要我们注意的点有：
 
@@ -292,7 +276,7 @@ createEmbeddedStringObject对sds重新分配内存，将robj和sds放在一个
             return createRawStringObject(ptr,len);
     }
 
-#### 再谈sds与string的关系
+## 再谈sds与string的关系
 
 在上一篇文章中，我们简单地提到了sds与string的关系；在本文介绍了robj的概念之后，我们重新总结一下sds与string的关系。
 
@@ -305,7 +289,7 @@ createEmbeddedStringObject对sds重新分配内存，将robj和sds放在一个
     *   t_string.c中的getrangeCommand函数。
 
 值得一提的是，append和setbit命令的实现中，都会最终调用到db.c中的dbUnshareStringValue函数，将string对象的内部编码转成OBJ_ENCODING_RAW的（只有这种编码的robj对象，其内部的sds 才能在后面自由追加新的内容），并解除可能存在的对象共享状态。这里面调用了前面提到的getDecodedObject。
-
+````
     
     robj *dbUnshareStringValue(redisDb *db, robj *key, robj *o) {
         serverAssert(o->type == OBJ_STRING);
@@ -317,13 +301,13 @@ createEmbeddedStringObject对sds重新分配内存，将robj和sds放在一个
         }
         return o;
     }
+````
 
-
-#### robj的引用计数操作
+## robj的引用计数操作
 
 将robj的引用计数加1和减1的操作，定义在object.c中：
 
-
+````
     void incrRefCount(robj *o) {
         o->refcount++;
     }
@@ -344,7 +328,7 @@ createEmbeddedStringObject对sds重新分配内存，将robj和sds放在一个
             o->refcount--;
         }
     }
-
+````
 我们特别关注一下将引用计数减1的操作decrRefCount。如果只剩下最后一个引用了（refcount已经是1了），那么在decrRefCount被调用后，整个robj将被释放。
 
 注意：Redis的del命令就依赖decrRefCount操作将value释放掉。
diff --git "a/docs/algorithms/\345\211\221\346\214\207offer.md" "b/docs/cs/algorithms/\345\211\221\346\214\207offer.md"
similarity index 98%
rename from "docs/algorithms/\345\211\221\346\214\207offer.md"
rename to "docs/cs/algorithms/\345\211\221\346\214\207offer.md"
index a4f7aca..7952448 100644
--- "a/docs/algorithms/\345\211\221\346\214\207offer.md"
+++ "b/docs/cs/algorithms/\345\211\221\346\214\207offer.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
 * [数论和数字规律](#数论和数字规律)
   * [从1到n整数中1出现的次数](#从1到n整数中1出现的次数)
@@ -73,9 +73,7 @@
 * [回溯和DFS](#回溯和dfs)
   * [矩阵中的路径](#矩阵中的路径)
   * [机器人的运动范围](#机器人的运动范围)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取Java工程师必备学习资源。
@@ -1715,20 +1713,4 @@ public static int LastRemaining_Solution(int n, int m) {
             return sum;
         }
     }
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/network/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\345\255\246\344\271\240\346\200\273\347\273\223.md" "b/docs/cs/network/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\345\255\246\344\271\240\346\200\273\347\273\223.md"
similarity index 96%
rename from "docs/network/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\345\255\246\344\271\240\346\200\273\347\273\223.md"
rename to "docs/cs/network/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\345\255\246\344\271\240\346\200\273\347\273\223.md"
index 96a1ef4..6f4ee49 100644
--- "a/docs/network/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\345\255\246\344\271\240\346\200\273\347\273\223.md"
+++ "b/docs/cs/network/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234\345\255\246\344\271\240\346\200\273\347\273\223.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [网卡和路由器](#网卡和路由器)
   * [交换机](#交换机)
@@ -44,9 +44,7 @@
     * [ip分片详谈](#ip分片详谈)
     * [路由选择协议和算法](#路由选择协议和算法)
   * [链路层](#链路层)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 ---
@@ -527,7 +525,7 @@ IP 地址的编址方式经历了三个历史阶段：
 *   子网划分
 *   无分类
 
-### [](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C.md#1-%E5%88%86%E7%B1%BB)1\. 分类
+### 分类
 
 由两部分组成，网络号和主机号，其中不同分类具有不同的网络号长度，并且是固定的。
 
@@ -694,20 +692,4 @@ OSPF 具有以下特点：
 
 要避免广播风暴，可以采用恰当划分VLAN、缩小广播域、隔离广播风暴，还可在千兆以太网口上启用广播风暴控制，最大限度地避免网络再次陷入瘫痪。
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/operating-system/Linux\345\206\205\346\240\270\344\270\216\345\237\272\347\241\200\345\221\275\344\273\244\345\255\246\344\271\240\346\200\273\347\273\223.md" "b/docs/cs/operating-system/Linux\345\206\205\346\240\270\344\270\216\345\237\272\347\241\200\345\221\275\344\273\244\345\255\246\344\271\240\346\200\273\347\273\223.md"
similarity index 93%
rename from "docs/operating-system/Linux\345\206\205\346\240\270\344\270\216\345\237\272\347\241\200\345\221\275\344\273\244\345\255\246\344\271\240\346\200\273\347\273\223.md"
rename to "docs/cs/operating-system/Linux\345\206\205\346\240\270\344\270\216\345\237\272\347\241\200\345\221\275\344\273\244\345\255\246\344\271\240\346\200\273\347\273\223.md"
index 3728891..4dd7996 100644
--- "a/docs/operating-system/Linux\345\206\205\346\240\270\344\270\216\345\237\272\347\241\200\345\221\275\344\273\244\345\255\246\344\271\240\346\200\273\347\273\223.md"
+++ "b/docs/cs/operating-system/Linux\345\206\205\346\240\270\344\270\216\345\237\272\347\241\200\345\221\275\344\273\244\345\255\246\344\271\240\346\200\273\347\273\223.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [文件系统和VFS](#文件系统和vfs)
   * [进程和线程](#进程和线程)
@@ -60,9 +60,7 @@
   * [ifconfig](#ifconfig)
   * [uname](#uname)
   * [实际场景问题](#实际场景问题)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 ---
@@ -311,7 +309,7 @@ linux使用inode来标识任意一个文件。inode存储除了文件名以外
 
 
 
-<pre>#include <unistd> ssize_t write(int filedes, void *buf, size_t nbytes); // 返回：若成功则返回写入的字节数，若出错则返回-1 // filedes：文件描述符 // buf:待写入数据缓存区 // nbytes:要写入的字节数</pre>
+#include <unistd> ssize_t write(int filedes, void *buf, size_t nbytes); // 返回：若成功则返回写入的字节数，若出错则返回-1 // filedes：文件描述符 // buf:待写入数据缓存区 // nbytes:要写入的字节数目录
 
 
 
@@ -323,7 +321,7 @@ linux使用inode来标识任意一个文件。inode存储除了文件名以外
 
 ![复制代码](http://common.cnblogs.com/images/copycode.gif)
 
-<pre> 1 ssize_t                        /* Write "n" bytes to a descriptor. */
+ 1 ssize_t                        /* Write "n" bytes to a descriptor. */
  2 writen(int fd, const void *vptr, size_t n)
  3 {
  4     size_t nleft;
@@ -337,7 +335,7 @@ linux使用inode来标识任意一个文件。inode存储除了文件名以外
 18         nleft -= nwritten; 19         ptr   += nwritten; 20 } 21     return(n); 22 } 23 /* end writen */
 24 
 25 void
-26 Writen(int fd, void *ptr, size_t nbytes) 27 { 28     if (writen(fd, ptr, nbytes) != nbytes) 29         err_sys("writen error"); 30 }</pre>
+26 Writen(int fd, void *ptr, size_t nbytes) 27 { 28     if (writen(fd, ptr, nbytes) != nbytes) 29         err_sys("writen error"); 30 }目录
 
 ![复制代码](http://common.cnblogs.com/images/copycode.gif)
 
@@ -351,7 +349,7 @@ linux使用inode来标识任意一个文件。inode存储除了文件名以外
 
 
 
-<pre>#include <unistd> ssize_t read(int filedes, void *buf, size_t nbytes); // 返回：若成功则返回读到的字节数，若已到文件末尾则返回0，若出错则返回-1 // filedes：文件描述符 // buf:读取数据缓存区 // nbytes:要读取的字节数</pre>
+#include <unistd> ssize_t read(int filedes, void *buf, size_t nbytes); // 返回：若成功则返回读到的字节数，若已到文件末尾则返回0，若出错则返回-1 // filedes：文件描述符 // buf:读取数据缓存区 // nbytes:要读取的字节数目录
 
 
 
@@ -377,7 +375,7 @@ linux使用inode来标识任意一个文件。inode存储除了文件名以外
 
 ![复制代码](http://common.cnblogs.com/images/copycode.gif)
 
-<pre> 1 ssize_t                        /* Read "n" bytes from a descriptor. */
+ 1 ssize_t                        /* Read "n" bytes from a descriptor. */
  2 readn(int fd, void *vptr, size_t n)
  3 {
  4     size_t nleft;
@@ -392,7 +390,7 @@ linux使用inode来标识任意一个文件。inode存储除了文件名以外
 23 } 24 /* end readn */
 25 
 26 ssize_t 27 Readn(int fd, void *ptr, size_t nbytes) 28 { 29 ssize_t        n; 30 
-31     if ( (n = readn(fd, ptr, nbytes)) < 0) 32         err_sys("readn error"); 33     return(n); 34 }</pre>
+31     if ( (n = readn(fd, ptr, nbytes)) < 0) 32         err_sys("readn error"); 33     return(n); 34 }目录
 
 ![复制代码](http://common.cnblogs.com/images/copycode.gif)
 
@@ -408,7 +406,7 @@ linux使用inode来标识任意一个文件。inode存储除了文件名以外
 
 
 
-<pre>#include <unistd.h> ssize_t write(int fd, const void *buf, size_t count);</pre>
+#include <unistd.h> ssize_t write(int fd, const void *buf, size_t count);目录
 
 
 
@@ -418,10 +416,10 @@ linux使用inode来标识任意一个文件。inode存储除了文件名以外
 
 
 
-<pre># 获取socket的发送/接受缓冲区的大小：（后面的值是在Linux 2.6.38 x86_64上测试的结果）</pre>
+# 获取socket的发送/接受缓冲区的大小：（后面的值是在Linux 2.6.38 x86_64上测试的结果）目录
 
-<pre>sysctl net.core.wmem_default       #126976
-sysctl net.core.wmem_max　　　　    #131071</pre>
+sysctl net.core.wmem_default       #126976
+sysctl net.core.wmem_max　　　　    #131071目录
 
 
 
@@ -916,20 +914,4 @@ uname可以显示一些重要的系统信息，例如内核名称、主机名、
     
     5内存
     free
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/operating-system/\346\223\215\344\275\234\347\263\273\347\273\237\345\255\246\344\271\240\346\200\273\347\273\223.md" "b/docs/cs/operating-system/\346\223\215\344\275\234\347\263\273\347\273\237\345\255\246\344\271\240\346\200\273\347\273\223.md"
similarity index 93%
rename from "docs/operating-system/\346\223\215\344\275\234\347\263\273\347\273\237\345\255\246\344\271\240\346\200\273\347\273\223.md"
rename to "docs/cs/operating-system/\346\223\215\344\275\234\347\263\273\347\273\237\345\255\246\344\271\240\346\200\273\347\273\223.md"
index d0e096f..4c97490 100644
--- "a/docs/operating-system/\346\223\215\344\275\234\347\263\273\347\273\237\345\255\246\344\271\240\346\200\273\347\273\223.md"
+++ "b/docs/cs/operating-system/\346\223\215\344\275\234\347\263\273\347\273\237\345\255\246\344\271\240\346\200\273\347\273\223.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [CPU](#cpu)
     * [程序执行过程](#程序执行过程)
@@ -21,9 +21,7 @@
     * [磁盘和寻址](#磁盘和寻址)
     * [IO设备](#io设备)
     * [文件系统](#文件系统)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 ---
@@ -332,20 +330,4 @@ linux使用inode来标识任意一个文件。inode存储除了文件名以外
     
     然后寻道到对应的磁盘位置，读取内容到缓冲区，通过系统调用把内容读到内存中，最后进行访问。
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/database/Mysql\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265\346\200\273\347\273\223.md" "b/docs/database/Mysql\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265\346\200\273\347\273\223.md"
index 53ed5a0..fb0660c 100644
--- "a/docs/database/Mysql\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265\346\200\273\347\273\223.md"
+++ "b/docs/database/Mysql\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265\346\200\273\347\273\223.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
 * [数据库原理](#数据库原理)
   * [范式 反范式](#范式-反范式)
   * [主键 外键](#主键-外键)
@@ -21,20 +20,8 @@
   * [分库分表](#分库分表)
   * [主从复制，读写分离](#主从复制，读写分离)
   * [分布式数据库](#分布式数据库)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
 
 
----
-title: Mysql原理与实践总结
-date: 2018-07-08 22:15:04
-tags:
-	- Mysql
-categories:
-	- 后端
-	- 技术总结
----
 
 本文根据自己对MySQL的学习和实践以及各类文章与书籍总结而来。
 囊括了MySQL数据库的基本原理和技术。本文主要是我的一个学习总结，基于之前的系列文章做了一个概括，如有错误，还望指出，谢谢。
@@ -98,8 +85,7 @@ MySQL数据库的架构可以分为客户端，服务端，存储引擎和文件
 
     最高层的客户端，通过tcp连接mysql的服务器，然后执行sql语句，其中涉及了查询缓存，执行计划处理和优化，接下来再到存储引擎层执行查询，底层实际上访问的是主机的文件系统。
 
-![image](http://image20.it168.com/201611_670x502/2701/39b96aa41090f9bb.png)
-
+![image](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/39b96aa41090f9bb.png)
 ## mysql常用语法
 
 1 登录mysql
@@ -108,7 +94,7 @@ mysql -h 127.0.0.1 -u 用户名 -p
 
 2 创建表
 语法还是比较复杂的，之前有腾讯面试官问这个，然后答不上来。
-    
+````    
     CREATE TABLE `user_accounts` (
       `id`             int(100) unsigned NOT NULL AUTO_INCREMENT primary key,
       `password`       varchar(32)       NOT NULL DEFAULT '' COMMENT '用户密码',
@@ -120,7 +106,7 @@ mysql -h 127.0.0.1 -u 用户名 -p
       UNIQUE INDEX idx_user_mobile(`mobile`)
     )
     ENGINE=InnoDB DEFAULT CHARSET=utf8
-
+````
 
 3 crud比较简单，不谈
 
@@ -172,14 +158,12 @@ mysql使用两个文件分别存储数据库的元数据和数据库的真正数
 数据页结构
 页是 InnoDB 存储引擎管理数据的最小磁盘单位，而 B-Tree 节点就是实际存放表中数据的页面，我们在这里将要介绍页是如何组织和存储记录的；首先，一个 InnoDB 页有以下七个部分：
 
-![InnoDB-B-Tree-Node](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/InnoDB-B-Tree-Node.jpg)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405195759.png)
 每一个页中包含了两对 header/trailer：内部的 Page Header/Page Directory 关心的是页的状态信息，而 Fil Header/Fil Trailer 关心的是记录页的头信息。
 
     也就是说，外部的h-t对用来和其他页形成联系，而内部的h-t用来是保存内部记录的状态。
 
-![https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Infimum-Rows-Supremum.jpg](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Infimum-Rows-Supremum.jpg)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405195900.png)
 User Records 就是整个页面中真正用于存放行记录的部分，而 Free Space 就是空余空间了，它是一个链表的数据结构，为了保证插入和删除的效率，整个页面并不会按照主键顺序对所有记录进行排序，它会自动从左侧向右寻找空白节点进行插入，行记录在物理存储上并不是按照顺序的，它们之间的顺序是由 next_record 这一指针控制的。
     
     也就是说，一个页中存了非常多行的数据，而每一行数据和相邻行使用指针进行链表连接。
@@ -205,47 +189,47 @@ mysql慢查询日志可以在mysql的,my.cnf文件中配置开启，然后执行
 比如分析一个sql：
 
     explain查看执行计划
-    
+````    
     id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
     
     1	SIMPLE	vote_record	\N	ALL	votenum,vote	\N	\N	\N	996507	50.00	Using where
+````
 
-
-​    
-​    
+    
+    
     还是没用到索引，因为不符合最左前缀匹配。查询需要3.5秒左右
 
 
-​    
-​    
-    最后修改一下sql语句
     
+    
+    最后修改一下sql语句
+````    
     EXPLAIN SELECT * FROM vote_record WHERE id > 0 AND vote_num > 1000;
     
     id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
     
     1	SIMPLE	vote_record	\N	range	PRIMARY,votenum,vote	PRIMARY	4	\N	498253	50.00	Using where
+````
 
-
-​    
-​    
+    
+    
     用到了索引，但是只用到了主键索引。再修改一次
 
 
-​    
-​    
+    
+````    
     EXPLAIN SELECT * FROM vote_record WHERE id > 0 AND vote_num = 1000;
 
 
-​    
-​    
+    
+    
     id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
     
     1	SIMPLE	vote_record	\N	index_merge	PRIMARY,votenum,vote	votenum,PRIMARY	8,4	\N	51	100.00	Using intersect(votenum,PRIMARY); Using where
 
 
-​    
-​    
+    
+````    
     用到了两个索引，votenum,PRIMARY。
 
 ## mysql的binlog,redo log和undo log。
@@ -334,8 +318,8 @@ innodb支持行级锁和事务，而myisam只支持表锁，它的所有操作
 实现的原理是next-key lock。是gap lock的加强版。不会锁住全表，只会锁住被读取行前后的间隙行。
 
 
-​    
-​    
+    
+    
 ## 分库分表
 
 分库分表的方案比较多，首先看下分表。
@@ -350,7 +334,7 @@ innodb支持行级锁和事务，而myisam只支持表锁，它的所有操作
 
 我们需要考虑扩展性，所以需要使用分布式的数据库。
 
-==分布式数据库解决方案mycat==
+分布式数据库解决方案mycat
     
     mycat是一款支持分库分表的数据库中间件，支持单机也支持分布式。
     
@@ -378,20 +362,4 @@ innodb支持行级锁和事务，而myisam只支持表锁，它的所有操作
 
 redis的分布式部署方案也比较成熟。
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\22310\357\274\232MySQL\351\207\214\347\232\204\351\202\243\344\272\233\346\227\245\345\277\227\344\273\254.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\22310\357\274\232MySQL\351\207\214\347\232\204\351\202\243\344\272\233\346\227\245\345\277\227\344\273\254.md"
deleted file mode 100644
index f233134..0000000
--- "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\22310\357\274\232MySQL\351\207\214\347\232\204\351\202\243\344\272\233\346\227\245\345\277\227\344\273\254.md"
+++ /dev/null
@@ -1,130 +0,0 @@
-# Table of Contents
-
-  * [重新学习MySQL数据库10：MySQL里的那些日志们](#重新学习mysql数据库10：mysql里的那些日志们)
-    * [1.MySQL日志文件系统的组成](#1mysql日志文件系统的组成)
-    * [2.错误日志](#2错误日志)
-    * [3.InnoDB中的日志](#3innodb中的日志)
-    * [4- 慢查询日志](#4--慢查询日志)
-    * [5.二进制日志](#5二进制日志)
-  * [总结](#总结)
-
-
-本文转自互联网
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-本也将整理到我的个人博客：
-> www.how2playlife.com
-
-更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
-
-本文是《重新学习MySQL数据库》系列其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从入门到进阶，从sql基本的使用方法，从MySQL执行引擎再到索引、事务等知识，一步步地学习MySQL相关技术的实现原理，更好地了解如何基于这些知识来优化sql，减少SQL执行时间，通过执行计划对SQL性能进行分析，再到MySQL的主从复制、主备部署等内容，以便让你更完整地了解整个MySQL方面的技术体系，形成自己的知识框架。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-<!-- more -->
-
-
-## 重新学习MySQL数据库10：MySQL里的那些日志们
-
-同大多数关系型数据库一样，日志文件是MySQL数据库的重要组成部分。MySQL有几种不同的日志文件，通常包括错误日志文件，二进制日志，通用日志，慢查询日志，等等。这些日志可以帮助我们定位mysqld内部发生的事件，数据库性能故障，记录数据的变更历史，用户恢复数据库等等。本文主要描述错误日志文件。
-
-### 1.MySQL日志文件系统的组成
-
-a、错误日志：记录启动、运行或停止mysqld时出现的问题。 b、通用日志：记录建立的客户端连接和执行的语句。 c、更新日志：记录更改数据的语句。该日志在MySQL 5.1中已不再使用。 d、二进制日志：记录所有更改数据的语句。还用于复制。 e、慢查询日志：记录所有执行时间超过long_query_time秒的所有查询或不使用索引的查询。 f、Innodb日志：innodb redo log 和undo log
-
-缺省情况下，所有日志创建于mysqld数据目录中。 可以通过刷新日志，来强制mysqld来关闭和重新打开日志文件（或者在某些情况下切换到一个新的日志）。 当你执行一个FLUSH LOGS语句或执行mysqladmin flush-logs或mysqladmin refresh时，则日志被老化。 对于存在MySQL复制的情形下，从复制服务器将维护更多日志文件，被称为接替日志。
-
-### 2.错误日志
-
-错误日志是一个文本文件。 错误日志记录了MySQL Server每次启动和关闭的详细信息以及运行过程中所有较为严重的警告和错误信息。 可以用--log-error[=file_name]选项来开启mysql错误日志，该选项指定mysqld保存错误日志文件的位置。 对于指定--log-error[=file_name]选项而未给定file_name值，mysqld使用错误日志名host_name.err 并在数据目录中写入日志文件。 在mysqld正在写入错误日志到文件时，执行FLUSH LOGS 或者mysqladmin flush-logs时，服务器将关闭并重新打开日志文件。 建议在flush之前手动重命名错误日志文件，之后mysql服务将使用原始文件名打开一个新文件。 以下为错误日志备份方法： shell> mv host_name.err host_name.err-old shell> mysqladmin flush-logs shell> mv host_name.err-old backup-directory
-
-### 3.InnoDB中的日志
-
-MySQL数据库InnoDB存储引擎Log漫游
-
-1 – Undo Log
-
-**Undo Log 是为了实现事务的原子性**，在MySQL数据库InnoDB存储引擎中，还用Undo Log来实现多版本并发控制(简称：MVCC)。
-
-*   事务的原子性(Atomicity) 事务中的所有操作，要么全部完成，要么不做任何操作，不能只做部分操作。如果在执行的过程中发生 了错误，要回滚(Rollback)到事务开始前的状态，就像这个事务从来没有执行过。
-
-*   原理 Undo Log的原理很简单，为了满足事务的原子性，在操作任何数据之前，首先将数据备份到一个地方 （这个存储数据备份的地方称为Undo Log）。然后进行数据的修改。如果出现了错误或者用户执行了 ROLLBACK语句，系统可以利用Undo Log中的备份将数据恢复到事务开始之前的状态。
-
-除了可以保证事务的原子性，**Undo Log也可以用来辅助完成事务的持久化**。
-
-*   事务的持久性(Durability) 事务一旦完成，该事务对数据库所做的所有修改都会持久的保存到数据库中。为了保证持久性，数据库 系统会将修改后的数据完全的记录到持久的存储上。
-
-*   用Undo Log实现原子性和持久化的事务的简化过程 假设有A、B两个数据，值分别为1,2。 A.事务开始. B.记录A=1到undo log. C.修改A=3. D.记录B=2到undo log. E.修改B=4. F.将undo log写到磁盘。 G.将数据写到磁盘。 H.事务提交 这里有一个隐含的前提条件：‘数据都是先读到内存中，然后修改内存中的数据，最后将数据写回磁盘’。
-
-    之所以能同时保证原子性和持久化，是因为以下特点： A. 更新数据前记录Undo log。 B. 为了保证持久性，必须将数据在事务提交前写到磁盘。只要事务成功提交，数据必然已经持久化。 C. Undo log必须先于数据持久化到磁盘。如果在G,H之间系统崩溃，undo log是完整的， 可以用来回滚事务。 D. 如果在A-F之间系统崩溃,因为数据没有持久化到磁盘。所以磁盘上的数据还是保持在事务开始前的状态。
-
-缺陷：每个事务提交前将数据和Undo Log写入磁盘，这样会导致大量的磁盘IO，因此性能很低。
-
-如果能够将数据缓存一段时间，就能减少IO提高性能。但是这样就会丧失事务的持久性。因此引入了另外一 种机制来实现持久化，即Redo Log.
-
-2 – Redo Log
-
-*   原理 和Undo Log相反，**Redo Log记录的是新数据的备份**。在事务提交前，只要将Redo Log持久化即可， 不需要将数据持久化。当系统崩溃时，虽然数据没有持久化，但是Redo Log已经持久化。系统可以根据 Redo Log的内容，将所有数据恢复到最新的状态。
-
-*   Undo + Redo事务的简化过程 假设有A、B两个数据，值分别为1,2. A.事务开始. B.记录A=1到undo log. C.修改A=3. D.记录A=3到redo log. E.记录B=2到undo log. F.修改B=4. G.记录B=4到redo log. H.将redo log写入磁盘。 I.事务提交
-
-    **undo log 保存的是修改前的数据,并且保存到内存中,回滚的时候在读取里面的内容(从而实现了原子性),redolog保存的是修改后的数据(对新数据的备份,同时也会将redo log备份),在事务提交写入到磁盘,从而保证了持久性**
-
-### 4- 慢查询日志
-
-概述 　　数据库查询快慢是影响项目性能的一大因素，对于数据库，我们除了要优化 SQL，更重要的是得先找到需要优化的 SQL。如何找到低效的 SQL 是写这篇文章的主要目的。
-
-　　MySQL 数据库有一个“慢查询日志”功能，用来记录查询时间超过某个设定值的SQL，这将极大程度帮助我们快速定位到问题所在，以便对症下药。至于查询时间的多少才算慢，每个项目、业务都有不同的要求，传统企业的软件允许查询时间高于某个值，但是把这个标准放在互联网项目或者访问量大的网站上，估计就是一个bug，甚至可能升级为一个功能性缺陷。
-
-　　为避免误导读者，特申明本文的讨论限制在 Win 64位 + MySQL 5.6 范围内。其他平台或数据库种类及版本，我没有尝试过，不做赘述。
-
-设置日志功能 关于慢查询日志，主要涉及到下面几个参数：
-
-slow_query_log ：是否开启慢查询日志功能（必填） long_query_time ：超过设定值，将被视作慢查询，并记录至慢查询日志文件中（必填） log-slow-queries ：慢查询日志文件（不可填），自动在 \data\ 创建一个 [hostname]-slow.log 文件 　　也就是说，只有满足以上三个条件，“慢查询功能”才可能正确开启或关闭。
-
-### 5.二进制日志
-
-*   主从复制的基础：binlog日志和relaylog日志
-
-什么是MySQL主从复制 简单来说就是保证主SQL（Master）和从SQL（Slave）的数据是一致性的，向Master插入数据后，Slave会自动从Master把修改的数据同步过来（有一定的延迟），通过这种方式来保证数据的一致性，就是主从复制
-
-复制方式 MySQL5.6开始主从复制有两种方式：基于日志（binlog）、基于GTID（全局事务标示符）。 本文只涉及基于日志binlog的主从配置
-
-复制原理 1、Master将数据改变记录到二进制日志(binary log)中，也就是配置文件log-bin指定的文件，这些记录叫做二进制日志事件(binary log events) 2、Slave通过I/O线程读取Master中的binary log events并写入到它的中继日志(relay log) 3、Slave重做中继日志中的事件，把中继日志中的事件信息一条一条的在本地执行一次，完成数据在本地的存储，从而实现将改变反映到它自己的数据(数据重放)
-
-1、什么是binlog binlog是一个二进制格式的文件，用于记录用户对数据库更新的SQL语句信息，例如更改数据库表和更改内容的SQL语句都会记录到binlog里，但是对库表等内容的查询不会记录。
-
-默认情况下，binlog日志是二进制格式的，不能使用查看文本工具的命令（比如，cat，vi等）查看，而使用mysqlbinlog解析查看。
-
-2.binlog的作用 当有数据写入到数据库时，还会同时把更新的SQL语句写入到对应的binlog文件里，这个文件就是上文说的binlog文件。使用mysqldump备份时，只是对一段时间的数据进行全备，但是如果备份后突然发现数据库服务器故障，这个时候就要用到binlog的日志了。
-
-主要作用是用于数据库的主从复制及数据的增量恢复。
-
-1.啥是binlog? 记录数据库增删改,不记录查询的二进制日志. 2.作用:用于数据同步. 3、如何开启binlog日志功能 在mysql的配置文件my.cnf中，增加log_bin参数即可开启binlog日志，也可以通过赋值来指定binlog日志的文件名，实例如下：
-
-[root@DB02 ~]# grep log_bin /etc/my.cnf log_bin = /application/mysql/logs/dadong-bin
-
-
-log_bin
-
-[root@DB02 ~]# 提示：也可以按“log_bin = /application/mysql/logs/dadong-bin”命名，目录要存在 为什么要刷新binlog?找到全备数据和binlog文件的恢复临界点.
-
-## 总结
-
-mysql数据库的binlog和relay log日志有着举足轻重的作用，并且relay log仅仅存在于mysql 的slave库，它的作用就是记录slave库中的io进程接收的从主库传过来的binlog,然后等待slave库的sql进程去读取和应用，保证主从同步，但是binlog主库和从库（slave）都可以存在，记录对数据发生或潜在发生更改的SQL语句，并以二进制的形式保存在磁盘，所以可以通过binlog来实时备份和恢复数据库。
-
-1、什么是binlog binlog是一个二进制格式的文件，用于记录用户对数据库更新的SQL语句信息，例如更改数据库表和更改内容的SQL语句都会记录到binlog里，但是对库表等内容的查询不会记录。
-
-默认情况下，binlog日志是二进制格式的，不能使用查看文本工具的命令（比如，cat，vi等）查看，而使用mysqlbinlog解析查看。
-
-2.binlog的作用 当有数据写入到数据库时，还会同时把更新的SQL语句写入到对应的binlog文件里，这个文件就是上文说的binlog文件。使用mysqldump备份时，只是对一段时间的数据进行全备，但是如果备份后突然发现数据库服务器故障，这个时候就要用到binlog的日志了。
-
-主要作用是用于数据库的主从复制及数据的增量恢复。
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\2239\357\274\232Innodb\344\270\255\347\232\204\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253\345\222\214\351\224\201\347\232\204\345\205\263\347\263\273.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232Innodb\344\270\255\347\232\204\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253\345\222\214\351\224\201\347\232\204\345\205\263\347\263\273.md"
similarity index 80%
rename from "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\2239\357\274\232Innodb\344\270\255\347\232\204\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253\345\222\214\351\224\201\347\232\204\345\205\263\347\263\273.md"
rename to "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232Innodb\344\270\255\347\232\204\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253\345\222\214\351\224\201\347\232\204\345\205\263\347\263\273.md"
index 17dd649..5223578 100644
--- "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\2239\357\274\232Innodb\344\270\255\347\232\204\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253\345\222\214\351\224\201\347\232\204\345\205\263\347\263\273.md"
+++ "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232Innodb\344\270\255\347\232\204\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253\345\222\214\351\224\201\347\232\204\345\205\263\347\263\273.md"
@@ -1,19 +1,15 @@
-# Table of Contents
+# 目录
 
   * [Innodb中的事务隔离级别和锁的关系](#innodb中的事务隔离级别和锁的关系)
   * [事务中的加锁方式](#事务中的加锁方式)
-                                                                                                                                            * [](#)
   * [MySQL中锁的种类](#mysql中锁的种类)
     * [Read Committed（读取提交内容）](#read-committed（读取提交内容）)
     * [Repeatable Read（可重读）](#repeatable-read（可重读）)
-                                                                                                                          * [](#-1)
     * [不可重复读和幻读的区别](#不可重复读和幻读的区别)
     * [悲观锁和乐观锁](#悲观锁和乐观锁)
   * [MVCC在MySQL的InnoDB中的实现](#mvcc在mysql的innodb中的实现)
   * [“读”与“读”的区别](#读与读的区别)
-                                                                                                                                                                                                                                    * [](#-2)
-                                                                                                                        * [](#-3)
-                                                                                                                                                                                                                                                    * [](#-4)
+                                                                                                                                                                                                                                                  * [](#-2)
 
 
 本文转自互联网
@@ -36,8 +32,6 @@
 
 <!-- more -->
 
-<!-- more -->
-
 
 ## Innodb中的事务隔离级别和锁的关系
 
@@ -45,7 +39,7 @@
 > 
 > 我们都知道事务的几种性质，数据库为了维护这些性质，尤其是一致性和隔离性，一般使用加锁这种方式。同时数据库又是个高并发的应用，同一时间会有大量的并发访问，如果加锁过度，会极大的降低并发处理能力。所以对于加锁的处理，可以说就是数据库对于事务处理的精髓所在。这里通过分析MySQL中InnoDB引擎的加锁机制，来抛砖引玉，让读者更好的理解，在事务处理中数据库到底做了什么。
 
-一次封锁or两段锁？ 因为有大量的并发访问，为了预防死锁，一般应用中推荐使用**一次封锁法**，就是**在方法的开始阶段，已经预先知道会用到哪些数据，然后全部锁住，在方法运行之后，再全部解锁**。这种方式可以有效的避免循环死锁，但在数据库中却不适用，因为在事务开始阶段，**数据库并不知道会用到哪些数据**。 数据库遵循的是两段锁协议，将事务分成两个阶段，加锁阶段和解锁阶段（所以叫两段锁）
+一次封锁or两段锁？因为有大量的并发访问，为了预防死锁，一般应用中推荐使用**一次封锁法**，就是**在方法的开始阶段，已经预先知道会用到哪些数据，然后全部锁住，在方法运行之后，再全部解锁**。这种方式可以有效的避免循环死锁，但在数据库中却不适用，因为在事务开始阶段，**数据库并不知道会用到哪些数据**。数据库遵循的是两段锁协议，将事务分成两个阶段，加锁阶段和解锁阶段（所以叫两段锁）
 
 *   加锁阶段：在该阶段可以进行加锁操作。在对任何数据进行读操作之前要申请并获得S锁（共享锁，其它事务可以继续加共享锁，但不能加排它锁），在进行写操作之前要申请并获得X锁（排它锁，其它事务不能再获得任何锁）。**加锁不成功，则事务进入等待状态，直到加锁成功才继续执行。**
 
@@ -53,7 +47,7 @@
 
 | 事务 | 加锁/解锁处理 |
 | --- | --- |
-| begin； |   |
+| begin； |  |
 | insert into test ..... | 加insert对应的锁 |
 | update test set... | 加update对应的锁 |
 | delete from test .... | 加delete对应的锁 |
@@ -63,7 +57,7 @@
 
 ## 事务中的加锁方式
 
-##事务的四种隔离级别 在数据库操作中，为了有效保证并发读取数据的正确性，提出的事务隔离级别。我们的数据库锁，也是为了构建这些隔离级别存在的。
+##事务的四种隔离级别在数据库操作中，为了有效保证并发读取数据的正确性，提出的事务隔离级别。我们的数据库锁，也是为了构建这些隔离级别存在的。
 
 | 隔离级别 | 脏读（Dirty Read） | 不可重复读（NonRepeatable Read） | 幻读（Phantom Read） |
 | --- | --- | --- | --- |
@@ -91,95 +85,95 @@ MySQL中锁的种类很多，有常见的表锁和行锁，也有新加入的Met
 ### Read Committed（读取提交内容）
 
 在RC级别中，数据的读取都是不加锁的，但是数据的写入、修改和删除是需要加锁的。效果如下
+````
+MySQL> show create table class_teacher \G\
+
+
 
-<pre>MySQL> show create table class_teacher \G\
-​
-​
-​
 Table: class_teacher
-​
-​
-​
+
+
+
 Create Table: CREATE TABLE `class_teacher` (
-​
-​
-​
+
+
+
  `id` int(11) NOT NULL AUTO_INCREMENT,
-​
-​
-​
+
+
+
  `class_name` varchar(100) COLLATE utf8mb4_unicode_ci NOT NULL,
-​
-​
-​
+
+
+
  `teacher_id` int(11) NOT NULL,
-​
-​
-​
+
+
+
  PRIMARY KEY (`id`),
-​
-​
-​
+
+
+
  KEY `idx_teacher_id` (`teacher_id`)
-​
-​
-​
+
+
+
 ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
-​
-​
-​
+
+
+
 1 row in set (0.02 sec)
-​
-​
-​
+
+
+
 MySQL> select * from class_teacher;
-​
-​
-​
+
+
+
 +----+--------------+------------+
-​
-​
-​
-| id | class_name   | teacher_id |
-​
-​
-​
+
+
+
+| id | class_name  | teacher_id |
+
+
+
 +----+--------------+------------+
-​
-​
-​
-|  1 | 初三一班     |          1 |
-​
-​
-​
-|  3 | 初二一班     |          2 |
-​
-​
-​
-|  4 | 初二二班     |          2 |
-​
-​
-​
-+----+--------------+------------+</pre>
 
+
+
+| 1 | 初三一班   |     1 |
+
+
+
+| 3 | 初二一班   |     2 |
+
+
+
+| 4 | 初二二班   |     2 |
+
+
+
++----+--------------+------------+
+````
 由于MySQL的InnoDB默认是使用的RR级别，所以我们先要将该session开启成RC级别，并且设置binlog的模式
+````
+SET session transaction isolation level read committed;
+
 
-<pre>SET session transaction isolation level read committed;
-​
-​
-​
-SET SESSION binlog_format = 'ROW';（或者是MIXED）</pre>
 
+SET SESSION binlog_format = 'ROW';（或者是MIXED）
+````
 | 事务A | 事务B |
 | --- | --- |
 | begin; | begin; |
 | update class_teacher set class_name='初三二班' where teacher_id=1; | update class_teacher set class_name='初三三班' where teacher_id=1; |
-|   | ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction |
-| commit; |   |
+|  | ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction |
+| commit; |  |
 
 为了防止并发过程中的修改冲突，事务A中MySQL给teacher_id=1的数据行加锁，并一直不commit（释放锁），那么事务B也就一直拿不到该行锁，wait直到超时。
 
-这时我们要注意到，teacher_id是有索引的，如果是没有索引的class_name呢？update class_teacher set teacher_id=3 where class_name = '初三一班'; 那么MySQL会给整张表的所有数据行的加行锁。这里听起来有点不可思议，但是当sql运行的过程中，MySQL并不知道哪些数据行是 class_name = '初三一班'的（没有索引嘛），如果一个条件无法通过索引快速过滤，存储引擎层面就会将所有记录加锁后返回，再由MySQL Server层进行过滤。
+这时我们要注意到，teacher_id是有索引的，如果是没有索引的class_name呢？update class_teacher set teacher_id=3 where class_name = '初三一班';那么MySQL会给整张表的所有数据行的加行锁。这里听起来有点不可思议，但是当sql运行的过程中，MySQL并不知道哪些数据行是 class_name = '初三一班'的（没有索引嘛），如果一个条件无法通过索引快速过滤，存储引擎层面就会将所有记录加锁后返回，再由MySQL Server层进行过滤。
 
 但在实际使用过程当中，MySQL做了一些改进，在MySQL Server过滤条件，发现不满足后，会调用unlock_row方法，把不满足条件的记录释放锁 (违背了二段锁协议的约束)。这样做，保证了最后只会持有满足条件记录上的锁，但是每条记录的加锁操作还是不能省略的。可见即使是MySQL，为了效率也是会违反规范的。（参见《高性能MySQL》中文第三版p181）
 
@@ -189,29 +183,29 @@ SET SESSION binlog_format = 'ROW';（或者是MIXED）</pre>
 
 这是MySQL中InnoDB默认的隔离级别。我们姑且分“读”和“写”两个模块来讲解。
 
-####读 读就是可重读，可重读这个概念是一事务的多个实例在并发读取数据时，会看到同样的数据行，有点抽象，我们来看一下效果。
+####读读就是可重读，可重读这个概念是一事务的多个实例在并发读取数据时，会看到同样的数据行，有点抽象，我们来看一下效果。
 
 RC（不可重读）模式下的展现
 
 | 事务A | 事务B |
 | --- | --- |
 | begin; | begin; |
-| select id,class_name,teacher_id from class_teacher where teacher_id=1; idclass_name,teacher_id1初三二班12初三一班1 |   |
-|   | update class_teacher set class_name='初三三班' where id=1; |
-|   | commit; |
-| select id,class_name,teacher_id from class_teacher where teacher_id=1; idclass_name,teacher_id1初三三班12初三一班1 读到了事务B修改的数据，和第一次查询的结果不一样，是不可重读的。 |   |
-| commit; |   |
+| select id,class_name,teacher_id from class_teacher where teacher_id=1; idclass_name,teacher_id1初三二班12初三一班1 |  |
+|  | update class_teacher set class_name='初三三班' where id=1; |
+|  | commit; |
+| select id,class_name,teacher_id from class_teacher where teacher_id=1; idclass_name,teacher_id1初三三班12初三一班1 读到了事务B修改的数据，和第一次查询的结果不一样，是不可重读的。 |  |
+| commit; |  |
 
 事务B修改id=1的数据提交之后，事务A同样的查询，后一次和前一次的结果不一样，这就是不可重读（重新读取产生的结果不一样）。这就很可能带来一些问题，那么我们来看看在RR级别中MySQL的表现：
 
 | 事务A | 事务B | 事务C |
 | --- | --- | --- |
 | begin; | begin; | begin; |
-| select id,class_name,teacher_id from class_teacher where teacher_id=1;idclass_nameteacher_id1初三二班12初三一班1 |   |   |
-|   | update class_teacher set class_name='初三三班' where id=1;commit; |   |
-|   |   | insert into class_teacher values (null,'初三三班',1); commit; |
-| select id,class_name,teacher_id from class_teacher where teacher_id=1;idclass_nameteacher_id1初三二班12初三一班1 没有读到事务B修改的数据，和第一次sql读取的一样，是可重复读的。没有读到事务C新添加的数据。 |   |   |
-| commit; |   |   |
+| select id,class_name,teacher_id from class_teacher where teacher_id=1;idclass_nameteacher_id1初三二班12初三一班1 |  |  |
+|  | update class_teacher set class_name='初三三班' where id=1;commit; |  |
+|  |  | insert into class_teacher values (null,'初三三班',1); commit; |
+| select id,class_name,teacher_id from class_teacher where teacher_id=1;idclass_nameteacher_id1初三二班12初三一班1 没有读到事务B修改的数据，和第一次sql读取的一样，是可重复读的。没有读到事务C新添加的数据。 |  |  |
+| commit; |  |  |
 
 我们注意到，当teacher_id=1时，事务A先做了一次读取，事务B中间修改了id=1的数据，并commit之后，事务A第二次读到的数据和第一次完全相同。所以说它是可重读的。那么MySQL是怎么做到的呢？这里姑且卖个关子，我们往下看。
 
@@ -285,9 +279,9 @@ RC（不可重读）模式下的展现
 
 事务的隔离级别实际上都是定义了当前读的级别，MySQL为了减少锁处理（包括等待其它锁）的时间，提升并发能力，引入了快照读的概念，使得select不用加锁。而update、insert这些“当前读”，就需要另外的模块来解决了。
 
-###写（"当前读"） 事务的隔离级别中虽然只定义了读数据的要求，实际上这也可以说是写数据的要求。上文的“读”，实际是讲的快照读；而这里说的“写”就是当前读了。 为了解决当前读中的幻读问题，MySQL事务使用了Next-Key锁。
+写（"当前读"）事务的隔离级别中虽然只定义了读数据的要求，实际上这也可以说是写数据的要求。上文的“读”，实际是讲的快照读；而这里说的“写”就是当前读了。为了解决当前读中的幻读问题，MySQL事务使用了Next-Key锁。
 
-####Next-Key锁 Next-Key锁是行锁和GAP（间隙锁）的合并，行锁上文已经介绍了，接下来说下GAP间隙锁。
+Next-Key锁Next-Key锁是行锁和GAP（间隙锁）的合并，行锁上文已经介绍了，接下来说下GAP间隙锁。
 
 行锁可以防止不同事务版本的数据修改提交时造成数据冲突的情况。但如何避免别的事务插入数据就成了问题。我们可以看看RR级别和RC级别的对比
 
@@ -296,20 +290,20 @@ RC级别：
 | 事务A | 事务B |
 | --- | --- |
 | begin; | begin; |
-| select id,class_name,teacher_id from class_teacher where teacher_id=30;idclass_nameteacher_id2初三二班30 |   |
-| update class_teacher set class_name='初三四班' where teacher_id=30; |   |
-|   | insert into class_teacher values (null,'初三二班',30);commit; |
-| select id,class_name,teacher_id from class_teacher where teacher_id=30;idclass_nameteacher_id2初三四班3010初三二班30 |   |
+| select id,class_name,teacher_id from class_teacher where teacher_id=30;idclass_nameteacher_id2初三二班30 |  |
+| update class_teacher set class_name='初三四班' where teacher_id=30; |  |
+|  | insert into class_teacher values (null,'初三二班',30);commit; |
+| select id,class_name,teacher_id from class_teacher where teacher_id=30;idclass_nameteacher_id2初三四班3010初三二班30 |  |
 
 RR级别：
 
 | 事务A | 事务B |
 | --- | --- |
 | begin; | begin; |
-| select id,class_name,teacher_id from class_teacher where teacher_id=30;idclass_nameteacher_id2初三二班30 |   |
-| update class_teacher set class_name='初三四班' where teacher_id=30; |   |
-|   | insert into class_teacher values (null,'初三二班',30);waiting.... |
-| select id,class_name,teacher_id from class_teacher where teacher_id=30;idclass_nameteacher_id2初三四班30 |   |
+| select id,class_name,teacher_id from class_teacher where teacher_id=30;idclass_nameteacher_id2初三二班30 |  |
+| update class_teacher set class_name='初三四班' where teacher_id=30; |  |
+|  | insert into class_teacher values (null,'初三二班',30);waiting.... |
+| select id,class_name,teacher_id from class_teacher where teacher_id=30;idclass_nameteacher_id2初三四班30 |  |
 | commit; | 事务Acommit后，事务B的insert执行。 |
 
 通过对比我们可以发现，在RC级别中，事务A修改了所有teacher_id=30的数据，但是当事务B insert进新数据后，事务A发现莫名其妙多了一行teacher_id=30的数据，而且没有被之前的update语句所修改，这就是“当前读”的幻读。
@@ -337,11 +331,11 @@ update class_teacher set class_name='初三四班' where teacher_id=30;不仅用
 | 事务A | 事务B | 事务C |
 | --- | --- | --- |
 | begin; | begin; | begin; |
-| select id,class_name,teacher_id from class_teacher;idclass_nameteacher_id1初三一班52初三二班30 |   |   |
-| update class_teacher set class_name='初一一班' where teacher_id=20; |   |   |
-|   | insert into class_teacher values (null,'初三五班',10);waiting ..... | insert into class_teacher values (null,'初三五班',40); |
+| select id,class_name,teacher_id from class_teacher;idclass_nameteacher_id1初三一班52初三二班30 |  |  |
+| update class_teacher set class_name='初一一班' where teacher_id=20; |  |  |
+|  | insert into class_teacher values (null,'初三五班',10);waiting ..... | insert into class_teacher values (null,'初三五班',40); |
 | commit; | 事务A commit之后，这条语句才插入成功 | commit; |
-|   | commit; |   |
+|  | commit; |  |
 
 update的teacher_id=20是在(5，30]区间，即使没有修改任何数据，Innodb也会在这个区间加gap锁，而其它区间不会影响，事务C正常插入。
 
@@ -349,6 +343,6 @@ update的teacher_id=20是在(5，30]区间，即使没有修改任何数据，In
 
 行锁防止别的事务修改或删除，GAP锁防止别的事务新增，行锁和GAP锁结合形成的的Next-Key锁共同解决了RR级别在写数据时的幻读问题。
 
-###Serializable 这个级别很简单，**读加共享锁，写加排他锁，读写互斥**。使用的**悲观锁的理论**，实现简单，数据更加安全，但是并发能力非常差。如果你的业务并发的特别少或者没有并发，同时又要求数据及时可靠的话，可以使用这种模式。
+###Serializable这个级别很简单，**读加共享锁，写加排他锁，读写互斥**。使用的**悲观锁的理论**，实现简单，数据更加安全，但是并发能力非常差。如果你的业务并发的特别少或者没有并发，同时又要求数据及时可靠的话，可以使用这种模式。
 
 这里要吐槽一句，**不要看到select就说不会加锁了，在Serializable这个级别，还是会加锁的**！
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2238\357\274\232MySQL\347\232\204\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253\345\256\236\346\210\230.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232MySQL\347\232\204\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253\345\256\236\346\210\230.md"
similarity index 67%
rename from "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2238\357\274\232MySQL\347\232\204\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253\345\256\236\346\210\230.md"
rename to "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232MySQL\347\232\204\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253\345\256\236\346\210\230.md"
index 0bda9d3..d048c74 100644
--- "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2238\357\274\232MySQL\347\232\204\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253\345\256\236\346\210\230.md"
+++ "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232MySQL\347\232\204\344\272\213\345\212\241\351\232\224\347\246\273\347\272\247\345\210\253\345\256\236\346\210\230.md"
@@ -1,5 +1,5 @@
-# Table of Contents
 
+# 目录
   * [事务的基本要素（ACID）](#事务的基本要素（acid）)
   * [事务的并发问题](#事务的并发问题)
   * [MySQL事务隔离级别](#mysql事务隔离级别)
@@ -25,14 +25,12 @@
 
 <!-- more -->
 
-<!-- more -->
-
 
 ## 事务的基本要素（ACID）
 
 　　1、原子性（Atomicity）：事务开始后所有操作，要么全部做完，要么全部不做，不可能停滞在中间环节。事务执行过程中出错，会回滚到事务开始前的状态，所有的操作就像没有发生一样。也就是说事务是一个不可分割的整体，就像化学中学过的原子，是物质构成的基本单位。
 
-　　 2、一致性（Consistency）：事务开始前和结束后，数据库的完整性约束没有被破坏 。比如A向B转账，不可能A扣了钱，B却没收到。
+　　2、一致性（Consistency）：事务开始前和结束后，数据库的完整性约束没有被破坏 。比如A向B转账，不可能A扣了钱，B却没收到。
 
 　　 3、隔离性（Isolation）：同一时间，只允许一个事务请求同一数据，不同的事务之间彼此没有任何干扰。比如A正在从一张银行卡中取钱，在A取钱的过程结束前，B不能向这张卡转账。
 
@@ -59,15 +57,15 @@
 
 
 
-1、  读未提交例子
+1、 读未提交例子
 
 （1）打开客户端A，设置事务模式为read uncommitted，查询表
 
 
 
- （1）      在A提交事务之前，打开客户端B，更新表
+（1）在A提交事务之前，打开客户端B，更新表
+
 
- 
 
 
 
@@ -83,39 +81,39 @@
 
 
 
-2、  读已提交
+2、 读已提交
 
-（1）      在客户端A设置事务模式为read committed;
+（1）在客户端A设置事务模式为read committed;
 
 
 
-（2）      在客户端A事务提交之前，打开客户端B，起事务更新表
+（2）在客户端A事务提交之前，打开客户端B，起事务更新表
 
 
 
-（3）      B的事务还未提交，A不能查到已经更新的数据，解决了脏读问题：
+（3）B的事务还未提交，A不能查到已经更新的数据，解决了脏读问题：
 
 
 
-（4）      此时提交客户端B的事务
+（4）此时提交客户端B的事务
 
 
 
-（5）      A执行与上一步相同的查询，结果发现与上一步不同，这就是不可重复读的问题：
+（5）A执行与上一步相同的查询，结果发现与上一步不同，这就是不可重复读的问题：
 
 
 
-3、  可重复读
+3、 可重复读
 
-（1）      打开客户端A，设置事务模式为repeatable read。
+（1）打开客户端A，设置事务模式为repeatable read。
 
 
 
-（2）      在A事务提交之前，打开客户端B，更新表account并提交：
+（2）在A事务提交之前，打开客户端B，更新表account并提交：
 
 
 
-（3）      在客户端A执行步骤1的查询，zhangsan的balance依然是450与步骤（1）查询结果一致，没有出现不可重复读的问题；接着执行update balance = balance – 50 where id=4;balance没有变成450-50=400；zhangsan的balance值用的是步骤 （2）中的400来算的，所以是350。数据的一致性没有被破坏。
+（3）在客户端A执行步骤1的查询，zhangsan的balance依然是450与步骤（1）查询结果一致，没有出现不可重复读的问题；接着执行update balance = balance – 50 where id=4;balance没有变成450-50=400；zhangsan的balance值用的是步骤 （2）中的400来算的，所以是350。数据的一致性没有被破坏。
 
 
 
@@ -123,25 +121,25 @@
 
 
 
-（5）      在客户端A开启事务，随后在客户端B开启事务，新增一条数据。提交
+（5）在客户端A开启事务，随后在客户端B开启事务，新增一条数据。提交
 
 
 
-（6）      在A计算balance之和，值为350+16000+2400=18750，没有把客户端B新增的数据算进去，客户端A提交后再计算balance之和，居然变成了19350，这时因为把客户端B的600算进去了。站在客户的角度，客户是看不到客户端B的，他会觉得天上掉馅饼了，多了600块，这就是幻读，站在开发者的角度，数据的一致性没有破坏。但是在应用程序中，我们的代码可能会把18750提交给用户了，如果一定要避免这种小概率状况的发生，那么就要采取“串行化”的事务隔离级别了。
+（6）在A计算balance之和，值为350+16000+2400=18750，没有把客户端B新增的数据算进去，客户端A提交后再计算balance之和，居然变成了19350，这时因为把客户端B的600算进去了。站在客户的角度，客户是看不到客户端B的，他会觉得天上掉馅饼了，多了600块，这就是幻读，站在开发者的角度，数据的一致性没有破坏。但是在应用程序中，我们的代码可能会把18750提交给用户了，如果一定要避免这种小概率状况的发生，那么就要采取“串行化”的事务隔离级别了。
 
 
 
-4、  串行化
+4、 串行化
 
-（1）      打开客户端A，设置事务隔离级别为serializable并开启事务。
+（1）打开客户端A，设置事务隔离级别为serializable并开启事务。
 
 
 
-（2）      打开客户端B，同样设置事务隔离级别为serializable，开启事务插入数据，报错。表被锁了，插入失败，mysql中事务隔离级别为serializable时会锁表，因此不会出现幻读的情况，这种隔离级别并发性很低，开发中很少用到。
+（2）打开客户端B，同样设置事务隔离级别为serializable，开启事务插入数据，报错。表被锁了，插入失败，mysql中事务隔离级别为serializable时会锁表，因此不会出现幻读的情况，这种隔离级别并发性很低，开发中很少用到。
 
 
 
- 　　补充：
+　　补充：
 
 　　1、SQL规范所规定的标准，不同的数据库具体的实现可能会有些差异
 
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232MySQL\351\207\214\347\232\204\351\202\243\344\272\233\346\227\245\345\277\227\344\273\254.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232MySQL\351\207\214\347\232\204\351\202\243\344\272\233\346\227\245\345\277\227\344\273\254.md"
new file mode 100644
index 0000000..347ecee
--- /dev/null
+++ "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232MySQL\351\207\214\347\232\204\351\202\243\344\272\233\346\227\245\345\277\227\344\273\254.md"
@@ -0,0 +1,126 @@
+# 目录
+  * [重新学习MySQL数据库10：MySQL里的那些日志们](#重新学习mysql数据库10：mysql里的那些日志们)
+    * [1.MySQL日志文件系统的组成](#1mysql日志文件系统的组成)
+    * [2.错误日志](#2错误日志)
+    * [3.InnoDB中的日志](#3innodb中的日志)
+    * [4- 慢查询日志](#4--慢查询日志)
+    * [5.二进制日志](#5二进制日志)
+  * [总结](#总结)
+
+
+本文转自互联网
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+本也将整理到我的个人博客：
+> www.how2playlife.com
+
+更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
+
+本文是《重新学习MySQL数据库》系列其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
+
+该系列博文会告诉你如何从入门到进阶，从sql基本的使用方法，从MySQL执行引擎再到索引、事务等知识，一步步地学习MySQL相关技术的实现原理，更好地了解如何基于这些知识来优化sql，减少SQL执行时间，通过执行计划对SQL性能进行分析，再到MySQL的主从复制、主备部署等内容，以便让你更完整地了解整个MySQL方面的技术体系，形成自己的知识框架。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+<!-- more -->
+
+## 重新学习MySQL数据库10：MySQL里的那些日志们
+
+同大多数关系型数据库一样，日志文件是MySQL数据库的重要组成部分。MySQL有几种不同的日志文件，通常包括错误日志文件，二进制日志，通用日志，慢查询日志，等等。这些日志可以帮助我们定位mysqld内部发生的事件，数据库性能故障，记录数据的变更历史，用户恢复数据库等等。本文主要描述错误日志文件。
+
+### 1.MySQL日志文件系统的组成
+
+a、错误日志：记录启动、运行或停止mysqld时出现的问题。b、通用日志：记录建立的客户端连接和执行的语句。c、更新日志：记录更改数据的语句。该日志在MySQL 5.1中已不再使用。d、二进制日志：记录所有更改数据的语句。还用于复制。e、慢查询日志：记录所有执行时间超过long_query_time秒的所有查询或不使用索引的查询。f、Innodb日志：innodb redo log 和undo log
+
+缺省情况下，所有日志创建于mysqld数据目录中。可以通过刷新日志，来强制mysqld来关闭和重新打开日志文件（或者在某些情况下切换到一个新的日志）。当你执行一个FLUSH LOGS语句或执行mysqladmin flush-logs或mysqladmin refresh时，则日志被老化。对于存在MySQL复制的情形下，从复制服务器将维护更多日志文件，被称为接替日志。
+
+### 2.错误日志
+
+错误日志是一个文本文件。错误日志记录了MySQL Server每次启动和关闭的详细信息以及运行过程中所有较为严重的警告和错误信息。可以用--log-error[=file_name]选项来开启mysql错误日志，该选项指定mysqld保存错误日志文件的位置。对于指定--log-error[=file_name]选项而未给定file_name值，mysqld使用错误日志名host_name.err 并在数据目录中写入日志文件。在mysqld正在写入错误日志到文件时，执行FLUSH LOGS 或者mysqladmin flush-logs时，服务器将关闭并重新打开日志文件。建议在flush之前手动重命名错误日志文件，之后mysql服务将使用原始文件名打开一个新文件。以下为错误日志备份方法：shell> mv host_name.err host_name.err-oldshell> mysqladmin flush-logsshell> mv host_name.err-old backup-directory
+
+### 3.InnoDB中的日志
+
+MySQL数据库InnoDB存储引擎Log漫游
+
+1 – Undo Log
+
+**Undo Log 是为了实现事务的原子性**，在MySQL数据库InnoDB存储引擎中，还用Undo Log来实现多版本并发控制(简称：MVCC)。
+
+*   事务的原子性(Atomicity)事务中的所有操作，要么全部完成，要么不做任何操作，不能只做部分操作。如果在执行的过程中发生了错误，要回滚(Rollback)到事务开始前的状态，就像这个事务从来没有执行过。
+
+*   原理Undo Log的原理很简单，为了满足事务的原子性，在操作任何数据之前，首先将数据备份到一个地方（这个存储数据备份的地方称为Undo Log）。然后进行数据的修改。如果出现了错误或者用户执行了ROLLBACK语句，系统可以利用Undo Log中的备份将数据恢复到事务开始之前的状态。
+
+除了可以保证事务的原子性，**Undo Log也可以用来辅助完成事务的持久化**。
+
+*   事务的持久性(Durability)事务一旦完成，该事务对数据库所做的所有修改都会持久的保存到数据库中。为了保证持久性，数据库系统会将修改后的数据完全的记录到持久的存储上。
+
+*   用Undo Log实现原子性和持久化的事务的简化过程假设有A、B两个数据，值分别为1,2。A.事务开始.B.记录A=1到undo log.C.修改A=3.D.记录B=2到undo log.E.修改B=4.F.将undo log写到磁盘。G.将数据写到磁盘。H.事务提交这里有一个隐含的前提条件：‘数据都是先读到内存中，然后修改内存中的数据，最后将数据写回磁盘’。
+
+    之所以能同时保证原子性和持久化，是因为以下特点：A. 更新数据前记录Undo log。B. 为了保证持久性，必须将数据在事务提交前写到磁盘。只要事务成功提交，数据必然已经持久化。C. Undo log必须先于数据持久化到磁盘。如果在G,H之间系统崩溃，undo log是完整的，可以用来回滚事务。D. 如果在A-F之间系统崩溃,因为数据没有持久化到磁盘。所以磁盘上的数据还是保持在事务开始前的状态。
+
+缺陷：每个事务提交前将数据和Undo Log写入磁盘，这样会导致大量的磁盘IO，因此性能很低。
+
+如果能够将数据缓存一段时间，就能减少IO提高性能。但是这样就会丧失事务的持久性。因此引入了另外一种机制来实现持久化，即Redo Log.
+
+2 – Redo Log
+
+*   原理和Undo Log相反，**Redo Log记录的是新数据的备份**。在事务提交前，只要将Redo Log持久化即可，不需要将数据持久化。当系统崩溃时，虽然数据没有持久化，但是Redo Log已经持久化。系统可以根据Redo Log的内容，将所有数据恢复到最新的状态。
+
+*   Undo + Redo事务的简化过程假设有A、B两个数据，值分别为1,2.A.事务开始.B.记录A=1到undo log.C.修改A=3.D.记录A=3到redo log.E.记录B=2到undo log.F.修改B=4.G.记录B=4到redo log.H.将redo log写入磁盘。I.事务提交
+
+    **undo log 保存的是修改前的数据,并且保存到内存中,回滚的时候在读取里面的内容(从而实现了原子性),redolog保存的是修改后的数据(对新数据的备份,同时也会将redo log备份),在事务提交写入到磁盘,从而保证了持久性**
+
+### 4- 慢查询日志
+
+概述　　数据库查询快慢是影响项目性能的一大因素，对于数据库，我们除了要优化 SQL，更重要的是得先找到需要优化的 SQL。如何找到低效的 SQL 是写这篇文章的主要目的。
+
+　　MySQL 数据库有一个“慢查询日志”功能，用来记录查询时间超过某个设定值的SQL，这将极大程度帮助我们快速定位到问题所在，以便对症下药。至于查询时间的多少才算慢，每个项目、业务都有不同的要求，传统企业的软件允许查询时间高于某个值，但是把这个标准放在互联网项目或者访问量大的网站上，估计就是一个bug，甚至可能升级为一个功能性缺陷。
+
+　　为避免误导读者，特申明本文的讨论限制在 Win 64位 + MySQL 5.6 范围内。其他平台或数据库种类及版本，我没有尝试过，不做赘述。
+
+设置日志功能关于慢查询日志，主要涉及到下面几个参数：
+
+slow_query_log ：是否开启慢查询日志功能（必填）long_query_time ：超过设定值，将被视作慢查询，并记录至慢查询日志文件中（必填）log-slow-queries ：慢查询日志文件（不可填），自动在 \data\ 创建一个 [hostname]-slow.log 文件　　也就是说，只有满足以上三个条件，“慢查询功能”才可能正确开启或关闭。
+
+### 5.二进制日志
+
+*   主从复制的基础：binlog日志和relaylog日志
+
+什么是MySQL主从复制简单来说就是保证主SQL（Master）和从SQL（Slave）的数据是一致性的，向Master插入数据后，Slave会自动从Master把修改的数据同步过来（有一定的延迟），通过这种方式来保证数据的一致性，就是主从复制
+
+复制方式MySQL5.6开始主从复制有两种方式：基于日志（binlog）、基于GTID（全局事务标示符）。本文只涉及基于日志binlog的主从配置
+
+复制原理1、Master将数据改变记录到二进制日志(binary log)中，也就是配置文件log-bin指定的文件，这些记录叫做二进制日志事件(binary log events)2、Slave通过I/O线程读取Master中的binary log events并写入到它的中继日志(relay log)3、Slave重做中继日志中的事件，把中继日志中的事件信息一条一条的在本地执行一次，完成数据在本地的存储，从而实现将改变反映到它自己的数据(数据重放)
+
+1、什么是binlogbinlog是一个二进制格式的文件，用于记录用户对数据库更新的SQL语句信息，例如更改数据库表和更改内容的SQL语句都会记录到binlog里，但是对库表等内容的查询不会记录。
+
+默认情况下，binlog日志是二进制格式的，不能使用查看文本工具的命令（比如，cat，vi等）查看，而使用mysqlbinlog解析查看。
+
+2.binlog的作用当有数据写入到数据库时，还会同时把更新的SQL语句写入到对应的binlog文件里，这个文件就是上文说的binlog文件。使用mysqldump备份时，只是对一段时间的数据进行全备，但是如果备份后突然发现数据库服务器故障，这个时候就要用到binlog的日志了。
+
+主要作用是用于数据库的主从复制及数据的增量恢复。
+
+1.啥是binlog? 记录数据库增删改,不记录查询的二进制日志.2.作用:用于数据同步.3、如何开启binlog日志功能在mysql的配置文件my.cnf中，增加log_bin参数即可开启binlog日志，也可以通过赋值来指定binlog日志的文件名，实例如下：
+
+[root@DB02 ~]# grep log_bin /etc/my.cnflog_bin = /application/mysql/logs/dadong-bin
+
+
+log_bin
+
+[root@DB02 ~]#提示：也可以按“log_bin = /application/mysql/logs/dadong-bin”命名，目录要存在为什么要刷新binlog?找到全备数据和binlog文件的恢复临界点.
+
+## 总结
+
+mysql数据库的binlog和relay log日志有着举足轻重的作用，并且relay log仅仅存在于mysql 的slave库，它的作用就是记录slave库中的io进程接收的从主库传过来的binlog,然后等待slave库的sql进程去读取和应用，保证主从同步，但是binlog主库和从库（slave）都可以存在，记录对数据发生或潜在发生更改的SQL语句，并以二进制的形式保存在磁盘，所以可以通过binlog来实时备份和恢复数据库。
+
+1、什么是binlogbinlog是一个二进制格式的文件，用于记录用户对数据库更新的SQL语句信息，例如更改数据库表和更改内容的SQL语句都会记录到binlog里，但是对库表等内容的查询不会记录。
+
+默认情况下，binlog日志是二进制格式的，不能使用查看文本工具的命令（比如，cat，vi等）查看，而使用mysqlbinlog解析查看。
+
+2.binlog的作用当有数据写入到数据库时，还会同时把更新的SQL语句写入到对应的binlog文件里，这个文件就是上文说的binlog文件。使用mysqldump备份时，只是对一段时间的数据进行全备，但是如果备份后突然发现数据库服务器故障，这个时候就要用到binlog的日志了。
+
+主要作用是用于数据库的主从复制及数据的增量恢复。
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\25613\357\274\232Mysql\344\270\273\344\273\216\345\244\215\345\210\266\357\274\214\350\257\273\345\206\231\345\210\206\347\246\273\357\274\214\345\210\206\350\241\250\345\210\206\345\272\223\347\255\226\347\225\245\344\270\216\345\256\236\350\267\265.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232Mysql\344\270\273\344\273\216\345\244\215\345\210\266\357\274\214\350\257\273\345\206\231\345\210\206\347\246\273\357\274\214\345\210\206\350\241\250\345\210\206\345\272\223\347\255\226\347\225\245\344\270\216\345\256\236\350\267\265.md"
similarity index 89%
rename from "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\25613\357\274\232Mysql\344\270\273\344\273\216\345\244\215\345\210\266\357\274\214\350\257\273\345\206\231\345\210\206\347\246\273\357\274\214\345\210\206\350\241\250\345\210\206\345\272\223\347\255\226\347\225\245\344\270\216\345\256\236\350\267\265.md"
rename to "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232Mysql\344\270\273\344\273\216\345\244\215\345\210\266\357\274\214\350\257\273\345\206\231\345\210\206\347\246\273\357\274\214\345\210\206\350\241\250\345\210\206\345\272\223\347\255\226\347\225\245\344\270\216\345\256\236\350\267\265.md"
index 38d0148..6a2ae30 100644
--- "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\25613\357\274\232Mysql\344\270\273\344\273\216\345\244\215\345\210\266\357\274\214\350\257\273\345\206\231\345\210\206\347\246\273\357\274\214\345\210\206\350\241\250\345\210\206\345\272\223\347\255\226\347\225\245\344\270\216\345\256\236\350\267\265.md"
+++ "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232Mysql\344\270\273\344\273\216\345\244\215\345\210\266\357\274\214\350\257\273\345\206\231\345\210\206\347\246\273\357\274\214\345\210\206\350\241\250\345\210\206\345\272\223\347\255\226\347\225\245\344\270\216\345\256\236\350\267\265.md"
@@ -1,37 +1,36 @@
-# Table of Contents
-
-  * [二、分表实现策略](#二、分表实现策略)
-  * [三、分库实现策略](#三、分库实现策略)
-  * [四、分库与分表实现策略](#四、分库与分表实现策略)
-  * [五、分库分表总结](#五、分库分表总结)
-  * [六、总结](#六、总结)
-  * [Mycat实现主从复制，读写分离，以及分库分表的实践](#mycat实现主从复制，读写分离，以及分库分表的实践)
+# 目录
+* [二、分表实现策略](#二、分表实现策略)
+* [三、分库实现策略](#三、分库实现策略)
+* [四、分库与分表实现策略](#四、分库与分表实现策略)
+* [五、分库分表总结](#五、分库分表总结)
+* [六、总结](#六、总结)
+* [Mycat实现主从复制，读写分离，以及分库分表的实践](#mycat实现主从复制，读写分离，以及分库分表的实践)
     * [Mycat是什么](#mycat是什么)
     * [一、分区分表](#一、分区分表)
     * [二、Mycat 数据分片的种类](#二、mycat-数据分片的种类)
     * [三、Mycat 垂直切分、水平切分实战](#三、mycat-垂直切分、水平切分实战)
-      * [1、垂直切分](#1、垂直切分)
-      * [2、水平切分](#2、水平切分)
-* [range start-end ,data node index](#range-start-end-data-node-index)
-* [K=1000,M=10000.](#k1000m10000)
-      * [为什么需要读写分离](#为什么需要读写分离)
-      * [MySQL主从复制](#mysql主从复制)
-      * [Mycat读写分离设置](#mycat读写分离设置)
-        * [配置Mycat用户](#配置mycat用户)
-        * [配置Mycat逻辑库](#配置mycat逻辑库)
-          * [schema](#schema)
-          * [dataNode](#datanode)
-          * [dataHost](#datahost)
+        * [1、垂直切分](#1、垂直切分)
+        * [2、水平切分](#2、水平切分)
+  * [为什么需要读写分离](#为什么需要读写分离)
+  * [MySQL主从复制](#mysql主从复制)
+  * [Mycat读写分离设置](#mycat读写分离设置)
+  * [配置Mycat用户](#配置mycat用户)
+  * [配置Mycat逻辑库](#配置mycat逻辑库)
+  * [schema](#schema)
+  * [dataNode](#datanode)
+  * [dataHost](#datahost)
 
 
 本文转自互联网
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本也将整理到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -44,9 +43,6 @@
 
 <!-- more -->
 
-<!-- more -->
-
-
 一、MySQL扩展具体的实现方式
 
 随着业务规模的不断扩大，需要选择合适的方案去应对数据规模的增长，以应对逐渐增长的访问压力和数据量。
@@ -55,7 +51,7 @@
 
 （1）业务拆分
 
-在 [大型网站应用之海量数据和高并发解决方案总结一二](http://blog.csdn.net/xlgen157387/article/details/53230138) 一篇文章中也具体讲述了为什么要对业务进行拆分。
+在[大型网站应用之海量数据和高并发解决方案总结一二](http://blog.csdn.net/xlgen157387/article/details/53230138)一篇文章中也具体讲述了为什么要对业务进行拆分。
 
 业务起步初始，为了加快应用上线和快速迭代，很多应用都采用集中式的架构。随着业务系统的扩大，系统变得越来越复杂，越来越难以维护，开发效率变得越来越低，并且对资源的消耗也变得越来越大，通过硬件提高系统性能的方式带来的成本也越来越高。
 
@@ -63,11 +59,11 @@
 
 例如：电商平台，包含了用户、商品、评价、订单等几大模块，最简单的做法就是在一个数据库中分别创建users、shops、comment、order四张表。
 
-![这里写图片描述](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190824171414385-1549042254.png)
+![这里写图片描述](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190824171414385-1549042254.png)
 
 但是，随着业务规模的增大，访问量的增大，我们不得不对业务进行拆分。每一个模块都使用单独的数据库来进行存储，不同的业务访问不同的数据库，将原本对一个数据库的依赖拆分为对4个数据库的依赖，这样的话就变成了4个数据库同时承担压力，系统的吞吐量自然就提高了。
 
-![这里写图片描述](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190824171414592-1710110308.png)
+![这里写图片描述](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190824171414592-1710110308.png)
 
 （2）主从复制
 
@@ -81,7 +77,7 @@
 
 上述三篇文章中，讲述了如何配置主从数据库，以及如何实现数据库的读写分离，这里不再赘述，有需要的选择性点击查看。
 
-![这里写图片描述](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190824171415114-995239105.png)
+![这里写图片描述](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190824171415114-995239105.png)
 
 上图是网上的一张关于MySQL的Master和Slave之间数据同步的过程图。
 
@@ -111,17 +107,17 @@ CREATE TABLE `order` (
 
 当数据比较大的时候，对数据进行分表操作，首先要确定需要将数据平均分配到多少张表中，也就是：表容量。
 
-这里假设有100张表进行存储，则我们在进行存储数据的时候，首先对用户ID进行取模操作，根据 `user_id%100` 获取对应的表进行存储查询操作，示意图如下：
+这里假设有100张表进行存储，则我们在进行存储数据的时候，首先对用户ID进行取模操作，根据`user_id%100`获取对应的表进行存储查询操作，示意图如下：
 
-![这里写图片描述](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190824171415339-1589002733.png)
+![这里写图片描述](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190824171415339-1589002733.png)
 
-例如，`user_id = 101` 那么，我们在获取值的时候的操作，可以通过下边的sql语句：
+例如，`user_id = 101`那么，我们在获取值的时候的操作，可以通过下边的sql语句：
 
 ```
 select * from order_1 where user_id= 101
 ```
 
-其中，`order_1`是根据 `101%100` 计算所得，表示分表之后的第一章order表。
+其中，`order_1`是根据`101%100`计算所得，表示分表之后的第一章order表。
 
 注意：
 
@@ -130,7 +126,6 @@ select * from order_1 where user_id= 101
 接口定义：
 
 ```
-
 /**
   * 获取用户相关的订单详细信息
   * @param tableNum 具体某一个表的编号
@@ -149,7 +144,7 @@ xml配置映射文件：
   </select>
 ```
 
-其中`${tableNum}` 含义是直接让参数加入到sql中，这是MyBatis支持的特性。
+其中`${tableNum}`含义是直接让参数加入到sql中，这是MyBatis支持的特性。
 
 注意：
 
@@ -171,7 +166,7 @@ xml配置映射文件：
 
 路由的示意图如下：
 
-![这里写图片描述](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190824171415519-516549009.png)
+![这里写图片描述](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190824171415519-516549009.png)
 
 上图中库容量为100。
 
@@ -203,7 +198,7 @@ xml配置映射文件：
 
 示意图如下：
 
-![这里写图片描述](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190824171416563-1109228018.png)
+![这里写图片描述](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190824171416563-1109228018.png)
 
 ## 五、分库分表总结
 
@@ -301,7 +296,10 @@ Mycat 的分片其实和分表差不多意思，就是当数据库过于庞大
 
 上面说到，垂直切分主要是根据具体业务来进行拆分的，那么，我们可以想象这么一个场景，假设我们有一个非常大的电商系统，那么我们需要将订单表、流水表、用户表、用户评论表等分别分不到不同的数据库中来提高吞吐量，架构图大概如下：
 
-<embed src="https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190824171417040-1009330909.webp">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190824171417040-1009330909.webp)
+
 
 由于小编是在一台机器上测试，因此就只有host1这个节点，但不同的表还是依旧对应不同的数据库，只不过是所有数据库属于同一个数据库实例（主机）而已，后期不同主机只需增加`<dataHost>`节点即可。
 
@@ -361,17 +359,20 @@ create database database4 character set utf8;
 
 执行`bin`目录下的`startup_nowrap.bat`文件，如果输出下面内容，则说明已经启动mycat成功，如果没有，请检查`order,trade,user,comment`4个数据库是否已经创建。
 
-<embed src="https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190824171417782-1932957742.webp">
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190824171417782-1932957742.webp)
+
 
 采用下面语句登陆Mycat服务器：
 
 `mysql -uroot -proot -P8066 -h127.0.0.1`
 
-<embed src="https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190824171418203-391358451.webp">
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190824171418203-391358451.webp)
+
 
 在`comment`数据库中创建`Comment`表，并插入一条数据
 
-<embed src="https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190824171418351-1853467698.webp">
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1092007-20190824171418351-1853467698.webp)
+
 
 上图1处新建一个`Comment`表，2处插入一条记录，3处查看记录插入到哪个数据节点中，即`database4`。
 
@@ -526,13 +527,13 @@ Mycat的配置有很多，不过因为我们只是使用Mycat的读写分类的
 
 ###### schema
 
-`schema` 标签是用来定义逻辑库的，`schema`有四个属性`dataNode`,`checkSQLschema`,`sqlMaxLimit`,`name`
+`schema`标签是用来定义逻辑库的，`schema`有四个属性`dataNode`,`checkSQLschema`,`sqlMaxLimit`,`name`
 
-`dataNode` 标签属性用于绑定逻辑库到某个具体的 database 上，1.3 版本如果配置了 dataNode，则不可以配置分片表，1.4 可以配置默认分片，只需要配置需要分片的表即可
+`dataNode`标签属性用于绑定逻辑库到某个具体的 database 上，1.3 版本如果配置了 dataNode，则不可以配置分片表，1.4 可以配置默认分片，只需要配置需要分片的表即可
 
 `name`是定义当前逻辑库的名字的，方便`server.xml`中定义用户时的引用
 
-`checkSQLschema`当该值设置为 true 时，如果我们执行语句select * from separate.users;则 MyCat 会把语句修改 为select * from users;。即把表示 schema 的字符去掉，避免发送到后端数据库执行时报（ERROR 1146 (42S02): Table ‘separate.users’ doesn’t exist）。 不过，即使设置该值为 true ，如果语句所带的是并非是 schema 指定的名字，例如：select * from db1.users; 那么 MyCat 并不会删除 db1 这个字段，如果没有定义该库的话则会报错，所以在提供 SQL语句的最好是不带这个字段。
+`checkSQLschema`当该值设置为 true 时，如果我们执行语句select * from separate.users;则 MyCat 会把语句修改 为select * from users;。即把表示 schema 的字符去掉，避免发送到后端数据库执行时报（ERROR 1146 (42S02): Table ‘separate.users’ doesn’t exist）。不过，即使设置该值为 true ，如果语句所带的是并非是 schema 指定的名字，例如：select * from db1.users;那么 MyCat 并不会删除 db1 这个字段，如果没有定义该库的话则会报错，所以在提供 SQL语句的最好是不带这个字段。
 
 `sqlMaxLimit`当该值设置为某个数值时。每条执行的 SQL 语句，如果没有加上 limit 语句，MyCat 也会自动的加上所对应的值。例如设置值为 100，执行select * from users;的效果为和执行select * from users limit 100;相同。设置该值的话，MyCat 默认会把查询到的信息全部都展示出来，造成过多的输出。所以，在正常使用中，还是建议加上一个值，用于减少过多的数据返回。当然 SQL 语句中也显式的指定 limit 的大小，不受该属性的约束。需要注意的是，如果运行的 schema 为非拆分库的，那么该属性不会生效。需要手动添加 limit 语句。
 
@@ -558,7 +559,7 @@ Mycat的配置有很多，不过因为我们只是使用Mycat的读写分类的
 
 `minCon`指定每个读写实例连接池的最小连接，初始化连接池的大小
 
-`balance` 读取负载均衡类型
+`balance`读取负载均衡类型
 
 1.  balance="0", 不开启读写分离机制，所有读操作都发送到当前可用的 writeHost 上。
 
@@ -574,7 +575,7 @@ Mycat的配置有很多，不过因为我们只是使用Mycat的读写分类的
 
 2.  writeType="1"，所有写操作都随机的发送到配置的 writeHost
 
-`dbType` 指定后端连接的数据库类型，目前支持二进制的 mysql 协议，还有其他使用 JDBC 连接的数据库。例如：mongodb、oracle、spark 等
+`dbType`指定后端连接的数据库类型，目前支持二进制的 mysql 协议，还有其他使用 JDBC 连接的数据库。例如：mongodb、oracle、spark 等
 
 `dbDriver`指定连接后端数据库使用的 Driver，目前可选的值有 native 和 JDBC。使用 native 的话，因为这个值执行的 是二进制的 mysql 协议，所以可以使用 mysql 和 maridb。其他类型的数据库则需要使用 JDBC 驱动来支持。从 1.6 版本开始支持 postgresql 的 native 原始协议。 如果使用 JDBC 的话需要将符合 JDBC 4 标准的驱动 JAR 包放到 MYCAT\lib 目录下，并检查驱动 JAR 包中包括如下目录结构的文件：META-INF\services\java.sql.Driver。在这个文件内写上具体的 Driver 类名，例如： com.mysql.jdbc.Driver。
 
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232Mysql\345\255\230\345\202\250\345\274\225\346\223\216\344\270\216\346\225\260\346\215\256\345\255\230\345\202\250\345\216\237\347\220\206.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232Mysql\345\255\230\345\202\250\345\274\225\346\223\216\344\270\216\346\225\260\346\215\256\345\255\230\345\202\250\345\216\237\347\220\206.md"
new file mode 100644
index 0000000..3d694e3
--- /dev/null
+++ "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232Mysql\345\255\230\345\202\250\345\274\225\346\223\216\344\270\216\346\225\260\346\215\256\345\255\230\345\202\250\345\216\237\347\220\206.md"
@@ -0,0 +1,289 @@
+# 目录
+
+  * [**一、 MySQL记录存储（页为单位）**](#一、-mysql记录存储（页为单位）)
+    * [**页头**](#页头)
+    * [**虚记录**](#虚记录)
+    * [**记录堆**](#记录堆)
+    * [**自由空间链表**](#自由空间链表)
+    * [**未分配空间**](#未分配空间)
+    * [**Slot区**](#slot区)
+    * [**页内记录维护**](#页内记录维护)
+  * [**二、 MySQL InnoDB存储引擎内存管理**](#二、-mysql-innodb存储引擎内存管理)
+    * [**预分配内存空间**](#预分配内存空间)
+    * [**数据以页为单位加载 （减少io访问次数）**](#数据以页为单位加载-（减少io访问次数）)
+    * [**数据内外存交换**](#数据内外存交换)
+    * [**页面管理**](#页面管理)
+    * [**页面淘汰**](#页面淘汰)
+    * [**全表扫描对内存的影响？**](#全表扫描对内存的影响？)
+    * [**页面淘汰**](#页面淘汰-1)
+    * [**位置移动**](#位置移动)
+  * [**三、MySQL事务实现原理**](#三、mysql事务实现原理)
+    * [**1、事务特性**](#1、事务特性)
+    * [**2、并发问题**](#2、并发问题)
+    * [**3、隔离级别**](#3、隔离级别)
+    * [**MySQL事务实现原理（事务管理机制）**](#mysql事务实现原理（事务管理机制）)
+    * [**1、MVCC 多版本并发控制**](#1、mvcc-多版本并发控制)
+    * [**2、undo log**](#2、undo-log)
+    * [**3、redo log**](#3、redo-log)
+    * [**意义**](#意义)
+  * [**四、MySQL锁实现原理**](#四、mysql锁实现原理)
+
+
+## **一、 MySQL记录存储（页为单位）**
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405205306.png)
+
+### **页头**
+
+记录页面的控制信息，共占56字节，包括页的左右兄弟页面指针、页面空间使用情况等。
+
+### **虚记录**
+
+最大虚记录：比页内最大主键还大 最小虚记录：比页内最小主键还小 (作用：比如说我们要查看一个记录是否在这个页面里，就要看这个记录是否在最大最小虚记录范围内)
+
+### **记录堆**
+
+行记录存储区，分为有效记录和已删除记录两种
+
+### **自由空间链表**
+
+已删除记录组成的链表 (重复利用空间)
+
+### **未分配空间**
+
+页面未使用的存储空间；
+
+### **Slot区**
+
+页尾 页面最后部分，占8个字节，主要存储页面的校验信息；
+
+### **页内记录维护**
+
+**顺序保证**
+
+物理有序(利于查询，不利于插入删除)
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-db41a4ce70476cb846cbcd92d3cb6efd_720w.webp)
+
+**逻辑有序(插入删除性能高，查询效率低)** 默认
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405205330.png)
+
+所以`MySQL`是像下图所示这样子有序的组织数据的。
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-5c927bccdfd6815a65b5bb1aebb13aae_720w.webp)
+
+**2、插入策略**
+
+**自由空间链表**（优先利用自由空间链表）
+
+**未使用空间**
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405205347.png)
+
+**3、页内查询**
+
+**遍历**
+
+**二分查找(数据不一样大，不能用二分)**
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-0b09abe7fa1b04a6274003c2dd08f733_720w.webp)
+
+利用槽位做二分，实现近似的二分查找，近似于跳表 。
+
+## **二、 MySQL InnoDB存储引擎内存管理**
+
+### **预分配内存空间**
+
+内存池
+
+### **数据以页为单位加载 （减少io访问次数）**
+
+内存页面管理
+
+- 页面映射（记录哪块磁盘上的数据加载到哪块内存上了）
+- 页面数据管理
+
+### **数据内外存交换**
+
+数据淘汰
+
+- 内存页耗尽
+- 需要加载新数据
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-369ec920b95324b4f2359cbe505c9a75_720w.webp)
+
+### **页面管理**
+
+- 空闲页
+- 数据页
+- 脏页（需刷回磁盘）
+
+### **页面淘汰**
+
+LRU(淘汰冷数据)
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-065e91777cbc08461d0e5a6d6c5de606_720w.webp)
+
+
+
+```
+某时刻状态->访问P2->访问新页P7
+```
+
+### **全表扫描对内存的影响？**
+
+可能会把内存中的热数据淘汰掉（比如说对一个几乎没有访问量的表进行全表扫描）
+
+所以`MySQL`不是单纯的利用`LRU算法`
+
+解决问题：如何避免热数据被淘汰？
+
+解决方案：访问时间 + 频率(redis)
+
+两个`LRU`表
+
+`MySQL`的解决方案
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-9bf6f401a22185ae7852b596f58c0fa4_720w.webp)
+
+MySQL内存管理—LRU
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405205410.png)
+
+
+**页面装载**
+
+磁盘数据到内存
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-3ad4cc1b1a83d8a7c0ecc8f7b9befd12_720w.webp)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405205420.png)
+
+没有空闲页怎么办？`Free list中取 > LRU中淘汰 > LRU Flush`
+
+### **页面淘汰**
+
+`LRU`尾部淘汰`Flush LRU`淘汰
+
+`LRU`链表中将第一个脏页刷盘并“释放”，放到`LRU`尾部？直接放`FreeList`？
+
+### **位置移动**
+
+old 到 new new 到 old
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405205431.png)
+
+思考：移动时机是什么？`innodb_old_blocks_time`old区存活时间，大于此值，有机会进入new区
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405205437.png)
+
+`LRU_new`的操作 链表操作效率很高，有访问移动到表头？`Lock！！！MySQL`设计思路：减少移动次数
+
+两个重要参考：1、`freed_page_clock：Buffer Pool`淘汰页数 2、`LRU_new`长度1/4
+
+当前`freed_page_clock` - 上次移动到Header时`freed_page_clock>LRU_new长度1/4`
+
+
+
+## **三、MySQL事务实现原理**
+
+MySQL事务基本概念。
+
+### **1、事务特性**
+
+A（`Atomicity`原子性）：全部成功或全部失败
+
+I（`Isolation`隔离性）：并行事务之间互不干扰
+
+D（`Durability`持久性）：事务提交后，永久生效
+
+C（`Consistency`一致性）：通过AID保证
+
+### **2、并发问题**
+
+脏读(`Drity Read`)：读取到未提交的数据
+
+不可重复读(`Non-repeatable read`)：两次读取结果不同
+
+幻读(`Phantom Read`)：select 操作得到的结果所表征的数据状态无法支撑后续的业务操作
+
+### **3、隔离级别**
+
+`Read Uncommitted`（未提交读）：最低隔离级别，会读取到其他事务未提交的数据。脏读；
+
+`Read Committed`（提交读）：事务过程中可以读取到其他事务已提交的数据。不可重复读；
+
+`Repeatable Read`（可重复读）：每次读取相同结果集，不管其他事务是否提交，幻读；（两次当前读不会产生幻读）
+
+`Serializable`（串行化）：事务排队，隔离级别最高，性能最差；
+
+### **MySQL事务实现原理（事务管理机制）**
+
+### **1、MVCC 多版本并发控制**
+
+解决读-写冲突 如何工作：隐藏列
+
+–当前读（读在存储引擎中存储的那个数据）
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-241cfc7589ea0de0cac531355324d0a7_720w.webp)
+
+RR级别下
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-70c832b4a5b81c944c99a96557bcddd6_720w.webp)
+
+### **2、undo log**
+
+回滚日志 保证事务原子性 实现数据多版本`delete undo log`：用于回滚，提交即清理；`update undo log`：用于回滚，同时实现快照读，不能随便删除
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-1e9ecbc408164c034a73c3415aa9105d_720w.webp)
+
+思考：undolog如何清理？依据系统活跃的最小活跃事务ID Read view 为什么InnoDB count（*）这么慢？因为
+
+### **3、redo log**
+
+实现事务持久性
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-029212b1ddd7fb111cefdfe9e6648bb7_720w.webp)
+
+写入流程 l 记录页的修改，状态为prepare l 事务提交，讲事务记录为commit状态
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405205454.png)
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-7d685adf553d18f2e8dcdcd632d8696f_720w.webp)
+
+### **意义**
+
+体积小，记录页的修改，比写入页代价低 末尾追加，随机写变顺序写，发生改变的页不固定
+
+## **四、MySQL锁实现原理**
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-44403b5fcb1bd988f68f72172c95627b_720w.webp)
+
+所有当前读加排他锁，都有哪些是当前读？`SELECT FOR UPDATEUPDATEDELETE`
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-6161f7636962904b6e17d57e1a2540dc_720w.webp)
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-c6b3c1d5c628b0c2fc104421ddc0faad_720w.webp)
+
+唯一索引/非唯一索引 `* RC/RR`4种情况逐一分析
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-323f7b0fc7e2bfbdee1bb19e8f7dea0f_720w.webp)
+
+会出现幻读问题，不可重复读了
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-3e9c8bda25b0b6788952f5024819e4ff_720w.webp)
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-7f9ba333592f1253ffa6adf619448aaf_720w.webp)
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-55b01d4fd841e1c417004c86a80746b7_720w.webp)
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-b155fff4fd294066127c2e6c2650f559_720w.webp)
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405205509.png)
+
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-e87ad5dc811f52789e20adb3b53b8ba1_720w.webp)
+
+死锁在库表中有记录，通过kill 那个锁删除。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/%E5%86%B3%E5%AE%9A%E7%89%88.jpeg)
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2234\357\274\232Mysql\347\264\242\345\274\225\345\256\236\347\216\260\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\346\225\260\346\215\256\347\273\223\346\236\204\347\256\227\346\263\225.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232Mysql\347\264\242\345\274\225\345\256\236\347\216\260\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\346\225\260\346\215\256\347\273\223\346\236\204\347\256\227\346\263\225.md"
similarity index 94%
rename from "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2234\357\274\232Mysql\347\264\242\345\274\225\345\256\236\347\216\260\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\346\225\260\346\215\256\347\273\223\346\236\204\347\256\227\346\263\225.md"
rename to "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232Mysql\347\264\242\345\274\225\345\256\236\347\216\260\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\346\225\260\346\215\256\347\273\223\346\236\204\347\256\227\346\263\225.md"
index b15743e..b522104 100644
--- "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2234\357\274\232Mysql\347\264\242\345\274\225\345\256\236\347\216\260\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\346\225\260\346\215\256\347\273\223\346\236\204\347\256\227\346\263\225.md"
+++ "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232Mysql\347\264\242\345\274\225\345\256\236\347\216\260\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\346\225\260\346\215\256\347\273\223\346\236\204\347\256\227\346\263\225.md"
@@ -1,11 +1,12 @@
-# Table of Contents
-
-  * [MySQL索引](#mysql索引)
-    * [一、简介](#一、简介)
-    * [二、语句](#二、语句)
-    * [三、索引类型](#三、索引类型)
-    * [四、缺点](#四、缺点)
-    * [五、注意事项](#五、注意事项)
+
+# 目录
+
+* [MySQL索引](#mysql索引)
+  * [一、简介](#一、简介)
+  * [二、语句](#二、语句)
+  * [三、索引类型](#三、索引类型)
+  * [四、缺点](#四、缺点)
+  * [五、注意事项](#五、注意事项)
 * [摘要](#摘要)
 * [数据结构及算法基础](#数据结构及算法基础)
   * [索引的本质](#索引的本质)
@@ -40,11 +41,13 @@
 本文转自互联网
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本也将整理到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -57,7 +60,6 @@
 
 <!-- more -->
 
-<!-- more -->
 ## MySQL索引
 
 ### 一、简介
@@ -73,10 +75,8 @@ MySQL目前主要有以下几种索引类型：
 
 
 
-<pre>CREATE TABLE table_name[col_name data type]
-[unique|fulltext][index|key][index_name](col_name[length])[asc|desc]</pre>
-
-
+CREATE TABLE table_name[col_name data type]
+[unique|fulltext][index|key][index_name](col_name[length])[asc|desc]
 
 1.unique|fulltext为可选参数，分别表示唯一索引、全文索引
 2.index和key为同义词，两者作用相同，用来指定创建索引
@@ -91,37 +91,38 @@ MySQL目前主要有以下几种索引类型：
 是最基本的索引，它没有任何限制。它有以下几种创建方式：
 （1）直接创建索引
 
+````
 
-
-<pre>CREATE INDEX index_name ON table(column(length))</pre>
-
+CREATE INDEX index_name ON table(column(length))
+````
 
 
 （2）修改表结构的方式添加索引
 
 
-
-<pre>ALTER TABLE table_name ADD INDEX index_name ON (column(length))</pre>
-
+````
+ALTER TABLE table_name ADD INDEX index_name ON (column(length))
+````
 
 
 （3）创建表的时候同时创建索引
 
-
-<pre>CREATE TABLE `table` (
+````
+CREATE TABLE `table` (
     `id` int(11) NOT NULL AUTO_INCREMENT ,
     `title` char(255) CHARACTER NOT NULL ,
     `content` text CHARACTER NULL ,
     `time` int(10) NULL DEFAULT NULL , PRIMARY KEY (`id`), INDEX index_name (title(length))
-)</pre>
+)
+````
 
 
 （4）删除索引
 
 
-
-<pre>DROP INDEX index_name ON table</pre>
-
+````
+DROP INDEX index_name ON table
+````
 
 
 2.唯一索引
@@ -129,48 +130,50 @@ MySQL目前主要有以下几种索引类型：
 （1）创建唯一索引
 
 
-
-<pre>CREATE UNIQUE INDEX indexName ON table(column(length))</pre>
-
+````
+CREATE UNIQUE INDEX indexName ON table(column(length))
+````
 
 
 （2）修改表结构
 
 
-
-<pre>ALTER TABLE table_name ADD UNIQUE indexName ON (column(length))</pre>
-
+````
+ALTER TABLE table_name ADD UNIQUE indexName ON (column(length))
+````
 
 
 （3）创建表的时候直接指定
 
-
-<pre>CREATE TABLE `table` (
+````
+CREATE TABLE `table` (
     `id` int(11) NOT NULL AUTO_INCREMENT ,
     `title` char(255) CHARACTER NOT NULL ,
     `content` text CHARACTER NULL ,
     `time` int(10) NULL DEFAULT NULL , UNIQUE indexName (title(length))
-);</pre>
+);
+````
 
 
 
 3.主键索引
 是一种特殊的唯一索引，一个表只能有一个主键，不允许有空值。一般是在建表的时候同时创建主键索引：
 
-
-<pre>CREATE TABLE `table` (
+````
+CREATE TABLE `table` (
     `id` int(11) NOT NULL AUTO_INCREMENT ,
     `title` char(255) NOT NULL , PRIMARY KEY (`id`)
-);</pre>
+);
+````
 
 
 4.组合索引
 指多个字段上创建的索引，只有在查询条件中使用了创建索引时的第一个字段，索引才会被使用。使用组合索引时遵循最左前缀集合
 
 
-
-<pre>ALTER TABLE `table` ADD INDEX name_city_age (name,city,age); </pre>
-
+````
+ALTER TABLE `table` ADD INDEX name_city_age (name,city,age); 
+````
 
 
 5.全文索引
@@ -179,30 +182,31 @@ MySQL目前主要有以下几种索引类型：
 它可以在create table，alter table ，create index使用，不过目前只有char、varchar，text 列上可以创建全文索引。值得一提的是，在数据量较大时候，现将数据放入一个没有全局索引的表中，然后再用CREATE index创建fulltext索引，要比先为一张表建立fulltext然后再将数据写入的速度快很多。
 （1）创建表的适合添加全文索引
 
-
-<pre>CREATE TABLE `table` (
+````
+CREATE TABLE `table` (
     `id` int(11) NOT NULL AUTO_INCREMENT ,
     `title` char(255) CHARACTER NOT NULL ,
     `content` text CHARACTER NULL ,
     `time` int(10) NULL DEFAULT NULL , PRIMARY KEY (`id`),
     FULLTEXT (content)
-);</pre>
+);
+````
 
 
 （2）修改表结构添加全文索引
 
 
-
-<pre>ALTER TABLE article ADD FULLTEXT index_content(content)</pre>
-
+````
+ALTER TABLE article ADD FULLTEXT index_content(content)
+````
 
 
 （3）直接创建索引
 
 
-
-<pre>CREATE FULLTEXT INDEX index_content ON article(content)</pre>
-
+````
+CREATE FULLTEXT INDEX index_content ON article(content)
+````
 
 
 ### 四、缺点
@@ -231,9 +235,9 @@ MySQL目前主要有以下几种索引类型：
 这将导致索引失效而进行全表扫描，例如
 
 
-
-<pre>SELECT * FROM table_name WHERE YEAR(column_name)<2017;</pre>
-
+````
+SELECT * FROM table_name WHERE YEAR(column_name)<2017;
+````
 
 
 6.不使用not in和<>操作
@@ -260,7 +264,7 @@ MySQL官方对索引的定义为：索引（Index）是帮助MySQL高效获取
 
 看一个例子：
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/1.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1.png)
 
 图1
 
@@ -298,26 +302,27 @@ key和指针互相间隔，节点两端是指针。
 
 图2是一个d=2的B-Tree示意图。
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/2.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/2.png)
 
 图2
 
 由于B-Tree的特性，在B-Tree中按key检索数据的算法非常直观：首先从根节点进行二分查找，如果找到则返回对应节点的data，否则对相应区间的指针指向的节点递归进行查找，直到找到节点或找到null指针，前者查找成功，后者查找失败。B-Tree上查找算法的伪代码如下：
 
-<pre>
 
-1.  BTree_Search(node, key)  {
-2.   if(node ==  null)  return  null;
-3.   foreach(node.key)
-4.   {
-5.   if(node.key[i]  == key)  return node.data[i];
-6.   if(node.key[i]  > key)  return  BTree_Search(point[i]->node);
-7.   }
-8.   return  BTree_Search(point[i+1]->node);
-9.  }
-10.  data =  BTree_Search(root, my_key);
 
-</pre>
+````
+BTree_Search(node, key)  {
+if(node ==  null)  return  null;
+foreach(node.key)
+{
+if(node.key[i]  == key)  return node.data[i];
+if(node.key[i]  > key)  return  BTree_Search(point[i]->node);
+}
+return  BTree_Search(point[i+1]->node);
+}
+ data =  BTree_Search(root, my_key);
+````
+
 
 关于B-Tree有一系列有趣的性质，例如一个度为d的B-Tree，设其索引N个key，从这点可以看出，B-Tree是一个非常有效率的索引数据结构。
 
@@ -335,7 +340,7 @@ B-Tree有许多变种，其中最常见的是B+Tree，例如MySQL就普遍使用
 
 图3是一个简单的B+Tree示意。
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/3.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/3.png)
 
 图3
 
@@ -347,9 +352,7 @@ B-Tree有许多变种，其中最常见的是B+Tree，例如MySQL就普遍使用
 
 一般在数据库系统或文件系统中使用的B+Tree结构都在经典B+Tree的基础上进行了优化，增加了顺序访问指针。
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/4.png)
-
-图4
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/4.png)
 
 如图4所示，在B+Tree的每个叶子节点增加一个指向相邻叶子节点的指针，就形成了带有顺序访问指针的B+Tree。做这个优化的目的是为了提高区间访问的性能，例如图4中如果要查询key为从18到49的所有数据记录，当找到18后，只需顺着节点和指针顺序遍历就可以一次性访问到所有数据节点，极大提到了区间查询效率。
 
@@ -365,9 +368,7 @@ B-Tree有许多变种，其中最常见的是B+Tree，例如MySQL就普遍使用
 
 目前计算机使用的主存基本都是随机读写存储器（RAM），现代RAM的结构和存取原理比较复杂，这里本文抛却具体差别，抽象出一个十分简单的存取模型来说明RAM的工作原理。
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/5.png)
-
-图5
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/5.png)
 
 从抽象角度看，主存是一系列的存储单元组成的矩阵，每个存储单元存储固定大小的数据。每个存储单元有唯一的地址，现代主存的编址规则比较复杂，这里将其简化成一个二维地址：通过一个行地址和一个列地址可以唯一定位到一个存储单元。图5展示了一个4 x 4的主存模型。
 
@@ -385,17 +386,13 @@ B-Tree有许多变种，其中最常见的是B+Tree，例如MySQL就普遍使用
 
 图6是磁盘的整体结构示意图。
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/6.png)
-
-图6
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/6.png)
 
 一个磁盘由大小相同且同轴的圆形盘片组成，磁盘可以转动（各个磁盘必须同步转动）。在磁盘的一侧有磁头支架，磁头支架固定了一组磁头，每个磁头负责存取一个磁盘的内容。磁头不能转动，但是可以沿磁盘半径方向运动（实际是斜切向运动），每个磁头同一时刻也必须是同轴的，即从正上方向下看，所有磁头任何时候都是重叠的（不过目前已经有多磁头独立技术，可不受此限制）。
 
 图7是磁盘结构的示意图。
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/7.png)
-
-图7
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/7.png)
 
 盘片被划分成一系列同心环，圆心是盘片中心，每个同心环叫做一个磁道，所有半径相同的磁道组成一个柱面。磁道被沿半径线划分成一个个小的段，每个段叫做一个扇区，每个扇区是磁盘的最小存储单元。为了简单起见，我们下面假设磁盘只有一个盘片和一个磁头。
 
@@ -437,15 +434,11 @@ floor表示向下取整。由于B+Tree内节点去掉了data域，因此可以
 
 MyISAM引擎使用B+Tree作为索引结构，叶节点的data域存放的是数据记录的地址。下图是MyISAM索引的原理图：
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/8.png)
-
-图8
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/8.png)
 
 这里设表一共有三列，假设我们以Col1为主键，则图8是一个MyISAM表的主索引（Primary key）示意。可以看出MyISAM的索引文件仅仅保存数据记录的地址。在MyISAM中，主索引和辅助索引（Secondary key）在结构上没有任何区别，只是主索引要求key是唯一的，而辅助索引的key可以重复。如果我们在Col2上建立一个辅助索引，则此索引的结构如下图所示：
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/9.png)
-
-图9
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/9.png)
 
 同样也是一颗B+Tree，data域保存数据记录的地址。因此，MyISAM中索引检索的算法为首先按照B+Tree搜索算法搜索索引，如果指定的Key存在，则取出其data域的值，然后以data域的值为地址，读取相应数据记录。
 
@@ -457,17 +450,13 @@ MyISAM的索引方式也叫做“非聚集”的，之所以这么称呼是为
 
 第一个重大区别是InnoDB的数据文件本身就是索引文件。从上文知道，MyISAM索引文件和数据文件是分离的，索引文件仅保存数据记录的地址。而在InnoDB中，表数据文件本身就是按B+Tree组织的一个索引结构，这棵树的叶节点data域保存了完整的数据记录。这个索引的key是数据表的主键，因此InnoDB表数据文件本身就是主索引。
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/10.png)
-
-图10
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/10.png)
 
 图10是InnoDB主索引（同时也是数据文件）的示意图，可以看到叶节点包含了完整的数据记录。这种索引叫做聚集索引。因为InnoDB的数据文件本身要按主键聚集，所以InnoDB要求表必须有主键（MyISAM可以没有），如果没有显式指定，则MySQL系统会自动选择一个可以唯一标识数据记录的列作为主键，如果不存在这种列，则MySQL自动为InnoDB表生成一个隐含字段作为主键，这个字段长度为6个字节，类型为长整形。
 
 第二个与MyISAM索引的不同是InnoDB的辅助索引data域存储相应记录主键的值而不是地址。换句话说，InnoDB的所有辅助索引都引用主键作为data域。例如，图11为定义在Col3上的一个辅助索引：
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/11.png)
-
-图11
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/11.png)
 
 这里以英文字符的ASCII码作为比较准则。聚集索引这种实现方式使得按主键的搜索十分高效，但是辅助索引搜索需要检索两遍索引：首先检索辅助索引获得主键，然后用主键到主索引中检索获得记录。
 
@@ -483,9 +472,7 @@ MySQL的优化主要分为结构优化（Scheme optimization）和查询优化
 
 为了讨论索引策略，需要一个数据量不算小的数据库作为示例。本文选用MySQL官方文档中提供的示例数据库之一：employees。这个数据库关系复杂度适中，且数据量较大。下图是这个数据库的E-R关系图（引用自MySQL官方手册）：
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/12.png)
-
-图12
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/12.png)
 
 MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/employee/en/employee.html](http://dev.mysql.com/doc/employee/en/employee.html "http://dev.mysql.com/doc/employee/en/employee.html")。里面详细介绍了此数据库，并提供了下载地址和导入方法，如果有兴趣导入此数据库到自己的MySQL可以参考文中内容。
 
@@ -497,7 +484,8 @@ MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/empl
 
 以employees.titles表为例，下面先查看其上都有哪些索引：
 
-<pre>
+
+````
 
 1.  SHOW INDEX FROM employees.titles;
 2.  +--------+------------+----------+--------------+-------------+-----------+-------------+------+------------+
@@ -508,22 +496,24 @@ MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/empl
 7.  | titles |  0  | PRIMARY |  3  | from_date | A |  443308  |  | BTREE |
 8.  | titles |  1  | emp_no |  1  | emp_no | A |  443308  |  | BTREE |
 9.  +--------+------------+----------+--------------+-------------+-----------+-------------+------+------------+
+````
 
-</pre>
 
 从结果中可以到titles表的主索引为<emp_no, title, from_date>，还有一个辅助索引<emp_no>。为了避免多个索引使事情变复杂（MySQL的SQL优化器在多索引时行为比较复杂），这里我们将辅助索引drop掉：
 
-<pre>
+
+````
 
 1.  ALTER TABLE employees.titles DROP INDEX emp_no;
 
-</pre>
+````
 
 这样就可以专心分析索引PRIMARY的行为了。
 
 ### 情况一：全列匹配。
 
-<pre>
+
+````
 
 1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no='10001' AND title='Senior Engineer' AND from_date='1986-06-26';
 2.  +----+-------------+--------+-------+---------------+---------+---------+-------------------+------+-------+
@@ -531,12 +521,13 @@ MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/empl
 4.  +----+-------------+--------+-------+---------------+---------+---------+-------------------+------+-------+
 5.  |  1  | SIMPLE | titles |  const  | PRIMARY | PRIMARY |  59  |  const,const,const  |  1  |  |
 6.  +----+-------------+--------+-------+---------------+---------+---------+-------------------+------+-------+
+````
 
-</pre>
 
 很明显，当按照索引中所有列进行精确匹配（这里精确匹配指“=”或“IN”匹配）时，索引可以被用到。这里有一点需要注意，理论上索引对顺序是敏感的，但是由于MySQL的查询优化器会自动调整where子句的条件顺序以使用适合的索引，例如我们将where中的条件顺序颠倒：
 
-<pre>
+
+````
 
 1.  EXPLAIN SELECT * FROM employees.titles WHERE from_date='1986-06-26' AND emp_no='10001' AND title='Senior Engineer';
 2.  +----+-------------+--------+-------+---------------+---------+---------+-------------------+------+-------+
@@ -544,15 +535,16 @@ MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/empl
 4.  +----+-------------+--------+-------+---------------+---------+---------+-------------------+------+-------+
 5.  |  1  | SIMPLE | titles |  const  | PRIMARY | PRIMARY |  59  |  const,const,const  |  1  |  |
 6.  +----+-------------+--------+-------+---------------+---------+---------+-------------------+------+-------+
+````
 
-</pre>
 
 效果是一样的。
 
 ### 情况二：最左前缀匹配。
 
-<pre>
 
+
+````
 1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no='10001';
 2.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------+
 3.  | id | select_type | table | type | possible_keys | key | key_len |  ref  | rows |  Extra  |
@@ -560,13 +552,14 @@ MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/empl
 5.  |  1  | SIMPLE | titles |  ref  | PRIMARY | PRIMARY |  4  |  const  |  1  |  |
 6.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------+
 
-</pre>
+````
 
 当查询条件精确匹配索引的左边连续一个或几个列时，如<emp_no>或<emp_no, title>，所以可以被用到，但是只能用到一部分，即条件所组成的最左前缀。上面的查询从分析结果看用到了PRIMARY索引，但是key_len为4，说明只用到了索引的第一列前缀。
 
 ### 情况三：查询条件用到了索引中列的精确匹配，但是中间某个条件未提供。
 
-<pre>
+
+````
 
 1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no='10001' AND from_date='1986-06-26';
 2.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------------+
@@ -575,14 +568,15 @@ MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/empl
 5.  |  1  | SIMPLE | titles |  ref  | PRIMARY | PRIMARY |  4  |  const  |  1  |  Using  where  |
 6.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------------+
 
-</pre>
+````
 
 此时索引使用情况和情况二相同，因为title未提供，所以查询只用到了索引的第一列，而后面的from_date虽然也在索引中，但是由于title不存在而无法和左前缀连接，因此需要对结果进行扫描过滤from_date（这里由于emp_no唯一，所以不存在扫描）。如果想让from_date也使用索引而不是where过滤，可以增加一个辅助索引<emp_no, from_date>，此时上面的查询会使用这个索引。除此之外，还可以使用一种称之为“隔离列”的优化方法，将emp_no与from_date之间的“坑”填上。
 
 首先我们看下title一共有几种不同的值：
 
-<pre>
 
+
+````
 1.  SELECT DISTINCT(title) FROM employees.titles;
 2.  +--------------------+
 3.  | title |
@@ -595,13 +589,14 @@ MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/empl
 10.  |  Technique  Leader  |
 11.  |  Manager  |
 12.  +--------------------+
+````
 
-</pre>
 
 只有7种。在这种成为“坑”的列值比较少的情况下，可以考虑用“IN”来填补这个“坑”从而形成最左前缀：
 
-<pre>
 
+
+````
 1.  EXPLAIN SELECT * FROM employees.titles
 2.  WHERE emp_no='10001'
 3.  AND title IN ('Senior Engineer',  'Staff',  'Engineer',  'Senior Staff',  'Assistant Engineer',  'Technique Leader',  'Manager')
@@ -611,13 +606,14 @@ MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/empl
 7.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
 8.  |  1  | SIMPLE | titles | range | PRIMARY | PRIMARY |  59  | NULL |  7  |  Using  where  |
 9.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
+````
 
-</pre>
 
 这次key_len为59，说明索引被用全了，但是从type和rows看出IN实际上执行了一个range查询，这里检查了7个key。看下两种查询的性能比较：
 
-<pre>
 
+
+````
 1.  SHOW PROFILES;
 2.  +----------+------------+-------------------------------------------------------------------------------+
 3.  |  Query_ID  |  Duration  |  Query  |
@@ -625,58 +621,62 @@ MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/empl
 5.  |  10  |  0.00058000  | SELECT * FROM employees.titles WHERE emp_no='10001' AND from_date='1986-06-26'|
 6.  |  11  |  0.00052500  | SELECT * FROM employees.titles WHERE emp_no='10001' AND title IN ...  |
 7.  +----------+------------+-------------------------------------------------------------------------------+
+````
 
-</pre>
 
 “填坑”后性能提升了一点。如果经过emp_no筛选后余下很多数据，则后者性能优势会更加明显。当然，如果title的值很多，用填坑就不合适了，必须建立辅助索引。
 
 ### 情况四：查询条件没有指定索引第一列。
 
-<pre>
 
+
+````
 1.  EXPLAIN SELECT * FROM employees.titles WHERE from_date='1986-06-26';
 2.  +----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
 3.  | id | select_type | table | type | possible_keys | key | key_len |  ref  | rows |  Extra  |
 4.  +----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
 5.  |  1  | SIMPLE | titles | ALL | NULL | NULL | NULL | NULL |  443308  |  Using  where  |
 6.  +----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
+````
 
-</pre>
 
 由于不是最左前缀，索引这样的查询显然用不到索引。
 
 ### 情况五：匹配某列的前缀字符串。
 
-<pre>
 
+
+````
 1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no='10001' AND title LIKE 'Senior%';
 2.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
 3.  | id | select_type | table | type | possible_keys | key | key_len |  ref  | rows |  Extra  |
 4.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
 5.  |  1  | SIMPLE | titles | range | PRIMARY | PRIMARY |  56  | NULL |  1  |  Using  where  |
 6.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
+````
 
-</pre>
 
 此时可以用到索引，~~但是如果通配符不是只出现在末尾，则无法使用索引。~~（原文表述有误，如果通配符%不出现在开头，则可以用到索引，但根据具体情况不同可能只会用其中一个前缀）
 
 ### 情况六：范围查询。
 
-<pre>
 
+
+````
 1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no <  '10010'  and title='Senior Engineer';
 2.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
 3.  | id | select_type | table | type | possible_keys | key | key_len |  ref  | rows |  Extra  |
 4.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
 5.  |  1  | SIMPLE | titles | range | PRIMARY | PRIMARY |  4  | NULL |  16  |  Using  where  |
 6.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
+````
 
-</pre>
 
 范围列可以用到索引（必须是最左前缀），但是范围列后面的列无法用到索引。同时，索引最多用于一个范围列，因此如果查询条件中有两个范围列则无法全用到索引。
 
-<pre>
 
+
+````
 1.  EXPLAIN SELECT * FROM employees.titles
 2.  WHERE emp_no <  '10010'
 3.  AND title='Senior Engineer'
@@ -686,12 +686,13 @@ MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/empl
 7.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
 8.  |  1  | SIMPLE | titles | range | PRIMARY | PRIMARY |  4  | NULL |  16  |  Using  where  |
 9.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
+````
 
-</pre>
 
 可以看到索引对第二个范围索引无能为力。这里特别要说明MySQL一个有意思的地方，那就是仅用explain可能无法区分范围索引和多值匹配，因为在type中这两者都显示为range。同时，用了“between”并不意味着就是范围查询，例如下面的查询：
 
-<pre>
+
+````
 
 1.  EXPLAIN SELECT * FROM employees.titles
 2.  WHERE emp_no BETWEEN '10001' AND '10010'
@@ -703,7 +704,7 @@ MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/empl
 8.  |  1  | SIMPLE | titles | range | PRIMARY | PRIMARY |  59  | NULL |  16  |  Using  where  |
 9.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
 
-</pre>
+````
 
 看起来是用了两个范围查询，但作用于emp_no上的“BETWEEN”实际上相当于“IN”，也就是说emp_no实际是多值精确匹配。可以看到这个查询用到了索引全部三个列。因此在MySQL中要谨慎地区分多值匹配和范围匹配，否则会对MySQL的行为产生困惑。
 
@@ -711,7 +712,8 @@ MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/empl
 
 很不幸，如果查询条件中含有函数或表达式，则MySQL不会为这列使用索引（虽然某些在数学意义上可以使用）。例如：
 
-<pre>
+
+````
 
 1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no='10001' AND left(title,  6)='Senior';
 2.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------------+
@@ -720,20 +722,21 @@ MySQL官方文档中关于此数据库的页面为[http://dev.mysql.com/doc/empl
 5.  |  1  | SIMPLE | titles |  ref  | PRIMARY | PRIMARY |  4  |  const  |  1  |  Using  where  |
 6.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------------+
 
-</pre>
+````
 
 虽然这个查询和情况五中功能相同，但是由于使用了函数left，则无法为title列应用索引，而情况五中用LIKE则可以。再如：
 
-<pre>
 
+
+````
 1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no -  1='10000';
 2.  +----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
 3.  | id | select_type | table | type | possible_keys | key | key_len |  ref  | rows |  Extra  |
 4.  +----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
 5.  |  1  | SIMPLE | titles | ALL | NULL | NULL | NULL | NULL |  443308  |  Using  where  |
 6.  +----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
+````
 
-</pre>
 
 显然这个查询等价于查询emp_no为10001的函数，但是由于查询条件是一个表达式，MySQL无法为其使用索引。看来MySQL还没有智能到自动优化常量表达式的程度，因此在写查询语句时尽量避免表达式出现在查询中，而是先手工私下代数运算，转换为无表达式的查询语句。
 
@@ -749,16 +752,17 @@ Index Selectivity = Cardinality / #T
 
 显然选择性的取值范围为(0, 1]，选择性越高的索引价值越大，这是由B+Tree的性质决定的。例如，上文用到的employees.titles表，如果title字段经常被单独查询，是否需要建索引，我们看一下它的选择性：
 
-<pre>
 
+
+````
 1.  SELECT count(DISTINCT(title))/count(*) AS Selectivity FROM employees.titles;
 2.  +-------------+
 3.  |  Selectivity  |
 4.  +-------------+
 5.  |  0.0000  |
 6.  +-------------+
+````
 
-</pre>
 
 title的选择性不足0.0001（精确值为0.00001579），所以实在没有什么必要为其单独建索引。
 
@@ -766,21 +770,23 @@ title的选择性不足0.0001（精确值为0.00001579），所以实在没有
 
 从图12可以看到employees表只有一个索引<emp_no>，那么如果我们想按名字搜索一个人，就只能全表扫描了：
 
-<pre>
 
+
+````
 1.  EXPLAIN SELECT * FROM employees.employees WHERE first_name='Eric' AND last_name='Anido';
 2.  +----+-------------+-----------+------+---------------+------+---------+------+--------+-------------+
 3.  | id | select_type | table | type | possible_keys | key | key_len |  ref  | rows |  Extra  |
 4.  +----+-------------+-----------+------+---------------+------+---------+------+--------+-------------+
 5.  |  1  | SIMPLE | employees | ALL | NULL | NULL | NULL | NULL |  300024  |  Using  where  |
 6.  +----+-------------+-----------+------+---------------+------+---------+------+--------+-------------+
+````
 
-</pre>
 
 如果频繁按名字搜索员工，这样显然效率很低，因此我们可以考虑建索引。有两种选择，建<first_name>或<first_name, last_name>，看下两个索引的选择性：
 
-<pre>
 
+
+````
 1.  SELECT count(DISTINCT(first_name))/count(*) AS Selectivity FROM employees.employees;
 2.  +-------------+
 3.  |  Selectivity  |
@@ -793,48 +799,52 @@ title的选择性不足0.0001（精确值为0.00001579），所以实在没有
 10.  +-------------+
 11.  |  0.9313  |
 12.  +-------------+
+````
 
-</pre>
 
 <first_name>显然选择性太低，<first_name, last_name>选择性很好，但是first_name和last_name加起来长度为30，有没有兼顾长度和选择性的办法？可以考虑用first_name和last_name的前几个字符建立索引，例如<first_name, left(last_name, 3)>，看看其选择性：
 
-<pre>
 
+
+````
 1.  SELECT count(DISTINCT(concat(first_name, left(last_name,  3))))/count(*) AS Selectivity FROM employees.employees;
 2.  +-------------+
 3.  |  Selectivity  |
 4.  +-------------+
 5.  |  0.7879  |
 6.  +-------------+
+````
 
-</pre>
 
 选择性还不错，但离0.9313还是有点距离，那么把last_name前缀加到4：
 
-<pre>
 
+
+````
 1.  SELECT count(DISTINCT(concat(first_name, left(last_name,  4))))/count(*) AS Selectivity FROM employees.employees;
 2.  +-------------+
 3.  |  Selectivity  |
 4.  +-------------+
 5.  |  0.9007  |
 6.  +-------------+
+````
 
-</pre>
 
 这时选择性已经很理想了，而这个索引的长度只有18，比<first_name, last_name>短了接近一半，我们把这个前缀索引 建上：
 
-<pre>
 
+
+````
 1.  ALTER TABLE employees.employees
 2.  ADD INDEX `first_name_last_name4`  (first_name, last_name(4));
+````
 
-</pre>
 
 此时再执行一遍按名字查询，比较分析一下与建索引前的结果：
 
-<pre>
 
+
+````
 1.  SHOW PROFILES;
 2.  +----------+------------+---------------------------------------------------------------------------------+
 3.  |  Query_ID  |  Duration  |  Query  |
@@ -842,8 +852,8 @@ title的选择性不足0.0001（精确值为0.00001579），所以实在没有
 5.  |  87  |  0.11941700  | SELECT * FROM employees.employees WHERE first_name='Eric' AND last_name='Anido'  |
 6.  |  90  |  0.00092400  | SELECT * FROM employees.employees WHERE first_name='Eric' AND last_name='Anido'  |
 7.  +----------+------------+---------------------------------------------------------------------------------+
+````
 
-</pre>
 
 性能的提升是显著的，查询速度提高了120多倍。
 
@@ -859,7 +869,7 @@ title的选择性不足0.0001（精确值为0.00001579），所以实在没有
 
 如果表使用自增主键，那么每次插入新的记录，记录就会顺序添加到当前索引节点的后续位置，当一页写满，就会自动开辟一个新的页。如下图所示：
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/13.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/13.png)
 
 图13
 
@@ -867,7 +877,7 @@ title的选择性不足0.0001（精确值为0.00001579），所以实在没有
 
 如果使用非自增主键（如果身份证号或学号等），由于每次插入主键的值近似于随机，因此每次新纪录都要被插到现有索引页得中间某个位置：
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/14.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/14.png)
 
 图14
 
@@ -895,4 +905,4 @@ title的选择性不足0.0001（精确值为0.00001579），所以实在没有
 
 [5] Codd, E. F. (1970). "A relational model of data for large shared data banks". Communications of the ACM, , Vol. 13, No. 6, pp. 377-387
 
-[6] MySQL5.1参考手册 - [http://dev.mysql.com/doc/refman/5.1/zh/index.html](http://dev.mysql.com/doc/refman/5.1/zh/index.html "http://dev.mysql.com/doc/refman/5.1/zh/index.html")
+[6] MySQL5.1参考手册 -[http://dev.mysql.com/doc/refman/5.1/zh/index.html](http://dev.mysql.com/doc/refman/5.1/zh/index.html "http://dev.mysql.com/doc/refman/5.1/zh/index.html")
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2232\357\274\232\343\200\216\346\265\205\345\205\245\346\265\205\345\207\272\343\200\217MySQL \345\222\214 InnoDB.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\343\200\216\346\265\205\345\205\245\346\265\205\345\207\272\343\200\217MySQL\345\222\214InnoDB.md"
similarity index 68%
rename from "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2232\357\274\232\343\200\216\346\265\205\345\205\245\346\265\205\345\207\272\343\200\217MySQL \345\222\214 InnoDB.md"
rename to "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\343\200\216\346\265\205\345\205\245\346\265\205\345\207\272\343\200\217MySQL\345\222\214InnoDB.md"
index 40e7408..8e3991b 100644
--- "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2232\357\274\232\343\200\216\346\265\205\345\205\245\346\265\205\345\207\272\343\200\217MySQL \345\222\214 InnoDB.md"	
+++ "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\343\200\216\346\265\205\345\205\245\346\265\205\345\207\272\343\200\217MySQL\345\222\214InnoDB.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [数据库的定义](#数据库的定义)
     * [数据库和实例](#数据库和实例)
     * [MySQL 的架构](#mysql-的架构)
@@ -23,7 +22,7 @@
     * [不可重复读](#不可重复读)
     * [幻读](#幻读)
   * [总结](#总结)
-  * [[Innodb与Myisam引擎的区别与应用场景](https://www.cnblogs.com/changna1314/p/6878900.html)](#[innodb与myisam引擎的区别与应用场景]httpswwwcnblogscomchangna1314p6878900html)
+  * [Innodb与Myisam引擎的区别与应用场景](#[innodb与myisam引擎的区别与应用场景])
 
 
 本文转自互联网
@@ -46,14 +45,9 @@
 
 <!-- more -->
 
-<!-- more -->
-
-
-
 作为一名开发人员，在日常的工作中会难以避免地接触到数据库，无论是基于文件的 sqlite 还是工程上使用非常广泛的 MySQL、PostgreSQL，但是一直以来也没有对数据库有一个非常清晰并且成体系的认知，所以最近两个月的时间看了几本数据库相关的书籍并且阅读了 MySQL 的官方文档，希望对各位了解数据库的、不了解数据库的有所帮助。
 
-![mysql](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/mysql.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405202853.png)
 本文中对于数据库的介绍以及研究都是在 MySQL 上进行的，如果涉及到了其他数据库的内容或者实现会在文中单独指出。
 
 ## 数据库的定义
@@ -63,23 +57,23 @@
 *   数据库：物理操作文件系统或其他形式文件类型的集合；
 *   实例：MySQL 数据库由后台线程以及一个共享内存区组成；
 
-> 对于数据库和实例的定义都来自于 [MySQL 技术内幕：InnoDB 存储引擎](https://book.douban.com/subject/24708143/) 一书，想要了解 InnoDB 存储引擎的读者可以阅读这本书籍。
+> 对于数据库和实例的定义都来自于[MySQL 技术内幕：InnoDB 存储引擎](https://book.douban.com/subject/24708143/)一书，想要了解 InnoDB 存储引擎的读者可以阅读这本书籍。
 
 ### 数据库和实例
 
 在 MySQL 中，实例和数据库往往都是一一对应的，而我们也无法直接操作数据库，而是要通过数据库实例来操作数据库文件，可以理解为数据库实例是数据库为上层提供的一个专门用于操作的接口。
 
-![Database - Instance](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Database%20-%20Instance.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405202622.png)
 
-在 Unix 上，启动一个 MySQL 实例往往会产生两个进程，`mysqld` 就是真正的数据库服务守护进程，而 `mysqld_safe` 是一个用于检查和设置 `mysqld` 启动的控制程序，它负责监控 MySQL 进程的执行，当 `mysqld` 发生错误时，`mysqld_safe` 会对其状态进行检查并在合适的条件下重启。
+在 Unix 上，启动一个 MySQL 实例往往会产生两个进程，`mysqld`就是真正的数据库服务守护进程，而`mysqld_safe`是一个用于检查和设置`mysqld`启动的控制程序，它负责监控 MySQL 进程的执行，当`mysqld`发生错误时，`mysqld_safe`会对其状态进行检查并在合适的条件下重启。
 
 ### MySQL 的架构
 
 MySQL 从第一个版本发布到现在已经有了 20 多年的历史，在这么多年的发展和演变中，整个应用的体系结构变得越来越复杂：
 
-![Logical-View-of-MySQL-Architecture](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Logical-View-of-MySQL-Architecture.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405202911.png)
 
-最上层用于连接、线程处理的部分并不是 MySQL 『发明』的，很多服务都有类似的组成部分；第二层中包含了大多数 MySQL 的核心服务，包括了对 SQL 的解析、分析、优化和缓存等功能，存储过程、触发器和视图都是在这里实现的；而第三层就是 MySQL 中真正负责数据的存储和提取的存储引擎，例如：[InnoDB](https://en.wikipedia.org/wiki/InnoDB)、[MyISAM](https://en.wikipedia.org/wiki/MyISAM) 等，文中对存储引擎的介绍都是对 InnoDB 实现的分析。
+最上层用于连接、线程处理的部分并不是 MySQL 『发明』的，很多服务都有类似的组成部分；第二层中包含了大多数 MySQL 的核心服务，包括了对 SQL 的解析、分析、优化和缓存等功能，存储过程、触发器和视图都是在这里实现的；而第三层就是 MySQL 中真正负责数据的存储和提取的存储引擎，例如：[InnoDB](https://en.wikipedia.org/wiki/InnoDB)、[MyISAM](https://en.wikipedia.org/wiki/MyISAM)等，文中对存储引擎的介绍都是对 InnoDB 实现的分析。
 
 ## 数据的存储
 
@@ -87,39 +81,37 @@ MySQL 从第一个版本发布到现在已经有了 20 多年的历史，在这
 
 在 InnoDB 存储引擎中，所有的数据都被**逻辑地**存放在表空间中，表空间（tablespace）是存储引擎中最高的存储逻辑单位，在表空间的下面又包括段（segment）、区（extent）、页（page）：
 
-![Tablespace-segment-extent-page-row](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Tablespace-segment-extent-page-row.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405202927.png)
 
-同一个数据库实例的所有表空间都有相同的页大小；默认情况下，表空间中的页大小都为 16KB，当然也可以通过改变 `innodb_page_size` 选项对默认大小进行修改，需要注意的是不同的页大小最终也会导致区大小的不同：
+同一个数据库实例的所有表空间都有相同的页大小；默认情况下，表空间中的页大小都为 16KB，当然也可以通过改变`innodb_page_size`选项对默认大小进行修改，需要注意的是不同的页大小最终也会导致区大小的不同：
 
-![Relation Between Page Size - Extent Size](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Relation%20Between%20Page%20Size%20-%20Extent%20Size.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405202938.png)
 
 从图中可以看出，在 InnoDB 存储引擎中，一个区的大小最小为 1MB，页的数量最少为 64 个。
 
 ### 如何存储表
 
-MySQL 使用 InnoDB 存储表时，会将**表的定义**和**数据索引**等信息分开存储，其中前者存储在 `.frm` 文件中，后者存储在 `.ibd` 文件中，这一节就会对这两种不同的文件分别进行介绍。
-
-![frm-and-ibd-file](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/frm-and-ibd-file.jpg)
+MySQL 使用 InnoDB 存储表时，会将**表的定义**和**数据索引**等信息分开存储，其中前者存储在`.frm`文件中，后者存储在`.ibd`文件中，这一节就会对这两种不同的文件分别进行介绍。
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203010.png)
 .frm 文件
 
-无论在 MySQL 中选择了哪个存储引擎，所有的 MySQL 表都会在硬盘上创建一个 `.frm` 文件用来描述表的格式或者说定义；`.frm` 文件的格式在不同的平台上都是相同的。
+无论在 MySQL 中选择了哪个存储引擎，所有的 MySQL 表都会在硬盘上创建一个`.frm`文件用来描述表的格式或者说定义；`.frm`文件的格式在不同的平台上都是相同的。
 
 ```
  CREATE TABLE test_frm(    column1 CHAR(5),    column2 INTEGER);
 ```
 
-当我们使用上面的代码创建表时，会在磁盘上的 `datadir` 文件夹中生成一个 `test_frm.frm` 的文件，这个文件中就包含了表结构相关的信息：
-
-![frm-file-hex](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/frm-file-hex.png)
+当我们使用上面的代码创建表时，会在磁盘上的`datadir`文件夹中生成一个`test_frm.frm`的文件，这个文件中就包含了表结构相关的信息：
 
-> MySQL 官方文档中的 [11.1 MySQL .frm File Format](https://dev.mysql.com/doc/internals/en/frm-file-format.html) 一文对于 `.frm`文件格式中的二进制的内容有着非常详细的表述，在这里就不展开介绍了。
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203026.png)
+> MySQL 官方文档中的[11.1 MySQL .frm File Format](https://dev.mysql.com/doc/internals/en/frm-file-format.html)一文对于`.frm`文件格式中的二进制的内容有着非常详细的表述，在这里就不展开介绍了。
 
 .ibd 文件
 
-InnoDB 中用于存储数据的文件总共有两个部分，一是系统表空间文件，包括 `ibdata1`、`ibdata2` 等文件，其中存储了 InnoDB 系统信息和用户数据库表数据和索引，是所有表公用的。
+InnoDB 中用于存储数据的文件总共有两个部分，一是系统表空间文件，包括`ibdata1`、`ibdata2`等文件，其中存储了 InnoDB 系统信息和用户数据库表数据和索引，是所有表公用的。
 
-当打开 `innodb_file_per_table` 选项时，`.ibd` 文件就是每一个表独有的表空间，文件存储了当前表的数据和相关的索引数据。
+当打开`innodb_file_per_table`选项时，`.ibd`文件就是每一个表独有的表空间，文件存储了当前表的数据和相关的索引数据。
 
 ### 如何存储记录
 
@@ -127,13 +119,12 @@ InnoDB 中用于存储数据的文件总共有两个部分，一是系统表空
 
 当 InnoDB 存储数据时，它可以使用不同的行格式进行存储；MySQL 5.7 版本支持以下格式的行存储方式：
 
-![Antelope-Barracuda-Row-Format](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Antelope-Barracuda-Row-Format.jpg)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203135.png)
 > Antelope 是 InnoDB 最开始支持的文件格式，它包含两种行格式 Compact 和 Redundant，它最开始并没有名字；Antelope 的名字是在新的文件格式 Barracuda 出现后才起的，Barracuda 的出现引入了两种新的行格式 Compressed 和 Dynamic；InnoDB 对于文件格式都会向前兼容，而官方文档中也对之后会出现的新文件格式预先定义好了名字：Cheetah、Dragon、Elk 等等。
 
 两种行记录格式 Compact 和 Redundant 在磁盘上按照以下方式存储：
 
-![COMPACT-And-REDUNDANT-Row-Format](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/COMPACT-And-REDUNDANT-Row-Format.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203147.png)
 
 Compact 和 Redundant 格式最大的不同就是记录格式的第一个部分；在 Compact 中，行记录的第一部分倒序存放了一行数据中列的长度（Length），而 Redundant 中存的是每一列的偏移量（Offset），从总体上上看，Compact 行记录格式相比 Redundant 格式能够减少 20% 的存储空间。
 
@@ -141,31 +132,29 @@ Compact 和 Redundant 格式最大的不同就是记录格式的第一个部分
 
 当 InnoDB 使用 Compact 或者 Redundant 格式存储极长的 VARCHAR 或者 BLOB 这类大对象时，我们并不会直接将所有的内容都存放在数据页节点中，而是将行数据中的前 768 个字节存储在数据页中，后面会通过偏移量指向溢出页。
 
-![Row-Overflo](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Row-Overflow.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203203.png)
 
 但是当我们使用新的行记录格式 Compressed 或者 Dynamic 时都只会在行记录中保存 20 个字节的指针，实际的数据都会存放在溢出页面中。
 
-![Row-Overflow-in-Barracuda](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Row-Overflow-in-Barracuda.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203320.png)
 
 当然在实际存储中，可能会对不同长度的 TEXT 和 BLOB 列进行优化，不过这就不是本文关注的重点了。
 
-> 想要了解更多与 InnoDB 存储引擎中记录的数据格式的相关信息，可以阅读 [InnoDB Record Structure](https://dev.mysql.com/doc/internals/en/innodb-record-structure.html)
+> 想要了解更多与 InnoDB 存储引擎中记录的数据格式的相关信息，可以阅读[InnoDB Record Structure](https://dev.mysql.com/doc/internals/en/innodb-record-structure.html)
 
 ### 数据页结构
 
 页是 InnoDB 存储引擎管理数据的最小磁盘单位，而 B-Tree 节点就是实际存放表中数据的页面，我们在这里将要介绍页是如何组织和存储记录的；首先，一个 InnoDB 页有以下七个部分：
 
-![InnoDB-B-Tree-Node](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/InnoDB-B-Tree-Node.jpg)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203334.png)
 每一个页中包含了两对 header/trailer：内部的 Page Header/Page Directory 关心的是页的状态信息，而 Fil Header/Fil Trailer 关心的是记录页的头信息。
 
 在页的头部和尾部之间就是用户记录和空闲空间了，每一个数据页中都包含 Infimum 和 Supremum 这两个**虚拟**的记录（可以理解为占位符），Infimum 记录是比该页中任何主键值都要小的值，Supremum 是该页中的最大值：
 
-![Infimum-Rows-Supremum](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Infimum-Rows-Supremum.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203346.png)
+User Records 就是整个页面中真正用于存放行记录的部分，而 Free Space 就是空余空间了，它是一个链表的数据结构，为了保证插入和删除的效率，整个页面并不会按照主键顺序对所有记录进行排序，它会自动从左侧向右寻找空白节点进行插入，行记录在物理存储上并不是按照顺序的，它们之间的顺序是由`next_record`这一指针控制的。
 
-User Records 就是整个页面中真正用于存放行记录的部分，而 Free Space 就是空余空间了，它是一个链表的数据结构，为了保证插入和删除的效率，整个页面并不会按照主键顺序对所有记录进行排序，它会自动从左侧向右寻找空白节点进行插入，行记录在物理存储上并不是按照顺序的，它们之间的顺序是由 `next_record` 这一指针控制的。
-
-B+ 树在查找对应的记录时，并不会直接从树中找出对应的行记录，它只能获取记录所在的页，将整个页加载到内存中，再通过 Page Directory 中存储的稀疏索引和 `n_owned`、`next_record` 属性取出对应的记录，不过因为这一操作是在内存中进行的，所以通常会忽略这部分查找的耗时。
+B+ 树在查找对应的记录时，并不会直接从树中找出对应的行记录，它只能获取记录所在的页，将整个页加载到内存中，再通过 Page Directory 中存储的稀疏索引和`n_owned`、`next_record`属性取出对应的记录，不过因为这一操作是在内存中进行的，所以通常会忽略这部分查找的耗时。
 
 InnoDB 存储引擎中对数据的存储是一个非常复杂的话题，这一节中也只是对表、行记录以及页面的存储进行一定的分析和介绍，虽然作者相信这部分知识对于大部分开发者已经足够了，但是想要真正消化这部分内容还需要很多的努力和实践。
 
@@ -177,7 +166,7 @@ InnoDB 存储引擎中对数据的存储是一个非常复杂的话题，这一
 
 在上一节中，我们谈了行记录的存储和页的存储，在这里我们就要从更高的层面看 InnoDB 中对于数据是如何存储的；InnoDB 存储引擎在绝大多数情况下使用 B+ 树建立索引，这是关系型数据库中查找最为常用和有效的索引，但是 B+ 树索引并不能找到一个给定键对应的具体值，它只能找到数据行对应的页，然后正如上一节所提到的，数据库把整个页读入到内存中，并在内存中查找具体的数据行。
 
-![B+Tree](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/B+Tree.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203520.png)
 
 B+ 树是平衡树，它查找任意节点所耗费的时间都是完全相同的，比较的次数就是 B+ 树的高度；在这里，我们并不会深入分析或者动手实现一个 B+ 树，只是对它的特性进行简单的介绍。
 
@@ -193,9 +182,9 @@ InnoDB 存储引擎中的表都是使用索引组织的，也就是按照键的
  CREATE TABLE users(    id INT NOT NULL,    first_name VARCHAR(20) NOT NULL,    last_name VARCHAR(20) NOT NULL,    age INT NOT NULL,    PRIMARY KEY(id),    KEY(last_name, first_name, age)    KEY(first_name));
 ```
 
-如果使用上面的 SQL 在数据库中创建一张表，B+ 树就会使用 `id` 作为索引的键，并在叶子节点中存储一条记录中的**所有**信息。
+如果使用上面的 SQL 在数据库中创建一张表，B+ 树就会使用`id`作为索引的键，并在叶子节点中存储一条记录中的**所有**信息。
 
-![Clustered-Index](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Clustered-Index.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203541.png)
 
 > 图中对 B+ 树的描述与真实情况下 B+ 树中的数据结构有一些差别，不过这里想要表达的主要意思是：聚集索引叶节点中保存的是整条行记录，而不是其中的一部分。
 
@@ -211,17 +200,17 @@ InnoDB 存储引擎中的表都是使用索引组织的，也就是按照键的
 
 > 一张表一定包含一个聚集索引构成的 B+ 树以及若干辅助索引的构成的 B+ 树。
 
-![Secondary-Index](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Secondary-Index.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203552.png)
 
-如果在表 `users` 中存在一个辅助索引 `(first_name, age)`，那么它构成的 B+ 树大致就是上图这样，按照 `(first_name, age)` 的字母顺序对表中的数据进行排序，当查找到主键时，再通过聚集索引获取到整条行记录。
+如果在表`users`中存在一个辅助索引`(first_name, age)`，那么它构成的 B+ 树大致就是上图这样，按照`(first_name, age)`的字母顺序对表中的数据进行排序，当查找到主键时，再通过聚集索引获取到整条行记录。
 
-![Clustered-Secondary-Index](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Clustered-Secondary-Index.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203606.png)
 
 上图展示了一个使用辅助索引查找一条表记录的过程：通过辅助索引查找到对应的主键，最后在聚集索引中使用主键获取对应的行记录，这也是通常情况下行记录的查找方式。
 
 ### 索引的设计
 
-索引的设计其实是一个非常重要的内容，同时也是一个非常复杂的内容；索引的设计与创建对于提升数据库的查询性能至关重要，不过这不是本文想要介绍的内容，有关索引的设计与优化可以阅读 [数据库索引设计与优化](https://draveness.me/%E6%95%B0%E6%8D%AE%E5%BA%93%E7%B4%A2%E5%BC%95%E8%AE%BE%E8%AE%A1%E4%B8%8E%E4%BC%98%E5%8C%96) 一书，书中提供了一种非常科学合理的方法能够帮助我们在数据库中建立最适合的索引，当然作者也可能会在之后的文章中对索引的设计进行简单的介绍和分析。
+索引的设计其实是一个非常重要的内容，同时也是一个非常复杂的内容；索引的设计与创建对于提升数据库的查询性能至关重要，不过这不是本文想要介绍的内容，有关索引的设计与优化可以阅读[数据库索引设计与优化](https://draveness.me/%E6%95%B0%E6%8D%AE%E5%BA%93%E7%B4%A2%E5%BC%95%E8%AE%BE%E8%AE%A1%E4%B8%8E%E4%BC%98%E5%8C%96)一书，书中提供了一种非常科学合理的方法能够帮助我们在数据库中建立最适合的索引，当然作者也可能会在之后的文章中对索引的设计进行简单的介绍和分析。
 
 ## 锁
 
@@ -236,7 +225,7 @@ InnoDB 存储引擎中的表都是使用索引组织的，也就是按照键的
 
 虽然乐观锁和悲观锁在本质上并不是同一种东西，一个是一种思想，另一个是一种真正的锁，但是它们都是一种并发控制机制。
 
-![Optimistic-Pessimistic-Locks](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Optimistic-Pessimistic-Locks.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203616.png)
 
 乐观锁不会存在死锁的问题，但是由于更新后验证，所以当**冲突频率**和**重试成本**较高时更推荐使用悲观锁，而需要非常高的**响应速度**并且**并发量**非常大的时候使用乐观锁就能较好的解决问题，在这时使用悲观锁就可能出现严重的性能问题；在选择并发控制机制时，需要综合考虑上面的四个方面（冲突频率、重试成本、响应速度和并发量）进行选择。
 
@@ -249,7 +238,7 @@ InnoDB 存储引擎中的表都是使用索引组织的，也就是按照键的
 
 而它们的名字也暗示着各自的另外一个特性，共享锁之间是兼容的，而互斥锁与其他任意锁都不兼容：
 
-![Shared-Exclusive-Lock](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Shared-Exclusive-Lock.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203627.png)
 
 稍微对它们的使用进行思考就能想明白它们为什么要这么设计，因为共享锁代表了读操作、互斥锁代表了写操作，所以我们可以在数据库中**并行读**，但是只能**串行写**，只有这样才能保证不会发生线程竞争，实现线程安全。
 
@@ -264,7 +253,7 @@ InnoDB 存储引擎中的表都是使用索引组织的，也就是按照键的
 
 随着意向锁的加入，锁类型之间的兼容矩阵也变得愈加复杂：
 
-![Lock-Type-Compatibility-Matrix](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Lock-Type-Compatibility-Matrix.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203640.png)
 
 意向锁其实不会阻塞全表扫描之外的任何请求，它们的主要目的是为了表示**是否有人请求锁定表中的某一行数据**。
 
@@ -276,17 +265,17 @@ InnoDB 存储引擎中的表都是使用索引组织的，也就是按照键的
 
 Record Lock
 
-记录锁（Record Lock）是加到**索引记录**上的锁，假设我们存在下面的一张表 `users`：
+记录锁（Record Lock）是加到**索引记录**上的锁，假设我们存在下面的一张表`users`：
 
 ```
  CREATE TABLE users(    id INT NOT NULL AUTO_INCREMENT,    last_name VARCHAR(255) NOT NULL,    first_name VARCHAR(255),    age INT,    PRIMARY KEY(id),    KEY(last_name),    KEY(age));
 ```
 
-如果我们使用 `id` 或者 `last_name` 作为 SQL 中 `WHERE` 语句的过滤条件，那么 InnoDB 就可以通过索引建立的 B+ 树找到行记录并添加索引，但是如果使用 `first_name` 作为过滤条件时，由于 InnoDB 不知道待修改的记录具体存放的位置，也无法对将要修改哪条记录提前做出判断就会锁定整个表。
+如果我们使用`id`或者`last_name`作为 SQL 中`WHERE`语句的过滤条件，那么 InnoDB 就可以通过索引建立的 B+ 树找到行记录并添加索引，但是如果使用`first_name`作为过滤条件时，由于 InnoDB 不知道待修改的记录具体存放的位置，也无法对将要修改哪条记录提前做出判断就会锁定整个表。
 
 Gap Lock
 
-记录锁是在存储引擎中最为常见的锁，除了记录锁之外，InnoDB 中还存在间隙锁（Gap Lock），间隙锁是对索引记录中的一段连续区域的锁；当使用类似 `SELECT * FROM users WHERE id BETWEEN 10 AND 20 FOR UPDATE;` 的 SQL 语句时，就会阻止其他事务向表中插入 `id = 15` 的记录，因为整个范围都被间隙锁锁定了。
+记录锁是在存储引擎中最为常见的锁，除了记录锁之外，InnoDB 中还存在间隙锁（Gap Lock），间隙锁是对索引记录中的一段连续区域的锁；当使用类似`SELECT * FROM users WHERE id BETWEEN 10 AND 20 FOR UPDATE;`的 SQL 语句时，就会阻止其他事务向表中插入`id = 15`的记录，因为整个范围都被间隙锁锁定了。
 
 > 间隙锁是存储引擎对于性能和并发做出的权衡，并且只用于某些事务隔离级别。
 
@@ -294,7 +283,7 @@ Gap Lock
 
 Next-Key Lock
 
-Next-Key 锁相比前两者就稍微有一些复杂，它是记录锁和记录前的间隙锁的结合，在 `users` 表中有以下记录：
+Next-Key 锁相比前两者就稍微有一些复杂，它是记录锁和记录前的间隙锁的结合，在`users`表中有以下记录：
 
 ```
  +------|-------------|--------------|-------+|   id | last_name   | first_name   |   age ||------|-------------|--------------|-------||    4 | stark       | tony         |    21 ||    1 | tom         | hiddleston   |    30 ||    3 | morgan      | freeman      |    40 ||    5 | jeff        | dean         |    50 ||    2 | donald      | trump        |    80 |+------|-------------|--------------|-------+
@@ -308,7 +297,7 @@ Next-Key 锁相比前两者就稍微有一些复杂，它是记录锁和记录
 
 > 既然叫 Next-Key 锁，锁定的应该是当前值和后面的范围，但是实际上却不是，Next-Key 锁锁定的是当前值和前面的范围。
 
-当我们更新一条记录，比如 `SELECT * FROM users WHERE age = 30 FOR UPDATE;`，InnoDB 不仅会在范围 `(21, 30]` 上加 Next-Key 锁，还会在这条记录后面的范围 `(30, 40]` 加间隙锁，所以插入 `(21, 40]` 范围内的记录都会被锁定。
+当我们更新一条记录，比如`SELECT * FROM users WHERE age = 30 FOR UPDATE;`，InnoDB 不仅会在范围`(21, 30]`上加 Next-Key 锁，还会在这条记录后面的范围`(30, 40]`加间隙锁，所以插入`(21, 40]`范围内的记录都会被锁定。
 
 Next-Key 锁的作用其实是为了解决幻读的问题，我们会在下一节谈事务的时候具体介绍。
 
@@ -316,8 +305,7 @@ Next-Key 锁的作用其实是为了解决幻读的问题，我们会在下一
 
 既然 InnoDB 中实现的锁是悲观的，那么不同事务之间就可能会互相等待对方释放锁造成死锁，最终导致事务发生错误；想要在 MySQL 中制造死锁的问题其实非常容易：
 
-![Deadlocks](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Deadlocks.jpg)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203653.png)
 两个会话都持有一个锁，并且尝试获取对方的锁时就会发生死锁，不过 MySQL 也能在发生死锁时及时发现问题，并保证其中的一个事务能够正常工作，这对我们来说也是一个好消息。
 
 ## 事务与隔离级别
@@ -330,17 +318,16 @@ Next-Key 锁的作用其实是为了解决幻读的问题，我们会在下一
 
 事务的隔离性是数据库处理数据的几大基础之一，而隔离级别其实就是提供给用户用于在性能和可靠性做出选择和权衡的配置项。
 
-ISO 和 ANIS SQL 标准制定了四种事务隔离级别，而 InnoDB 遵循了 SQL:1992 标准中的四种隔离级别：`READ UNCOMMITED`、`READ COMMITED`、`REPEATABLE READ` 和 `SERIALIZABLE`；每个事务的隔离级别其实都比上一级多解决了一个问题：
+ISO 和 ANIS SQL 标准制定了四种事务隔离级别，而 InnoDB 遵循了 SQL:1992 标准中的四种隔离级别：`READ UNCOMMITED`、`READ COMMITED`、`REPEATABLE READ`和`SERIALIZABLE`；每个事务的隔离级别其实都比上一级多解决了一个问题：
 
 *   `RAED UNCOMMITED`：使用查询语句不会加锁，可能会读到未提交的行（Dirty Read）；
 *   `READ COMMITED`：只对记录加记录锁，而不会在记录之间加间隙锁，所以允许新的记录插入到被锁定记录的附近，所以再多次使用查询语句时，可能得到不同的结果（Non-Repeatable Read）；
 *   `REPEATABLE READ`：多次读取同一范围的数据会返回第一次查询的快照，不会返回不同的数据行，但是可能发生幻读（Phantom Read）；
 *   `SERIALIZABLE`：InnoDB 隐式地将全部的查询语句加上共享锁，解决了幻读的问题；
 
-MySQL 中默认的事务隔离级别就是 `REPEATABLE READ`，但是它通过 Next-Key 锁也能够在某种程度上解决幻读的问题。
-
-![Transaction-Isolation-Matrix](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Transaction-Isolation-Matrix.jpg)
+MySQL 中默认的事务隔离级别就是`REPEATABLE READ`，但是它通过 Next-Key 锁也能够在某种程度上解决幻读的问题。
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203715.png)
 接下来，我们将数据库中创建如下的表并通过个例子来展示在不同的事务隔离级别之下，会发生什么样的问题：
 
 ```
@@ -351,45 +338,42 @@ MySQL 中默认的事务隔离级别就是 `REPEATABLE READ`，但是它通过
 
 > 在一个事务中，读取了其他事务未提交的数据。
 
-当事务的隔离级别为 `READ UNCOMMITED` 时，我们在 `SESSION 2` 中插入的**未提交**数据在 `SESSION 1` 中是可以访问的。
-
-![Read-Uncommited-Dirty-Read](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Read-Uncommited-Dirty-Read.jpg)
+当事务的隔离级别为`READ UNCOMMITED`时，我们在`SESSION 2`中插入的**未提交**数据在`SESSION 1`中是可以访问的。
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203738.png)
 ### 不可重复读
 
 > 在一个事务中，同一行记录被访问了两次却得到了不同的结果。
 
-当事务的隔离级别为 `READ COMMITED` 时，虽然解决了脏读的问题，但是如果在 `SESSION 1` 先查询了**一行**数据，在这之后 `SESSION 2` 中修改了同一行数据并且提交了修改，在这时，如果 `SESSION 1` 中再次使用相同的查询语句，就会发现两次查询的结果不一样。
+当事务的隔离级别为`READ COMMITED`时，虽然解决了脏读的问题，但是如果在`SESSION 1`先查询了**一行**数据，在这之后`SESSION 2`中修改了同一行数据并且提交了修改，在这时，如果`SESSION 1`中再次使用相同的查询语句，就会发现两次查询的结果不一样。
 
-![Read-Commited-Non-Repeatable-Read](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Read-Commited-Non-Repeatable-Read.jpg)
-
-不可重复读的原因就是，在 `READ COMMITED` 的隔离级别下，存储引擎不会在查询记录时添加行锁，锁定 `id = 3` 这条记录。
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203753.png)
+不可重复读的原因就是，在`READ COMMITED`的隔离级别下，存储引擎不会在查询记录时添加行锁，锁定`id = 3`这条记录。
 
 ### 幻读
 
 > 在一个事务中，同一个范围内的记录被读取时，其他事务向这个范围添加了新的记录。
 
-重新开启了两个会话 `SESSION 1` 和 `SESSION 2`，在 `SESSION 1` 中我们查询全表的信息，没有得到任何记录；在 `SESSION 2` 中向表中插入一条数据并提交；由于 `REPEATABLE READ` 的原因，再次查询全表的数据时，我们获得到的仍然是空集，但是在向表中插入同样的数据却出现了错误。
-
-![Repeatable-Read-Phantom-Read](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Repeatable-Read-Phantom-Read.jpg)
+重新开启了两个会话`SESSION 1`和`SESSION 2`，在`SESSION 1`中我们查询全表的信息，没有得到任何记录；在`SESSION 2`中向表中插入一条数据并提交；由于`REPEATABLE READ`的原因，再次查询全表的数据时，我们获得到的仍然是空集，但是在向表中插入同样的数据却出现了错误。
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203803.png)
 这种现象在数据库中就被称作幻读，虽然我们使用查询语句得到了一个空的集合，但是插入数据时却得到了错误，好像之前的查询是幻觉一样。
 
-在标准的事务隔离级别中，幻读是由更高的隔离级别 `SERIALIZABLE` 解决的，但是它也可以通过 MySQL 提供的 Next-Key 锁解决：
+在标准的事务隔离级别中，幻读是由更高的隔离级别`SERIALIZABLE`解决的，但是它也可以通过 MySQL 提供的 Next-Key 锁解决：
 
-![Repeatable-with-Next-Key-Lock](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Repeatable-with-Next-Key-Lock.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405203813.png)
 
-`REPERATABLE READ` 和 `READ UNCOMMITED` 其实是矛盾的，如果保证了前者就看不到已经提交的事务，如果保证了后者，就会导致两次查询的结果不同，MySQL 为我们提供了一种折中的方式，能够在 `REPERATABLE READ` 模式下加锁访问已经提交的数据，其本身并不能解决幻读的问题，而是通过文章前面提到的 Next-Key 锁来解决。
+`REPERATABLE READ`和`READ UNCOMMITED`其实是矛盾的，如果保证了前者就看不到已经提交的事务，如果保证了后者，就会导致两次查询的结果不同，MySQL 为我们提供了一种折中的方式，能够在`REPERATABLE READ`模式下加锁访问已经提交的数据，其本身并不能解决幻读的问题，而是通过文章前面提到的 Next-Key 锁来解决。
 
 ## 总结
 
-> 文章中的内容大都来自于 [高性能 MySQL](https://book.douban.com/subject/23008813/)、[MySQL 技术内幕：InnoDB 存储引擎](https://book.douban.com/subject/24708143/)、[数据库索引设计与优化](https://book.douban.com/subject/26419771/) 以及 MySQL 的 [官方文档](https://dev.mysql.com/doc/)。
+> 文章中的内容大都来自于[高性能 MySQL](https://book.douban.com/subject/23008813/)、[MySQL 技术内幕：InnoDB 存储引擎](https://book.douban.com/subject/24708143/)、[数据库索引设计与优化](https://book.douban.com/subject/26419771/)以及 MySQL 的[官方文档](https://dev.mysql.com/doc/)。
 
 由于篇幅所限仅能对数据库中一些重要内容进行简单的介绍和总结，文中内容难免有所疏漏，如果对文章内容的有疑问，可以在博客下面评论留言。
 
-## [Innodb与Myisam引擎的区别与应用场景](https://www.cnblogs.com/changna1314/p/6878900.html)
+## Innodb与Myisam引擎的区别与应用场景
 
-1\. 区别：
+1. 区别：
 
 （1）事务处理：
 
@@ -407,24 +391,24 @@ InnoDB：如果你的数据执行大量的INSERT或UPDATE，出于性能方面
 
 （4）查询表的行数不同：
 
-MyISAM：select count(*) from table,MyISAM只要简单的读出保存好的行数，注意的是，当count(*)语句包含   where条件时，两种表的操作是一样的
+MyISAM：select count(*) from table,MyISAM只要简单的读出保存好的行数，注意的是，当count(*)语句包含 where条件时，两种表的操作是一样的
 
-InnoDB ： InnoDB 中不保存表的具体行数，也就是说，执行select count(*) from table时，InnoDB要扫描一遍整个表来计算有多少行
+InnoDB：InnoDB 中不保存表的具体行数，也就是说，执行select count(*) from table时，InnoDB要扫描一遍整个表来计算有多少行
 
 （5）外键支持：
 
 mysiam表不支持外键，而InnoDB支持
 
-2. 为什么MyISAM会比Innodb 的查询速度快。
+2. 为什么MyISAM会比Innodb 的查询速度快。
 
 INNODB在做SELECT的时候，要维护的东西比MYISAM引擎多很多；
-1）数据块，INNODB要缓存，MYISAM只缓存索引块，  这中间还有换进换出的减少； 
+1）数据块，INNODB要缓存，MYISAM只缓存索引块，这中间还有换进换出的减少；
 2）innodb寻址要映射到块，再到行，MYISAM 记录的直接是文件的OFFSET，定位比INNODB要快
 3）INNODB还需要维护MVCC一致；虽然你的场景没有，但他还是需要去检查和维护
 
-MVCC ( Multi-Version Concurrency Control )多版本并发控制 
+MVCC ( Multi-Version Concurrency Control )多版本并发控制
 
-3\. 应用场景
+3. 应用场景
 
 MyISAM适合：(1)做很多count 的计算；(2)插入不频繁，查询非常频繁；(3)没有事务。
 
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\22312\357\274\232\344\273\216\345\256\236\350\267\265sql\350\257\255\345\217\245\344\274\230\345\214\226\345\274\200\345\247\213.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\344\273\216\345\256\236\350\267\265sql\350\257\255\345\217\245\344\274\230\345\214\226\345\274\200\345\247\213.md"
similarity index 78%
rename from "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\22312\357\274\232\344\273\216\345\256\236\350\267\265sql\350\257\255\345\217\245\344\274\230\345\214\226\345\274\200\345\247\213.md"
rename to "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\344\273\216\345\256\236\350\267\265sql\350\257\255\345\217\245\344\274\230\345\214\226\345\274\200\345\247\213.md"
index fb8bce6..f3bd6d8 100644
--- "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\22312\357\274\232\344\273\216\345\256\236\350\267\265sql\350\257\255\345\217\245\344\274\230\345\214\226\345\274\200\345\247\213.md"
+++ "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\344\273\216\345\256\236\350\267\265sql\350\257\255\345\217\245\344\274\230\345\214\226\345\274\200\345\247\213.md"
@@ -1,26 +1,28 @@
-# Table of Contents
+# 目录
 
-  * [字段](#字段)
-  * [索引](#索引)
-  * [查询SQL](#查询sql)
-  * [引擎](#引擎)
-    * [MyISAM](#myisam)
-    * [InnoDB](#innodb)
-    * [0、自己写的海量数据sql优化实践](#0、自己写的海量数据sql优化实践)
-  * [mysql百万级分页优化](#mysql百万级分页优化)
-    * [　　普通分页](#　　普通分页)
-    * [　　 优化分页](#　　-优化分页)
-  * [　　总结](#　　总结)
+* [字段](#字段)
+* [索引](#索引)
+* [查询SQL](#查询sql)
+* [引擎](#引擎)
+  * [MyISAM](#myisam)
+  * [InnoDB](#innodb)
+  * [0、自己写的海量数据sql优化实践](#0、自己写的海量数据sql优化实践)
+* [mysql百万级分页优化](#mysql百万级分页优化)
+  * [普通分页](#普通分页)
+  * [优化分页](#优化分页)
+* [总结](#总结)
 
 
 本文转自互联网
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本也将整理到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -33,8 +35,6 @@
 
 <!-- more -->
 
-<!-- more -->
-
 
 除非单表数据未来会一直不断上涨，否则不要一开始就考虑拆分，拆分会带来逻辑、部署、运维的各种复杂度，一般以整型值为主的表在`千万级`以下，字符串为主的表在`五百万`以下是没有太大问题的。而事实上很多时候MySQL单表的性能依然有不少优化空间，甚至能正常支撑千万级以上的数据量：
 
@@ -240,55 +240,69 @@ SELECT * FROM vote_record；
 
 SET timestamp=1529034398; select * from vote_record;
 
- Time: 2018-06-15T03:52:58.804850Z
+Time: 2018-06-15T03:52:58.804850Z
 
- User[@Host](https://my.oschina.net/u/116016): root[root] @ localhost [::1]  Id:    74
+User[@Host](https://my.oschina.net/u/116016): root[root] @ localhost [::1] Id:  74
 
- Query_time: 3.166424  Lock_time: 0.000000 Rows_sent: 900500  Rows_examined: 999999
+Query_time: 3.166424 Lock_time: 0.000000 Rows_sent: 900500 Rows_examined: 999999
 
 耗时3秒，我设置的门槛是一秒。所以记录了下来。
 
 **explain执行计划**
 
+````
 id select_type table partitions type possible_keys key key_len ref rows filtered Extra
 
 1 SIMPLE vote_record \N ALL \N \N \N \N 996507 100.00 \N
+````
 
 全表扫描耗时3秒多，用不到索引。
 
+````
 **2 select * from vote_record where vote_num > 1000**
+````
 
 没有索引，所以相当于全表扫描，一样是3.5秒左右
 
+````
 **3 select * from vote_record where vote_num > 1000**
+````
 
-**加索引create **
+**加索引create**
 
+````
 **CREATE INDEX vote ON vote_record(vote_num);**
+````
 
 **explain查看执行计划**
 
+````
 id select_type table partitions type possible_keys key key_len ref rows filtered Extra
 
 1 SIMPLE vote_record \N ALL votenum,vote \N \N \N 996507 50.00 Using where
+````
 
 还是没用到索引，因为不符合最左前缀匹配。查询需要3.5秒左右
 
 最后修改一下sql语句
 
+````
 EXPLAIN SELECT * FROM vote_record WHERE id > 0 AND vote_num > 1000;
 
 id select_type table partitions type possible_keys key key_len ref rows filtered Extra
 
 1 SIMPLE vote_record \N range PRIMARY,votenum,vote PRIMARY 4 \N 498253 50.00 Using where
+````
 
 用到了索引，但是只用到了主键索引。再修改一次
 
+````
 EXPLAIN SELECT * FROM vote_record WHERE id > 0 AND vote_num = 1000;
 
 id select_type table partitions type possible_keys key key_len ref rows filtered Extra
 
 1 SIMPLE vote_record \N index_merge PRIMARY,votenum,vote votenum,PRIMARY 8,4 \N 51 100.00 Using intersect(votenum,PRIMARY); Using where
+````
 
 用到了两个索引，votenum,PRIMARY。
 
@@ -296,11 +310,13 @@ id select_type table partitions type possible_keys key key_len ref rows filtered
 
 再看一个语句
 
+````
 EXPLAIN SELECT * FROM vote_record WHERE id = 1000 AND vote_num > 1000
 
 id select_type table partitions type possible_keys key key_len ref rows filtered Extra
 
 1 SIMPLE vote_record \N const PRIMARY,votenum PRIMARY 4 const 1 100.00 \N
+````
 
 也只有主键用到了索引。这是因为只有最左前缀索引可以用>或<，其他索引用<或者>会导致用不到索引。
 
@@ -312,37 +328,37 @@ id select_type table partitions type possible_keys key key_len ref rows filtered
 
 步骤1：设置慢查询日志的超时时间，先查看日志存放路径查询慢日志的地址，因为有慢查询的内容，就会到这个日志中：
 
-<pre>show global variables like "%slow%";</pre>
+show global variables like "%slow%";
 
-![](https://oscimg.oschina.net/oscnet/318ac710c3fcf1b293f4a280bbb4642a951.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/318ac710c3fcf1b293f4a280bbb4642a951.jpg)
 
 2.开启慢查询日志
 
-<pre>set global slow_query_log=on;</pre>
+set global slow_query_log=on;
 
 3.查看慢查询日志的设置时间，是否是自己需要的
 
-<pre>show global variables like "%long%";</pre>
+show global variables like "%long%";
 
-![](https://oscimg.oschina.net/oscnet/25c18a8fbb6cc43a48b554bde844191d75d.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/25c18a8fbb6cc43a48b554bde844191d75d.jpg)
 
 4.如果不是自己想的时间，修改慢查询时间，只要超过了以下的设置时间，查询的日志就会到刚刚的日志中，我设置查询时间超过1S就进入到慢查询日志中
 
-<pre>set global long_query_time=1;</pre>
+set global long_query_time=1;
 
 5.大数据已准备，进行数据的查询，xshell最好开两个窗口，一个查看日志，一个执行内容
 
-<pre>Sql查询语句：select sql_no_cache * from employees_tmp where first_name='Duangkaew' and gender='M'</pre>
+Sql查询语句：select sql_no_cache * from employees_tmp where first_name='Duangkaew' and gender='M'
 
-![](https://oscimg.oschina.net/oscnet/19fa580673fef04c767680a8010c444b786.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/19fa580673fef04c767680a8010c444b786.jpg)
 
 发现查数据的总时间去掉了17.74S
 
 查看日志：打开日志
 
-![](https://oscimg.oschina.net/oscnet/a55efa460d5393061ddb62d6d225d62532a.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/a55efa460d5393061ddb62d6d225d62532a.jpg)
 
-![](https://oscimg.oschina.net/oscnet/290fac71753491a5a18fe66015adc1f7687.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/290fac71753491a5a18fe66015adc1f7687.jpg)
 
 标记1：执行的sql语句
 
@@ -358,69 +374,87 @@ id select_type table partitions type possible_keys key key_len ref rows filtered
 
 6.执行打印计划，主要是查看是否使用了索引等其他内容,主要就是在sql前面加上explain 关键字
 
-<pre>explain select sql_no_cache * from employees_tmp where first_name='Duangkaew' and gender='M';</pre>
+````
+explain select sql_no_cache * from employees_tmp where first_name='Duangkaew' and gender='M';
+````
 
-![](https://oscimg.oschina.net/oscnet/c15fd4c1db312050661a019557401f4b1cf.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/c15fd4c1db312050661a019557401f4b1cf.jpg)
 
 描述extra中，表示只使用了where条件，没有其他什么索引之类的
 
 7.进行sql优化，建一个fist_name的索引，索引就是将你需要的数据先给筛选出来，这样就可以节省很多扫描时间
 
-<pre>create index firstname on employees_tmp(first_name);</pre>
+````
+create index firstname on employees_tmp(first_name);
+````
 
- ![](https://oscimg.oschina.net/oscnet/325f92967bec30c8fcec3376725d21ea9ad.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/325f92967bec30c8fcec3376725d21ea9ad.jpg)
 
 注：创建索引时会很慢，是对整个表做了一个复制功能，并进行数据的一些分类（我猜是这样，所以会很慢）
 
 8.查看建立的索引
 
-<pre>show index from employees_tmp;</pre>
+````
+show index from employees_tmp;
+````
 
- ![](https://oscimg.oschina.net/oscnet/240bdc203ec8db9c4e2f9a1715816dcf928.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/240bdc203ec8db9c4e2f9a1715816dcf928.jpg)
 
 9.在执行查询语句，查看语句的执行时间
 
-<pre>select sql_no_cache * from employees_tmp where first_name='Duangkaew' and gender='M'</pre>
+````
+select sql_no_cache * from employees_tmp where first_name='Duangkaew' and gender='M'
+````
 
-![](https://oscimg.oschina.net/oscnet/addc98d4a52648e09b8c29f773865cf00ba.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/addc98d4a52648e09b8c29f773865cf00ba.jpg)
 
-   发现时间已经有所提升了，其实选择索引也不一开始就知道，我们在试试使用性别，gender进行索引
+发现时间已经有所提升了，其实选择索引也不一开始就知道，我们在试试使用性别，gender进行索引
 
 10.删除已经有的索引，删除索引：
 
-<pre>drop index first_name on employees_tmp;</pre>
+````
+drop index first_name on employees_tmp;
+````
 
 11.创建性别的索引(性别是不怎么好的索引方式，因为有很多重复数据)
 
-<pre>create index index_gendar on employees_tmp(gender);</pre>
+````
+create index index_gendar on employees_tmp(gender);
+````
 
 在执行sql语句查询数据，查看查询执行时间，没有创建比较优秀的索引，导致查询时间还变长了，
 
 为嘛还变长了，这个我没有弄懂
 
-![](https://oscimg.oschina.net/oscnet/d043c97d87b9fa6eb65f17b281db14d4df8.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/d043c97d87b9fa6eb65f17b281db14d4df8.jpg)
 
 12.我们在试试使用创建组合索引，使用性别和姓名
 
-<pre>alter table employees_tmp add index idx_union (first_name,gender);</pre>
+````
+alter table employees_tmp add index idx_union (first_name,gender);
+````
 
 在执行sql查看sql数据的执行时间
 
-<pre>select sql_no_cache * from employees_tmp where first_name='Duangkaew' and gender='M'</pre>
+````
+select sql_no_cache * from employees_tmp where first_name='Duangkaew' and gender='M'
+````
 
 速度提升了N多倍啊
 
-![](https://oscimg.oschina.net/oscnet/a2da1ce647c8e31ec16d9a6750f1e29b014.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/a2da1ce647c8e31ec16d9a6750f1e29b014.jpg)
 
 查看创建的索引
 
-<pre>show index from employees_tmp;</pre>
+````
+show index from employees_tmp;
+````
 
-![](https://oscimg.oschina.net/oscnet/9704ee337b205ce64e31dbe4c12af495c5b.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/9704ee337b205ce64e31dbe4c12af495c5b.jpg)
 
 索引建的好真的一个好帮手，建不好就是费时的一个操作
 
- 目前还不知道为什么建立性别的索引会这么慢
+目前还不知道为什么建立性别的索引会这么慢
 
 二：sql优化注意要点，比如索引是否用到，查询优化是否改变了执行计划，以及一些细节
 
@@ -495,7 +529,6 @@ CREATE index sc_score_index on SC(score);
 
 但是1s的时间还是太长了，还能进行优化吗，仔细看执行计划：
 
-![image](http://static.codeceo.com/images/2015/04/5f5a2cffb3c1f46725c97891f38de796.png "image")
 
 查看优化后的sql:
 
@@ -507,11 +540,7 @@ SELECT    `YSB`.`s`.`s_id` AS `s_id`,    `YSB`.`s`.`name` AS `name`FROM    `YSB`
 
 方法如下：
 
-在命令窗口执行 
-
-![image](http://static.codeceo.com/images/2015/04/0e19723574e5c7933c06775b4ddc288c.png "image")
-
-![image](http://static.codeceo.com/images/2015/04/077cd791216230276824fa4fdff5f965.png "image")
+在命令窗口执行
 
 有type=all
 
@@ -524,10 +553,6 @@ select s_id from SC sc where sc.c_id = 0 and sc.score = 100
 
 耗时：0.001s
 
-得到如下结果：
-
-![image](http://static.codeceo.com/images/2015/04/18f95079548bd3f27aaa0a335cf07a52.png "image")
-
 然后再执行
 
 ```
@@ -553,22 +578,16 @@ SELECT s.* from  Student s INNER JOIN SC sc on sc.s_id = s.s_id where sc.c_id=0
 
 效率有所提高，看看执行计划：
 
-![image](http://static.codeceo.com/images/2015/04/bd52af34bf50067236e4857ce214ecff.png "image")
-
 这里有连表的情况出现，我猜想是不是要给sc表的s_id建立个索引
 
 CREATE index sc_s_id_index on SC(s_id);
 
 show index from SC
 
-![image](http://static.codeceo.com/images/2015/04/729e4844ae44553d1422d480dc8c0e0a.png "image")
-
 在执行连接查询
 
 时间: 1.076s，竟然时间还变长了，什么原因？查看执行计划：
 
-![image](http://static.codeceo.com/images/2015/04/ac1b338ea87df2dba5577abf413833cb.png "image")
-
 优化后的查询语句为：
 
 ```
@@ -579,11 +598,8 @@ SELECT    `YSB`.`s`.`s_id` AS `s_id`,    `YSB`.`s`.`name` AS `name`FROM    `YSB`
 
 回到前面的执行计划：
 
-![image](http://static.codeceo.com/images/2015/04/7d46786578e5b88a00b59c4ebab098d9.png "image")
-
 这里是先做的where过滤，再做连表，执行计划还不是固定的，那么我们先看下标准的sql执行顺序：
 
-![image](http://static.codeceo.com/images/2015/04/9ca2a9a19c797c4e6d6d8c6959433b92.png "image")
 
 正常情况下是先join再where过滤，但是我们这里的情况，如果先join，将会有70w条数据发送join做操，因此先执行where
 
@@ -599,8 +615,6 @@ SELECT    s.*FROM    (        SELECT            *        FROM            SC sc
 
 查看执行计划：
 
-![image](http://static.codeceo.com/images/2015/04/570a833e7153af710a59b9da940d56d9.png "image")
-
 先提取sc再连表，这样效率就高多了，现在的问题是提取sc的时候出现了扫描表，那么现在可以明确需要建立相关索引
 
 ```
@@ -623,8 +637,6 @@ SELECT    s.*FROM    (        SELECT            *        FROM            SC sc
 
 执行计划：
 
-![image](http://static.codeceo.com/images/2015/04/0c66c0f779dcecfda9c69039a0fe3751.png "image")
-
 我们会看到，先提取sc，再连表，都用到了索引。
 
 那么再来执行下sql
@@ -637,8 +649,6 @@ SELECT s.* from  Student s INNER JOIN SC sc on sc.s_id = s.s_id where sc.c_id=0
 
 执行计划：
 
-![image](http://static.codeceo.com/images/2015/04/0fd83ae9e1fae07ad9d55c2f5b15e259.png "image")
-
 这里是mysql进行了查询语句优化，先执行了where过滤，再执行连接操作，且都用到了索引。
 
 总结：
@@ -657,35 +667,35 @@ SELECT s.* from  Student s INNER JOIN SC sc on sc.s_id = s.s_id where sc.c_id=0
 
 ## mysql百万级分页优化
 
-### 　　普通分页
+### 普通分页
 
- 　　数据分页在网页中十分多见，分页一般都是limit start,offset,然后根据页码page计算start
+数据分页在网页中十分多见，分页一般都是limit start,offset,然后根据页码page计算start
 
-<pre>　select * from user limit **1**,**20**</pre>
+　select * from user limit **1**,**20**
 
-　　 这种分页在几十万的时候分页效率就会比较低了，MySQL需要从头开始一直往后计算，这样大大影响效率
+这种分页在几十万的时候分页效率就会比较低了，MySQL需要从头开始一直往后计算，这样大大影响效率
 
-<pre>SELECT * from user limit **100001**,**20**; //time **0**.151s explain SELECT * from user limit **100001**,**20**;</pre>
+SELECT * from user limit **100001**,**20**; //time **0**.151s explain SELECT * from user limit **100001**,**20**;
 
-　　我们可以用explain分析下语句，没有用到任何索引，MySQL执行的行数是16W+，于是我们可以想用到索引去实现分页
+我们可以用explain分析下语句，没有用到任何索引，MySQL执行的行数是16W+，于是我们可以想用到索引去实现分页
 
-　　![](https://oscimg.oschina.net/oscnet/d327669b28bc017d62dfe25833ba98245cf.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/d327669b28bc017d62dfe25833ba98245cf.jpg)
 
-### 　　 优化分页
+### 优化分页
 
-　　 使用主键索引来优化数据分页
+使用主键索引来优化数据分页
 
-<pre> select * from user where id>(select id from user where id>=**100000** limit **1**) limit **20**; //time **0**.003s</pre>
+ select * from user where id>(select id from user where id>=**100000** limit **1**) limit **20**; //time **0**.003s
 
-　　使用explain分析语句，MySQL这次扫描的行数是8W+，时间也大大缩短。
+使用explain分析语句，MySQL这次扫描的行数是8W+，时间也大大缩短。
 
-<pre> explain select * from user where id>(select id from user where id>=**100000** limit **1**) limit **20**;</pre>
+ explain select * from user where id>(select id from user where id>=**100000** limit **1**) limit **20**;
 
-     ![](https://oscimg.oschina.net/oscnet/05fffbffc5e3ef9add4719846ad53f25099.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/05fffbffc5e3ef9add4719846ad53f25099.jpg)
 
-## 　　总结
+## 总结
 
-　　在数据量比较大的时候，我们尽量去利用索引来优化语句。上面的优化方法如果id不是主键索引，查询效率比第一种还要低点。我们可以先使用explain来分析语句，查看语句的执行顺序和执行性能。
+在数据量比较大的时候，我们尽量去利用索引来优化语句。上面的优化方法如果id不是主键索引，查询效率比第一种还要低点。我们可以先使用explain来分析语句，查看语句的执行顺序和执行性能。
 
 
 
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\22311\357\274\232\344\273\245Java\347\232\204\350\247\206\350\247\222\346\235\245\350\201\212\350\201\212SQL\346\263\250\345\205\245.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\344\273\245Java\347\232\204\350\247\206\350\247\222\346\235\245\350\201\212\350\201\212SQL\346\263\250\345\205\245.md"
similarity index 99%
rename from "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\22311\357\274\232\344\273\245Java\347\232\204\350\247\206\350\247\222\346\235\245\350\201\212\350\201\212SQL\346\263\250\345\205\245.md"
rename to "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\344\273\245Java\347\232\204\350\247\206\350\247\222\346\235\245\350\201\212\350\201\212SQL\346\263\250\345\205\245.md"
index 8ee94df..88a69e6 100644
--- "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\22311\357\274\232\344\273\245Java\347\232\204\350\247\206\350\247\222\346\235\245\350\201\212\350\201\212SQL\346\263\250\345\205\245.md"
+++ "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\344\273\245Java\347\232\204\350\247\206\350\247\222\346\235\245\350\201\212\350\201\212SQL\346\263\250\345\205\245.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [前言](#前言)
     * [靶场准备](#靶场准备)
     * [SQL注入测试](#sql注入测试)
@@ -31,8 +30,6 @@
 
 <!-- more -->
 
-<!-- more -->
-
 本文转自互联网
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2231\357\274\232\346\227\240\345\272\237\350\257\235MySQL\345\205\245\351\227\250.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\346\227\240\345\272\237\350\257\235MySQL\345\205\245\351\227\250.md"
similarity index 93%
rename from "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2231\357\274\232\346\227\240\345\272\237\350\257\235MySQL\345\205\245\351\227\250.md"
rename to "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\346\227\240\345\272\237\350\257\235MySQL\345\205\245\351\227\250.md"
index f33d12a..40de9bd 100644
--- "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2231\357\274\232\346\227\240\345\272\237\350\257\235MySQL\345\205\245\351\227\250.md"
+++ "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\346\227\240\345\272\237\350\257\235MySQL\345\205\245\351\227\250.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [前言](#前言)
     * [登录MySQL](#登录mysql)
     * [创建数据库](#创建数据库)
@@ -123,8 +122,8 @@ CREATE TABLE `user_accounts` (  `id`             int(100) unsigned NOT NULL AUTO
 
 ### SELECT
 
-> SELECT 语句用于从表中选取数据。 
-> 语法：`SELECT 列名称 FROM 表名称` 
+> SELECT 语句用于从表中选取数据。
+> 语法：`SELECT 列名称 FROM 表名称`
 > 语法：`SELECT * FROM 表名称`
 
 ```
@@ -133,7 +132,7 @@ CREATE TABLE `user_accounts` (  `id`             int(100) unsigned NOT NULL AUTO
 
 ### UPDATE
 
-> Update 语句用于修改表中的数据。 
+> Update 语句用于修改表中的数据。
 > 语法：`UPDATE 表名称 SET 列名称 = 新值 WHERE 列名称 = 某值`
 
 ```
@@ -142,8 +141,8 @@ CREATE TABLE `user_accounts` (  `id`             int(100) unsigned NOT NULL AUTO
 
 ### INSERT
 
-> INSERT INTO 语句用于向表格中插入新的行。 
-> 语法：`INSERT INTO 表名称 VALUES (值1, 值2,....)` 
+> INSERT INTO 语句用于向表格中插入新的行。
+> 语法：`INSERT INTO 表名称 VALUES (值1, 值2,....)`
 > 语法：`INSERT INTO 表名称 (列1, 列2,...) VALUES (值1, 值2,....)`
 
 ```
@@ -152,7 +151,7 @@ CREATE TABLE `user_accounts` (  `id`             int(100) unsigned NOT NULL AUTO
 
 ### DELETE
 
-> DELETE 语句用于删除表中的行。 
+> DELETE 语句用于删除表中的行。
 > 语法：`DELETE FROM 表名称 WHERE 列名称 = 值`
 
 ```
@@ -161,7 +160,7 @@ CREATE TABLE `user_accounts` (  `id`             int(100) unsigned NOT NULL AUTO
 
 ## WHERE
 
-> WHERE 子句用于规定选择的标准。 
+> WHERE 子句用于规定选择的标准。
 > 语法：`SELECT 列名称 FROM 表名称 WHERE 列 运算符 值`
 
 ```
@@ -170,7 +169,7 @@ CREATE TABLE `user_accounts` (  `id`             int(100) unsigned NOT NULL AUTO
 
 ## AND 和 OR
 
-> AND - 如果第一个条件和第二个条件都成立； 
+> AND - 如果第一个条件和第二个条件都成立；
 > OR - 如果第一个条件和第二个条件中只要有一个成立；
 
 ### AND
@@ -187,10 +186,10 @@ CREATE TABLE `user_accounts` (  `id`             int(100) unsigned NOT NULL AUTO
 
 ## ORDER BY
 
-> 语句默认按照升序对记录进行排序。 
-> `ORDER BY` - 语句用于根据指定的列对结果集进行排序。 
-> `DESC` - 按照降序对记录进行排序。 
-> `ASC` - 按照顺序对记录进行排序。
+> 语句默认按照升序对记录进行排序。
+> `ORDER BY`- 语句用于根据指定的列对结果集进行排序。
+> `DESC`- 按照降序对记录进行排序。
+> `ASC`- 按照顺序对记录进行排序。
 
 ```
 -- Company在表Orders中为字母，则会以字母顺序显示公司名称SELECT Company, OrderNumber FROM Orders ORDER BY Company -- 后面跟上 DESC 则为降序显示SELECT Company, OrderNumber FROM Orders ORDER BY Company DESC -- Company以降序显示公司名称，并OrderNumber以顺序显示SELECT Company, OrderNumber FROM Orders ORDER BY Company DESC, OrderNumber ASC
@@ -198,7 +197,7 @@ CREATE TABLE `user_accounts` (  `id`             int(100) unsigned NOT NULL AUTO
 
 ## IN
 
-> IN - 操作符允许我们在 WHERE 子句中规定多个值。 
+> IN - 操作符允许我们在 WHERE 子句中规定多个值。
 > IN - 操作符用来指定范围，范围中的每一条，都进行匹配。IN取值规律，由逗号分割，全部放置括号中。
 > 语法：`SELECT "字段名"FROM "表格名"WHERE "字段名" IN ('值一', '值二', ...);`
 
@@ -211,7 +210,7 @@ CREATE TABLE `user_accounts` (  `id`             int(100) unsigned NOT NULL AUTO
 > NOT - 操作符总是与其他操作符一起使用，用在要过滤的前面。
 
 ```
-SELECT vend_id, prod_name FROM Products WHERE NOT vend_id = 'DLL01' ORDER BYprod_name;
+SELECTvend_id, prod_nameFROMProductsWHERENOTvend_id ='DLL01'ORDERBYprod_name;
 ```
 
 ## UNION
@@ -224,8 +223,8 @@ SELECT vend_id, prod_name FROM Products WHERE NOT vend_id = 'DLL01' ORDE
 
 ## AS
 
-> as - 可理解为：用作、当成，作为；别名 
-> 一般是重命名列名或者表名。 
+> as - 可理解为：用作、当成，作为；别名
+> 一般是重命名列名或者表名。
 > 语法：`select column_1 as 列1,column_2 as 列2 from table as 表`
 
 ```
@@ -254,7 +253,7 @@ SELECT Persons.LastName, Persons.FirstName, Orders.OrderNoFROM PersonsINNER JOIN
 
 ### COUNT
 
-> COUNT 让我们能够数出在表格中有多少笔资料被选出来。 
+> COUNT 让我们能够数出在表格中有多少笔资料被选出来。
 > 语法：`SELECT COUNT("字段名") FROM "表格名";`
 
 ```
@@ -263,7 +262,7 @@ SELECT Persons.LastName, Persons.FirstName, Orders.OrderNoFROM PersonsINNER JOIN
 
 ### MAX
 
-> MAX 函数返回一列中的最大值。NULL 值不包括在计算中。 
+> MAX 函数返回一列中的最大值。NULL 值不包括在计算中。
 > 语法：`SELECT MAX("字段名") FROM "表格名"`
 
 ```
@@ -294,7 +293,7 @@ OLD和NEW不区分大小写
 
 ### 普通索引(INDEX)
 
-> 语法：ALTER TABLE `表名字` ADD INDEX 索引名字 ( `字段名字` )
+> 语法：ALTER TABLE`表名字`ADD INDEX 索引名字 (`字段名字`)
 
 ```
 -- –直接创建索引CREATE INDEX index_user ON user(title)-- –修改表结构的方式添加索引ALTER TABLE table_name ADD INDEX index_name ON (column(length))-- 给 user 表中的 name字段 添加普通索引(INDEX)ALTER TABLE `table` ADD INDEX index_name (name)-- –创建表的时候同时创建索引CREATE TABLE `table` (    `id` int(11) NOT NULL AUTO_INCREMENT ,    `title` char(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL ,    `content` text CHARACTER SET utf8 COLLATE utf8_general_ci NULL ,    `time` int(10) NULL DEFAULT NULL ,    PRIMARY KEY (`id`),    INDEX index_name (title(length)))-- –删除索引DROP INDEX index_name ON table
@@ -302,7 +301,7 @@ OLD和NEW不区分大小写
 
 ### 主键索引(PRIMARY key)
 
-> 语法：ALTER TABLE `表名字` ADD PRIMARY KEY ( `字段名字` )
+> 语法：ALTER TABLE`表名字`ADD PRIMARY KEY (`字段名字`)
 
 ```
 -- 给 user 表中的 id字段 添加主键索引(PRIMARY key)ALTER TABLE `user` ADD PRIMARY key (id);
@@ -310,7 +309,7 @@ OLD和NEW不区分大小写
 
 ### 唯一索引(UNIQUE)
 
-> 语法：ALTER TABLE `表名字` ADD UNIQUE (`字段名字`)
+> 语法：ALTER TABLE`表名字`ADD UNIQUE (`字段名字`)
 
 ```
 -- 给 user 表中的 creattime 字段添加唯一索引(UNIQUE)ALTER TABLE `user` ADD UNIQUE (creattime);
@@ -318,7 +317,7 @@ OLD和NEW不区分大小写
 
 ### 全文索引(FULLTEXT)
 
-> 语法：ALTER TABLE `表名字` ADD FULLTEXT (`字段名字`)
+> 语法：ALTER TABLE`表名字`ADD FULLTEXT (`字段名字`)
 
 ```
 -- 给 user 表中的 description 字段添加全文索引(FULLTEXT)ALTER TABLE `user` ADD FULLTEXT (description);
@@ -328,7 +327,7 @@ OLD和NEW不区分大小写
 
 > 语法：
 
-ALTER TABLE `table_name` ADD INDEX index_name ( `column1`, `column2`, `column3`)
+ALTER TABLE`table_name`ADD INDEX index_name (`column1`,`column2`,`column3`)
 
 ```
 -- 给 user 表中的 name、city、age 字段添加名字为name_city_age的普通索引(INDEX)ALTER TABLE user ADD INDEX name_city_age (name(10),city,age); 
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2235\357\274\232\346\240\271\346\215\256MySQL\347\264\242\345\274\225\345\216\237\347\220\206\350\277\233\350\241\214\345\210\206\346\236\220\344\270\216\344\274\230\345\214\226.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\346\240\271\346\215\256MySQL\347\264\242\345\274\225\345\216\237\347\220\206\350\277\233\350\241\214\345\210\206\346\236\220\344\270\216\344\274\230\345\214\226.md"
similarity index 80%
rename from "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2235\357\274\232\346\240\271\346\215\256MySQL\347\264\242\345\274\225\345\216\237\347\220\206\350\277\233\350\241\214\345\210\206\346\236\220\344\270\216\344\274\230\345\214\226.md"
rename to "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\346\240\271\346\215\256MySQL\347\264\242\345\274\225\345\216\237\347\220\206\350\277\233\350\241\214\345\210\206\346\236\220\344\270\216\344\274\230\345\214\226.md"
index 276dae3..3dd0dbf 100644
--- "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2235\357\274\232\346\240\271\346\215\256MySQL\347\264\242\345\274\225\345\216\237\347\220\206\350\277\233\350\241\214\345\210\206\346\236\220\344\270\216\344\274\230\345\214\226.md"
+++ "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\346\240\271\346\215\256MySQL\347\264\242\345\274\225\345\216\237\347\220\206\350\277\233\350\241\214\345\210\206\346\236\220\344\270\216\344\274\230\345\214\226.md"
@@ -1,12 +1,11 @@
-# Table of Contents
-
-  * [一：Mysql原理与慢查询](#一：mysql原理与慢查询)
-  * [一个慢查询引发的思考](#一个慢查询引发的思考)
-  * [二：索引建立](#二：索引建立)
-  * [三：浅析explain用法](#三：浅析explain用法)
+# 目录
+* [一：Mysql原理与慢查询](#一：mysql原理与慢查询)
+* [一个慢查询引发的思考](#一个慢查询引发的思考)
+* [二：索引建立](#二：索引建立)
+* [三：浅析explain用法](#三：浅析explain用法)
     * [有什么用？](#有什么用？)
     * [怎么使用？](#怎么使用？)
-  * [参数介绍](#参数介绍)
+* [参数介绍](#参数介绍)
     * [id](#id)
     * [select_type](#select_type)
     * [extra](#extra)
@@ -15,12 +14,12 @@
     * [key_len](#key_len)
     * [ref](#ref)
     * [rows](#rows)
-  * [四：慢查询优化](#四：慢查询优化)
+* [四：慢查询优化](#四：慢查询优化)
     * [建索引的几大原则](#建索引的几大原则)
     * [回到开始的慢查询](#回到开始的慢查询)
     * [查询优化神器 - explain命令](#查询优化神器---explain命令)
     * [慢查询优化基本步骤](#慢查询优化基本步骤)
-  * [五：最左前缀原理与相关优化](#五：最左前缀原理与相关优化)
+* [五：最左前缀原理与相关优化](#五：最左前缀原理与相关优化)
     * [情况一：全列匹配。](#情况一：全列匹配。)
     * [情况二：最左前缀匹配。](#情况二：最左前缀匹配。)
     * [情况三：查询条件用到了索引中列的精确匹配，但是中间某个条件未提供。](#情况三：查询条件用到了索引中列的精确匹配，但是中间某个条件未提供。)
@@ -28,18 +27,20 @@
     * [情况五：匹配某列的前缀字符串。](#情况五：匹配某列的前缀字符串。)
     * [情况六：范围查询。](#情况六：范围查询。)
     * [情况七：查询条件中含有函数或表达式。](#情况七：查询条件中含有函数或表达式。)
-  * [索引选择性与前缀索引](#索引选择性与前缀索引)
-  * [六：InnoDB的主键选择与插入优化](#六：innodb的主键选择与插入优化)
+* [索引选择性与前缀索引](#索引选择性与前缀索引)
+* [六：InnoDB的主键选择与插入优化](#六：innodb的主键选择与插入优化)
 
 
 本文转自互联网
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本也将整理到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -78,20 +79,20 @@ select   count(*) from   task where   status=2    and operator_id=20839    and o
 
 ## 二：索引建立
 
-1\. 主键索引
+1. 主键索引
 
-primary key() 要求关键字不能重复，也不能为null,同时增加主键约束 
+primary key() 要求关键字不能重复，也不能为null,同时增加主键约束
 主键索引定义时，不能命名
 
-2\. 唯一索引
+2. 唯一索引
 
 unique index() 要求关键字不能重复，同时增加唯一约束
 
-3\. 普通索引
+3. 普通索引
 
 index() 对关键字没有要求
 
-4\. 全文索引
+4. 全文索引
 
 fulltext key() 关键字的来源不是所有字段的数据，而是字段中提取的特别关键字
 
@@ -234,17 +235,17 @@ select count(*) from task where status = 0 ;
 这里先说一下联合索引的概念。在上文中，我们都是假设索引只引用了单个的列，实际上，MySQL中的索引可以以一定顺序引用多个列，这种索引叫做联合索引，一般的，一个联合索引是一个有序元组，其中各个元素均为数据表的一列，实际上要严格定义索引需要用到关系代数，但是这里我不想讨论太多关系代数的话题，因为那样会显得很枯燥，所以这里就不再做严格定义。另外，单列索引可以看成联合索引元素数为1的特例。
 
 以employees.titles表为例，下面先查看其上都有哪些索引：
-
+````
 1.  SHOW INDEX FROM employees.titles;
 2.  +--------+------------+----------+--------------+-------------+-----------+-------------+------+------------+
-3.  | Table | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Null | Index_type |
+3.  |Table|Non_unique|Key_name|Seq_in_index|Column_name|Collation|Cardinality|Null|Index_type|
 4.  +--------+------------+----------+--------------+-------------+-----------+-------------+------+------------+
-5.  | titles | 0 | PRIMARY | 1 | emp_no | A | NULL | | BTREE |
-6.  | titles | 0 | PRIMARY | 2 | title | A | NULL | | BTREE |
-7.  | titles | 0 | PRIMARY | 3 | from_date | A | 443308 | | BTREE |
-8.  | titles | 1 | emp_no | 1 | emp_no | A | 443308 | | BTREE |
+5.  |titles|0|PRIMARY|1|emp_no|A|NULL||BTREE|
+6.  |titles|0|PRIMARY|2|title|A|NULL||BTREE|
+7.  |titles|0|PRIMARY|3|from_date|A|443308||BTREE|
+8.  |titles|1|emp_no|1|emp_no|A|443308||BTREE|
 9.  +--------+------------+----------+--------------+-------------+-----------+-------------+------+------------+
-
+````
 从结果中可以到titles表的主索引为<emp_no, title, from_date>，还有一个辅助索引<emp_no>。为了避免多个索引使事情变复杂（MySQL的SQL优化器在多索引时行为比较复杂），这里我们将辅助索引drop掉：
 
 1.  ALTER TABLE employees.titles DROP INDEX emp_no;
@@ -252,165 +253,165 @@ select count(*) from task where status = 0 ;
 这样就可以专心分析索引PRIMARY的行为了。
 
 ### 情况一：全列匹配。
-
-1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no='10001' AND title='Senior Engineer' AND from_date='1986-06-26';
+````
+1.  EXPLAIN SELECT*FROM employees.titles WHERE emp_no='10001'AND title='Senior Engineer'AND from_date='1986-06-26';
 2.  +----+-------------+--------+-------+---------------+---------+---------+-------------------+------+-------+
-3.  | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+3.  |id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|
 4.  +----+-------------+--------+-------+---------------+---------+---------+-------------------+------+-------+
-5.  | 1 | SIMPLE | titles | const | PRIMARY | PRIMARY | 59 | const,const,const | 1 | |
+5.  |1|SIMPLE|titles|const|PRIMARY|PRIMARY|59|const,const,const|1||
 6.  +----+-------------+--------+-------+---------------+---------+---------+-------------------+------+-------+
-
+````
 很明显，当按照索引中所有列进行精确匹配（这里精确匹配指“=”或“IN”匹配）时，索引可以被用到。这里有一点需要注意，理论上索引对顺序是敏感的，但是由于MySQL的查询优化器会自动调整where子句的条件顺序以使用适合的索引，例如我们将where中的条件顺序颠倒：
-
-1.  EXPLAIN SELECT * FROM employees.titles WHERE from_date='1986-06-26' AND emp_no='10001' AND title='Senior Engineer';
+````
+1.  EXPLAIN SELECT*FROM employees.titles WHERE from_date='1986-06-26'AND emp_no='10001'AND title='Senior Engineer';
 2.  +----+-------------+--------+-------+---------------+---------+---------+-------------------+------+-------+
-3.  | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+3.  |id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|
 4.  +----+-------------+--------+-------+---------------+---------+---------+-------------------+------+-------+
-5.  | 1 | SIMPLE | titles | const | PRIMARY | PRIMARY | 59 | const,const,const | 1 | |
+5.  |1|SIMPLE|titles|const|PRIMARY|PRIMARY|59|const,const,const|1||
 6.  +----+-------------+--------+-------+---------------+---------+---------+-------------------+------+-------+
-
+````
 效果是一样的。
 
 ### 情况二：最左前缀匹配。
-
-1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no='10001';
+````
+1.  EXPLAIN SELECT*FROM employees.titles WHERE emp_no='10001';
 2.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------+
-3.  | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+3.  |id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|
 4.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------+
-5.  | 1 | SIMPLE | titles | ref | PRIMARY | PRIMARY | 4 | const | 1 | |
+5.  |1|SIMPLE|titles|ref|PRIMARY|PRIMARY|4|const|1||
 6.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------+
-
+````
 当查询条件精确匹配索引的左边连续一个或几个列时，如<emp_no>或<emp_no, title>，所以可以被用到，但是只能用到一部分，即条件所组成的最左前缀。上面的查询从分析结果看用到了PRIMARY索引，但是key_len为4，说明只用到了索引的第一列前缀。
 
 ### 情况三：查询条件用到了索引中列的精确匹配，但是中间某个条件未提供。
-
-1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no='10001' AND from_date='1986-06-26';
+````
+1.  EXPLAIN SELECT*FROM employees.titles WHERE emp_no='10001'AND from_date='1986-06-26';
 2.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------------+
-3.  | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+3.  |id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|
 4.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------------+
-5.  | 1 | SIMPLE | titles | ref | PRIMARY | PRIMARY | 4 | const | 1 | Using where |
+5.  |1|SIMPLE|titles|ref|PRIMARY|PRIMARY|4|const|1|Usingwhere|
 6.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------------+
-
+````
 此时索引使用情况和情况二相同，因为title未提供，所以查询只用到了索引的第一列，而后面的from_date虽然也在索引中，但是由于title不存在而无法和左前缀连接，因此需要对结果进行扫描过滤from_date（这里由于emp_no唯一，所以不存在扫描）。
 
 如果想让from_date也使用索引而不是where过滤，可以增加一个辅助索引<emp_no, from_date>，此时上面的查询会使用这个索引。除此之外，还可以使用一种称之为“隔离列”的优化方法，将emp_no与from_date之间的“坑”填上。
 
 首先我们看下title一共有几种不同的值：
-
-1.  SELECT DISTINCT(title) FROM employees.titles;
+````
+1.  SELECT DISTINCT(title)FROM employees.titles;
 2.  +--------------------+
-3.  | title |
+3.  |title|
 4.  +--------------------+
-5.  | Senior Engineer |
-6.  | Staff |
-7.  | Engineer |
-8.  | Senior Staff |
-9.  | Assistant Engineer |
-10.  | Technique Leader |
-11.  | Manager |
+5.  |SeniorEngineer|
+6.  |Staff|
+7.  |Engineer|
+8.  |SeniorStaff|
+9.  |AssistantEngineer|
+10.  |TechniqueLeader|
+11.  |Manager|
 12.  +--------------------+
-
+````
 只有7种。在这种成为“坑”的列值比较少的情况下，可以考虑用“IN”来填补这个“坑”从而形成最左前缀：
-
-1.  EXPLAIN SELECT * FROM employees.titles
+````
+1.  EXPLAIN SELECT*FROM employees.titles
 2.  WHERE emp_no='10001'
-3.  AND title IN ('Senior Engineer', 'Staff', 'Engineer', 'Senior Staff', 'Assistant Engineer', 'Technique Leader', 'Manager')
+3.  AND title IN('Senior Engineer','Staff','Engineer','Senior Staff','Assistant Engineer','Technique Leader','Manager')
 4.  AND from_date='1986-06-26';
 5.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-6.  | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+6.  |id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|
 7.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-8.  | 1 | SIMPLE | titles | range | PRIMARY | PRIMARY | 59 | NULL | 7 | Using where |
+8.  |1|SIMPLE|titles|range|PRIMARY|PRIMARY|59|NULL|7|Usingwhere|
 9.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-
+````
 这次key_len为59，说明索引被用全了，但是从type和rows看出IN实际上执行了一个range查询，这里检查了7个key。看下两种查询的性能比较：
-
+````
 1.  SHOW PROFILES;
 2.  +----------+------------+-------------------------------------------------------------------------------+
-3.  | Query_ID | Duration | Query |
+3.  |Query_ID|Duration|Query|
 4.  +----------+------------+-------------------------------------------------------------------------------+
-5.  | 10 | 0.00058000 | SELECT * FROM employees.titles WHERE emp_no='10001' AND from_date='1986-06-26'|
-6.  | 11 | 0.00052500 | SELECT * FROM employees.titles WHERE emp_no='10001' AND title IN ... |
+5.  |10|0.00058000|SELECT*FROM employees.titles WHERE emp_no='10001'AND from_date='1986-06-26'|
+6.  |11|0.00052500|SELECT*FROM employees.titles WHERE emp_no='10001'AND title IN...|
 7.  +----------+------------+-------------------------------------------------------------------------------+
-
+````
 “填坑”后性能提升了一点。如果经过emp_no筛选后余下很多数据，则后者性能优势会更加明显。当然，如果title的值很多，用填坑就不合适了，必须建立辅助索引。
 
 ### 情况四：查询条件没有指定索引第一列。
-
-1.  EXPLAIN SELECT * FROM employees.titles WHERE from_date='1986-06-26';
+````
+1.  EXPLAIN SELECT*FROM employees.titles WHERE from_date='1986-06-26';
 2.  +----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
-3.  | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+3.  |id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|
 4.  +----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
-5.  | 1 | SIMPLE | titles | ALL | NULL | NULL | NULL | NULL | 443308 | Using where |
+5.  |1|SIMPLE|titles|ALL|NULL|NULL|NULL|NULL|443308|Usingwhere|
 6.  +----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
-
+````
 由于不是最左前缀，索引这样的查询显然用不到索引。
 
 ### 情况五：匹配某列的前缀字符串。
-
-1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no='10001' AND title LIKE 'Senior%';
+````
+1.  EXPLAIN SELECT*FROM employees.titles WHERE emp_no='10001'AND title LIKE'Senior%';
 2.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-3.  | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+3.  |id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|
 4.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-5.  | 1 | SIMPLE | titles | range | PRIMARY | PRIMARY | 56 | NULL | 1 | Using where |
+5.  |1|SIMPLE|titles|range|PRIMARY|PRIMARY|56|NULL|1|Usingwhere|
 6.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-
+````
 此时可以用到索引，但是如果通配符不是只出现在末尾，则无法使用索引。（原文表述有误，如果通配符%不出现在开头，则可以用到索引，但根据具体情况不同可能只会用其中一个前缀）
 
 ### 情况六：范围查询。
-
-1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no < '10010' and title='Senior Engineer';
+````
+1.  EXPLAIN SELECT*FROM employees.titles WHERE emp_no<'10010'andtitle='Senior Engineer';
 2.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-3.  | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+3.  |id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|
 4.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-5.  | 1 | SIMPLE | titles | range | PRIMARY | PRIMARY | 4 | NULL | 16 | Using where |
+5.  |1|SIMPLE|titles|range|PRIMARY|PRIMARY|4|NULL|16|Usingwhere|
 6.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-
+````
 范围列可以用到索引（必须是最左前缀），但是范围列后面的列无法用到索引。同时，索引最多用于一个范围列，因此如果查询条件中有两个范围列则无法全用到索引。
-
-1.  EXPLAIN SELECT * FROM employees.titles
-2.  WHERE emp_no < '10010'
+````
+1.  EXPLAIN SELECT*FROM employees.titles
+2.  WHERE emp_no<'10010'
 3.  AND title='Senior Engineer'
-4.  AND from_date BETWEEN '1986-01-01' AND '1986-12-31';
+4.  AND from_date BETWEEN'1986-01-01'AND'1986-12-31';
 5.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-6.  | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+6.  |id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|
 7.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-8.  | 1 | SIMPLE | titles | range | PRIMARY | PRIMARY | 4 | NULL | 16 | Using where |
+8.  |1|SIMPLE|titles|range|PRIMARY|PRIMARY|4|NULL|16|Usingwhere|
 9.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-
+````
 可以看到索引对第二个范围索引无能为力。这里特别要说明MySQL一个有意思的地方，那就是仅用explain可能无法区分范围索引和多值匹配，因为在type中这两者都显示为range。同时，用了“between”并不意味着就是范围查询，例如下面的查询：
-
-1.  EXPLAIN SELECT * FROM employees.titles
-2.  WHERE emp_no BETWEEN '10001' AND '10010'
+````
+1.  EXPLAIN SELECT*FROM employees.titles
+2.  WHERE emp_no BETWEEN'10001'AND'10010'
 3.  AND title='Senior Engineer'
-4.  AND from_date BETWEEN '1986-01-01' AND '1986-12-31';
+4.  AND from_date BETWEEN'1986-01-01'AND'1986-12-31';
 5.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-6.  | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+6.  |id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|
 7.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-8.  | 1 | SIMPLE | titles | range | PRIMARY | PRIMARY | 59 | NULL | 16 | Using where |
+8.  |1|SIMPLE|titles|range|PRIMARY|PRIMARY|59|NULL|16|Usingwhere|
 9.  +----+-------------+--------+-------+---------------+---------+---------+------+------+-------------+
-
+````
 看起来是用了两个范围查询，但作用于emp_no上的“BETWEEN”实际上相当于“IN”，也就是说emp_no实际是多值精确匹配。可以看到这个查询用到了索引全部三个列。因此在MySQL中要谨慎地区分多值匹配和范围匹配，否则会对MySQL的行为产生困惑。
 
 ### 情况七：查询条件中含有函数或表达式。
 
 很不幸，如果查询条件中含有函数或表达式，则MySQL不会为这列使用索引（虽然某些在数学意义上可以使用）。例如：
-
-1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no='10001' AND left(title, 6)='Senior';
+````
+1.  EXPLAIN SELECT*FROM employees.titles WHERE emp_no='10001'AND left(title,6)='Senior';
 2.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------------+
-3.  | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+3.  |id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|
 4.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------------+
-5.  | 1 | SIMPLE | titles | ref | PRIMARY | PRIMARY | 4 | const | 1 | Using where |
+5.  |1|SIMPLE|titles|ref|PRIMARY|PRIMARY|4|const|1|Usingwhere|
 6.  +----+-------------+--------+------+---------------+---------+---------+-------+------+-------------+
-
+````
 虽然这个查询和情况五中功能相同，但是由于使用了函数left，则无法为title列应用索引，而情况五中用LIKE则可以。再如：
-
-1.  EXPLAIN SELECT * FROM employees.titles WHERE emp_no - 1='10000';
+````
+1.  EXPLAIN SELECT*FROM employees.titles WHERE emp_no-1='10000';
 2.  +----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
-3.  | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+3.  |id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|
 4.  +----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
-5.  | 1 | SIMPLE | titles | ALL | NULL | NULL | NULL | NULL | 443308 | Using where |
+5.  |1|SIMPLE|titles|ALL|NULL|NULL|NULL|NULL|443308|Usingwhere|
 6.  +----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
-
+````
 显然这个查询等价于查询emp_no为10001的函数，但是由于查询条件是一个表达式，MySQL无法为其使用索引。看来MySQL还没有智能到自动优化常量表达式的程度，因此在写查询语句时尽量避免表达式出现在查询中，而是先手工私下代数运算，转换为无表达式的查询语句。
 
 ## 索引选择性与前缀索引
@@ -420,79 +421,79 @@ select count(*) from task where status = 0 ;
 第一种情况是表记录比较少，例如一两千条甚至只有几百条记录的表，没必要建索引，让查询做全表扫描就好了。至于多少条记录才算多，这个个人有个人的看法，我个人的经验是以2000作为分界线，记录数不超过 2000可以考虑不建索引，超过2000条可以酌情考虑索引。
 
 另一种不建议建索引的情况是索引的选择性较低。所谓索引的选择性（Selectivity），是指不重复的索引值（也叫基数，Cardinality）与表记录数（#T）的比值：
-
+````
 Index Selectivity = Cardinality / #T
-
+````
 显然选择性的取值范围为(0, 1]，选择性越高的索引价值越大，这是由B+Tree的性质决定的。例如，上文用到的employees.titles表，如果title字段经常被单独查询，是否需要建索引，我们看一下它的选择性：
-
-1.  SELECT count(DISTINCT(title))/count(*) AS Selectivity FROM employees.titles;
+````
+1.  SELECT count(DISTINCT(title))/count(*)ASSelectivityFROM employees.titles;
 2.  +-------------+
-3.  | Selectivity |
+3.  |Selectivity|
 4.  +-------------+
-5.  | 0.0000 |
+5.  |0.0000|
 6.  +-------------+
-
+````
 title的选择性不足0.0001（精确值为0.00001579），所以实在没有什么必要为其单独建索引。
 
 有一种与索引选择性有关的索引优化策略叫做前缀索引，就是用列的前缀代替整个列作为索引key，当前缀长度合适时，可以做到既使得前缀索引的选择性接近全列索引，同时因为索引key变短而减少了索引文件的大小和维护开销。下面以employees.employees表为例介绍前缀索引的选择和使用。
 
 从图12可以看到employees表只有一个索引<emp_no>，那么如果我们想按名字搜索一个人，就只能全表扫描了：
-
-1.  EXPLAIN SELECT * FROM employees.employees WHERE first_name='Eric' AND last_name='Anido';
+````
+1.  EXPLAIN SELECT*FROM employees.employees WHERE first_name='Eric'AND last_name='Anido';
 2.  +----+-------------+-----------+------+---------------+------+---------+------+--------+-------------+
-3.  | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+3.  |id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|
 4.  +----+-------------+-----------+------+---------------+------+---------+------+--------+-------------+
-5.  | 1 | SIMPLE | employees | ALL | NULL | NULL | NULL | NULL | 300024 | Using where |
+5.  |1|SIMPLE|employees|ALL|NULL|NULL|NULL|NULL|300024|Usingwhere|
 6.  +----+-------------+-----------+------+---------------+------+---------+------+--------+-------------+
-
+````
 如果频繁按名字搜索员工，这样显然效率很低，因此我们可以考虑建索引。有两种选择，建<first_name>或<first_name, last_name>，看下两个索引的选择性：
-
-1.  SELECT count(DISTINCT(first_name))/count(*) AS Selectivity FROM employees.employees;
+````
+1.  SELECT count(DISTINCT(first_name))/count(*)ASSelectivityFROM employees.employees;
 2.  +-------------+
-3.  | Selectivity |
+3.  |Selectivity|
 4.  +-------------+
-5.  | 0.0042 |
+5.  |0.0042|
 6.  +-------------+
-7.  SELECT count(DISTINCT(concat(first_name, last_name)))/count(*) AS Selectivity FROM employees.employees;
+7.  SELECT count(DISTINCT(concat(first_name,last_name)))/count(*)ASSelectivityFROM employees.employees;
 8.  +-------------+
-9.  | Selectivity |
+9.  |Selectivity|
 10.  +-------------+
-11.  | 0.9313 |
+11.  |0.9313|
 12.  +-------------+
-
+````
 <first_name>显然选择性太低，<first_name, last_name>选择性很好，但是first_name和last_name加起来长度为30，有没有兼顾长度和选择性的办法？可以考虑用first_name和last_name的前几个字符建立索引，例如<first_name, left(last_name, 3)>，看看其选择性：
-
-1.  SELECT count(DISTINCT(concat(first_name, left(last_name, 3))))/count(*) AS Selectivity FROM employees.employees;
+````
+1.  SELECT count(DISTINCT(concat(first_name,left(last_name,3))))/count(*)ASSelectivityFROM employees.employees;
 2.  +-------------+
-3.  | Selectivity |
+3.  |Selectivity|
 4.  +-------------+
-5.  | 0.7879 |
+5.  |0.7879|
 6.  +-------------+
-
+````
 选择性还不错，但离0.9313还是有点距离，那么把last_name前缀加到4：
-
-1.  SELECT count(DISTINCT(concat(first_name, left(last_name, 4))))/count(*) AS Selectivity FROM employees.employees;
+````
+1.  SELECT count(DISTINCT(concat(first_name,left(last_name,4))))/count(*)ASSelectivityFROM employees.employees;
 2.  +-------------+
-3.  | Selectivity |
+3.  |Selectivity|
 4.  +-------------+
-5.  | 0.9007 |
+5.  |0.9007|
 6.  +-------------+
-
+````
 这时选择性已经很理想了，而这个索引的长度只有18，比<first_name, last_name>短了接近一半，我们把这个前缀索引 建上：
-
+````
 1.  ALTER TABLE employees.employees
-2.  ADD INDEX `first_name_last_name4` (first_name, last_name(4));
-
+2.  ADD INDEX`first_name_last_name4`(first_name,last_name(4));
+````
 此时再执行一遍按名字查询，比较分析一下与建索引前的结果：
-
+````
 1.  SHOW PROFILES;
 2.  +----------+------------+---------------------------------------------------------------------------------+
-3.  | Query_ID | Duration | Query |
+3.  |Query_ID|Duration|Query|
 4.  +----------+------------+---------------------------------------------------------------------------------+
-5.  | 87 | 0.11941700 | SELECT * FROM employees.employees WHERE first_name='Eric' AND last_name='Anido' |
-6.  | 90 | 0.00092400 | SELECT * FROM employees.employees WHERE first_name='Eric' AND last_name='Anido' |
+5.  |87|0.11941700|SELECT*FROM employees.employees WHERE first_name='Eric'AND last_name='Anido'|
+6.  |90|0.00092400|SELECT*FROM employees.employees WHERE first_name='Eric'AND last_name='Anido'|
 7.  +----------+------------+---------------------------------------------------------------------------------+
-
+````
 性能的提升是显著的，查询速度提高了120多倍。
 
 前缀索引兼顾索引大小和查询速度，但是其缺点是不能用于ORDER BY和GROUP BY操作，也不能用于Covering index（即当索引本身包含查询所需全部数据时，不再访问数据文件本身
@@ -507,7 +508,7 @@ title的选择性不足0.0001（精确值为0.00001579），所以实在没有
 
 如果表使用自增主键，那么每次插入新的记录，记录就会顺序添加到当前索引节点的后续位置，当一页写满，就会自动开辟一个新的页。如下图所示：
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/13.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/13.png)
 
 图13
 
@@ -515,7 +516,7 @@ title的选择性不足0.0001（精确值为0.00001579），所以实在没有
 
 如果使用非自增主键（如果身份证号或学号等），由于每次插入主键的值近似于随机，因此每次新纪录都要被插到现有索引页得中间某个位置：
 
-![](http://blog.codinglabs.org/uploads/pictures/theory-of-mysql-index/14.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/14.png)
 
 图14
 
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\2236\357\274\232\346\265\205\350\260\210MySQL\347\232\204\344\270\255\344\272\213\345\212\241\344\270\216\351\224\201.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\346\265\205\350\260\210MySQL\347\232\204\344\270\255\344\272\213\345\212\241\344\270\216\351\224\201.md"
similarity index 87%
rename from "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\2236\357\274\232\346\265\205\350\260\210MySQL\347\232\204\344\270\255\344\272\213\345\212\241\344\270\216\351\224\201.md"
rename to "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\346\265\205\350\260\210MySQL\347\232\204\344\270\255\344\272\213\345\212\241\344\270\216\351\224\201.md"
index 94eee23..de4de11 100644
--- "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\2236\357\274\232\346\265\205\350\260\210MySQL\347\232\204\344\270\255\344\272\213\345\212\241\344\270\216\351\224\201.md"
+++ "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\346\265\205\350\260\210MySQL\347\232\204\344\270\255\344\272\213\345\212\241\344\270\216\351\224\201.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [『浅入深出』MySQL 中事务的实现](#『浅入深出』mysql-中事务的实现)
     * [原子性](#原子性)
     * [回滚日志](#回滚日志)
@@ -55,10 +54,6 @@
 
 <!-- more -->
 
-<!-- more -->
-
-
-
 ## 『浅入深出』MySQL 中事务的实现
 
 在关系型数据库中，事务的重要性不言而喻，只要对数据库稍有了解的人都知道事务具有 ACID 四个基本属性，而我们不知道的可能就是数据库是如何实现这四个属性的；在这篇文章中，我们将对事务的实现进行分析，尝试理解数据库是如何实现事务的，当然我们也会在文章中简单对 MySQL 中对 ACID 的实现进行简单的介绍。
@@ -79,9 +74,9 @@
 
 这个过程其实非常好理解，为了能够在发生错误时撤销之前的全部操作，肯定是需要将之前的操作都记录下来的，这样在发生错误时才可以回滚。
 
-回滚日志除了能够在发生错误或者用户执行 ROLLBACK 时提供回滚相关的信息，它还能够在整个系统发生崩溃、数据库进程直接被杀死后，当用户再次启动数据库进程时，还能够立刻通过查询回滚日志将之前未完成的事务进行回滚，这也就需要回滚日志必须先于数据持久化到磁盘上，是我们需要先写日志后写数据库的主要原因。
+回滚日志除了能够在发生错误或者用户执行ROLLBACK时提供回滚相关的信息，它还能够在整个系统发生崩溃、数据库进程直接被杀死后，当用户再次启动数据库进程时，还能够立刻通过查询回滚日志将之前未完成的事务进行回滚，这也就需要回滚日志必须先于数据持久化到磁盘上，是我们需要先写日志后写数据库的主要原因。
 
-回滚日志并不能将数据库物理地恢复到执行语句或者事务之前的样子；它是逻辑日志，当回滚日志被使用时，它只会按照日志逻辑地将数据库中的修改撤销掉看，可以理解为，我们在事务中使用的每一条 INSERT 都对应了一条 DELETE，每一条 UPDATE 也都对应一条相反的 UPDATE 语句。
+回滚日志并不能将数据库物理地恢复到执行语句或者事务之前的样子；它是逻辑日志，当回滚日志被使用时，它只会按照日志逻辑地将数据库中的修改撤销掉看，可以理解为，我们在事务中使用的每一条INSERT都对应了一条DELETE，每一条UPDATE也都对应一条相反的UPDATE语句。
 
 在这里，我们并不会介绍回滚日志的格式以及它是如何被管理的，本文重点关注在它到底是一个什么样的东西，究竟解决了、如何解决了什么样的问题，如果想要了解具体实现细节的读者，相信网络上关于回滚日志的文章一定不少。
 
@@ -91,7 +86,7 @@
 
 但是如果放大来看，我们会发现事务不再是原子的，其中包括了很多中间状态，比如部分提交，事务的状态图也变得越来越复杂。
 
-> 事务的状态图以及状态的描述取自 [Database System Concepts](https://www.amazon.com/Database-System-Concepts-Computer-Science/dp/0073523321 "按住 Ctrl 点击访问 https://www.amazon.com/Database-System-Concepts-Computer-Science/dp/0073523321") 一书中第 14 章的内容。
+> 事务的状态图以及状态的描述取自[Database System Concepts](https://www.amazon.com/Database-System-Concepts-Computer-Science/dp/0073523321 "按住 Ctrl 点击访问 https://www.amazon.com/Database-System-Concepts-Computer-Science/dp/0073523321")一书中第 14 章的内容。
 
 *   Active：事务的初始状态，表示事务正在执行；
 
@@ -111,7 +106,7 @@
 
 到目前为止，所有的事务都只是串行执行的，一直都没有考虑过并行执行的问题；然而在实际工作中，并行执行的事务才是常态，然而并行任务下，却可能出现非常复杂的问题：
 
-当 Transaction1 在执行的过程中对 id = 1 的用户进行了读写，但是没有将修改的内容进行提交或者回滚，在这时 Transaction2 对同样的数据进行了读操作并提交了事务；也就是说 Transaction2 是依赖于 Transaction1 的，当 Transaction1 由于一些错误需要回滚时，因为要保证事务的原子性，需要对 Transaction2 进行回滚，但是由于我们已经提交了 Transaction2，所以我们已经没有办法进行回滚操作，在这种问题下我们就发生了问题，[Database System Concepts](https://www.amazon.com/Database-System-Concepts-Computer-Science/dp/0073523321 "按住 Ctrl 点击访问 https://www.amazon.com/Database-System-Concepts-Computer-Science/dp/0073523321") 一书中将这种现象称为不可恢复安排（Nonrecoverable Schedule），那什么情况下是可以恢复的呢？
+当 Transaction1 在执行的过程中对id = 1的用户进行了读写，但是没有将修改的内容进行提交或者回滚，在这时 Transaction2 对同样的数据进行了读操作并提交了事务；也就是说 Transaction2 是依赖于 Transaction1 的，当 Transaction1 由于一些错误需要回滚时，因为要保证事务的原子性，需要对 Transaction2 进行回滚，但是由于我们已经提交了 Transaction2，所以我们已经没有办法进行回滚操作，在这种问题下我们就发生了问题，[Database System Concepts](https://www.amazon.com/Database-System-Concepts-Computer-Science/dp/0073523321 "按住 Ctrl 点击访问 https://www.amazon.com/Database-System-Concepts-Computer-Science/dp/0073523321")一书中将这种现象称为不可恢复安排（Nonrecoverable Schedule），那什么情况下是可以恢复的呢？
 
 > A recoverable schedule is one where, for each pair of transactions Ti and Tj such that Tj reads a data item previously written by Ti , the commit operation of Ti appears before the commit operation of Tj .
 
@@ -151,15 +146,15 @@
 
 ### 隔离性
 
-其实作者在之前的文章 [『浅入浅出』MySQL 和 InnoDB](http://draveness.me/mysql-innodb.html "按住 Ctrl 点击访问 http://draveness.me/mysql-innodb.html") 就已经介绍过数据库事务的隔离性，不过为了保证文章的独立性和完整性，我们还会对事务的隔离性进行介绍，介绍的内容可能稍微有所不同。
+其实作者在之前的文章[『浅入浅出』MySQL 和 InnoDB](http://draveness.me/mysql-innodb.html "按住 Ctrl 点击访问 http://draveness.me/mysql-innodb.html")就已经介绍过数据库事务的隔离性，不过为了保证文章的独立性和完整性，我们还会对事务的隔离性进行介绍，介绍的内容可能稍微有所不同。
 
-事务的隔离性是数据库处理数据的几大基础之一，如果没有数据库的事务之间没有隔离性，就会发生在 [并行事务的原子性](https://draveness.me/mysql-transaction#%E5%B9%B6%E8%A1%8C%E4%BA%8B%E5%8A%A1%E7%9A%84%E5%8E%9F%E5%AD%90%E6%80%A7 "按住 Ctrl 点击访问 https://draveness.me/mysql-transaction#%E5%B9%B6%E8%A1%8C%E4%BA%8B%E5%8A%A1%E7%9A%84%E5%8E%9F%E5%AD%90%E6%80%A7") 一节中提到的级联回滚等问题，造成性能上的巨大损失。如果所有的事务的执行顺序都是线性的，那么对于事务的管理容易得多，但是允许事务的并行执行却能能够提升吞吐量和资源利用率，并且可以减少每个事务的等待时间。
+事务的隔离性是数据库处理数据的几大基础之一，如果没有数据库的事务之间没有隔离性，就会发生在[并行事务的原子性](https://draveness.me/mysql-transaction#%E5%B9%B6%E8%A1%8C%E4%BA%8B%E5%8A%A1%E7%9A%84%E5%8E%9F%E5%AD%90%E6%80%A7 "按住 Ctrl 点击访问 https://draveness.me/mysql-transaction#%E5%B9%B6%E8%A1%8C%E4%BA%8B%E5%8A%A1%E7%9A%84%E5%8E%9F%E5%AD%90%E6%80%A7")一节中提到的级联回滚等问题，造成性能上的巨大损失。如果所有的事务的执行顺序都是线性的，那么对于事务的管理容易得多，但是允许事务的并行执行却能能够提升吞吐量和资源利用率，并且可以减少每个事务的等待时间。
 
 当多个事务同时并发执行时，事务的隔离性可能就会被违反，虽然单个事务的执行可能没有任何错误，但是从总体来看就会造成数据库的一致性出现问题，而串行虽然能够允许开发者忽略并行造成的影响，能够很好地维护数据库的一致性，但是却会影响事务执行的性能。
 
 ### 事务的隔离级别
 
-所以说数据库的隔离性和一致性其实是一个需要开发者去权衡的问题，为数据库提供什么样的隔离性层级也就决定了数据库的性能以及可以达到什么样的一致性；在 SQL 标准中定义了四种数据库的事务的隔离级别：READ UNCOMMITED、READ COMMITED、REPEATABLE READ 和 SERIALIZABLE；每个事务的隔离级别其实都比上一级多解决了一个问题：
+所以说数据库的隔离性和一致性其实是一个需要开发者去权衡的问题，为数据库提供什么样的隔离性层级也就决定了数据库的性能以及可以达到什么样的一致性；在 SQL 标准中定义了四种数据库的事务的隔离级别：READ UNCOMMITED、READ COMMITED、REPEATABLE READ和SERIALIZABLE；每个事务的隔离级别其实都比上一级多解决了一个问题：
 
 *   RAED UNCOMMITED：使用查询语句不会加锁，可能会读到未提交的行（Dirty Read）；
 
@@ -173,7 +168,7 @@
 
 对于数据库的使用者，从理论上说，并不需要知道事务的隔离级别是如何实现的，我们只需要知道这个隔离级别解决了什么样的问题，但是不同数据库对于不同隔离级别的是实现细节在很多时候都会让我们遇到意料之外的坑。
 
-如果读者不了解脏读、不可重复读和幻读究竟是什么，可以阅读之前的文章 [『浅入浅出』MySQL 和 InnoDB](http://draveness.me/mysql-innodb.html "按住 Ctrl 点击访问 http://draveness.me/mysql-innodb.html")，在这里我们仅放一张图来展示各个隔离层级对这几个问题的解决情况。
+如果读者不了解脏读、不可重复读和幻读究竟是什么，可以阅读之前的文章[『浅入浅出』MySQL 和 InnoDB](http://draveness.me/mysql-innodb.html "按住 Ctrl 点击访问 http://draveness.me/mysql-innodb.html")，在这里我们仅放一张图来展示各个隔离层级对这几个问题的解决情况。
 
 ### 隔离级别的实现
 
@@ -199,7 +194,7 @@
 
 在这里就需要简单提一下在在原子性一节中遇到的级联回滚等问题了，如果一个事务对数据进行了写入，这时就会获取一个互斥锁，其他的事务就想要获得改行数据的读锁就必须等待写锁的释放，自然就不会发生级联回滚等问题了。
 
-不过在大多数的数据库，比如 MySQL 中都使用了 MVCC 等特性，也就是正常的读方法是不需要获取锁的，在想要对读取的数据进行更新时需要使用 SELECT ... FOR UPDATE 尝试获取对应行的互斥锁，以保证不同事务可以正常工作。
+不过在大多数的数据库，比如 MySQL 中都使用了 MVCC 等特性，也就是正常的读方法是不需要获取锁的，在想要对读取的数据进行更新时需要使用SELECT ... FOR UPDATE尝试获取对应行的互斥锁，以保证不同事务可以正常工作。
 
 ### 一致性
 
@@ -217,7 +212,7 @@
 
 而第二层意思其实是指逻辑上的对于开发者的要求，我们要在代码中写出正确的事务逻辑，比如银行转账，事务中的逻辑不可能只扣钱或者只加钱，这是应用层面上对于数据库一致性的要求。
 
-> Ensuring consistency for an individual transaction is the responsibility of the application programmer who codes the transaction. - [Database System Concepts](https://www.amazon.com/Database-System-Concepts-Computer-Science/dp/0073523321 "按住 Ctrl 点击访问 https://www.amazon.com/Database-System-Concepts-Computer-Science/dp/0073523321")
+> Ensuring consistency for an individual transaction is the responsibility of the application programmer who codes the transaction. -[Database System Concepts](https://www.amazon.com/Database-System-Concepts-Computer-Science/dp/0073523321 "按住 Ctrl 点击访问 https://www.amazon.com/Database-System-Concepts-Computer-Science/dp/0073523321")
 
 数据库 ACID 中的一致性对事务的要求不止包含对数据完整性以及合法性的检查，还包含应用层面逻辑的正确。
 
@@ -299,7 +294,7 @@ CAP 定理中的数据一致性，其实是说分布式系统中的各个节点
 
 在上一节中我们其实提到死锁的检测可以通过一个有向的等待图来进行判断，如果一个事务依赖于另一个事务正在处理的数据，那么当前事务就会等待另一个事务的结束，这也就是整个等待图中的一条边：
 
-如上图所示，如果在这个有向图中出现了环，就说明当前数据库进入了死锁的状态 TransB -> TransE -> TransF -> TransD -> TransB，在这时就需要死锁恢复机制接入了。
+如上图所示，如果在这个有向图中出现了环，就说明当前数据库进入了死锁的状态TransB -> TransE -> TransF -> TransD -> TransB，在这时就需要死锁恢复机制接入了。
 
 如何从死锁中恢复其实非常简单，最常见的解决办法就是选择整个环中一个事务进行回滚，以打破整个等待图中的环，在整个恢复的过程中有三个事情需要考虑：
 
@@ -351,7 +346,7 @@ CAP 定理中的数据一致性，其实是说分布式系统中的各个节点
 
 到目前为止我们介绍的并发控制机制其实都是通过延迟或者终止相应的事务来解决事务之间的竞争条件（Race condition）来保证事务的可串行化；虽然前面的两种并发控制机制确实能够从根本上解决并发事务的可串行化的问题，但是在实际环境中数据库的事务大都是只读的，读请求是写请求的很多倍，如果写请求和读请求之前没有并发控制机制，那么最坏的情况也是读请求读到了已经写入的数据，这对很多应用完全是可以接受的。
 
-在这种大前提下，数据库系统引入了另一种并发控制机制 - 多版本并发控制（Multiversion Concurrency Control），每一个写操作都会创建一个新版本的数据，读操作会从有限多个版本的数据中挑选一个最合适的结果直接返回；在这时，读写操作之间的冲突就不再需要被关注，而管理和快速挑选数据的版本就成了 MVCC 需要解决的主要问题。
+在这种大前提下，数据库系统引入了另一种并发控制机制 -多版本并发控制（Multiversion Concurrency Control），每一个写操作都会创建一个新版本的数据，读操作会从有限多个版本的数据中挑选一个最合适的结果直接返回；在这时，读写操作之间的冲突就不再需要被关注，而管理和快速挑选数据的版本就成了 MVCC 需要解决的主要问题。
 
 MVCC 并不是一个与乐观和悲观并发控制对立的东西，它能够与两者很好的结合以增加事务的并发量，在目前最流行的 SQL 数据库 MySQL 和 PostgreSQL 中都对 MVCC 进行了实现；但是由于它们分别实现了悲观锁和乐观锁，所以 MVCC 实现的方式也不同。
 
@@ -359,7 +354,7 @@ MVCC 并不是一个与乐观和悲观并发控制对立的东西，它能够与
 
 MySQL 中实现的多版本两阶段锁协议（Multiversion 2PL）将 MVCC 和 2PL 的优点结合了起来，每一个版本的数据行都具有一个唯一的时间戳，当有读事务请求时，数据库程序会直接从多个版本的数据项中具有最大时间戳的返回。
 
-更新操作就稍微有些复杂了，事务会先读取最新版本的数据计算出数据更新后的结果，然后创建一个新版本的数据，新数据的时间戳是目前数据行的最大版本 ＋1：
+更新操作就稍微有些复杂了，事务会先读取最新版本的数据计算出数据更新后的结果，然后创建一个新版本的数据，新数据的时间戳是目前数据行的最大版本＋1：
 
 数据版本的删除也是根据时间戳来选择的，MySQL 会将版本最低的数据定时从数据库中清除以保证不会出现大量的遗留内容。
 
@@ -395,21 +390,21 @@ MVCC是通过保存数据在某个时间点的快照来实现的. 不同存储
 
 2.MVCC 具体实现分析
 
-下面,我们通过InnoDB的MVCC实现来分析MVCC使怎样进行并发控制的.  InnoDB的MVCC,是通过在每行记录后面保存两个隐藏的列来实现的,这两个列，分别保存了这个行的创建时间，一个保存的是行的删除时间。这里存储的并不是实际的时间值,而是系统版本号(可以理解为事务的ID)，没开始一个新的事务，系统版本号就会自动递增，事务开始时刻的系统版本号会作为事务的ID.下面看一下在REPEATABLE READ隔离级别下,MVCC具体是如何操作的.
+下面,我们通过InnoDB的MVCC实现来分析MVCC使怎样进行并发控制的. InnoDB的MVCC,是通过在每行记录后面保存两个隐藏的列来实现的,这两个列，分别保存了这个行的创建时间，一个保存的是行的删除时间。这里存储的并不是实际的时间值,而是系统版本号(可以理解为事务的ID)，没开始一个新的事务，系统版本号就会自动递增，事务开始时刻的系统版本号会作为事务的ID.下面看一下在REPEATABLE READ隔离级别下,MVCC具体是如何操作的.
 
 2.1简单的小例子
 
-create table yang(  id int primary key auto_increment,  name varchar(20));
+create table yang( id int primary key auto_increment, name varchar(20));
 
 > 假设系统的版本号从1开始.
 
 INSERT
 
-InnoDB为新插入的每一行保存当前系统版本号作为版本号.  第一个事务ID为1；
+InnoDB为新插入的每一行保存当前系统版本号作为版本号. 第一个事务ID为1；
+
+start transaction; insert into yang values(NULL,'yang')  ; insert into yang values(NULL,'long'); insert into yang values(NULL,'fei'); commit;
 
-<pre>start transaction; insert into yang values(NULL,'yang')  ; insert into yang values(NULL,'long'); insert into yang values(NULL,'fei'); commit;
 
-</pre>
 
 
 对应在数据中的表如下(后面两列是隐藏列,我们通过查询语句并看不到)
@@ -422,25 +417,19 @@ InnoDB为新插入的每一行保存当前系统版本号作为版本号.  第
 
 SELECT
 
-InnoDB会根据以下两个条件检查每行记录:  a.InnoDB只会查找版本早于当前事务版本的数据行(也就是,行的系统版本号小于或等于事务的系统版本号)，这样可以确保事务读取的行，要么是在事务开始前已经存在的，要么是事务自身插入或者修改过的.  b.行的删除版本要么未定义,要么大于当前事务版本号,这可以确保事务读取到的行，在事务开始之前未被删除.  只有a,b同时满足的记录，才能返回作为查询结果.
+InnoDB会根据以下两个条件检查每行记录: a.InnoDB只会查找版本早于当前事务版本的数据行(也就是,行的系统版本号小于或等于事务的系统版本号)，这样可以确保事务读取的行，要么是在事务开始前已经存在的，要么是事务自身插入或者修改过的. b.行的删除版本要么未定义,要么大于当前事务版本号,这可以确保事务读取到的行，在事务开始之前未被删除. 只有a,b同时满足的记录，才能返回作为查询结果.
 
 DELETE
 
-InnoDB会为删除的每一行保存当前系统的版本号(事务的ID)作为删除标识.  看下面的具体例子分析:  第二个事务,ID为2;
-
-<pre>start transaction; select *  from yang;  //(1) select *  from yang;  //(2) commit;  
-
-</pre>
+InnoDB会为删除的每一行保存当前系统的版本号(事务的ID)作为删除标识. 看下面的具体例子分析: 第二个事务,ID为2;
 
+start transaction; select *  from yang;  //(1) select *  from yang;  //(2) commit;
 
 假设1
 
-假设在执行这个事务ID为2的过程中,刚执行到(1),这时,有另一个事务ID为3往这个表里插入了一条数据;  第三个事务ID为3;
-
-<pre>start transaction; insert into yang values(NULL,'tian'); commit;
-
-</pre>
+假设在执行这个事务ID为2的过程中,刚执行到(1),这时,有另一个事务ID为3往这个表里插入了一条数据; 第三个事务ID为3;
 
+start transaction; insert into yang values(NULL,'tian'); commit;
 
 这时表中的数据如下:
 
@@ -461,11 +450,11 @@ InnoDB会为删除的每一行保存当前系统的版本号(事务的ID)作为
 
 假设2
 
-假设在执行这个事务ID为2的过程中,刚执行到(1),假设事务执行完事务3后，接着又执行了事务4;  第四个事务:
-
-<pre>start   transaction;  delete  from yang where id=1; commit;  
+假设在执行这个事务ID为2的过程中,刚执行到(1),假设事务执行完事务3后，接着又执行了事务4; 第四个事务:
+````
+start   transaction;  delete  from yang where id=1; commit;  
+````
 
-</pre>
 
 
 此时数据库中的表如下:
@@ -491,11 +480,11 @@ InnoDB执行UPDATE，实际上是新插入了一行记录，并保存其创建
 
 假设3
 
-假设在执行完事务2的(1)后又执行,其它用户执行了事务3,4,这时，又有一个用户对这张表执行了UPDATE操作:  第5个事务:
+假设在执行完事务2的(1)后又执行,其它用户执行了事务3,4,这时，又有一个用户对这张表执行了UPDATE操作: 第5个事务:
+
+start  transaction; update yang set name='Long' where id=2; commit;
 
-<pre>start  transaction; update yang set name='Long' where id=2; commit;
 
-</pre>
 
 
 根据update的更新原则:会生成新的一行,并在原来要修改的列的删除时间列上添加本事务ID,得到表如下:
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2237\357\274\232\350\257\246\350\247\243MyIsam\344\270\216InnoDB\345\274\225\346\223\216\347\232\204\351\224\201\345\256\236\347\216\260.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\350\257\246\350\247\243MyIsam\344\270\216InnoDB\345\274\225\346\223\216\347\232\204\351\224\201\345\256\236\347\216\260.md"
similarity index 59%
rename from "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2237\357\274\232\350\257\246\350\247\243MyIsam\344\270\216InnoDB\345\274\225\346\223\216\347\232\204\351\224\201\345\256\236\347\216\260.md"
rename to "docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\350\257\246\350\247\243MyIsam\344\270\216InnoDB\345\274\225\346\223\216\347\232\204\351\224\201\345\256\236\347\216\260.md"
index a562c57..3b3fb32 100644
--- "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2237\357\274\232\350\257\246\350\247\243MyIsam\344\270\216InnoDB\345\274\225\346\223\216\347\232\204\351\224\201\345\256\236\347\216\260.md"
+++ "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240MySQL\346\225\260\346\215\256\345\272\223\357\274\232\350\257\246\350\247\243MyIsam\344\270\216InnoDB\345\274\225\346\223\216\347\232\204\351\224\201\345\256\236\347\216\260.md"
@@ -1,6 +1,6 @@
-# Table of Contents
+# 目录
 
-  * [三类常见引擎：](#三类常见引擎：)
+* [三类常见引擎：](#三类常见引擎：)
     * [如何选择存储引擎：](#如何选择存储引擎：)
     * [Mysql中的锁](#mysql中的锁)
     * [MyISAM的锁机制：](#myisam的锁机制：)
@@ -16,11 +16,13 @@
 本文转自互联网
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本也将整理到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -32,21 +34,19 @@
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
 <!-- more -->
-
-<!-- more -->
-
+`
 
 说到锁机制之前，先来看看Mysql的存储引擎，毕竟不同的引擎的锁机制也随着不同。
 
 ## 三类常见引擎：
 
-MyIsam ：不支持事务，不支持外键，所以访问速度快。锁机制是表锁，支持全文索引
+MyIsam：不支持事务，不支持外键，所以访问速度快。锁机制是表锁，支持全文索引
 
-InnoDB ：支持事务、支持外键，所以对比MyISAM，InnoDB的处理效率差一些，并要占更多的磁盘空间保留数据和索引。锁机制是行锁，不支持全文索引
+InnoDB：支持事务、支持外键，所以对比MyISAM，InnoDB的处理效率差一些，并要占更多的磁盘空间保留数据和索引。锁机制是行锁，不支持全文索引
 
 Memory：数据是存放在内存中的，默认哈希索引，非常适合存储临时数据，服务器关闭后，数据会丢失掉。
 
-  
+
 
 
 
@@ -80,7 +80,7 @@ Mysql中的锁分为表锁和行锁：
 
 写锁是：当某一进程对某种表某张表的写时（insert，update，，delete），其他线程不能写也不能读。可以理解为，我写的时候，你不能读，也不能写。
 
-因此MyISAM的读操作和写操作，以及写操作之间是串行的！MyISAM在执行读写操作的时候会自动给表加相应的锁（也就是说不用显示的使用lock table命令），MyISAM总是一次获得SQL语句所需要的全部锁，这也是MyISAM不会出现死锁的原因。
+因此MyISAM的读操作和写操作，以及写操作之间是串行的！MyISAM在执行读写操作的时候会自动给表加相应的锁（也就是说不用显示的使用locktable命令），MyISAM总是一次获得SQL语句所需要的全部锁，这也是MyISAM不会出现死锁的原因。
 
 下面分别举关于写锁和读锁的例子：
 
@@ -88,12 +88,12 @@ Mysql中的锁分为表锁和行锁：
 
 
 
-| 事务1 | 事务2 |
-| --- | --- |
-| 取得first_test表的写锁：mysql> lock table first_test write;Query OK, 0 rows affected (0.00 sec) |  |
-| 当前事务对查询、更新和插入操作都可以执行mysql> select * from first_test ;+----+------+| id  | age   |+----+------+|  1   |   10  ||  2   |   11  ||  3   |   12  ||  4   |   13  |+----+------+4 rows in set (0.00 sec)mysql> insert into first_test(age) values(14);Query OK, 1 row affected (0.11 sec) | 其他事务对锁定表的查询被阻塞，需要等到锁被释放，才可以执行mysql> select * from first_test;等待...... |
-| mysql> unlock table;Query OK, 0 rows affected (0.00 sec) | 等待 |
-|   | mysql> select * from first_test;+----+------+| id  | age  |+----+------+|  1  |   10  ||  2  |    11 ||  3  |    12 ||  4  |    13 ||  5  |    14 |+----+------+5 rows in set (9 min 45.02 sec) |
+| 事务1                                                        | 事务2                                     |
+| ------------------------------------------------------------ | ----------------------------------------- |
+| 取得first_test表的写锁：mysql>locktablefirst_testwrite;QueryOK,0rowsaffected(0.00sec) |                                           |
+| 当前事务对查询、更新和插入操作都可以执行mysql>select*fromfirst_test;+----+------+ | id                                        |
+| mysql>unlocktable;QueryOK,0rowsaffected(0.00sec)             | 等待                                      |
+|                                                              | mysql>select*fromfirst_test;+----+------+ |
 
 
 
@@ -101,13 +101,13 @@ Mysql中的锁分为表锁和行锁：
 
 
 
-| 事务1 | 事务2 |
-| --- | --- |
-| 获得表first_read的锁定mysql> lock table first_test read;Query OK, 0 rows affected (0.00 sec) |   |
-| 当前事务可以查询该表记录：mysql> select * from first_test;+----+------+| id   |  age |+----+------+|  1   |    10 ||  2   |    11 ||  3   |    12 ||  4   |    13 ||  5   |    14 |+----+------+5 rows in set (0.00 sec) | 其他事务也可以查到该表信息mysql> select * from first_test;+----+------+| id   |  age  |+----+------+|  1   |    10 ||  2   |    11 ||  3   |    12 ||  4   |    13 ||  5   |    14 |+----+------+5 rows in set (0.00 sec) |
-| 但是当前事务不能查询没有锁定的表：mysql> select * from goods;ERROR 1100 (HY000): Table 'goods' was not locked with LOCK TABLES | 其他事务可以查询或更新未锁定的表：mysql> select * from goods;+----+------------+------+| id   | name     | num |+----+------------+------+|  1  | firstGoods  |   11 ||  3 | ThirdGoods |   11 ||  4 | fourth            |   11 |+----+------------+------+10 rows in set (0.00 sec) |
-| 而且插入更新锁定的表都会报错：mysql> insert into first_test(age) values(15);ERROR 1099 (HY000): Table 'first_test' was locked with a READ lock and can't be updatedmysql> update first_test set age=100 where id =1;ERROR 1099 (HY000): Table 'first_test' was locked with a READ lock and can't be updated | 当更新被锁定的表时会等待：mysql> update first_test set age=100 where id =1;等待...... |
-| mysql> unlock table;Query OK, 0 rows affected (0.00 sec) | mysql> update first_test set age=100 where id =1;Query OK, 1 row affected (38.82 sec)Rows matched: 1  Changed: 1  Warnings: 0 |
+| 事务1                                                        | 事务2                                                        |
+| ------------------------------------------------------------ | ------------------------------------------------------------ |
+| 获得表first_read的锁定mysql>locktablefirst_testread;QueryOK,0rowsaffected(0.00sec) |                                                              |
+| 当前事务可以查询该表记录：mysql>select*fromfirst_test;+----+------+ | id                                                           |
+| 但是当前事务不能查询没有锁定的表：mysql>select*fromgoods;ERROR1100(HY000):Table'goods'wasnotlockedwithLOCKTABLES | 其他事务可以查询或更新未锁定的表：mysql>select*fromgoods;+----+------------+------+ |
+| 而且插入更新锁定的表都会报错：mysql>insertintofirst_test(age)values(15);ERROR1099(HY000):Table'first_test'waslockedwithaREADlockandcan'tbe updatedmysql>updatefirst_testsetage=100whereid=1;ERROR1099(HY000):Table'first_test'waslockedwithaREADlockandcan'tbe updated | 当更新被锁定的表时会等待：mysql>updatefirst_testsetage=100whereid=1;等待...... |
+| mysql>unlocktable;QueryOK,0rowsaffected(0.00sec)             | mysql>updatefirst_testsetage=100whereid=1;QueryOK,1rowaffected(38.82sec)Rowsmatched:1Changed:1Warnings:0 |
 
 
 
@@ -125,13 +125,13 @@ MyISAM中有一个系统变量concurrent_insert（默认为1），用以控制
 
 
 
-| 事务1    | 事务2 |
-| --- | --- |
-| mysql> lock table first_test read local;Query OK, 0 rows affected (0.00 sec)--加入local选项是说明，在表满足并发插入的前提下，允许在末尾插入数据 |   |
-| 当前进程不能进行插入和更新操作mysql> insert into first_test(age) values(15);ERROR 1099 (HY000): Table 'first_test' was locked with a READ lock and can't be updatedmysql> update first_test set age=200 where id =1;ERROR 1099 (HY000): Table 'first_test' was locked with a READ lock and can't be updated | 其他进程可以进行插入，但是更新会等待：mysql> insert into first_test(age) values(15);Query OK, 1 row affected (0.00 sec)mysql> update first_test set age=200 where id =2;等待..... |
-| 当前进程不能不能访问其他进程插入的数据mysql> select * from first_test;+----+------+| id | age  |+----+------+|  1 |  100 ||  2 |   11 ||  3 |   12 ||  4 |   13 ||  5 |   14 ||  6 |   14 |+----+------+6 rows in set (0.00 sec) |   |
-| 释放锁以后皆大欢喜mysql> unlock table;Query OK, 0 rows affected (0.00 sec) | 等待 |
-| 插入的和更新的都出来的：mysql> select * from first_test;+----+------+| id | age  |+----+------+|  1 |  100 ||  2 |  200 ||  3 |   12 ||  4 |   13 ||  5 |   14 ||  6 |   14 ||  7 |   15 |+----+------+7 rows in set (0.00 sec) | mysql> update first_test set age=200 where id =2;Query OK, 1 row affected (1 min 39.75 sec)Rows matched: 1  Changed: 1  Warnings: 0 |
+| 事务1                                                        | 事务2                                                        |
+| ------------------------------------------------------------ | ------------------------------------------------------------ |
+| mysql>locktablefirst_testreadlocal;QueryOK,0rowsaffected(0.00sec)--加入local选项是说明，在表满足并发插入的前提下，允许在末尾插入数据 |                                                              |
+| 当前进程不能进行插入和更新操作mysql>insertintofirst_test(age)values(15);ERROR1099(HY000):Table'first_test'waslockedwithaREADlockandcan'tbeupdatedmysql>updatefirst_testsetage=200whereid=1;ERROR1099(HY000):Table'first_test'waslockedwithaREADlockandcan'tbeupdated | 其他进程可以进行插入，但是更新会等待：mysql>insertintofirst_test(age)values(15);QueryOK,1rowaffected(0.00sec)mysql>updatefirst_testsetage=200whereid=2;等待..... |
+| 当前进程不能不能访问其他进程插入的数据mysql>select*fromfirst_test;+----+------+ | id                                                           |
+| 释放锁以后皆大欢喜mysql>unlocktable;QueryOK,0rowsaffected(0.00sec) | 等待                                                         |
+| 插入的和更新的都出来的：mysql>select*fromfirst_test;+----+------+ | id                                                           |
 
 
 
@@ -139,7 +139,7 @@ MyISAM中有一个系统变量concurrent_insert（默认为1），用以控制
 
 并发插入是解决对同一表中的查询和插入的锁争用。
 
-如果对有空洞的表进行并发插入会产生碎片，所以在空闲时可以利用optimize table命令回收因删除记录产生的空洞。
+如果对有空洞的表进行并发插入会产生碎片，所以在空闲时可以利用optimizetable命令回收因删除记录产生的空洞。
 
 ### 锁调度
 
@@ -153,7 +153,7 @@ MyISAM中有一个系统变量concurrent_insert（默认为1），用以控制
 
 2、指定启动参数low-priority-updates，使得MyISAM默认给读请求优先的权利。
 
-3、执行命令set low_priority_updates=1，使该连接发出的请求降低。
+3、执行命令setlow_priority_updates=1，使该连接发出的请求降低。
 
 4、指定max_write_lock_count设置一个合适的值，当写锁达到这个值后，暂时降低写请求的优先级，让读请求获取锁。
 
@@ -185,7 +185,7 @@ InnoDB实现了两种类型的行锁。
 
 InnoDB行锁模式兼容列表：
 
-![](https://img-blog.csdn.net/20150809115556064?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405210259.png)
 
 
 注意：
@@ -196,19 +196,21 @@ InnoDB行锁模式兼容列表：
 
 对于insert、update、delete，InnoDB会自动给涉及的数据加排他锁（X）；对于一般的Select语句，InnoDB不会加任何锁，事务可以通过以下语句给显示加共享锁或排他锁。
 
-共享锁：select * from table_name where .....lock in share mode
+共享锁：select*fromtable_namewhere.....lockinsharemode
 
-排他锁：select * from table_name where .....for update
+排他锁：select*fromtable_namewhere.....forupdate
 
 加入共享锁的例子：
 
-![](https://blog.csdn.net/u014307117/article/details/47374531)
 
-![](https://img-blog.csdn.net/20150809115652652)
 
-利用select ....for update加入排他锁
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405210309.png)
 
-![](https://blog.csdn.net/u014307117/article/details/47374531)![](https://img-blog.csdn.net/20150809115737527)
+利用select....forupdate加入排他锁
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405210359.png)
 
 ### 锁的实现方式：
 
@@ -218,19 +220,19 @@ InnoDB行锁是通过给索引项加锁实现的，如果没有索引，InnoDB
 
 行锁分为三种情形：
 
-Record lock ：对索引项加锁，即锁定一条记录。
+Recordlock：对索引项加锁，即锁定一条记录。
 
-Gap lock：对索引项之间的‘间隙’、对第一条记录前的间隙或最后一条记录后的间隙加锁，即锁定一个范围的记录，不包含记录本身
+Gaplock：对索引项之间的‘间隙’、对第一条记录前的间隙或最后一条记录后的间隙加锁，即锁定一个范围的记录，不包含记录本身
 
-Next-key Lock：锁定一个范围的记录并包含记录本身（上面两者的结合）。
+Next-keyLock：锁定一个范围的记录并包含记录本身（上面两者的结合）。
 
 注意：InnoDB默认级别是repeatable-read级别，所以下面说的都是在RR级别中的。
 
-  
 
-之前一直搞不懂Gap Lock和Next-key Lock的区别，直到在网上看到一句话豁然开朗，希望对各位有帮助。
 
-Next-Key Lock是行锁与间隙锁的组合，这样，当InnoDB扫描索引记录的时候，会首先对选中的索引记录加上行锁（Record Lock），再对索引记录两边的间隙加上间隙锁（Gap Lock）。如果一个间隙被事务T1加了锁，其它事务是不能在这个间隙插入记录的。
+之前一直搞不懂GapLock和Next-keyLock的区别，直到在网上看到一句话豁然开朗，希望对各位有帮助。
+
+Next-KeyLock是行锁与间隙锁的组合，这样，当InnoDB扫描索引记录的时候，会首先对选中的索引记录加上行锁（RecordLock），再对索引记录两边的间隙加上间隙锁（GapLock）。如果一个间隙被事务T1加了锁，其它事务是不能在这个间隙插入记录的。
 
 干巴巴的说没意思，我们来看看具体实例：
 
@@ -238,38 +240,38 @@ Next-Key Lock是行锁与间隙锁的组合，这样，当InnoDB扫描索引记
 
 +----+------+
 
-| id | age  |
+|id|age|
 
 +----+------+
 
-|  1 |    3 |
+|1|3|
 
-|  2 |    6 |
+|2|6|
 
-|  3 |    9 |
+|3|9|
 
 +----+------+
 
 表结构如下：
 
 CREATE TABLE `test` (
-  `id` int(11) NOT NULL AUTO_INCREMENT,
-  `age` int(11) DEFAULT NULL,
-  PRIMARY KEY (`id`),
-  KEY `keyname` (`age`)
+`id` int(11) NOT NULL AUTO_INCREMENT,
+`age` int(11) DEFAULT NULL,
+PRIMARY KEY (`id`),
+KEY `keyname` (`age`)
 ) ENGINE=InnoDB AUTO_INCREMENT=302 DEFAULT CHARSET=gbk ;
 
 这样我们age段的索引就分为
 
-(negative infinity, 3],
+(negativeinfinity,3],
 
 (3,6],
 
 (6,9],
 
-(9,positive infinity)；
+(9,positiveinfinity)；
+
 
-  
 
 
 
@@ -277,23 +279,23 @@ CREATE TABLE `test` (
 
 1、当事务A执行以下语句：
 
-mysql> select * from fenye where age=6for update ;
+mysql>select*fromfenyewhereage=6forupdate;
 
-不仅使用行锁锁住了相应的数据行，同时也在两边的区间，（5,6]和（6，9] 都加入了gap锁。
+不仅使用行锁锁住了相应的数据行，同时也在两边的区间，（5,6]和（6，9]都加入了gap锁。
 
 这样事务B就无法在这个两个区间insert进新数据,但是事务B可以在两个区间外的区间插入数据。
 
 2、当事务A执行
 
-select * from fenye where age=7 for update ;
+select*fromfenyewhereage=7 forupdate;
 
 那么就会给(6,9]这个区间加锁，别的事务无法在此区间插入或更新数据。
 
 3、如果查询的数据不再范围内，
 
-比如事务A执行 select * from fenye where age=100 for update ;
+比如事务A执行select*fromfenyewhereage=100forupdate;
 
-那么加锁区间就是(9,positive infinity)。
+那么加锁区间就是(9,positiveinfinity)。
 
 小结：
 
diff --git "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2233\357\274\232Mysql\345\255\230\345\202\250\345\274\225\346\223\216\344\270\216\346\225\260\346\215\256\345\255\230\345\202\250\345\216\237\347\220\206.md" "b/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2233\357\274\232Mysql\345\255\230\345\202\250\345\274\225\346\223\216\344\270\216\346\225\260\346\215\256\345\255\230\345\202\250\345\216\237\347\220\206.md"
deleted file mode 100644
index 683b5ca..0000000
--- "a/docs/database/\351\207\215\346\226\260\345\255\246\344\271\240Mysql\346\225\260\346\215\256\345\272\2233\357\274\232Mysql\345\255\230\345\202\250\345\274\225\346\223\216\344\270\216\346\225\260\346\215\256\345\255\230\345\202\250\345\216\237\347\220\206.md"
+++ /dev/null
@@ -1,450 +0,0 @@
-# Table of Contents
-
-  * [前言](#前言)
-  * [[](https://draveness.me/mysql-innodb#%E6%95%B0%E6%8D%AE%E5%BA%93%E7%9A%84%E5%AE%9A%E4%B9%89)数据库的定义](#[]httpsdravenessmemysql-innodbe695b0e68daee5ba93e79a84e5ae9ae4b989数据库的定义)
-    * [[](https://draveness.me/mysql-innodb#%E6%95%B0%E6%8D%AE%E5%BA%93%E5%92%8C%E5%AE%9E%E4%BE%8B)数据库和实例](#[]httpsdravenessmemysql-innodbe695b0e68daee5ba93e5928ce5ae9ee4be8b数据库和实例)
-    * [[](https://draveness.me/mysql-innodb#mysql-%E7%9A%84%E6%9E%B6%E6%9E%84)MySQL 的架构](#[]httpsdravenessmemysql-innodbmysql-e79a84e69eb6e69e84mysql-的架构)
-  * [[](https://draveness.me/mysql-innodb#%E6%95%B0%E6%8D%AE%E7%9A%84%E5%AD%98%E5%82%A8)数据的存储](#[]httpsdravenessmemysql-innodbe695b0e68daee79a84e5ad98e582a8数据的存储)
-    * [[](https://draveness.me/mysql-innodb#%E5%A6%82%E4%BD%95%E5%AD%98%E5%82%A8%E8%A1%A8)如何存储表](#[]httpsdravenessmemysql-innodbe5a682e4bd95e5ad98e582a8e8a1a8如何存储表)
-      * [[](https://draveness.me/mysql-innodb#frm-%E6%96%87%E4%BB%B6).frm 文件](#[]httpsdravenessmemysql-innodbfrm-e69687e4bbb6frm-文件)
-      * [[](https://draveness.me/mysql-innodb#ibd-%E6%96%87%E4%BB%B6).ibd 文件](#[]httpsdravenessmemysql-innodbibd-e69687e4bbb6ibd-文件)
-    * [[](https://draveness.me/mysql-innodb#%E5%A6%82%E4%BD%95%E5%AD%98%E5%82%A8%E8%AE%B0%E5%BD%95)如何存储记录](#[]httpsdravenessmemysql-innodbe5a682e4bd95e5ad98e582a8e8aeb0e5bd95如何存储记录)
-      * [[](https://draveness.me/mysql-innodb#%E8%A1%8C%E6%BA%A2%E5%87%BA%E6%95%B0%E6%8D%AE)行溢出数据](#[]httpsdravenessmemysql-innodbe8a18ce6baa2e587bae695b0e68dae行溢出数据)
-    * [[](https://draveness.me/mysql-innodb#%E6%95%B0%E6%8D%AE%E9%A1%B5%E7%BB%93%E6%9E%84)数据页结构](#[]httpsdravenessmemysql-innodbe695b0e68daee9a1b5e7bb93e69e84数据页结构)
-  * [[](https://draveness.me/mysql-innodb#%E7%B4%A2%E5%BC%95)索引](#[]httpsdravenessmemysql-innodbe7b4a2e5bc95索引)
-    * [[](https://draveness.me/mysql-innodb#%E7%B4%A2%E5%BC%95%E7%9A%84%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84)索引的数据结构](#[]httpsdravenessmemysql-innodbe7b4a2e5bc95e79a84e695b0e68daee7bb93e69e84索引的数据结构)
-    * [[](https://draveness.me/mysql-innodb#%E8%81%9A%E9%9B%86%E7%B4%A2%E5%BC%95%E5%92%8C%E8%BE%85%E5%8A%A9%E7%B4%A2%E5%BC%95)聚集索引和辅助索引](#[]httpsdravenessmemysql-innodbe8819ae99b86e7b4a2e5bc95e5928ce8be85e58aa9e7b4a2e5bc95聚集索引和辅助索引)
-      * [[](https://draveness.me/mysql-innodb#%E8%81%9A%E9%9B%86%E7%B4%A2%E5%BC%95)聚集索引](#[]httpsdravenessmemysql-innodbe8819ae99b86e7b4a2e5bc95聚集索引)
-      * [[](https://draveness.me/mysql-innodb#%E8%BE%85%E5%8A%A9%E7%B4%A2%E5%BC%95)辅助索引](#[]httpsdravenessmemysql-innodbe8be85e58aa9e7b4a2e5bc95辅助索引)
-    * [[](https://draveness.me/mysql-innodb#%E7%B4%A2%E5%BC%95%E7%9A%84%E8%AE%BE%E8%AE%A1)索引的设计](#[]httpsdravenessmemysql-innodbe7b4a2e5bc95e79a84e8aebee8aea1索引的设计)
-  * [[](https://draveness.me/mysql-innodb#%E9%94%81)锁](#[]httpsdravenessmemysql-innodbe99481锁)
-    * [[](https://draveness.me/mysql-innodb#%E5%B9%B6%E5%8F%91%E6%8E%A7%E5%88%B6%E6%9C%BA%E5%88%B6)并发控制机制](#[]httpsdravenessmemysql-innodbe5b9b6e58f91e68ea7e588b6e69cbae588b6并发控制机制)
-    * [[](https://draveness.me/mysql-innodb#%E9%94%81%E7%9A%84%E7%A7%8D%E7%B1%BB)锁的种类](#[]httpsdravenessmemysql-innodbe99481e79a84e7a78de7b1bb锁的种类)
-    * [[](https://draveness.me/mysql-innodb#%E9%94%81%E7%9A%84%E7%B2%92%E5%BA%A6)锁的粒度](#[]httpsdravenessmemysql-innodbe99481e79a84e7b292e5baa6锁的粒度)
-    * [[](https://draveness.me/mysql-innodb#%E9%94%81%E7%9A%84%E7%AE%97%E6%B3%95)锁的算法](#[]httpsdravenessmemysql-innodbe99481e79a84e7ae97e6b395锁的算法)
-      * [[](https://draveness.me/mysql-innodb#record-lock)Record Lock](#[]httpsdravenessmemysql-innodbrecord-lockrecord-lock)
-      * [[](https://draveness.me/mysql-innodb#gap-lock)Gap Lock](#[]httpsdravenessmemysql-innodbgap-lockgap-lock)
-      * [[](https://draveness.me/mysql-innodb#next-key-lock)Next-Key Lock](#[]httpsdravenessmemysql-innodbnext-key-locknext-key-lock)
-    * [[](https://draveness.me/mysql-innodb#%E6%AD%BB%E9%94%81%E7%9A%84%E5%8F%91%E7%94%9F)死锁的发生](#[]httpsdravenessmemysql-innodbe6adbbe99481e79a84e58f91e7949f死锁的发生)
-  * [[](https://draveness.me/mysql-innodb#%E4%BA%8B%E5%8A%A1%E4%B8%8E%E9%9A%94%E7%A6%BB%E7%BA%A7%E5%88%AB)事务与隔离级别](#[]httpsdravenessmemysql-innodbe4ba8be58aa1e4b88ee99a94e7a6bbe7baa7e588ab事务与隔离级别)
-    * [[](https://draveness.me/mysql-innodb#%E5%87%A0%E7%A7%8D%E9%9A%94%E7%A6%BB%E7%BA%A7%E5%88%AB)几种隔离级别](#[]httpsdravenessmemysql-innodbe587a0e7a78de99a94e7a6bbe7baa7e588ab几种隔离级别)
-    * [[](https://draveness.me/mysql-innodb#%E8%84%8F%E8%AF%BB)脏读](#[]httpsdravenessmemysql-innodbe8848fe8afbb脏读)
-    * [[](https://draveness.me/mysql-innodb#%E4%B8%8D%E5%8F%AF%E9%87%8D%E5%A4%8D%E8%AF%BB)不可重复读](#[]httpsdravenessmemysql-innodbe4b88de58fafe9878de5a48de8afbb不可重复读)
-    * [[](https://draveness.me/mysql-innodb#%E5%B9%BB%E8%AF%BB)幻读](#[]httpsdravenessmemysql-innodbe5b9bbe8afbb幻读)
-  * [[](https://draveness.me/mysql-innodb#%E6%80%BB%E7%BB%93)总结](#[]httpsdravenessmemysql-innodbe680bbe7bb93总结)
-  * [[](https://draveness.me/mysql-innodb#reference)Reference](#[]httpsdravenessmemysql-innodbreferencereference)
-
-
-本文转自互联网
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-本也将整理到我的个人博客：
-> www.how2playlife.com
-
-更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
-
-本文是《重新学习MySQL数据库》系列其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从入门到进阶，从sql基本的使用方法，从MySQL执行引擎再到索引、事务等知识，一步步地学习MySQL相关技术的实现原理，更好地了解如何基于这些知识来优化sql，减少SQL执行时间，通过执行计划对SQL性能进行分析，再到MySQL的主从复制、主备部署等内容，以便让你更完整地了解整个MySQL方面的技术体系，形成自己的知识框架。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-<!-- more -->
-## 前言
-
-作为一名开发人员，在日常的工作中会难以避免地接触到数据库，无论是基于文件的 sqlite 还是工程上使用非常广泛的 MySQL、PostgreSQL，但是一直以来也没有对数据库有一个非常清晰并且成体系的认知，所以最近两个月的时间看了几本数据库相关的书籍并且阅读了 MySQL 的官方文档，希望对各位了解数据库的、不了解数据库的有所帮助。
-
-![mysql](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/mysql.png)
-
-本文中对于数据库的介绍以及研究都是在 MySQL 上进行的，如果涉及到了其他数据库的内容或者实现会在文中单独指出。
-
-## [](https://draveness.me/mysql-innodb#%E6%95%B0%E6%8D%AE%E5%BA%93%E7%9A%84%E5%AE%9A%E4%B9%89)数据库的定义
-
-很多开发者在最开始时其实都对数据库有一个比较模糊的认识，觉得数据库就是一堆数据的集合，但是实际却比这复杂的多，数据库领域中有两个词非常容易混淆，也就是_数据库_和_实例_：
-
-*   数据库：物理操作文件系统或其他形式文件类型的集合；
-*   实例：MySQL 数据库由后台线程以及一个共享内存区组成；
-
-> 对于数据库和实例的定义都来自于 [MySQL 技术内幕：InnoDB 存储引擎](https://book.douban.com/subject/24708143/) 一书，想要了解 InnoDB 存储引擎的读者可以阅读这本书籍。
-
-### [](https://draveness.me/mysql-innodb#%E6%95%B0%E6%8D%AE%E5%BA%93%E5%92%8C%E5%AE%9E%E4%BE%8B)数据库和实例
-
-在 MySQL 中，实例和数据库往往都是一一对应的，而我们也无法直接操作数据库，而是要通过数据库实例来操作数据库文件，可以理解为数据库实例是数据库为上层提供的一个专门用于操作的接口。
-
-![Database - Instance](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Database%20-%20Instance.jpg)
-
-在 Unix 上，启动一个 MySQL 实例往往会产生两个进程，`mysqld` 就是真正的数据库服务守护进程，而 `mysqld_safe` 是一个用于检查和设置 `mysqld` 启动的控制程序，它负责监控 MySQL 进程的执行，当 `mysqld` 发生错误时，`mysqld_safe` 会对其状态进行检查并在合适的条件下重启。
-
-### [](https://draveness.me/mysql-innodb#mysql-%E7%9A%84%E6%9E%B6%E6%9E%84)MySQL 的架构
-
-MySQL 从第一个版本发布到现在已经有了 20 多年的历史，在这么多年的发展和演变中，整个应用的体系结构变得越来越复杂：
-
-![Logical-View-of-MySQL-Architecture](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Logical-View-of-MySQL-Architecture.jpg)
-
-最上层用于连接、线程处理的部分并不是 MySQL 『发明』的，很多服务都有类似的组成部分；第二层中包含了大多数 MySQL 的核心服务，包括了对 SQL 的解析、分析、优化和缓存等功能，存储过程、触发器和视图都是在这里实现的；而第三层就是 MySQL 中真正负责数据的存储和提取的存储引擎，例如：[InnoDB](https://en.wikipedia.org/wiki/InnoDB)、[MyISAM](https://en.wikipedia.org/wiki/MyISAM) 等，文中对存储引擎的介绍都是对 InnoDB 实现的分析。
-
-## [](https://draveness.me/mysql-innodb#%E6%95%B0%E6%8D%AE%E7%9A%84%E5%AD%98%E5%82%A8)数据的存储
-
-在整个数据库体系结构中，我们可以使用不同的存储引擎来存储数据，而绝大多数存储引擎都以二进制的形式存储数据；这一节会介绍 InnoDB 中对数据是如何存储的。
-
-在 InnoDB 存储引擎中，所有的数据都被**逻辑地**存放在表空间中，表空间（tablespace）是存储引擎中最高的存储逻辑单位，在表空间的下面又包括段（segment）、区（extent）、页（page）：
-
-![Tablespace-segment-extent-page-row](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Tablespace-segment-extent-page-row.jpg)
-
-同一个数据库实例的所有表空间都有相同的页大小；默认情况下，表空间中的页大小都为 16KB，当然也可以通过改变 `innodb_page_size` 选项对默认大小进行修改，需要注意的是不同的页大小最终也会导致区大小的不同：
-
-![Relation Between Page Size - Extent Size](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Relation%20Between%20Page%20Size%20-%20Extent%20Size.png)
-
-从图中可以看出，在 InnoDB 存储引擎中，一个区的大小最小为 1MB，页的数量最少为 64 个。
-
-### [](https://draveness.me/mysql-innodb#%E5%A6%82%E4%BD%95%E5%AD%98%E5%82%A8%E8%A1%A8)如何存储表
-
-MySQL 使用 InnoDB 存储表时，会将**表的定义**和**数据索引**等信息分开存储，其中前者存储在 `.frm` 文件中，后者存储在 `.ibd` 文件中，这一节就会对这两种不同的文件分别进行介绍。
-
-![frm-and-ibd-file](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/frm-and-ibd-file.jpg)
-
-#### [](https://draveness.me/mysql-innodb#frm-%E6%96%87%E4%BB%B6).frm 文件
-
-无论在 MySQL 中选择了哪个存储引擎，所有的 MySQL 表都会在硬盘上创建一个 `.frm` 文件用来描述表的格式或者说定义；`.frm` 文件的格式在不同的平台上都是相同的。
-
-```
-CREATE TABLE test_frm(
-    column1 CHAR(5),
-    column2 INTEGER
-);
-
-```
-
-当我们使用上面的代码创建表时，会在磁盘上的 `datadir` 文件夹中生成一个 `test_frm.frm` 的文件，这个文件中就包含了表结构相关的信息：
-
-![frm-file-hex](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/frm-file-hex.png)
-
-> MySQL 官方文档中的 [11.1 MySQL .frm File Format](https://dev.mysql.com/doc/internals/en/frm-file-format.html) 一文对于 `.frm` 文件格式中的二进制的内容有着非常详细的表述，在这里就不展开介绍了。
-
-#### [](https://draveness.me/mysql-innodb#ibd-%E6%96%87%E4%BB%B6).ibd 文件
-
-InnoDB 中用于存储数据的文件总共有两个部分，一是系统表空间文件，包括 `ibdata1`、`ibdata2` 等文件，其中存储了 InnoDB 系统信息和用户数据库表数据和索引，是所有表公用的。
-
-当打开 `innodb_file_per_table` 选项时，`.ibd` 文件就是每一个表独有的表空间，文件存储了当前表的数据和相关的索引数据。
-
-### [](https://draveness.me/mysql-innodb#%E5%A6%82%E4%BD%95%E5%AD%98%E5%82%A8%E8%AE%B0%E5%BD%95)如何存储记录
-
-与现有的大多数存储引擎一样，InnoDB 使用页作为磁盘管理的最小单位；数据在 InnoDB 存储引擎中都是按行存储的，每个 16KB 大小的页中可以存放 2-200 行的记录。
-
-当 InnoDB 存储数据时，它可以使用不同的行格式进行存储；MySQL 5.7 版本支持以下格式的行存储方式：
-
-![Antelope-Barracuda-Row-Format](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Antelope-Barracuda-Row-Format.jpg)
-
-> Antelope 是 InnoDB 最开始支持的文件格式，它包含两种行格式 Compact 和 Redundant，它最开始并没有名字；Antelope 的名字是在新的文件格式 Barracuda 出现后才起的，Barracuda 的出现引入了两种新的行格式 Compressed 和 Dynamic；InnoDB 对于文件格式都会向前兼容，而官方文档中也对之后会出现的新文件格式预先定义好了名字：Cheetah、Dragon、Elk 等等。
-
-两种行记录格式 Compact 和 Redundant 在磁盘上按照以下方式存储：
-
-![COMPACT-And-REDUNDANT-Row-Format](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/COMPACT-And-REDUNDANT-Row-Format.jpg)
-
-Compact 和 Redundant 格式最大的不同就是记录格式的第一个部分；在 Compact 中，行记录的第一部分倒序存放了一行数据中列的长度（Length），而 Redundant 中存的是每一列的偏移量（Offset），从总体上上看，Compact 行记录格式相比 Redundant 格式能够减少 20% 的存储空间。
-
-#### [](https://draveness.me/mysql-innodb#%E8%A1%8C%E6%BA%A2%E5%87%BA%E6%95%B0%E6%8D%AE)行溢出数据
-
-当 InnoDB 使用 Compact 或者 Redundant 格式存储极长的 VARCHAR 或者 BLOB 这类大对象时，我们并不会直接将所有的内容都存放在数据页节点中，而是将行数据中的前 768 个字节存储在数据页中，后面会通过偏移量指向溢出页。
-
-![Row-Overflo](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Row-Overflow.jpg)
-
-但是当我们使用新的行记录格式 Compressed 或者 Dynamic 时都只会在行记录中保存 20 个字节的指针，实际的数据都会存放在溢出页面中。
-
-![Row-Overflow-in-Barracuda](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Row-Overflow-in-Barracuda.jpg)
-
-当然在实际存储中，可能会对不同长度的 TEXT 和 BLOB 列进行优化，不过这就不是本文关注的重点了。
-
-> 想要了解更多与 InnoDB 存储引擎中记录的数据格式的相关信息，可以阅读 [InnoDB Record Structure](https://dev.mysql.com/doc/internals/en/innodb-record-structure.html)
-
-### [](https://draveness.me/mysql-innodb#%E6%95%B0%E6%8D%AE%E9%A1%B5%E7%BB%93%E6%9E%84)数据页结构
-
-页是 InnoDB 存储引擎管理数据的最小磁盘单位，而 B-Tree 节点就是实际存放表中数据的页面，我们在这里将要介绍页是如何组织和存储记录的；首先，一个 InnoDB 页有以下七个部分：
-
-![InnoDB-B-Tree-Node](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/InnoDB-B-Tree-Node.jpg)
-
-每一个页中包含了两对 header/trailer：内部的 Page Header/Page Directory 关心的是页的状态信息，而 Fil Header/Fil Trailer 关心的是记录页的头信息。
-
-在页的头部和尾部之间就是用户记录和空闲空间了，每一个数据页中都包含 Infimum 和 Supremum 这两个**虚拟**的记录（可以理解为占位符），Infimum 记录是比该页中任何主键值都要小的值，Supremum 是该页中的最大值：
-
-![Infimum-Rows-Supremum](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Infimum-Rows-Supremum.jpg)
-
-User Records 就是整个页面中真正用于存放行记录的部分，而 Free Space 就是空余空间了，它是一个链表的数据结构，为了保证插入和删除的效率，整个页面并不会按照主键顺序对所有记录进行排序，它会自动从左侧向右寻找空白节点进行插入，行记录在物理存储上并不是按照顺序的，它们之间的顺序是由 `next_record` 这一指针控制的。
-
-B+ 树在查找对应的记录时，并不会直接从树中找出对应的行记录，它只能获取记录所在的页，将整个页加载到内存中，再通过 Page Directory 中存储的稀疏索引和 `n_owned`、`next_record` 属性取出对应的记录，不过因为这一操作是在内存中进行的，所以通常会忽略这部分查找的耗时。
-
-InnoDB 存储引擎中对数据的存储是一个非常复杂的话题，这一节中也只是对表、行记录以及页面的存储进行一定的分析和介绍，虽然作者相信这部分知识对于大部分开发者已经足够了，但是想要真正消化这部分内容还需要很多的努力和实践。
-
-## [](https://draveness.me/mysql-innodb#%E7%B4%A2%E5%BC%95)索引
-
-索引是数据库中非常非常重要的概念，它是存储引擎能够快速定位记录的秘密武器，对于提升数据库的性能、减轻数据库服务器的负担有着非常重要的作用；**索引优化是对查询性能优化的最有效手段**，它能够轻松地将查询的性能提高几个数量级。
-
-### [](https://draveness.me/mysql-innodb#%E7%B4%A2%E5%BC%95%E7%9A%84%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84)索引的数据结构
-
-在上一节中，我们谈了行记录的存储和页的存储，在这里我们就要从更高的层面看 InnoDB 中对于数据是如何存储的；InnoDB 存储引擎在绝大多数情况下使用 B+ 树建立索引，这是关系型数据库中查找最为常用和有效的索引，但是 B+ 树索引并不能找到一个给定键对应的具体值，它只能找到数据行对应的页，然后正如上一节所提到的，数据库把整个页读入到内存中，并在内存中查找具体的数据行。
-
-![B+Tree](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/B+Tree.jpg)
-
-B+ 树是平衡树，它查找任意节点所耗费的时间都是完全相同的，比较的次数就是 B+ 树的高度；在这里，我们并不会深入分析或者动手实现一个 B+ 树，只是对它的特性进行简单的介绍。
-
-### [](https://draveness.me/mysql-innodb#%E8%81%9A%E9%9B%86%E7%B4%A2%E5%BC%95%E5%92%8C%E8%BE%85%E5%8A%A9%E7%B4%A2%E5%BC%95)聚集索引和辅助索引
-
-数据库中的 B+ 树索引可以分为聚集索引（clustered index）和辅助索引（secondary index），它们之间的最大区别就是，聚集索引中存放着一条行记录的全部信息，而辅助索引中只包含索引列和一个用于查找对应行记录的『书签』。
-
-#### [](https://draveness.me/mysql-innodb#%E8%81%9A%E9%9B%86%E7%B4%A2%E5%BC%95)聚集索引
-
-InnoDB 存储引擎中的表都是使用索引组织的，也就是按照键的顺序存放；聚集索引就是按照表中主键的顺序构建一颗 B+ 树，并在叶节点中存放表中的行记录数据。
-
-```
-CREATE TABLE users(
-    id INT NOT NULL,
-    first_name VARCHAR(20) NOT NULL,
-    last_name VARCHAR(20) NOT NULL,
-    age INT NOT NULL,
-    PRIMARY KEY(id),
-    KEY(last_name, first_name, age)
-    KEY(first_name)
-);
-
-```
-
-如果使用上面的 SQL 在数据库中创建一张表，B+ 树就会使用 `id` 作为索引的键，并在叶子节点中存储一条记录中的**所有**信息。
-
-![Clustered-Index](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Clustered-Index.jpg)
-
-> 图中对 B+ 树的描述与真实情况下 B+ 树中的数据结构有一些差别，不过这里想要表达的主要意思是：聚集索引叶节点中保存的是整条行记录，而不是其中的一部分。
-
-聚集索引与表的物理存储方式有着非常密切的关系，所有正常的表应该**有且仅有一个**聚集索引（绝大多数情况下都是主键），表中的所有行记录数据都是按照**聚集索引**的顺序存放的。
-
-当我们使用聚集索引对表中的数据进行检索时，可以直接获得聚集索引所对应的整条行记录数据所在的页，不需要进行第二次操作。
-
-#### [](https://draveness.me/mysql-innodb#%E8%BE%85%E5%8A%A9%E7%B4%A2%E5%BC%95)辅助索引
-
-数据库将所有的非聚集索引都划分为辅助索引，但是这个概念对我们理解辅助索引并没有什么帮助；辅助索引也是通过 B+ 树实现的，但是它的叶节点并不包含行记录的全部数据，仅包含索引中的所有键和一个用于查找对应行记录的『书签』，在 InnoDB 中这个书签就是当前记录的主键。
-
-辅助索引的存在并不会影响聚集索引，因为聚集索引构成的 B+ 树是数据实际存储的形式，而辅助索引只用于加速数据的查找，所以一张表上往往有多个辅助索引以此来提升数据库的性能。
-
-> 一张表一定包含一个聚集索引构成的 B+ 树以及若干辅助索引的构成的 B+ 树。
-
-![Secondary-Index](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Secondary-Index.jpg)
-
-如果在表 `users` 中存在一个辅助索引 `(first_name, age)`，那么它构成的 B+ 树大致就是上图这样，按照 `(first_name, age)` 的字母顺序对表中的数据进行排序，当查找到主键时，再通过聚集索引获取到整条行记录。
-
-![Clustered-Secondary-Index](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Clustered-Secondary-Index.jpg)
-
-上图展示了一个使用辅助索引查找一条表记录的过程：通过辅助索引查找到对应的主键，最后在聚集索引中使用主键获取对应的行记录，这也是通常情况下行记录的查找方式。
-
-### [](https://draveness.me/mysql-innodb#%E7%B4%A2%E5%BC%95%E7%9A%84%E8%AE%BE%E8%AE%A1)索引的设计
-
-索引的设计其实是一个非常重要的内容，同时也是一个非常复杂的内容；索引的设计与创建对于提升数据库的查询性能至关重要，不过这不是本文想要介绍的内容，有关索引的设计与优化可以阅读 [数据库索引设计与优化](https://draveness.me/%E6%95%B0%E6%8D%AE%E5%BA%93%E7%B4%A2%E5%BC%95%E8%AE%BE%E8%AE%A1%E4%B8%8E%E4%BC%98%E5%8C%96) 一书，书中提供了一种非常科学合理的方法能够帮助我们在数据库中建立最适合的索引，当然作者也可能会在之后的文章中对索引的设计进行简单的介绍和分析。
-
-## [](https://draveness.me/mysql-innodb#%E9%94%81)锁
-
-我们都知道锁的种类一般分为乐观锁和悲观锁两种，InnoDB 存储引擎中使用的就是悲观锁，而按照锁的粒度划分，也可以分成行锁和表锁。
-
-### [](https://draveness.me/mysql-innodb#%E5%B9%B6%E5%8F%91%E6%8E%A7%E5%88%B6%E6%9C%BA%E5%88%B6)并发控制机制
-
-乐观锁和悲观锁其实都是并发控制的机制，同时它们在原理上就有着本质的差别；
-
-*   乐观锁是一种思想，它其实并不是一种真正的『锁』，它会先尝试对资源进行修改，在写回时判断资源是否进行了改变，如果没有发生改变就会写回，否则就会进行重试，在整个的执行过程中其实都**没有对数据库进行加锁**；
-*   悲观锁就是一种真正的锁了，它会在获取资源前对资源进行加锁，确保同一时刻只有有限的线程能够访问该资源，其他想要尝试获取资源的操作都会进入等待状态，直到该线程完成了对资源的操作并且释放了锁后，其他线程才能重新操作资源；
-
-虽然乐观锁和悲观锁在本质上并不是同一种东西，一个是一种思想，另一个是一种真正的锁，但是它们都是一种并发控制机制。
-
-![Optimistic-Pessimistic-Locks](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Optimistic-Pessimistic-Locks.jpg)
-
-乐观锁不会存在死锁的问题，但是由于更新后验证，所以当**冲突频率**和**重试成本**较高时更推荐使用悲观锁，而需要非常高的**响应速度**并且**并发量**非常大的时候使用乐观锁就能较好的解决问题，在这时使用悲观锁就可能出现严重的性能问题；在选择并发控制机制时，需要综合考虑上面的四个方面（冲突频率、重试成本、响应速度和并发量）进行选择。
-
-### [](https://draveness.me/mysql-innodb#%E9%94%81%E7%9A%84%E7%A7%8D%E7%B1%BB)锁的种类
-
-对数据的操作其实只有两种，也就是读和写，而数据库在实现锁时，也会对这两种操作使用不同的锁；InnoDB 实现了标准的行级锁，也就是共享锁（Shared Lock）和互斥锁（Exclusive Lock）；共享锁和互斥锁的作用其实非常好理解：
-
-*   **共享锁（读锁）**：允许事务对一条行数据进行读取；
-*   **互斥锁（写锁）**：允许事务对一条行数据进行删除或更新；
-
-而它们的名字也暗示着各自的另外一个特性，共享锁之间是兼容的，而互斥锁与其他任意锁都不兼容：
-
-![Shared-Exclusive-Lock](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Shared-Exclusive-Lock.jpg)
-
-稍微对它们的使用进行思考就能想明白它们为什么要这么设计，因为共享锁代表了读操作、互斥锁代表了写操作，所以我们可以在数据库中**并行读**，但是只能**串行写**，只有这样才能保证不会发生线程竞争，实现线程安全。
-
-### [](https://draveness.me/mysql-innodb#%E9%94%81%E7%9A%84%E7%B2%92%E5%BA%A6)锁的粒度
-
-无论是共享锁还是互斥锁其实都只是对某一个数据行进行加锁，InnoDB 支持多种粒度的锁，也就是行锁和表锁；为了支持多粒度锁定，InnoDB 存储引擎引入了意向锁（Intention Lock），意向锁就是一种表级锁。
-
-与上一节中提到的两种锁的种类相似的是，意向锁也分为两种：
-
-*   **意向共享锁**：事务想要在获得表中某些记录的共享锁，需要在表上先加意向共享锁；
-*   **意向互斥锁**：事务想要在获得表中某些记录的互斥锁，需要在表上先加意向互斥锁；
-
-随着意向锁的加入，锁类型之间的兼容矩阵也变得愈加复杂：
-
-![Lock-Type-Compatibility-Matrix](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Lock-Type-Compatibility-Matrix.jpg)
-
-意向锁其实不会阻塞全表扫描之外的任何请求，它们的主要目的是为了表示**是否有人请求锁定表中的某一行数据**。
-
-> 有的人可能会对意向锁的目的并不是完全的理解，我们在这里可以举一个例子：如果没有意向锁，当已经有人使用行锁对表中的某一行进行修改时，如果另外一个请求要对全表进行修改，那么就需要对所有的行是否被锁定进行扫描，在这种情况下，效率是非常低的；不过，在引入意向锁之后，当有人使用行锁对表中的某一行进行修改之前，会先为表添加意向互斥锁（IX），再为行记录添加互斥锁（X），在这时如果有人尝试对全表进行修改就不需要判断表中的每一行数据是否被加锁了，只需要通过等待意向互斥锁被释放就可以了。
-
-### [](https://draveness.me/mysql-innodb#%E9%94%81%E7%9A%84%E7%AE%97%E6%B3%95)锁的算法
-
-到目前为止已经对 InnoDB 中锁的粒度有一定的了解，也清楚了在对数据库进行读写时会获取不同的锁，在这一小节将介绍锁是如何添加到对应的数据行上的，我们会分别介绍三种锁的算法：Record Lock、Gap Lock 和 Next-Key Lock。
-
-#### [](https://draveness.me/mysql-innodb#record-lock)Record Lock
-
-记录锁（Record Lock）是加到**索引记录**上的锁，假设我们存在下面的一张表 `users`：
-
-```
-CREATE TABLE users(
-    id INT NOT NULL AUTO_INCREMENT,
-    last_name VARCHAR(255) NOT NULL,
-    first_name VARCHAR(255),
-    age INT,
-    PRIMARY KEY(id),
-    KEY(last_name),
-    KEY(age)
-);
-
-```
-
-如果我们使用 `id` 或者 `last_name` 作为 SQL 中 `WHERE` 语句的过滤条件，那么 InnoDB 就可以通过索引建立的 B+ 树找到行记录并添加索引，但是如果使用 `first_name` 作为过滤条件时，由于 InnoDB 不知道待修改的记录具体存放的位置，也无法对将要修改哪条记录提前做出判断就会锁定整个表。
-
-#### [](https://draveness.me/mysql-innodb#gap-lock)Gap Lock
-
-记录锁是在存储引擎中最为常见的锁，除了记录锁之外，InnoDB 中还存在间隙锁（Gap Lock），间隙锁是对索引记录中的一段连续区域的锁；当使用类似 `SELECT * FROM users WHERE id BETWEEN 10 AND 20 FOR UPDATE;` 的 SQL 语句时，就会阻止其他事务向表中插入 `id = 15` 的记录，因为整个范围都被间隙锁锁定了。
-
-> 间隙锁是存储引擎对于性能和并发做出的权衡，并且只用于某些事务隔离级别。
-
-虽然间隙锁中也分为共享锁和互斥锁，不过它们之间并不是互斥的，也就是不同的事务可以同时持有一段相同范围的共享锁和互斥锁，它唯一阻止的就是**其他事务向这个范围中添加新的记录**。
-
-#### [](https://draveness.me/mysql-innodb#next-key-lock)Next-Key Lock
-
-Next-Key 锁相比前两者就稍微有一些复杂，它是记录锁和记录前的间隙锁的结合，在 `users` 表中有以下记录：
-
-```
-+------|-------------|--------------|-------+
-|   id | last_name   | first_name   |   age |
-|------|-------------|--------------|-------|
-|    4 | stark       | tony         |    21 |
-|    1 | tom         | hiddleston   |    30 |
-|    3 | morgan      | freeman      |    40 |
-|    5 | jeff        | dean         |    50 |
-|    2 | donald      | trump        |    80 |
-+------|-------------|--------------|-------+
-
-```
-
-如果使用 Next-Key 锁，那么 Next-Key 锁就可以在需要的时候锁定以下的范围：
-
-```
-(-∞, 21]
-(21, 30]
-(30, 40]
-(40, 50]
-(50, 80]
-(80, ∞)
-
-```
-
-> 既然叫 Next-Key 锁，锁定的应该是当前值和后面的范围，但是实际上却不是，Next-Key 锁锁定的是当前值和前面的范围。
-
-当我们更新一条记录，比如 `SELECT * FROM users WHERE age = 30 FOR UPDATE;`，InnoDB 不仅会在范围 `(21, 30]` 上加 Next-Key 锁，还会在这条记录后面的范围 `(30, 40]` 加间隙锁，所以插入 `(21, 40]` 范围内的记录都会被锁定。
-
-Next-Key 锁的作用其实是为了解决幻读的问题，我们会在下一节谈事务的时候具体介绍。
-
-### [](https://draveness.me/mysql-innodb#%E6%AD%BB%E9%94%81%E7%9A%84%E5%8F%91%E7%94%9F)死锁的发生
-
-既然 InnoDB 中实现的锁是悲观的，那么不同事务之间就可能会互相等待对方释放锁造成死锁，最终导致事务发生错误；想要在 MySQL 中制造死锁的问题其实非常容易：
-
-![Deadlocks](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Deadlocks.jpg)
-
-两个会话都持有一个锁，并且尝试获取对方的锁时就会发生死锁，不过 MySQL 也能在发生死锁时及时发现问题，并保证其中的一个事务能够正常工作，这对我们来说也是一个好消息。
-
-## [](https://draveness.me/mysql-innodb#%E4%BA%8B%E5%8A%A1%E4%B8%8E%E9%9A%94%E7%A6%BB%E7%BA%A7%E5%88%AB)事务与隔离级别
-
-在介绍了锁之后，我们再来谈谈数据库中一个非常重要的概念 —— 事务；相信只要是一个合格的软件工程师就对事务的特性有所了解，其中被人经常提起的就是事务的原子性，在数据提交工作时，要么保证所有的修改都能够提交，要么就所有的修改全部回滚。
-
-但是事务还遵循包括原子性在内的 ACID 四大特性：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability）；文章不会对这四大特性全部展开进行介绍，相信你能够通过 Google 和数据库相关的书籍轻松获得有关它们的概念，本文最后要介绍的就是事务的四种隔离级别。
-
-### [](https://draveness.me/mysql-innodb#%E5%87%A0%E7%A7%8D%E9%9A%94%E7%A6%BB%E7%BA%A7%E5%88%AB)几种隔离级别
-
-事务的隔离性是数据库处理数据的几大基础之一，而隔离级别其实就是提供给用户用于在性能和可靠性做出选择和权衡的配置项。
-
-ISO 和 ANIS SQL 标准制定了四种事务隔离级别，而 InnoDB 遵循了 SQL:1992 标准中的四种隔离级别：`READ UNCOMMITED`、`READ COMMITED`、`REPEATABLE READ` 和 `SERIALIZABLE`；每个事务的隔离级别其实都比上一级多解决了一个问题：
-
-*   `RAED UNCOMMITED`：使用查询语句不会加锁，可能会读到未提交的行（Dirty Read）；
-*   `READ COMMITED`：只对记录加记录锁，而不会在记录之间加间隙锁，所以允许新的记录插入到被锁定记录的附近，所以再多次使用查询语句时，可能得到不同的结果（Non-Repeatable Read）；
-*   `REPEATABLE READ`：多次读取同一范围的数据会返回第一次查询的快照，不会返回不同的数据行，但是可能发生幻读（Phantom Read）；
-*   `SERIALIZABLE`：InnoDB 隐式地将全部的查询语句加上共享锁，解决了幻读的问题；
-
-MySQL 中默认的事务隔离级别就是 `REPEATABLE READ`，但是它通过 Next-Key 锁也能够在某种程度上解决幻读的问题。
-
-![Transaction-Isolation-Matrix](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Transaction-Isolation-Matrix.jpg)
-
-接下来，我们将数据库中创建如下的表并通过个例子来展示在不同的事务隔离级别之下，会发生什么样的问题：
-
-```
-CREATE TABLE test(
-    id INT NOT NULL,
-    UNIQUE(id)
-);
-
-```
-
-### [](https://draveness.me/mysql-innodb#%E8%84%8F%E8%AF%BB)脏读
-
-> 在一个事务中，读取了其他事务未提交的数据。
-
-当事务的隔离级别为 `READ UNCOMMITED` 时，我们在 `SESSION 2` 中插入的**未提交**数据在 `SESSION 1` 中是可以访问的。
-
-![Read-Uncommited-Dirty-Read](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Read-Uncommited-Dirty-Read.jpg)
-
-### [](https://draveness.me/mysql-innodb#%E4%B8%8D%E5%8F%AF%E9%87%8D%E5%A4%8D%E8%AF%BB)不可重复读
-
-> 在一个事务中，同一行记录被访问了两次却得到了不同的结果。
-
-当事务的隔离级别为 `READ COMMITED` 时，虽然解决了脏读的问题，但是如果在 `SESSION 1` 先查询了**一行**数据，在这之后 `SESSION 2` 中修改了同一行数据并且提交了修改，在这时，如果 `SESSION 1` 中再次使用相同的查询语句，就会发现两次查询的结果不一样。
-
-![Read-Commited-Non-Repeatable-Read](https://img.draveness.me/mweb/2019-07-16-Read-Commited-Non-Repeatable-Read.jpg)
-
-不可重复读的原因就是，在 `READ COMMITED` 的隔离级别下，存储引擎不会在查询记录时添加行锁，锁定 `id = 3` 这条记录。
-
-### [](https://draveness.me/mysql-innodb#%E5%B9%BB%E8%AF%BB)幻读
-
-> 在一个事务中，同一个范围内的记录被读取时，其他事务向这个范围添加了新的记录。
-
-重新开启了两个会话 `SESSION 1` 和 `SESSION 2`，在 `SESSION 1` 中我们查询全表的信息，没有得到任何记录；在 `SESSION 2` 中向表中插入一条数据并提交；由于 `REPEATABLE READ` 的原因，再次查询全表的数据时，我们获得到的仍然是空集，但是在向表中插入同样的数据却出现了错误。
-
-![Repeatable-Read-Phantom-Read](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Repeatable-Read-Phantom-Read.jpg)
-
-这种现象在数据库中就被称作幻读，虽然我们使用查询语句得到了一个空的集合，但是插入数据时却得到了错误，好像之前的查询是幻觉一样。
-
-在标准的事务隔离级别中，幻读是由更高的隔离级别 `SERIALIZABLE` 解决的，但是它也可以通过 MySQL 提供的 Next-Key 锁解决：
-
-![Repeatable-with-Next-Key-Lock](https://raw.githubusercontent.com/Draveness/Analyze/master/contents/Database/images/mysql/Repeatable-with-Next-Key-Lock.jpg)
-
-`REPEATABLE READ` 和 `READ UNCOMMITED` 其实是矛盾的，如果保证了前者就看不到已经提交的事务，如果保证了后者，就会导致两次查询的结果不同，MySQL 为我们提供了一种折中的方式，能够在 `REPEATABLE READ` 模式下加锁访问已经提交的数据，其本身并不能解决幻读的问题，而是通过文章前面提到的 Next-Key 锁来解决。
-
-## [](https://draveness.me/mysql-innodb#%E6%80%BB%E7%BB%93)总结
-
-> 文章中的内容大都来自于 [高性能 MySQL](https://book.douban.com/subject/23008813/)、[MySQL 技术内幕：InnoDB 存储引擎](https://book.douban.com/subject/24708143/)、[数据库索引设计与优化](https://book.douban.com/subject/26419771/) 以及 MySQL 的 [官方文档](https://dev.mysql.com/doc/)。
-
-由于篇幅所限仅能对数据库中一些重要内容进行简单的介绍和总结，文中内容难免有所疏漏，如果对文章内容的有疑问，可以在博客下面评论留言。
-
-## [](https://draveness.me/mysql-innodb#reference)Reference
-
-*   [mysqld_safe version different than mysqld?](https://dba.stackexchange.com/questions/35962/mysqld-safe-version-different-than-mysqld)
-*   [File Space Management](https://dev.mysql.com/doc/refman/5.7/en/innodb-file-space.html)
-*   [Externally Stored Fields in InnoDB](http://mysqlserverteam.com/externally-stored-fields-in-innodb/)
-*   [InnoDB Record Structure](https://dev.mysql.com/doc/internals/en/innodb-record-structure.html)
-*   [InnoDB Page Structure](https://dev.mysql.com/doc/internals/en/innodb-page-structure.html)
-*   [Difference between clustered and nonclustered index](https://stackoverflow.com/questions/5070529/difference-between-clustered-and-nonclustered-index)
-*   [InnoDB Locking](https://dev.mysql.com/doc/refman/5.7/en/innodb-locking.html)
-*   [乐观锁与悲观锁的区别](http://www.cnblogs.com/Bob-FD/p/3352216.html)
-*   [Optimistic concurrency control](https://en.wikipedia.org/wiki/Optimistic_concurrency_control)
-*   [MySQL 四种事务隔离级的说明](http://www.cnblogs.com/zhoujinyi/p/3437475.html)
diff --git "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2002 \357\274\232CAP.md" "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200 \357\274\232CAP.md"
similarity index 64%
rename from "docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2002 \357\274\232CAP.md"
rename to "docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200 \357\274\232CAP.md"
index 6a920e9..545e034 100644
--- "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2002 \357\274\232CAP.md"	
+++ "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200 \357\274\232CAP.md"	
@@ -1,11 +1,24 @@
+# 目录
+
+  * [**引言**](#引言)
+  * [**CAP定理**](#cap定理)
+  * [**CAP的工程启示**](#cap的工程启示)
+    * [**1、关于 P 的理解**](#1、关于-p-的理解)
+    * [**2、CA非0/1的选择**](#2、ca非01的选择)
+    * [**3、跳出CAP**](#3、跳出cap)
+    * [**小结**](#小结)
+
+
 本文转自：https://www.cnblogs.com/bangerlee/p/5328888.html
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本文也将同步到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -14,12 +27,12 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
-**引言**
+<!-- more -->  
+## **引言**
 
 CAP是分布式系统、特别是分布式存储领域中被讨论最多的理论，“[什么是CAP定理？](https://www.quora.com/What-Is-CAP-Theorem-1)”在Quora 分布式系统分类下排名 FAQ 的 No.1。CAP在程序员中也有较广的普及，它不仅仅是“C、A、P不能同时满足，最多只能3选2”，以下尝试综合各方观点，从发展历史、工程实践等角度讲述CAP理论。希望大家透过本文对CAP理论有更多地了解和认识。
 
-**CAP定理**
+## **CAP定理**
 
 CAP由[Eric Brewer](https://en.wikipedia.org/wiki/Eric_Brewer_(scientist))在2000年PODC会议上提出<sup>[1][2]</sup>，是Eric Brewer在Inktomi<sup>[3]</sup>期间研发搜索引擎、分布式web缓存时得出的关于数据一致性(consistency)、服务可用性(availability)、分区容错性(partition-tolerance)的猜想：
 
@@ -27,23 +40,22 @@ CAP由[Eric Brewer](https://en.wikipedia.org/wiki/Eric_Brewer_(scientist))在200
 
 该猜想在提出两年后被证明成立<sup>[4]</sup>，成为我们熟知的CAP定理：
 
-*   **数据一致性**(consistency)：如果系统对一个写操作返回成功，那么之后的读请求都必须读到这个新数据；如果返回失败，那么所有读操作都不能读到这个数据，对调用者而言数据具有强一致性(strong consistency) (又叫原子性 atomic、线性一致性 linearizable consistency)<sup>[5]</sup>
-*   **服务可用性**(availability)：所有读写请求在一定时间内得到响应，可终止、不会一直等待
+*   **数据一致性**(consistency)：如果系统对一个写操作返回成功，那么之后的读请求都必须读到这个新数据；如果返回失败，那么所有读操作都不能读到这个数据，对调用者而言数据具有强一致性(strong consistency) (又叫原子性 atomic、线性一致性 linearizable consistency)<sup>[5]</sup>*   **服务可用性**(availability)：所有读写请求在一定时间内得到响应，可终止、不会一直等待
 *   **分区容错性**(partition-tolerance)：在网络分区的情况下，被分隔的节点仍能正常对外服务
 
 在某时刻如果满足AP，分隔的节点同时对外服务但不能相互通信，将导致状态不一致，即不能满足C；如果满足CP，网络分区的情况下为达成C，请求只能一直等待，即不满足A；如果要满足CA，在一定时间内要达到节点状态一致，要求不能出现网络分区，则不能满足P。
 
 C、A、P三者最多只能满足其中两个，和FLP定理一样，CAP定理也指示了一个不可达的结果(impossibility result)。
 
-![](https://images2015.cnblogs.com/blog/116770/201603/116770-20160329205542613-1908405713.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407204500.png)
 
-**CAP的工程启示**
+## **CAP的工程启示**
 
 CAP理论提出7、8年后，NoSql圈将CAP理论当作对抗传统关系型数据库的依据、阐明自己放宽对数据一致性(consistency)要求的正确性<sup>[6]</sup>，随后引起了大范围关于CAP理论的讨论。
 
 CAP理论看似给我们出了一道3选2的选择题，但在工程实践中存在很多现实限制条件，需要我们做更多地考量与权衡，避免进入CAP认识误区<sup>[7]</sup>。
 
-**1、关于 P 的理解**
+### **1、关于 P 的理解**
 
 Partition字面意思是网络分区，即因网络因素将系统分隔为多个单独的部分，有人可能会说，网络分区的情况发生概率非常小啊，是不是不用考虑P，保证CA就好<sup>[8]</sup>。要理解P，我们看回CAP证明<sup>[4]</sup>中P的定义：
 
@@ -55,11 +67,11 @@ Partition字面意思是网络分区，即因网络因素将系统分隔为多
 
 > In a network subject to communication failures, it is impossible for any web service to implement an atomic read/write shared memory that guarantees a response to every request.
 
-**2、CA非0/1的选择**
+### **2、CA非0/1的选择**
 
-P 是必选项，那3选2的选择题不就变成数据一致性(consistency)、服务可用性(availability) 2选1？工程实践中一致性有不同程度，可用性也有不同等级，在保证分区容错性的前提下，放宽约束后可以兼顾一致性和可用性，两者不是非此即彼<sup>[12]</sup>。
+P 是必选项，那3选2的选择题不就变成数据一致性(consistency)、服务可用性(availability) 2选1？工程实践中一致性有不同程度，可用性也有不同等级，在保证分区容错性的前提下，放宽约束后可以兼顾一致性和可用性，两者不是非此即彼<sup>[12]</sup>。
 
-![](https://images2015.cnblogs.com/blog/116770/201604/116770-20160401221124957-2025686892.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160401221124957-2025686892.jpg)
 
 CAP定理证明中的一致性指强一致性，强一致性要求多节点组成的被调要能像单节点一样运作、操作具备原子性，数据在时间、时序上都有要求。如果放宽这些要求，还有其他一致性类型：
 
@@ -70,7 +82,7 @@ CAP定理证明中的一致性指强一致性，强一致性要求多节点组
 
 工程实践中，较常见的做法是通过异步拷贝副本(asynchronous replication)、quorum/NRW，实现在调用端看来数据强一致、被调端最终一致，在调用端看来服务可用、被调端允许部分节点不可用(或被网络分隔)的效果<sup>[15]</sup>。
 
-**3、跳出CAP**
+### **3、跳出CAP**
 
 CAP理论对实现分布式系统具有指导意义，但CAP理论并没有涵盖分布式工程实践中的所有重要因素。
 
@@ -78,7 +90,7 @@ CAP理论对实现分布式系统具有指导意义，但CAP理论并没有涵
 
 延时与数据一致性也是一对“冤家”，如果要达到强一致性、多个副本数据一致，必然增加延时。加上延时的考量，我们得到一个CAP理论的修改版本PACELC<sup>[17]</sup>：如果出现P(网络分区)，如何在A(服务可用性)、C(数据一致性)之间选择；否则，如何在L(延时)、C(数据一致性)之间选择。
 
-**小结**
+### **小结**
 
 以上介绍了CAP理论的源起和发展，介绍了CAP理论给分布式系统工程实践带来的启示。
 
@@ -86,45 +98,42 @@ CAP理论对分布式系统实现有非常重大的影响，我们可以根据
 
 有非常非常多文章讨论和研究CAP理论，希望这篇对你认识和了解CAP理论有帮助。
 
-[1] [Harvest, Yield, and Scalable Tolerant Systems](https://cs.uwaterloo.ca/~brecht/servers/readings-new2/harvest-yield.pdf), Armando Fox , Eric Brewer, 1999
-
-[2] [Towards Robust Distributed Systems](http://www.cs.berkeley.edu/~brewer/cs262b-2004/PODC-keynote.pdf), Eric Brewer, 2000
-
-[3] [Inktomi's wild ride - A personal view of the Internet bubble](https://www.youtube.com/watch?v=E91oEn1bnXM), Eric Brewer, 2004
-
-[4] [Brewer’s Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web](https://pdfs.semanticscholar.org/24ce/ce61e2128780072bc58f90b8ba47f624bc27.pdf), Seth Gilbert, Nancy Lynch, 2002
+[1] [Harvest, Yield, and Scalable Tolerant Systems](https://cs.uwaterloo.ca/~brecht/servers/readings-new2/harvest-yield.pdf), Armando Fox , Eric Brewer, 1999
 
-[5] [Linearizability: A Correctness Condition for Concurrent Objects](http://cs.brown.edu/~mph/HerlihyW90/p463-herlihy.pdf), Maurice P. Herlihy,Jeannette M. Wing, 1990
+[2] [Towards Robust Distributed Systems](http://www.cs.berkeley.edu/~brewer/cs262b-2004/PODC-keynote.pdf), Eric Brewer, 2000
 
-[6] [Brewer's CAP Theorem - The kool aid Amazon and Ebay have been drinking](http://julianbrowne.com/article/viewer/brewers-cap-theorem), Julian Browne, 2009
+[3] [Inktomi's wild ride - A personal view of the Internet bubble](https://www.youtube.com/watch?v=E91oEn1bnXM), Eric Brewer, 2004
 
-[7] [CAP Theorem between Claims and Misunderstandings: What is to be Sacrificed?](http://www.sersc.org/journals/IJAST/vol56/1.pdf), Balla Wade Diack,Samba Ndiaye,Yahya Slimani, 2013
+[4] [Brewer’s Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web](https://pdfs.semanticscholar.org/24ce/ce61e2128780072bc58f90b8ba47f624bc27.pdf), Seth Gilbert, Nancy Lynch, 2002
 
-[8] [Errors in Database Systems, Eventual Consistency, and the CAP Theorem](http://cacm.acm.org/blogs/blog-cacm/83396-errors-in-database-systems-eventual-consistency-and-the-cap-theorem/fulltext), Michael Stonebraker, 2010
+[5] [Linearizability: A Correctness Condition for Concurrent Objects](http://cs.brown.edu/~mph/HerlihyW90/p463-herlihy.pdf), Maurice P. Herlihy,Jeannette M. Wing, 1990
 
-[9] [CAP Confusion: Problems with 'partition tolerance'](http://blog.cloudera.com/blog/2010/04/cap-confusion-problems-with-partition-tolerance/), Henry Robinson, 2010
+[6] [Brewer's CAP Theorem - The kool aid Amazon and Ebay have been drinking](http://julianbrowne.com/article/viewer/brewers-cap-theorem), Julian Browne, 2009
 
-[10] [You Can’t Sacrifice Partition Tolerance](https://codahale.com/you-cant-sacrifice-partition-tolerance/), Coda Hale, 2010
+[7] [CAP Theorem between Claims and Misunderstandings: What is to be Sacrificed?](http://www.sersc.org/journals/IJAST/vol56/1.pdf), Balla Wade Diack,Samba Ndiaye,Yahya Slimani, 2013
 
-[11] [Perspectives on the CAP Theorem](https://groups.csail.mit.edu/tds/papers/Gilbert/Brewer2.pdf), Seth Gilbert, Nancy Lynch, 2012
+[8] [Errors in Database Systems, Eventual Consistency, and the CAP Theorem](http://cacm.acm.org/blogs/blog-cacm/83396-errors-in-database-systems-eventual-consistency-and-the-cap-theorem/fulltext), Michael Stonebraker, 2010
 
-[12] [CAP Twelve Years Later: How the "Rules" Have Changed](https://www.computer.org/cms/Computer.org/ComputingNow/homepage/2012/0512/T_CO2_CAP12YearsLater.pdf), Eric Brewer, 2012
+[9] [CAP Confusion: Problems with 'partition tolerance'](http://blog.cloudera.com/blog/2010/04/cap-confusion-problems-with-partition-tolerance/), Henry Robinson, 2010
 
-[13] [How to Make a Multiprocessor Computer That Correctly Executes Multiprocess Programs](http://research.microsoft.com/en-us/um/people/lamport/pubs/multi.pdf), Lamport Leslie, 1979
+[10] [You Can’t Sacrifice Partition Tolerance](https://codahale.com/you-cant-sacrifice-partition-tolerance/), Coda Hale, 2010
 
-[14] [Eventual Consistent Databases: State of the Art](http://www.ronpub.com/publications/OJDB-v1i1n03_Elbushra.pdf), Mawahib Elbushra , Jan Lindström, 2014
+[11] [Perspectives on the CAP Theorem](https://groups.csail.mit.edu/tds/papers/Gilbert/Brewer2.pdf), Seth Gilbert, Nancy Lynch, 2012
 
-[15] [Eventually Consistent](http://www.allthingsdistributed.com/2008/12/eventually_consistent.html), Werner Vogels, 2008
+[12] [CAP Twelve Years Later: How the "Rules" Have Changed](https://www.computer.org/cms/Computer.org/ComputingNow/homepage/2012/0512/T_CO2_CAP12YearsLater.pdf), Eric Brewer, 2012
 
-[16] [Speed Matters for Google Web Search](http://www.isaacsunyer.com/wp-content/uploads/2009/09/test_velocidad_google.pdf), Jake Brutlag, 2009
+[13] [How to Make a Multiprocessor Computer That Correctly Executes Multiprocess Programs](http://research.microsoft.com/en-us/um/people/lamport/pubs/multi.pdf), Lamport Leslie, 1979
 
-[17] [Consistency Tradeoffs in Modern Distributed Database System Design](http://cs-www.cs.yale.edu/homes/dna/papers/abadi-pacelc.pdf), Daniel J. Abadi, 2012
+[14] [Eventual Consistent Databases: State of the Art](http://www.ronpub.com/publications/OJDB-v1i1n03_Elbushra.pdf), Mawahib Elbushra , Jan Lindström, 2014
 
-[18] [A CAP Solution (Proving Brewer Wrong)](http://guysblogspot.blogspot.com/2008/09/cap-solution-proving-brewer-wrong.html), Guy's blog, 2008
+[15] [Eventually Consistent](http://www.allthingsdistributed.com/2008/12/eventually_consistent.html), Werner Vogels, 2008
 
-[19] [How to beat the CAP theorem](http://nathanmarz.com/blog/how-to-beat-the-cap-theorem.html), nathanmarz , 2011
+[16] [Speed Matters for Google Web Search](http://www.isaacsunyer.com/wp-content/uploads/2009/09/test_velocidad_google.pdf), Jake Brutlag, 2009
 
-[20] [The CAP FAQ](https://github.com/henryr/cap-faq), Henry Robinson
+[17] [Consistency Tradeoffs in Modern Distributed Database System Design](http://cs-www.cs.yale.edu/homes/dna/papers/abadi-pacelc.pdf), Daniel J. Abadi, 2012
 
+[18] [A CAP Solution (Proving Brewer Wrong)](http://guysblogspot.blogspot.com/2008/09/cap-solution-proving-brewer-wrong.html), Guy's blog, 2008
 
+[19] [How to beat the CAP theorem](http://nathanmarz.com/blog/how-to-beat-the-cap-theorem.html), nathanmarz , 2011
 
+[20] [The CAP FAQ](https://github.com/henryr/cap-faq), Henry Robinson
diff --git "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2001\357\274\232 \344\270\200\350\207\264\346\200\247\343\200\2012PC\345\222\2143PC.md" "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232 \344\270\200\350\207\264\346\200\247\343\200\201PC\345\222\214PC.md"
similarity index 69%
rename from "docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2001\357\274\232 \344\270\200\350\207\264\346\200\247\343\200\2012PC\345\222\2143PC.md"
rename to "docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232 \344\270\200\350\207\264\346\200\247\343\200\201PC\345\222\214PC.md"
index d192928..b2ac551 100644
--- "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2001\357\274\232 \344\270\200\350\207\264\346\200\247\343\200\2012PC\345\222\2143PC.md"	
+++ "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232 \344\270\200\350\207\264\346\200\247\343\200\201PC\345\222\214PC.md"	
@@ -1,3 +1,12 @@
+# 目录
+
+  * [**引言**](#引言)
+    * [**一致性(consensus)**](#一致性consensus)
+    * [**2PC**](#2pc)
+    * [**3PC**](#3pc)
+    * [**小结**](#小结)
+
+
 本文转自 https://www.cnblogs.com/bangerlee/p/5268485.html
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -14,7 +23,7 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 
 转自：https://www.cnblogs.com/bangerlee/p/5268485.html
 
@@ -26,17 +35,16 @@
 
 狭义的分布式系统指由网络连接的计算机系统，每个节点独立地承担计算或存储任务，节点间通过网络协同工作。广义的分布式系统是一个相对的概念，正如[Leslie Lamport](https://en.wikipedia.org/wiki/Leslie_Lamport)所说<sup>[1]</sup>：
 
-> What is a distributed systeme. **Distribution is in the eye of the beholder.**
-> To the user sitting at the keyboard, his IBM personal computer is a nondistributed system. 
-> To a flea crawling around on the circuit board, or to the engineer who designed it, it's very much a distributed system.
+> What is a distributed systeme.**Distribution is in the eye of the beholder.**  
+> To the user sitting at the keyboard, his IBM personal computer is a nondistributed system.> To a flea crawling around on the circuit board, or to the engineer who designed it, it's very much a distributed system.
 
- 一致性是分布式理论中的根本性问题，近半个世纪以来，科学家们围绕着一致性问题提出了很多理论模型，依据这些理论模型，业界也出现了很多工程实践投影。下面我们从一致性问题、特定条件下解决一致性问题的两种方法(2PC、3PC)入门，了解最基础的分布式系统理论。
+一致性是分布式理论中的根本性问题，近半个世纪以来，科学家们围绕着一致性问题提出了很多理论模型，依据这些理论模型，业界也出现了很多工程实践投影。下面我们从一致性问题、特定条件下解决一致性问题的两种方法(2PC、3PC)入门，了解最基础的分布式系统理论。
 
-**一致性(consensus)**
+### **一致性(consensus)**
 
 何为一致性问题？简单而言，一致性问题就是相互独立的节点之间如何达成一项决议的问题。分布式系统中，进行数据库事务提交(commit transaction)、Leader选举、序列号生成等都会遇到一致性问题。这个问题在我们的日常生活中也很常见，比如牌友怎么商定几点在哪打几圈麻将：
 
-![](https://images2015.cnblogs.com/blog/116770/201603/116770-20160313132041413-375351900.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160313132041413-375351900.jpg)
 
 _《赌圣》，1990_
 
@@ -61,24 +69,23 @@ _《赌圣》，1990_
 
 
 
-<pre>我: 老王，今晚7点老地方，搓够48圈不见不散！
-……
-（第二天凌晨3点） 隔壁老王: 没问题！ // 消息延迟
-我: ……
-----------------------------------------------
-我: 小张，今晚7点老地方，搓够48圈不见不散！
-小张: No …… 
-（两小时后……）
-小张: No problem！ // 宕机节点恢复
-我: ……
------------------------------------------------
-我: 老李头，今晚7点老地方，搓够48圈不见不散！
-老李: 必须的，大保健走起！ // 拜占庭将军 （这是要打麻将呢？还是要大保健？还是一边打麻将一边大保健……）</pre>
+我: 老王，今晚7点老地方，搓够48圈不见不散！  
+……  
+（第二天凌晨3点） 隔壁老王: 没问题！ // 消息延迟  
+我: ……  
+----------------------------------------------  
+我: 小张，今晚7点老地方，搓够48圈不见不散！  
+小张: No …… （两小时后……）  
+小张: No problem！ // 宕机节点恢复  
+我: ……  
+-----------------------------------------------  
+我: 老李头，今晚7点老地方，搓够48圈不见不散！  
+老李: 必须的，大保健走起！ // 拜占庭将军 （这是要打麻将呢？还是要大保健？还是一边打麻将一边大保健……）目录  
 
 
 
 
-还能不能一起愉快地玩耍...![](https://images2015.cnblogs.com/blog/116770/201603/116770-20160313010025194-2394933.png)
+还能不能一起愉快地玩耍...![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160313010025194-2394933.png)
 
 我们把以上所列的问题称为系统模型(system model)，讨论分布式系统理论和工程实践的时候，必先划定模型。例如有以下两种模型：
 
@@ -87,27 +94,26 @@ _《赌圣》，1990_
 
 2比1多了节点恢复、网络分化的考量，因而对这两种模型的理论研究和工程解决方案必定是不同的，在还没有明晰所要解决的问题前谈解决方案都是一本正经地耍流氓。
 
-一致性还具备两个属性，一个是强一致(safety)，它要求所有节点状态一致、共进退；一个是可用(liveness)，它要求分布式系统24*7无间断对外服务。FLP定理(FLP impossibility)<sup>[3][4] </sup>已经证明在一个收窄的模型中(异步环境并只存在节点宕机)，不能同时满足 safety 和 liveness。
+一致性还具备两个属性，一个是强一致(safety)，它要求所有节点状态一致、共进退；一个是可用(liveness)，它要求分布式系统24*7无间断对外服务。FLP定理(FLP impossibility)<sup>[3][4]</sup>已经证明在一个收窄的模型中(异步环境并只存在节点宕机)，不能同时满足 safety 和 liveness。
 
 FLP定理是分布式系统理论中的基础理论，正如物理学中的能量守恒定律彻底否定了永动机的存在，FLP定理否定了同时满足safety 和 liveness 的一致性协议的存在。
 
-![](https://images2015.cnblogs.com/blog/116770/201603/116770-20160314181639599-564845788.jpg)
-
-_《怦然心动 (Flipped)》，2010_ 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160314181639599-564845788.jpg)
 
+_《怦然心动 (Flipped)》，2010_   
 工程实践上根据具体的业务场景，或保证强一致(safety)，或在节点宕机、网络分化的时候保证可用(liveness)。2PC、3PC是相对简单的解决一致性问题的协议，下面我们就来了解2PC和3PC。
 
-**2PC**
+### **2PC**
 
 2PC(tow phase commit)两阶段提交<sup>[5]</sup>顾名思义它分成两个阶段，先由一方进行提议(propose)并收集其他节点的反馈(vote)，再根据反馈决定提交(commit)或中止(abort)事务。我们将提议的节点称为协调者(coordinator)，其他参与决议节点称为参与者(participants, 或cohorts)：
 
-![](https://images2015.cnblogs.com/blog/116770/201603/116770-20160313202532507-1396598167.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160313202532507-1396598167.png)
 
 _2PC, phase one_
 
 在阶段1中，coordinator发起一个提议，分别问询各participant是否接受。
 
-![](https://images2015.cnblogs.com/blog/116770/201603/116770-20160313203429600-179395429.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160313203429600-179395429.png)
 
 _2PC, phase two_
 
@@ -115,11 +121,11 @@ _2PC, phase two_
 
 在异步环境(asynchronous)并且没有节点宕机(fail-stop)的模型下，2PC可以满足全认同、值合法、可结束，是解决一致性问题的一种协议。但如果再加上节点宕机(fail-recover)的考虑，2PC是否还能解决一致性问题呢？
 
-coordinator如果在发起提议后宕机，那么participant将进入阻塞(block)状态、一直等待coordinator回应以完成该次决议。这时需要另一角色把系统从不可结束的状态中带出来，我们把新增的这一角色叫协调者备份(coordinator watchdog)。coordinator宕机一定时间后，watchdog接替原coordinator工作，通过问询(query) 各participant的状态，决定阶段2是提交还是中止。这也要求 coordinator/participant 记录(logging)历史状态，以备coordinator宕机后watchdog对participant查询、coordinator宕机恢复后重新找回状态。
+coordinator如果在发起提议后宕机，那么participant将进入阻塞(block)状态、一直等待coordinator回应以完成该次决议。这时需要另一角色把系统从不可结束的状态中带出来，我们把新增的这一角色叫协调者备份(coordinator watchdog)。coordinator宕机一定时间后，watchdog接替原coordinator工作，通过问询(query) 各participant的状态，决定阶段2是提交还是中止。这也要求coordinator/participant 记录(logging)历史状态，以备coordinator宕机后watchdog对participant查询、coordinator宕机恢复后重新找回状态。
 
 从coordinator接收到一次事务请求、发起提议到事务完成，经过2PC协议后增加了2次RTT(propose+commit)，带来的时延(latency)增加相对较少。
 
-**3PC**
+### **3PC**
 
 3PC(three phase commit)即三阶段提交<sup>[6][7]</sup>，既然2PC可以在异步网络+节点宕机恢复的模型下实现一致性，那还需要3PC做什么，3PC是什么鬼？
 
@@ -130,7 +136,7 @@ coordinator如果在发起提议后宕机，那么participant将进入阻塞(blo
 
 相比2PC，3PC增加了一个准备提交(prepare to commit)阶段来解决以上问题：
 
-![](https://images2015.cnblogs.com/blog/116770/201603/116770-20160314002734304-489496391.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160314002734304-489496391.png)
 
 _图片截取自wikipedia_
 
@@ -138,31 +144,28 @@ coordinator接收完participant的反馈(vote)之后，进入阶段2，给各个
 
 participant如果在不同阶段宕机，我们来看看3PC如何应对：
 
-*   **阶段1**: coordinator或watchdog未收到宕机participant的vote，直接中止事务；宕机的participant恢复后，读取logging发现未发出赞成vote，自行中止该次事务
-*   **阶段2**: coordinator未收到宕机participant的precommit ACK，但因为之前已经收到了宕机participant的赞成反馈(不然也不会进入到阶段2)，coordinator进行commit；watchdog可以通过问询其他participant获得这些信息，过程同理；宕机的participant恢复后发现收到precommit或已经发出赞成vote，则自行commit该次事务
+*   **阶段1**:coordinator或watchdog未收到宕机participant的vote，直接中止事务；宕机的participant恢复后，读取logging发现未发出赞成vote，自行中止该次事务
+*   **阶段2**:coordinator未收到宕机participant的precommit ACK，但因为之前已经收到了宕机participant的赞成反馈(不然也不会进入到阶段2)，coordinator进行commit；watchdog可以通过问询其他participant获得这些信息，过程同理；宕机的participant恢复后发现收到precommit或已经发出赞成vote，则自行commit该次事务
 *   **阶段3**: 即便coordinator或watchdog未收到宕机participant的commit ACK，也结束该次事务；宕机的participant恢复后发现收到commit或者precommit，也将自行commit该次事务
 
 因为有了准备提交(prepare to commit)阶段，3PC的事务处理延时也增加了1个RTT，变为3个RTT(propose+precommit+commit)，但是它防止participant宕机后整个系统进入阻塞态，增强了系统的可用性，对一些现实业务场景是非常值得的。
 
-**小结**
+### **小结**
 
 以上介绍了分布式系统理论中的部分基础知识，阐述了一致性(consensus)的定义和实现一致性所要面临的问题，最后讨论在异步网络(asynchronous)、节点宕机恢复(fail-recover)模型下2PC、3PC怎么解决一致性问题。
 
 阅读前人对分布式系统的各项理论研究，其中有严谨地推理、证明，有一种数学的美；观现实中的分布式系统实现，是综合各种因素下妥协的结果。
 
-[1] [Solved Problems, Unsolved Problems and Problems in Concurrency](http://research.microsoft.com/en-us/um/people/lamport/pubs/solved-and-unsolved.pdf), Leslie Lamport, 1983
-
-[2] [The Byzantine Generals Problem](http://research.microsoft.com/en-us/um/people/lamport/pubs/byz.pdf), Leslie Lamport,Robert Shostak and Marshall Pease, 1982
-
-[3] [Impossibility of Distributed Consensus with One Faulty Process](http://cs-www.cs.yale.edu/homes/arvind/cs425/doc/fischer.pdf), Fischer, Lynch and Patterson, 1985
-
-[4] [FLP Impossibility的证明](http://danielw.cn/FLP-proof/), Daniel Wu, 2015
+[1][Solved Problems, Unsolved Problems and Problems in Concurrency](http://research.microsoft.com/en-us/um/people/lamport/pubs/solved-and-unsolved.pdf),Leslie Lamport, 1983
 
-[5] [Consensus Protocols: Two-Phase Commit](http://the-paper-trail.org/blog/consensus-protocols-two-phase-commit/), Henry Robinson, 2008
+[2][The Byzantine Generals Problem](http://research.microsoft.com/en-us/um/people/lamport/pubs/byz.pdf),Leslie Lamport,Robert Shostak and Marshall Pease, 1982
 
-[6] [Consensus Protocols: Three-phase Commit](http://the-paper-trail.org/blog/consensus-protocols-three-phase-commit/), Henry Robinson, 2008
+[3][Impossibility of Distributed Consensus with One Faulty Process](http://cs-www.cs.yale.edu/homes/arvind/cs425/doc/fischer.pdf),Fischer, Lynch and Patterson, 1985
 
-[7] [Three-phase commit protocol](https://en.wikipedia.org/wiki/Three-phase_commit_protocol), Wikipedia
+[4][FLP Impossibility的证明](http://danielw.cn/FLP-proof/),Daniel Wu, 2015
 
+[5][Consensus Protocols: Two-Phase Commit](http://the-paper-trail.org/blog/consensus-protocols-two-phase-commit/),Henry Robinson, 2008
 
+[6][Consensus Protocols: Three-phase Commit](http://the-paper-trail.org/blog/consensus-protocols-three-phase-commit/),Henry Robinson, 2008
 
+[7][Three-phase commit protocol](https://en.wikipedia.org/wiki/Three-phase_commit_protocol),Wikipedia
diff --git "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2003\357\274\232 \346\227\266\351\227\264\343\200\201\346\227\266\351\222\237\345\222\214\344\272\213\344\273\266\351\241\272\345\272\217.md" "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232 \346\227\266\351\227\264\343\200\201\346\227\266\351\222\237\345\222\214\344\272\213\344\273\266\351\241\272\345\272\217.md"
similarity index 61%
rename from "docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2003\357\274\232 \346\227\266\351\227\264\343\200\201\346\227\266\351\222\237\345\222\214\344\272\213\344\273\266\351\241\272\345\272\217.md"
rename to "docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232 \346\227\266\351\227\264\343\200\201\346\227\266\351\222\237\345\222\214\344\272\213\344\273\266\351\241\272\345\272\217.md"
index 0381390..d8f2e21 100644
--- "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2003\357\274\232 \346\227\266\351\227\264\343\200\201\346\227\266\351\222\237\345\222\214\344\272\213\344\273\266\351\241\272\345\272\217.md"	
+++ "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232 \346\227\266\351\227\264\343\200\201\346\227\266\351\222\237\345\222\214\344\272\213\344\273\266\351\241\272\345\272\217.md"	
@@ -1,3 +1,12 @@
+# 目录
+
+  * [**物理时钟 vs 逻辑时钟**](#物理时钟-vs-逻辑时钟)
+  * [**Lamport timestamps**](#lamport-timestamps)
+  * [**Vector clock**](#vector-clock)
+  * [**Version vector**](#version-vector)
+  * [**小结**](#小结)
+
+
 转自：https://www.cnblogs.com/bangerlee/p/5448766.html
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -14,29 +23,28 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 
 > 十六号…… 四月十六号。一九六零年四月十六号下午三点之前的一分钟你和我在一起，因为你我会记住这一分钟。从现在开始我们就是一分钟的朋友，这是事实，你改变不了，因为已经过去了。我明天会再来。
-> 
->     —— 《阿飞正传》
+> >   —— 《阿飞正传》
 
 现实生活中时间是很重要的概念，时间可以记录事情发生的时刻、比较事情发生的先后顺序。分布式系统的一些场景也需要记录和比较不同节点间事件发生的顺序，但不同于日常生活使用物理时钟记录时间，分布式系统使用逻辑时钟记录事件顺序关系，下面我们来看分布式系统中几种常见的逻辑时钟。
 
-**物理时钟 vs 逻辑时钟**
+## **物理时钟 vs 逻辑时钟**
 
 可能有人会问，为什么分布式系统不使用物理时钟(physical clock)记录事件？每个事件对应打上一个时间戳，当需要比较顺序的时候比较相应时间戳就好了。
 
-这是因为现实生活中物理时间有统一的标准，而分布式系统中每个节点记录的时间并不一样，即使设置了 [NTP](http://www.zhihu.com/question/24960940) 时间同步节点间也存在毫秒级别的偏差<sup>[1][2]</sup>。因而分布式系统需要有另外的方法记录事件顺序关系，这就是逻辑时钟(logical clock)。
+这是因为现实生活中物理时间有统一的标准，而分布式系统中每个节点记录的时间并不一样，即使设置了[NTP](http://www.zhihu.com/question/24960940)时间同步节点间也存在毫秒级别的偏差<sup>[1][2]</sup>。因而分布式系统需要有另外的方法记录事件顺序关系，这就是逻辑时钟(logical clock)。
 
-![](https://images2015.cnblogs.com/blog/116770/201605/116770-20160501132311347-349996615.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160501132311347-349996615.jpg)
 
-**Lamport timestamps**
+## **Lamport timestamps**
 
-[Leslie](https://en.wikipedia.org/wiki/Leslie_Cheung) [Lamport](https://en.wikipedia.org/wiki/Leslie_Lamport) 在1978年提出逻辑时钟的概念，并描述了一种逻辑时钟的表示方法，这个方法被称为Lamport时间戳(Lamport timestamps)<sup>[3]</sup>。
+[Leslie](https://en.wikipedia.org/wiki/Leslie_Cheung)[Lamport](https://en.wikipedia.org/wiki/Leslie_Lamport)在1978年提出逻辑时钟的概念，并描述了一种逻辑时钟的表示方法，这个方法被称为Lamport时间戳(Lamport timestamps)<sup>[3]</sup>。
 
 分布式系统中按是否存在节点交互可分为三类事件，一类发生于节点内部，二是发送事件，三是接收事件。Lamport时间戳原理如下：
 
-![](https://images2015.cnblogs.com/blog/116770/201605/116770-20160501174922566-1686627384.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160501174922566-1686627384.png)
 
 _图1: Lamport timestamps space time (图片来源: wikipedia)_
 
@@ -47,31 +55,31 @@ _图1: Lamport timestamps space time (图片来源: wikipedia)_
 
 假设有事件a、b，C(a)、C(b)分别表示事件a、b对应的Lamport时间戳，如果C(a) < C(b)，则有a发生在b之前(happened before)，记作 a -> b，例如图1中有 C1 -> B1。通过该定义，事件集中Lamport时间戳不等的事件可进行比较，我们获得事件的[偏序关系](https://en.wikipedia.org/wiki/Partially_ordered_set#Formal_definition)(partial order)。
 
-如果C(a) = C(b)，那a、b事件的顺序又是怎样的？假设a、b分别在节点P、Q上发生，P<sub>i、</sub>Q<sub>j</sub>分别表示我们给P、Q的编号，如果 C(a) = C(b) 并且 P<sub>i </sub><Q<sub>j</sub>，同样定义为a发生在b之前，记作 a => b。假如我们对图1的A、B、C分别编号A<sub>i</sub> = 1、B<sub>j</sub> = 2、C<sub>k</sub> = 3，因 C(B4) = C(C3) 并且 B<sub>j</sub> < C<sub>k</sub>，则 B4 => C3。
+如果C(a) = C(b)，那a、b事件的顺序又是怎样的？假设a、b分别在节点P、Q上发生，P<sub>i、</sub>Q<sub>j</sub>分别表示我们给P、Q的编号，如果C(a) = C(b) 并且P<sub>i</sub><Q<sub>j</sub>，同样定义为a发生在b之前，记作 a => b。假如我们对图1的A、B、C分别编号A<sub>i</sub>= 1、B<sub>j</sub>= 2、C<sub>k</sub>= 3，因 C(B4) = C(C3) 并且 B<sub>j</sub>< C<sub>k</sub>，则 B4 => C3。
 
 通过以上定义，我们可以对所有事件排序、获得事件的[全序关系](https://en.wikipedia.org/wiki/Total_order)(total order)。上图例子，我们可以从C1到A4进行排序。
 
-**Vector clock**
+## **Vector clock**
 
 Lamport时间戳帮助我们得到事件顺序关系，但还有一种顺序关系不能用Lamport时间戳很好地表示出来，那就是同时发生关系(concurrent)<sup>[4]</sup>。例如图1中事件B4和事件C3没有因果关系，属于同时发生事件，但Lamport时间戳定义两者有先后顺序。
 
 Vector clock是在Lamport时间戳基础上演进的另一种逻辑时钟方法，它通过vector结构不但记录本节点的Lamport时间戳，同时也记录了其他节点的Lamport时间戳<sup>[5][6]</sup>。Vector clock的原理与Lamport时间戳类似，使用图例如下：
 
-![](https://images2015.cnblogs.com/blog/116770/201605/116770-20160502134654404-1109556515.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160502134654404-1109556515.png)
 
 _图2: Vector clock space time (_图片来源: wikipedia)__
 
 假设有事件a、b分别在节点P、Q上发生，Vector clock分别为T<sub>a</sub>、T<sub>b</sub>，如果 T<sub>b</sub>[Q] > T<sub>a</sub>[Q] 并且 T<sub>b</sub>[P] >= T<sub>a</sub>[P]，则a发生于b之前，记作 a -> b。到目前为止还和Lamport时间戳差别不大，那Vector clock怎么判别同时发生关系呢？
 
-如果 T<sub>b</sub>[Q] > T<sub>a</sub>[Q] 并且 T<sub>b</sub>[P] < T<sub>a</sub>[P]，则认为a、b同时发生，记作 a <-> b。例如图2中节点B上的第4个事件 (A:2，B:4，C:1) 与节点C上的第2个事件 (B:3，C:2) 没有因果关系、属于同时发生事件。
+如果T<sub>b</sub>[Q] > T<sub>a</sub>[Q] 并且 T<sub>b</sub>[P] < T<sub>a</sub>[P]，则认为a、b同时发生，记作 a <-> b。例如图2中节点B上的第4个事件 (A:2，B:4，C:1) 与节点C上的第2个事件 (B:3，C:2) 没有因果关系、属于同时发生事件。
 
-**Version vector**
+## **Version vector**
 
 基于Vector clock我们可以获得任意两个事件的顺序关系，结果或为先后顺序或为同时发生，识别事件顺序在工程实践中有很重要的引申应用，最常见的应用是发现数据冲突(detect conflict)。
 
 分布式系统中数据一般存在多个副本(replication)，多个副本可能被同时更新，这会引起副本间数据不一致<sup>[7]</sup>，Version vector的实现与Vector clock非常类似<sup>[8]</sup>，目的用于发现数据冲突<sup>[9]</sup>。下面通过一个例子说明Version vector的用法<sup>[10]</sup>：
 
-![](https://images2015.cnblogs.com/blog/116770/201605/116770-20160502183034013-800335383.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160502183034013-800335383.png)
 
 _图3: Version vector_
 
@@ -82,45 +90,36 @@ _图3: Version vector_
 
 Vector clock只用于发现数据冲突，不能解决数据冲突。如何解决数据冲突因场景而异，具体方法有以最后更新为准(last write win)，或将冲突的数据交给client由client端决定如何处理，或通过quorum决议事先避免数据冲突的情况发生<sup>[11]</sup>。
 
-由于记录了所有数据在所有节点上的逻辑时钟信息，Vector clock和Version vector在实际应用中可能面临的一个问题是vector过大，用于数据管理的元数据(meta data)甚至大于数据本身<sup>[12]</sup>。
+由于记录了所有数据在所有节点上的逻辑时钟信息，Vector clock和Versionvector在实际应用中可能面临的一个问题是vector过大，用于数据管理的元数据(meta data)甚至大于数据本身<sup>[12]</sup>。
 
 解决该问题的方法是使用server id取代client id创建vector (因为server的数量相对client稳定)，或设定最大的size、如果超过该size值则淘汰最旧的vector信息<sup>[10][13]</sup>。
 
-**小结**
+## **小结**
 
 以上介绍了分布式系统里逻辑时钟的表示方法，通过Lamport timestamps可以建立事件的全序关系，通过Vector clock可以比较任意两个事件的顺序关系并且能表示无因果关系的事件，将Vector clock的方法用于发现数据版本冲突，于是有了Version vector。
 
-[1] [Time is an illusion](https://queue.acm.org/detail.cfm?id=2878574), George Neville-Neil, 2016
-
-[2] [There is No Now](https://queue.acm.org/detail.cfm?id=2745385&__hstc=53389751.f1483a2189ec5c779270b00cdb849993.1461983406379.1461983406379.1461997241982.2&__hssc=53389751.1.1461997241982&__hsfp=1028666893), Justin Sheehy, 2015
-
-[3] [Time, Clocks, and the Ordering of Events in a Distributed System](http://research.microsoft.com/en-us/um/people/lamport/pubs/time-clocks.pdf), Leslie Lamport, 1978
-
-[4] [Timestamps in Message-Passing Systems That Preserve the Partial Ordering](http://zoo.cs.yale.edu/classes/cs426/2012/lab/bib/fidge88timestamps.pdf), Colin J. Fidge, 1988
-
-[5] [Virtual Time and Global States of Distributed Systems](http://www.vs.inf.ethz.ch/publ/papers/VirtTimeGlobStates.pdf), Friedemann Mattern, 1988
-
-[6] [Why Vector Clocks are Easy](http://basho.com/posts/technical/why-vector-clocks-are-easy/), Bryan Fink, 2010
-
-[7] [Conflict Management](http://guide.couchdb.org/draft/conflicts.html), CouchDB
-
-[8] [Version Vectors are not Vector Clocks](https://haslab.wordpress.com/2011/07/08/version-vectors-are-not-vector-clocks/?__hstc=53389751.f1483a2189ec5c779270b00cdb849993.1461983406379.1461983406379.1461997241982.2&__hssc=53389751.1.1461997241982&__hsfp=1028666893), Carlos Baquero, 2011
-
-[9] [Detection of Mutual Inconsistency in Distributed Systems](http://zoo.cs.yale.edu/classes/cs422/2013/bib/parker83detection.pdf), IEEE Transactions on Software Engineering , 1983
-
-[10] [Dynamo: Amazon’s Highly Available Key-value Store](http://s3.amazonaws.com/AllThingsDistributed/sosp/amazon-dynamo-sosp2007.pdf), Amazon, 2007
+[1][Time is an illusion](https://queue.acm.org/detail.cfm?id=2878574), George Neville-Neil, 2016
 
-[11] [Conflict Resolution](http://pl.atyp.us/wordpress/?p=2601), Jeff Darcy , 2010
+[2][There is No Now](https://queue.acm.org/detail.cfm?id=2745385&__hstc=53389751.f1483a2189ec5c779270b00cdb849993.1461983406379.1461983406379.1461997241982.2&__hssc=53389751.1.1461997241982&__hsfp=1028666893),Justin Sheehy, 2015
 
-[12] [Why Vector Clocks Are Hard](http://basho.com/posts/technical/why-vector-clocks-are-hard/), Justin Sheehy, 2010
+[3][Time, Clocks, and the Ordering of Events in a Distributed System](http://research.microsoft.com/en-us/um/people/lamport/pubs/time-clocks.pdf), Leslie Lamport, 1978
 
-[13] [Causality Is Expensive (and What To Do About It)](http://www.bailis.org/blog/causality-is-expensive-and-what-to-do-about-it/), Peter Bailis ,2014
+[4][Timestamps in Message-Passing Systems That Preserve the Partial Ordering](http://zoo.cs.yale.edu/classes/cs426/2012/lab/bib/fidge88timestamps.pdf), Colin J. Fidge, 1988
 
+[5][Virtual Time and Global States of Distributed Systems](http://www.vs.inf.ethz.ch/publ/papers/VirtTimeGlobStates.pdf), Friedemann Mattern, 1988
 
+[6][Why Vector Clocks are Easy](http://basho.com/posts/technical/why-vector-clocks-are-easy/), Bryan Fink, 2010
 
+[7][Conflict Management](http://guide.couchdb.org/draft/conflicts.html), CouchDB
 
+[8][Version Vectors are not Vector Clocks](https://haslab.wordpress.com/2011/07/08/version-vectors-are-not-vector-clocks/?__hstc=53389751.f1483a2189ec5c779270b00cdb849993.1461983406379.1461983406379.1461997241982.2&__hssc=53389751.1.1461997241982&__hsfp=1028666893), Carlos Baquero,2011
 
+[9][Detection of Mutual Inconsistency in Distributed Systems](http://zoo.cs.yale.edu/classes/cs422/2013/bib/parker83detection.pdf), IEEE Transactions on Software Engineering , 1983
 
+[10][Dynamo: Amazon’s Highly Available Key-value Store](http://s3.amazonaws.com/AllThingsDistributed/sosp/amazon-dynamo-sosp2007.pdf), Amazon, 2007
 
+[11][Conflict Resolution](http://pl.atyp.us/wordpress/?p=2601), Jeff Darcy , 2010
 
+[12][Why Vector Clocks Are Hard](http://basho.com/posts/technical/why-vector-clocks-are-hard/), Justin Sheehy, 2010
 
+[13][Causality Is Expensive (and What To Do About It)](http://www.bailis.org/blog/causality-is-expensive-and-what-to-do-about-it/), Peter Bailis ,2014
diff --git "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2004\357\274\232Paxos.md" "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232Paxos.md"
similarity index 81%
rename from "docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2004\357\274\232Paxos.md"
rename to "docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232Paxos.md"
index 53fbd78..603d2d2 100644
--- "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2004\357\274\232Paxos.md"
+++ "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232Paxos.md"
@@ -1,3 +1,11 @@
+# 目录
+
+  * [**引言**](#引言)
+  * [**Basic Paxos**](#basic-paxos)
+  * [**Multi Paxos**](#multi-paxos)
+  * [**小结**](#小结)
+
+
 本文转自：https://www.cnblogs.com/bangerlee/p/5655754.html
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -14,28 +22,28 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 
 ## **引言**
 
 
 [《分布式系统理论基础 - 一致性、2PC和3PC》](http://www.cnblogs.com/bangerlee/p/5268485.html)一文介绍了一致性、达成一致性需要面临的各种问题以及2PC、3PC模型，Paxos协议在节点宕机恢复、消息无序或丢失、网络分化的场景下能保证决议的一致性，是被讨论最广泛的一致性协议。
 
-Paxos协议同时又以其“艰深晦涩”著称，下面结合 [Paxos Made Simple](http://research.microsoft.com/en-us/um/people/lamport/pubs/paxos-simple.pdf)、[The Part-Time Parliament](http://research.microsoft.com/en-us/um/people/lamport/pubs/lamport-paxos.pdf) 两篇论文，尝试通过Paxos推演、学习和了解Paxos协议。
+Paxos协议同时又以其“艰深晦涩”著称，下面结合[Paxos Made Simple](http://research.microsoft.com/en-us/um/people/lamport/pubs/paxos-simple.pdf)、[The Part-Time Parliament](http://research.microsoft.com/en-us/um/people/lamport/pubs/lamport-paxos.pdf)两篇论文，尝试通过Paxos推演、学习和了解Paxos协议。
 
-**Basic Paxos**
+## **Basic Paxos**
 
 何为一致性问题？简单而言，一致性问题是在节点宕机、消息无序等场景可能出现的情况下，相互独立的节点之间如何达成决议的问题，作为解决一致性问题的协议，Paxos的核心是节点间如何确定并只确定一个值(value)。
 
 也许你会疑惑只确定一个值能起什么作用，在Paxos协议里确定并只确定一个值是确定多值的基础，如何确定多值将在第二部分Multi Paxos中介绍，这部分我们聚焦在“Paxos如何确定并只确定一个值”这一问题上。
 
-![](https://images2015.cnblogs.com/blog/116770/201607/116770-20160711232543717-973749854.gif)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160711232543717-973749854.gif)
 
 和2PC类似，Paxos先把节点分成两类，发起提议(proposal)的一方为proposer，参与决议的一方为acceptor。假如只有一个proposer发起提议，并且节点不宕机、消息不丢包，那么acceptor做到以下这点就可以确定一个值：
 
 
 
-<pre>**P1**. 一个acceptor接受它收到的第一项提议</pre>
+**P1**. 一个acceptor接受它收到的第一项提议
 
 
 
@@ -45,7 +53,7 @@ Paxos协议同时又以其“艰深晦涩”著称，下面结合 [Paxos Made S
 
 1\. proposer发起的每项提议分别用一个ID标识，提议的组成因此变为(ID, value)
 
-2. acceptor可以接受(accept)不止一项提议，当多数(quorum) acceptor接受一项提议时该提议被确定(chosen)
+2.acceptor可以接受(accept)不止一项提议，当多数(quorum)acceptor接受一项提议时该提议被确定(chosen)
 
 _(注: 注意以上“接受”和“确定”的区别）_
 
@@ -53,7 +61,7 @@ _(注: 注意以上“接受”和“确定”的区别）_
 
 
 
-<pre>**P2**. 如果一项值为v的提议被确定，那么后续只确定值为v的提议</pre>
+**P2**. 如果一项值为v的提议被确定，那么后续只确定值为v的提议
 
 
 
@@ -63,7 +71,7 @@ _(注: 乍看这个条件不太好理解，谨记目标是“确定并只确定
 
 
 
-<pre>**P2a**. 如果一项值为v的提议被确定，那么acceptor后续只接受值为v的提议</pre>
+**P2a**. 如果一项值为v的提议被确定，那么acceptor后续只接受值为v的提议
 
 
 
@@ -75,25 +83,25 @@ _(注: 乍看这个条件不太好理解，谨记目标是“确定并只确定
 
 
 
-<pre>**P2b**. 如果一项值为v的提议被确定，那么proposer后续只发起值为v的提议</pre>
+**P2b**. 如果一项值为v的提议被确定，那么proposer后续只发起值为v的提议
 
 
 
-满足P2b则P2a成立 (P2b => P2a => P2)。
+满足P2b则P2a成立 (P2b =>P2a => P2)。
 
 P2b约束的是提议被确定(chosen)后proposer的行为，我们更关心提议被确定前proposer应该怎么做：
 
 
 
-<pre>**P2c**. 对于提议(n,v)，acceptor的多数派S中，如果存在acceptor最近一次(即ID值最大)接受的提议的值为v'，那么要求v = v'；否则v可为任意值</pre>
+**P2c**. 对于提议(n,v)，acceptor的多数派S中，如果存在acceptor最近一次(即ID值最大)接受的提议的值为v'，那么要求v = v'；否则v可为任意值
 
 
 
-满足P2c则P2b成立 (P2c => P2b => P2a => P2)。
+满足P2c则P2b成立 (P2c =>P2b => P2a => P2)。
 
-条件P2c是Basic Paxos的核心，光看P2c的描述可能会觉得一头雾水，我们通过 [The Part-Time Parliament](http://research.microsoft.com/en-us/um/people/lamport/pubs/lamport-paxos.pdf) 中的例子加深理解：
+条件P2c是Basic Paxos的核心，光看P2c的描述可能会觉得一头雾水，我们通过[The Part-Time Parliament](http://research.microsoft.com/en-us/um/people/lamport/pubs/lamport-paxos.pdf)中的例子加深理解：
 
-![](https://images2015.cnblogs.com/blog/116770/201607/116770-20160712103935326-2086911417.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160712103935326-2086911417.png)
 
 假设有A~E 5个acceptor，- 表示acceptor因宕机等原因缺席当次决议，x 表示acceptor不接受提议，o 表示接受提议；多数派acceptor接受提议后提议被确定，以上表格对应的决议过程如下：
 
@@ -105,9 +113,9 @@ P2b约束的是提议被确定(chosen)后proposer的行为，我们更关心提
 
 以上提到的各项约束条件可以归纳为3点，如果proposer/acceptor满足下面3点，那么在少数节点宕机、网络分化隔离的情况下，在“确定并只确定一个值”这件事情上可以保证一致性(consistency)：
 
-*   B1(ß): ß中每一轮决议都有唯一的ID标识
+*   B1(ß):ß中每一轮决议都有唯一的ID标识
 *   B2(ß): 如果决议B被acceptor多数派接受，则确定决议B
-*   B3(ß): 对于ß中的任意提议B(n,v)，acceptor的多数派中如果存在acceptor最近一次(即ID值最大)接受的提议的值为v'，那么要求v = v'；否则v可为任意值
+*   B3(ß):对于ß中的任意提议B(n,v)，acceptor的多数派中如果存在acceptor最近一次(即ID值最大)接受的提议的值为v'，那么要求v = v'；否则v可为任意值
 
 _(注: 希腊字母ß表示多轮决议的集合，字母B表示一轮决议)_
 
@@ -119,33 +127,33 @@ _(注: 希腊字母ß表示多轮决议的集合，字母B表示一轮决议)_
 
 至此，proposer/acceptor完成一轮决议可归纳为prepare和accept两个阶段。prepare阶段proposer发起提议问询提议值、acceptor回应问询并进行promise；accept阶段完成决议，图示如下：
 
-![](https://images2015.cnblogs.com/blog/116770/201607/116770-20160712125617045-527200085.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160712125617045-527200085.png)
 
 还有一个问题需要考量，假如proposer A发起ID为n的提议，在提议未完成前proposer B又发起ID为n+1的提议，在n+1提议未完成前proposer C又发起ID为n+2的提议…… 如此acceptor不能完成决议、形成活锁(livelock)，虽然这不影响一致性，但我们一般不想让这样的情况发生。解决的方法是从proposer中选出一个leader，提议统一由leader发起。
 
 最后我们再引入一个新的角色：learner，learner依附于acceptor，用于习得已确定的决议。以上决议过程都只要求acceptor多数派参与，而我们希望尽量所有acceptor的状态一致。如果部分acceptor因宕机等原因未知晓已确定决议，宕机恢复后可经本机learner采用pull的方式从其他acceptor习得。
 
-**Multi Paxos**
+## **Multi Paxos**
 
 通过以上步骤分布式系统已经能确定一个值，“只确定一个值有什么用？这可解决不了我面临的问题。” 你心中可能有这样的疑问。
 
-![](https://images2015.cnblogs.com/blog/116770/201607/116770-20160712150303811-1635028332.gif)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160712150303811-1635028332.gif)
 
 其实不断地进行“确定一个值”的过程、再为每个过程编上序号，就能得到具有全序关系(total order)的系列值，进而能应用在数据库副本存储等很多场景。我们把单次“确定一个值”的过程称为实例(instance)，它由proposer/acceptor/learner组成，下图说明了A/B/C三机上的实例：
 
-![](https://images2015.cnblogs.com/blog/116770/201607/116770-20160712212514107-1914374126.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160712212514107-1914374126.png)
 
 不同序号的实例之间互相不影响，A/B/C三机输入相同、过程实质等同于执行相同序列的状态机(state machine)指令 ，因而将得到一致的结果。
 
 proposer leader在Multi Paxos中还有助于提升性能，常态下统一由leader发起提议，可节省prepare步骤(leader不用问询acceptor曾接受过的ID最大的提议、只有leader提议也不需要acceptor进行promise)直至发生leader宕机、重新选主。
 
-**小结**
+## **小结**
 
 以上介绍了Paxos的推演过程、如何在Basic Paxos的基础上通过状态机构建Multi Paxos。Paxos协议比较“艰深晦涩”，但多读几遍论文一般能理解其内涵，更难的是如何将Paxos真正应用到工程实践。
 
 微信后台开发同学实现并开源了一套基于Paxos协议的多机状态拷贝类库[PhxPaxos](https://github.com/tencent-wechat/phxpaxos)，PhxPaxos用于将单机服务扩展到多机，其经过线上系统验证并在一致性保证、性能等方面作了很多考量。
-
---
+  
+--  
 
 本文提到的一些概念包括一致性(consistency)、一致性系统模型(system model)、多数派(quorum)、全序关系(total order)等，在以下文章中有介绍 :)
 
@@ -156,6 +164,3 @@ proposer leader在Multi Paxos中还有助于提升性能，常态下统一由lea
 [《分布式系统理论基础 - 时间、时钟和事件顺序》](http://www.cnblogs.com/bangerlee/p/5448766.html)
 
 [《分布式系统理论基础 - CAP》](http://www.cnblogs.com/bangerlee/p/5328888.html)
-
-
-
diff --git "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2006\357\274\232Raft\343\200\201Zab.md" "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232Raft\343\200\201Zab.md"
similarity index 56%
rename from "docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2006\357\274\232Raft\343\200\201Zab.md"
rename to "docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232Raft\343\200\201Zab.md"
index eed436a..4530e9d 100644
--- "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2006\357\274\232Raft\343\200\201Zab.md"
+++ "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232Raft\343\200\201Zab.md"
@@ -1,12 +1,23 @@
-本文转自：https://www.cnblogs.com/bangerlee/p/5991417.html
+# 目录
+
+  * [**引言**](#引言)
+  * [**Raft**](#raft)
+  * [**Zab**](#zab)
+  * [**Paxos、Raft、Zab再比较**](#paxos、raft、zab再比较)
+  * [**小结**](#小结)
+
+
+本文转自：[https://www.cnblogs.com/bangerlee/p/5991417.html](https://www.cnblogs.com/bangerlee/p/5991417.html)
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
+
+> [https://github.com/h2pl/Java-Tutorial](https://github.com/h2pl/Java-Tutorial)
 
 喜欢的话麻烦点下Star哈
 
 本文也将同步到我的个人博客：
-> www.how2playlife.com
+
+> [www.how2playlife.com](www.how2playlife.com)
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
 
@@ -20,92 +31,99 @@
 
 [《分布式系统理论进阶 - Paxos》](http://www.cnblogs.com/bangerlee/p/5655754.html)介绍了一致性协议Paxos，今天我们来学习另外两个常见的一致性协议——Raft和Zab。通过与Paxos对比，了解Raft和Zab的核心思想、加深对一致性协议的认识。
 
-**Raft**
+## **Raft**
 
-Paxos偏向于理论、对如何应用到工程实践提及较少。理解的难度加上现实的骨感，在生产环境中基于Paxos实现一个正确的分布式系统非常难<sup>[1]</sup>：
+Paxos偏向于理论、对如何应用到工程实践提及较少。理解的难度加上现实的骨感，在生产环境中基于Paxos实现一个正确的分布式系统非常难[1]：
 
-> **There are significant gaps between the description of the Paxos algorithm and the needs of a real-world system**. In order to build a real-world system, an expert needs to use numerous ideas scattered in the literature and make several relatively small protocol extensions. The cumulative effort will be substantial and **the final system will be based on an unproven protocol**.
+> **There are significant gaps between the description of the Paxos algorithm and the needs of a real-world system**. In order to build a real-world system, an expert needs to use numerous ideas scattered in the literature and make several relatively small protocol extensions. The cumulative effort will be substantial and**the final system will be based on an unproven protocol**.
 
-![](https://images2015.cnblogs.com/blog/116770/201610/116770-20161023233740326-287853098.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20161023233740326-287853098.png)
 
-Raft<sup>[2][3]</sup>在2013年提出，提出的时间虽然不长，但已经有很多系统基于Raft实现。相比Paxos，Raft的买点就是更利于理解、更易于实行。
+Raft[2](#)在2013年提出，提出的时间虽然不长，但已经有很多系统基于Raft实现。相比Paxos，Raft的买点就是更利于理解、更易于实行。
 
-为达到更容易理解和实行的目的，Raft将问题分解和具体化：Leader统一处理变更操作请求，一致性协议的作用具化为保证节点间操作日志副本(log replication)一致，以term作为逻辑时钟(logical clock)保证时序，节点运行相同状态机(state machine)<sup>[4]</sup>得到一致结果。Raft协议具体过程如下：
+为达到更容易理解和实行的目的，Raft将问题分解和具体化：Leader统一处理变更操作请求，一致性协议的作用具化为保证节点间操作日志副本(log replication)一致，以term作为逻辑时钟(logical clock)保证时序，节点运行相同状态机(state machine)[4]得到一致结果。Raft协议具体过程如下：
 
-![](https://images2015.cnblogs.com/blog/116770/201610/116770-20161024005549560-244386650.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20161024005549560-244386650.png)
 
 1.  Client发起请求，每一条请求包含操作指令
+
 2.  请求交由Leader处理，Leader将操作指令(entry)追加(append)至操作日志，紧接着对Follower发起AppendEntries请求、尝试让操作日志副本在Follower落地
+
 3.  如果Follower多数派(quorum)同意AppendEntries请求，Leader进行commit操作、把指令交由状态机处理
+
 4.  状态机处理完成后将结果返回给Client
 
+
 指令通过log index(指令id)和term number保证时序，正常情况下Leader、Follower状态机按相同顺序执行指令，得出相同结果、状态一致。
 
-宕机、网络分化等情况可引起Leader重新选举(每次选举产生新Leader的同时，产生新的term)、Leader/Follower间状态不一致。Raft中Leader为自己和所有Follower各维护一个nextIndex值，其表示Leader紧接下来要处理的指令id以及将要发给Follower的指令id，L<sub>nextIndex</sub>不等于F<sub>nextIndex</sub>时代表Leader操作日志和Follower操作日志存在不一致，这时将从Follower操作日志中最初不一致的地方开始，由Leader操作日志覆盖Follower，直到L<sub>nextIndex、</sub>F<sub>nextIndex</sub>相等。
+宕机、网络分化等情况可引起Leader重新选举(每次选举产生新Leader的同时，产生新的term)、Leader/Follower间状态不一致。Raft中Leader为自己和所有Follower各维护一个nextIndex值，其表示Leader紧接下来要处理的指令id以及将要发给Follower的指令id，LnextIndex不等于FnextIndex时代表Leader操作日志和Follower操作日志存在不一致，这时将从Follower操作日志中最初不一致的地方开始，由Leader操作日志覆盖Follower，直到LnextIndex、FnextIndex相等。
 
 Paxos中Leader的存在是为了提升决议效率，Leader的有无和数目并不影响决议一致性，Raft要求具备唯一Leader，并把一致性问题具体化为保持日志副本的一致性，以此实现相较Paxos而言更容易理解、更容易实现的目标。
 
-**Zab**
+## **Zab**
 
-Zab<sup>[5][6]</sup>的全称是Zookeeper atomic broadcast protocol，是Zookeeper内部用到的一致性协议。相比Paxos，Zab最大的特点是保证强一致性(strong consistency，或叫线性一致性linearizable consistency)。
+Zab[5](#)的全称是Zookeeper atomic broadcast protocol，是Zookeeper内部用到的一致性协议。相比Paxos，Zab最大的特点是保证强一致性(strong consistency，或叫线性一致性linearizable consistency)。
 
 和Raft一样，Zab要求唯一Leader参与决议，Zab可以分解成discovery、sync、broadcast三个阶段：
 
-![](https://images2015.cnblogs.com/blog/116770/201610/116770-20161025133734734-658183229.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20161025133734734-658183229.jpg)
+
+-   **discovery**: 选举产生PL(prospective leader)，PL收集Follower epoch(cepoch)，根据Follower的反馈PL产生newepoch(每次选举产生新Leader的同时产生新epoch，类似Raft的term)
+
+-   **sync**: PL补齐相比Follower多数派缺失的状态、之后各Follower再补齐相比PL缺失的状态，PL和Follower完成状态同步后PL变为正式Leader(established leader)
+
+-   **broadcast**: Leader处理Client的写操作，并将状态变更广播至Follower，Follower多数派通过之后Leader发起将状态变更落地(deliver/commit)
 
-*   **discovery**: 选举产生PL(prospective leader)，PL收集Follower epoch(cepoch)，根据Follower的反馈PL产生newepoch(每次选举产生新Leader的同时产生新epoch，类似Raft的term)
-*   **sync**: PL补齐相比Follower多数派缺失的状态、之后各Follower再补齐相比PL缺失的状态，PL和Follower完成状态同步后PL变为正式Leader(established leader)
-*   **broadcast**: Leader处理Client的写操作，并将状态变更广播至Follower，Follower多数派通过之后Leader发起将状态变更落地(deliver/commit)
 
 Leader和Follower之间通过心跳判别健康状态，正常情况下Zab处在broadcast阶段，出现Leader宕机、网络隔离等异常情况时Zab重新回到discovery阶段。
 
 了解完Zab的基本原理，我们再来看Zab怎样保证强一致性，Zab通过约束事务先后顺序达到强一致性，先广播的事务先commit、FIFO，Zab称之为primary order(以下简称PO)。实现PO的核心是zxid。
 
-Zab中每个事务对应一个zxid，它由两部分组成：<e, c>，e即Leader选举时生成的epoch，c表示当次epoch内事务的编号、依次递增。假设有两个事务的zxid分别是z、z'，当满足 z.e < z'.e 或者 z.e = z'.e && z.c < z'.c 时，定义z先于z'发生(z < z')。
+Zab中每个事务对应一个zxid，它由两部分组成：<e, c>，e即Leader选举时生成的epoch，c表示当次epoch内事务的编号、依次递增。假设有两个事务的zxid分别是z、z'，当满足z.e < z'.e 或者z.e = z'.e && z.c < z'.c时，定义z先于z'发生(z < z')。
 
 为实现PO，Zab对Follower、Leader有以下约束：
 
 1.  有事务z和z'，如果Leader先广播z，则Follower需保证先commit z对应的事务
+
 2.  有事务z和z'，z由Leader p广播，z'由Leader q广播，Leader p先于Leader q，则Follower需保证先commit z对应的事务
+
 3.  有事务z和z'，z由Leader p广播，z'由Leader q广播，Leader p先于Leader q，如果Follower已经commit z，则q需保证已commit z才能广播z'
 
+
 第1、2点保证事务FIFO，第3点保证Leader上具备所有已commit的事务。
 
 相比Paxos，Zab约束了事务顺序、适用于有强一致性需求的场景。
 
-**Paxos、Raft、Zab再比较**
+## **Paxos、Raft、Zab再比较**
 
-除Paxos、Raft和Zab外，Viewstamped Replication(简称VR)<sup>[7][8]</sup>也是讨论比较多的一致性协议。这些协议包含很多共同的内容(Leader、quorum、state machine等)，因而我们不禁要问：Paxos、Raft、Zab和VR等分布式一致性协议区别到底在哪，还是根本就是一回事？<sup>[9]</sup>
+除Paxos、Raft和Zab外，Viewstamped Replication(简称VR)[7](#)也是讨论比较多的一致性协议。这些协议包含很多共同的内容(Leader、quorum、state machine等)，因而我们不禁要问：Paxos、Raft、Zab和VR等分布式一致性协议区别到底在哪，还是根本就是一回事？[9]
 
-Paxos、Raft、Zab和VR都是解决一致性问题的协议，Paxos协议原文倾向于理论，Raft、Zab、VR倾向于实践，一致性保证程度等的不同也导致这些协议间存在差异。下图帮助我们理解这些协议的相似点和区别<sup>[10]</sup>：
+Paxos、Raft、Zab和VR都是解决一致性问题的协议，Paxos协议原文倾向于理论，Raft、Zab、VR倾向于实践，一致性保证程度等的不同也导致这些协议间存在差异。下图帮助我们理解这些协议的相似点和区别[10]：
 
-![](https://images2015.cnblogs.com/blog/116770/201610/116770-20161025213003515-974965973.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20161025213003515-974965973.jpg)
 
 相比Raft、Zab、VR，Paxos更纯粹、更接近一致性问题本源，尽管Paxos倾向理论，但不代表Paxos不能应用于工程。基于Paxos的工程实践，须考虑具体需求场景(如一致性要达到什么程度)，再在Paxos原始语意上进行包装。
 
-**小结**
+## **小结**
 
 以上介绍分布式一致性协议Raft、Zab的核心思想，分析Raft、Zab与Paxos的异同。实现分布式系统时，先从具体需求和场景考虑，Raft、Zab、VR、Paxos等协议没有绝对地好与不好，只是适不适合。
 
-[1] [Paxos made live - An engineering perspective](http://www.cs.utexas.edu/users/lorenzo/corsi/cs380d/papers/paper2-1.pdf), Tushar Chandra, Robert Griesemer and Joshua Redstone, 2007
-
-[2] [In Search of an Understandable Consensus Algorithm](http://files.catwell.info/misc/mirror/raft/raft.pdf), Diego Ongaro and John Ousterhout, 2013
-
-[3] [In Search of an Understandable Consensus Algorithm (Extended Version)](https://www.baidu.com/link?url=59S8Pf5DhEUcoYrNaNCLLF9d-rKeHrakboBuYcNcn86jxgxEIH-LzSzP_isdeyhTA3hkn7AYn64x1KCNAvSy22SJEMKGlqG5Ypum8iTcd9AT2QQwHoHAwVuTR7yBFc4n&wd=&eqid=8c4a598b000007f000000006580cec0c), Diego Ongaro and John Ousterhout, 2013
-
-[4] [Implementing Fault-Tolerant Services Using the State Machine](http://www.infosys.tuwien.ac.at/teaching/courses/AdvancedDistributedSystems/download/1990_Schneider_Implementing%20fault-tolerant%20services%20using%20the%20state%20machine%20approach.pdf), Fred B. Schneider, 1990
+[1][Paxos made live - An engineering perspective](http://www.cs.utexas.edu/users/lorenzo/corsi/cs380d/papers/paper2-1.pdf), Tushar Chandra, Robert Griesemer and Joshua Redstone, 2007
 
-[5] [Zab:High-performance broadcast for primary-backup systems](http://www.cs.cornell.edu/courses/cs6452/2012sp/papers/zab-ieee.pdf), FlavioP.Junqueira,BenjaminC.Reed,andMarcoSerafini, 2011
+[2][In Search of an Understandable Consensus Algorithm](http://files.catwell.info/misc/mirror/raft/raft.pdf),Diego Ongaro and John Ousterhout, 2013
 
-[6] [ZooKeeper's atomic broadcast protocol: Theory and practice](http://www.tcs.hut.fi/Studies/T-79.5001/reports/2012-deSouzaMedeiros.pdf), Andr´e Medeiros, 2012
+[3][In Search of an Understandable Consensus Algorithm (Extended Version)](https://www.baidu.com/link?url=59S8Pf5DhEUcoYrNaNCLLF9d-rKeHrakboBuYcNcn86jxgxEIH-LzSzP_isdeyhTA3hkn7AYn64x1KCNAvSy22SJEMKGlqG5Ypum8iTcd9AT2QQwHoHAwVuTR7yBFc4n&wd=&eqid=8c4a598b000007f000000006580cec0c), Diego Ongaro and John Ousterhout, 2013
 
-[7] [Viewstamped Replication A New Primary Copy Method to Support Highly-Available Distributed Systems](http://pmg.csail.mit.edu/papers/vr.pdf), Brian M.Oki and Barbar H.Liskov, 1988
+[4][Implementing Fault-Tolerant Services Using the State Machine](http://www.infosys.tuwien.ac.at/teaching/courses/AdvancedDistributedSystems/download/1990_Schneider_Implementing%20fault-tolerant%20services%20using%20the%20state%20machine%20approach.pdf), Fred B. Schneider, 1990
 
-[8] [Viewstamped Replication Revisited](http://pmg.csail.mit.edu/papers/vr-revisited.pdf), Barbara Liskov and James Cowling, Barbara Liskov and James Cowling ,2012
+[5][Zab:High-performance broadcast for primary-backup systems](http://www.cs.cornell.edu/courses/cs6452/2012sp/papers/zab-ieee.pdf), FlavioP.Junqueira,BenjaminC.Reed,andMarcoSerafini, 2011
 
-[9] [Can’t we all just agree?](https://blog.acolyer.org/2015/03/01/cant-we-all-just-agree/) The morning paper, 2015
+[6][ZooKeeper's atomic broadcast protocol: Theory and practice](http://www.tcs.hut.fi/Studies/T-79.5001/reports/2012-deSouzaMedeiros.pdf), Andr´e Medeiros, 2012
 
-[10] [Vive La Difference: Paxos vs. Viewstamped Replication vs. Zab](https://arxiv.org/pdf/1309.5671.pdf), Robbert van Renesse, Nicolas Schiper and Fred B. Schneider, 2014
+[7][Viewstamped Replication A New Primary Copy Method to Support Highly-Available Distributed Systems](http://pmg.csail.mit.edu/papers/vr.pdf), Brian M.Oki and Barbar H.Liskov, 1988
 
+[8][Viewstamped Replication Revisited](http://pmg.csail.mit.edu/papers/vr-revisited.pdf), Barbara Liskov and James Cowling, Barbara Liskov and James Cowling ,2012
 
+[9][Can’t we all just agree?](https://blog.acolyer.org/2015/03/01/cant-we-all-just-agree/)The morning paper, 2015
 
+[10][Vive La Difference: Paxos vs. Viewstamped Replication vs. Zab](https://arxiv.org/pdf/1309.5671.pdf),Robbert van Renesse, Nicolas Schiper and Fred B. Schneider, 2014
diff --git "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2008\357\274\232zookeeper\345\210\206\345\270\203\345\274\217\345\215\217\350\260\203\346\234\215\345\212\241.md" "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232zookeeper\345\210\206\345\270\203\345\274\217\345\215\217\350\260\203\346\234\215\345\212\241.md"
similarity index 86%
rename from "docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2008\357\274\232zookeeper\345\210\206\345\270\203\345\274\217\345\215\217\350\260\203\346\234\215\345\212\241.md"
rename to "docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232zookeeper\345\210\206\345\270\203\345\274\217\345\215\217\350\260\203\346\234\215\345\212\241.md"
index bdfd882..4dd3007 100644
--- "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2008\357\274\232zookeeper\345\210\206\345\270\203\345\274\217\345\215\217\350\260\203\346\234\215\345\212\241.md"
+++ "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232zookeeper\345\210\206\345\270\203\345\274\217\345\215\217\350\260\203\346\234\215\345\212\241.md"
@@ -1,3 +1,13 @@
+# 目录
+
+  * [**ZK API**](#zk-api)
+  * [**ZK应用场景**](#zk应用场景)
+  * [**Leader选举**](#leader选举)
+  * [**配置管理**](#配置管理)
+  * [**ZK监控**](#zk监控)
+  * [**小结**](#小结)
+
+
 本文转自 https://www.cnblogs.com/bangerlee/p/5268485.html
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -14,10 +24,9 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 
 
-## [分布式服务协调员zookeeper - 应用场景和监控](https://www.cnblogs.com/bangerlee/p/4427331.html)
 
 zookeeper在分布式系统中作为协调员的角色，可应用于Leader选举、分布式锁、配置管理等服务的实现。以下我们从zookeeper供的API、应用场景和监控三方面学习和了解zookeeper（以下简称ZK）。
 
@@ -25,11 +34,11 @@ zookeeper在分布式系统中作为协调员的角色，可应用于Leader选
 
 
 
-**ZK API**
+## **ZK API**
 
 ZK以Unix文件系统树结构的形式管理存储的数据，图示如下：
 
-![](https://images0.cnblogs.com/blog2015/116770/201504/142337054797921.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/142337054797921.png)
 
 其中每个树节点被称为**znode**，每个znode类似一个文件，包含文件元信息(meta data)和数据。
 
@@ -52,11 +61,11 @@ ZK提供了以下API，供client操作znode和znode中存储的数据：
 *   setData(path, data, version)：将data[]数据写入对应path/version的znode
 *   getChildren(path, watch)：返回指定znode的子节点集合
 
-**ZK应用场景**
+## **ZK应用场景**
 
 基于以上ZK提供的znode和znode数据的操作，可轻松实现Leader选举、分布式锁、配置管理等服务。
 
-**Leader选举**
+## **Leader选举**
 
 利用打上sequential标志的Ephemeral，我们可以实现Leader选举。假设需要从三个client中选取Leader，实现过程如下：
 
@@ -64,8 +73,8 @@ ZK提供了以下API，供client操作znode和znode中存储的数据：
 
 
 
-<pre>[zk: localhost:2181(CONNECTED) 4] ls /master
-[lock-0000000241, lock-0000000243, lock-0000000242]</pre>
+[zk: localhost:2181(CONNECTED) 4] ls /master  
+[lock-0000000241, lock-0000000243, lock-0000000242]
 
 
 
@@ -77,7 +86,7 @@ ZK提供了以下API，供client操作znode和znode中存储的数据：
 
 分布式锁的实现与以上Leader选举的实现相同，稍作修改，我们还可以基于ZK实现lease机制（有期限的授权服务）。
 
-**配置管理**
+## **配置管理**
 
 znode可以存储数据，基于这一点，我们可以用ZK实现分布式系统的配置管理，假设有服务A，A扩容设备时需要将相应新增的ip/port同步到全网服务器的A.conf配置，实现过程如下：
 
@@ -85,8 +94,8 @@ znode可以存储数据，基于这一点，我们可以用ZK实现分布式系
 
 
 
-<pre>[zk: localhost:2181(CONNECTED) 30] get /A/blk-0000340369 {"svr_info": [{"ip": "1.1.1.1.", "port": "11000"}]}
-cZxid = 0x2ffdeda3be ……</pre>
+[zk: localhost:2181(CONNECTED) 30] get /A/blk-0000340369 {"svr_info": [{"ip": "1.1.1.1.", "port": "11000"}]}  
+cZxid = 0x2ffdeda3be ……
 
 
 
@@ -96,16 +105,16 @@ cZxid = 0x2ffdeda3be ……</pre>
 
 服务缩容的步骤类似，机器下线时将ZK相应节点删除，全网机器监听到该事件后将配置中的设备剔除。
 
-**ZK监控**
+## **ZK监控**
 
 ZK自身提供了一些“四字命令”，通过这些四字命令，我们可以获得ZK集群中，某台ZK的角色、znode数、健康状态等信息：
 
 
 
 
-<pre># echo "mntr" | /usr/bin/netcat 127.0.0.1 2181 zk_version 3.4.3-1240972, built on 02/06/2012 10:48 GMT
-zk_packets_received 267044485 zk_packets_sent 267069992 zk_outstanding_requests 0 zk_server_state follower
-zk_znode_count 16216</pre>
+# echo "mntr" | /usr/bin/netcat 127.0.0.1 2181 zk_version 3.4.3-1240972, built on 02/06/2012 10:48 GMT  
+zk_packets_received 267044485 zk_packets_sent 267069992 zk_outstanding_requests 0 zk_server_state follower  
+zk_znode_count 16216
 
 
 
@@ -120,16 +129,13 @@ zk_znode_count 16216</pre>
 
 
 
-<pre>/usr/local/zookeeper/bin/zkCli.sh create /zookeeper/test 'test' >/dev/null 2>&1
-/usr/local/zookeeper/bin/zkCli.sh delete /zookeeper/test >/dev/null 2>&1</pre>
+/usr/local/zookeeper/bin/zkCli.sh create /zookeeper/test 'test' >/dev/null 2>&1  
+/usr/local/zookeeper/bin/zkCli.sh delete /zookeeper/test >/dev/null 2>&1
 
 
 
 再根据返回值判断添加、删除znode是否成功，从而判断该台ZK状态是否正常。
 
-**小结**
+## **小结**
 
 zookeeper以目录树的形式管理数据，提供znode监听、数据设置等接口，基于这些接口，我们可以实现Leader选举、配置管理、命名服务等功能。结合四字命令，加上模拟zookeeper client 创建/删除znode，我们可以实现对zookeeper的有效监控。在各种分布式系统中，我们经常可以看到zookeeper的身影。
-
-
-
diff --git "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2005\357\274\232\351\200\211\344\270\276\343\200\201\345\244\232\346\225\260\346\264\276\345\222\214\347\247\237\347\272\246.md" "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232\351\200\211\344\270\276\343\200\201\345\244\232\346\225\260\346\264\276\345\222\214\347\247\237\347\272\246.md"
similarity index 70%
rename from "docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2005\357\274\232\351\200\211\344\270\276\343\200\201\345\244\232\346\225\260\346\264\276\345\222\214\347\247\237\347\272\246.md"
rename to "docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232\351\200\211\344\270\276\343\200\201\345\244\232\346\225\260\346\264\276\345\222\214\347\247\237\347\272\246.md"
index 8d80f62..1455063 100644
--- "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\2005\357\274\232\351\200\211\344\270\276\343\200\201\345\244\232\346\225\260\346\264\276\345\222\214\347\247\237\347\272\246.md"
+++ "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\345\237\272\347\241\200\357\274\232\351\200\211\344\270\276\343\200\201\345\244\232\346\225\260\346\264\276\345\222\214\347\247\237\347\272\246.md"
@@ -1,11 +1,21 @@
+# 目录
+
+  * [**选举(electioin)**](#选举electioin)
+  * [**多数派(quorum)**](#多数派quorum)
+  * [**租约(lease)**](#租约lease)
+  * [**小结**](#小结)
+
+
 本文转自：https://www.cnblogs.com/bangerlee/p/5767845.html
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本文也将同步到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -15,7 +25,7 @@
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
 <!-- more -->
- <small></small> <small>选举(election)是分布式系统实践中常见的问题，通过打破节点间的对等关系，选得的leader(或叫master、coordinator)有助于实现事务原子性、提升决议效率。 多数派(quorum)的思路帮助我们在网络分化的情况下达成决议一致性，在leader选举的场景下帮助我们选出唯一leader。租约(lease)在一定期限内给予节点特定权利，也可以用于实现leader选举。</small>
+<small></small> <small>选举(election)是分布式系统实践中常见的问题，通过打破节点间的对等关系，选得的leader(或叫master、coordinator)有助于实现事务原子性、提升决议效率。 多数派(quorum)的思路帮助我们在网络分化的情况下达成决议一致性，在leader选举的场景下帮助我们选出唯一leader。租约(lease)在一定期限内给予节点特定权利，也可以用于实现leader选举。</small>
 
 
 
@@ -23,13 +33,13 @@
 
 下面我们就来学习分布式系统理论中的选举、多数派和租约。
 
-**选举(electioin)**
+## **选举(electioin)**
 
 一致性问题(consistency)是独立的节点间如何达成决议的问题，选出大家都认可的leader本质上也是一致性问题，因而如何应对宕机恢复、网络分化等在leader选举中也需要考量。
 
 Bully算法<sup>[1]</sup>是最常见的选举算法，其要求每个节点对应一个序号，序号最高的节点为leader。leader宕机后次高序号的节点被重选为leader，过程如下：
 
-![](https://images2015.cnblogs.com/blog/116770/201608/116770-20160814110211906-1201598126.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407204901.png)
 
 (a). 节点4发现leader不可达，向序号比自己高的节点发起重新选举，重新选举消息中带上自己的序号
 
@@ -43,23 +53,23 @@ Bully算法<sup>[1]</sup>是最常见的选举算法，其要求每个节点对
 
 在一致性算法[Paxos](http://www.cnblogs.com/bangerlee/p/5655754.html)、ZAB<sup>[2]</sup>、Raft<sup>[3]</sup>中，为提升决议效率均有节点充当leader的角色。ZAB、Raft中描述了具体的leader选举实现，与Bully算法类似ZAB中使用zxid标识节点，具有最大zxid的节点表示其所具备的事务(transaction)最新、被选为leader。
 
-**多数派(quorum)**
+## **多数派(quorum)**
 
 在网络分化的场景下以上Bully算法会遇到一个问题，被分隔的节点都认为自己具有最大的序号、将产生多个leader，这时候就需要引入多数派(quorum)<sup>[4]</sup>。多数派的思路在分布式系统中很常见，其确保网络分化情况下决议唯一。
 
 多数派的原理说起来很简单，假如节点总数为2f+1，则一项决议得到多于 f 节点赞成则获得通过。leader选举中，网络分化场景下只有具备多数派节点的部分才可能选出leader，这避免了多leader的产生。
 
-![](https://images2015.cnblogs.com/blog/116770/201608/116770-20160814195846250-9979865.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407204912.png)
 
 多数派的思路还被应用于副本(replica)管理，根据业务实际读写比例调整写副本数V<sub>w</sub>、读副本数V<sub>r</sub>，用以在可靠性和性能方面取得平衡<sup>[5]</sup>。
 
-**租约(lease)**
+## **租约(lease)**
 
 选举中很重要的一个问题，以上尚未提到：怎么判断leader不可用、什么时候应该发起重新选举？最先可能想到会通过心跳(heart beat)判别leader状态是否正常，但在网络拥塞或瞬断的情况下，这容易导致出现双主。
 
 租约(lease)是解决该问题的常用方法，其最初提出时用于解决分布式缓存一致性问题<sup>[6]</sup>，后面在分布式锁<sup>[7]</sup>等很多方面都有应用。
 
-![](https://images2015.cnblogs.com/blog/116770/201608/116770-20160821195833933-818514275.png) 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20160821195833933-818514275.png)
 
 租约的原理同样不复杂，中心思想是每次租约时长内只有一个节点获得租约、到期后必须重新颁发租约。假设我们有租约颁发节点Z，节点0、1和2竞选leader，租约过程如下：
 
@@ -69,7 +79,7 @@ Bully算法<sup>[1]</sup>是最常见的选举算法，其要求每个节点对
 
 租约机制确保了一个时刻最多只有一个leader，避免只使用心跳机制产生双主的问题。在实践应用中，zookeeper、ectd可用于租约颁发。
 
-**小结**
+## **小结**
 
 在分布式系统理论和实践中，常见leader、quorum和lease的身影。分布式系统内不一定事事协商、事事民主，leader的存在有助于提升决议效率。
 
@@ -77,21 +87,21 @@ Bully算法<sup>[1]</sup>是最常见的选举算法，其要求每个节点对
 
 最后提一个有趣的问题与大家思考，leader选举的本质是一致性问题，Paxos、Raft和ZAB等解决一致性问题的协议和算法本身又需要或依赖于leader，怎么理解这个看似“蛋生鸡、鸡生蛋”的问题？<sup>[8]</sup>
 
-[1] [Elections in a Distributed Computing System](http://homepage.divms.uiowa.edu/~ghosh/Bully.pdf), Hector Garcia-Molina, 1982
+[1][Elections in a Distributed Computing System](http://homepage.divms.uiowa.edu/~ghosh/Bully.pdf), Hector Garcia-Molina, 1982
 
-[2] [ZooKeeper’s atomic broadcast protocol: Theory and practice](http://www.tcs.hut.fi/Studies/T-79.5001/reports/2012-deSouzaMedeiros.pdf), Andre Medeiros, 2012
+[2][ZooKeeper’s atomic broadcast protocol: Theory and practice](http://www.tcs.hut.fi/Studies/T-79.5001/reports/2012-deSouzaMedeiros.pdf), Andre Medeiros, 2012
 
-[3] [In Search of an Understandable Consensus Algorithm](https://ramcloud.atlassian.net/wiki/download/attachments/6586375/raft.pdf), Diego Ongaro and John Ousterhout, 2013
+[3][In Search of an Understandable Consensus Algorithm](https://ramcloud.atlassian.net/wiki/download/attachments/6586375/raft.pdf), Diego Ongaro and John Ousterhout, 2013
 
-[4] [A quorum-based commit protocol](https://ecommons.cornell.edu/bitstream/handle/1813/6323/82-483.pdf?sequence=1), Dale Skeen, 1982
+[4][A quorum-based commit protocol](https://ecommons.cornell.edu/bitstream/handle/1813/6323/82-483.pdf?sequence=1), Dale Skeen, 1982
 
-[5] [Weighted Voting for Replicated Data](http://lass.cs.umass.edu/~shenoy/courses/spring04/677/readings/gifford.pdf), David K. Gifford, 1979
+[5][Weighted Voting for Replicated Data](http://lass.cs.umass.edu/~shenoy/courses/spring04/677/readings/gifford.pdf), David K. Gifford, 1979
 
-[6] [Leases: An Efficient Fault-Tolerant Mechanism for Distributed File Cache Consistency](http://web.stanford.edu/class/cs240/readings/89-leases.pdf), Cary G. Gray and David R. Cheriton, 1989
+[6][Leases: An Efficient Fault-Tolerant Mechanism for Distributed File Cache Consistency](http://web.stanford.edu/class/cs240/readings/89-leases.pdf), Cary G. Gray and David R. Cheriton, 1989
 
-[7] [The Chubby lock service for loosely-coupled distributed systems](http://research.google.com/archive/chubby-osdi06.pdf), Mike Burrows, 2006
+[7][The Chubby lock service for loosely-coupled distributed systems](http://research.google.com/archive/chubby-osdi06.pdf), Mike Burrows, 2006
 
-[8] [Why is Paxos leader election not done using Paxos?](http://stackoverflow.com/questions/23798724/why-is-paxos-leader-election-not-done-using-paxos)
+[8][Why is Paxos leader election not done using Paxos?](http://stackoverflow.com/questions/23798724/why-is-paxos-leader-election-not-done-using-paxos)
 
 
 
diff --git "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\350\277\233\351\230\2667\357\274\232Paxos\345\217\230\347\247\215\345\222\214\344\274\230\345\214\226.md" "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\350\277\233\351\230\266\357\274\232Paxos\345\217\230\347\247\215\345\222\214\344\274\230\345\214\226.md"
similarity index 76%
rename from "docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\350\277\233\351\230\2667\357\274\232Paxos\345\217\230\347\247\215\345\222\214\344\274\230\345\214\226.md"
rename to "docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\350\277\233\351\230\266\357\274\232Paxos\345\217\230\347\247\215\345\222\214\344\274\230\345\214\226.md"
index 1f62cb4..abc4289 100644
--- "a/docs/distrubuted/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\350\277\233\351\230\2667\357\274\232Paxos\345\217\230\347\247\215\345\222\214\344\274\230\345\214\226.md"
+++ "b/docs/distributed/basic/\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\220\206\350\256\272\350\277\233\351\230\266\357\274\232Paxos\345\217\230\347\247\215\345\222\214\344\274\230\345\214\226.md"
@@ -1,3 +1,11 @@
+# 目录
+  * [**引言**](#引言)
+  * [**Multi Paxos**](#multi-paxos)
+  * [**Fast Paxos**](#fast-paxos)
+  * [**EPaxos**](#epaxos)
+  * [**小结**](#小结)
+
+
 本文转自：https://www.cnblogs.com/bangerlee/p/6189646.html
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -14,21 +22,21 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 
-**引言**
+## **引言**
 
 [《分布式系统理论进阶 - Paxos》](http://www.cnblogs.com/bangerlee/p/5655754.html)中我们了解了Basic Paxos、Multi Paxos的基本原理，但如果想把Paxos应用于工程实践，了解基本原理还不够。
 
 有很多基于Paxos的优化，在保证一致性协议正确(safety)的前提下，减少Paxos决议通信步骤、避免单点故障、实现节点负载均衡，从而降低时延、增加吞吐量、提升可用性，下面我们就来了解这些Paxos变种。
 
-![](https://images2015.cnblogs.com/blog/116770/201612/116770-20161217185911917-43631009.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20161217185911917-43631009.jpg)
 
-**Multi Paxos**
+## **Multi Paxos**
 
 首先我们来回顾一下Multi Paxos，Multi Paxos在Basic Paxos的基础上确定一系列值，其决议过程如下：
 
-![](https://images2015.cnblogs.com/blog/116770/201612/116770-20161218102045714-754820695.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20161218102045714-754820695.png)
 
 phase1a: leader提交提议给acceptor
 
@@ -36,27 +44,27 @@ phase1b: acceptor返回最近一次接受的提议(即曾接受的最大的提
 
 phase2a: leader收集acceptor的应答，分两种情况处理
 
-　　phase2a.1: 如果应答内容都为空，则自由选择一个提议value
+phase2a.1: 如果应答内容都为空，则自由选择一个提议value
 
-　　phase2a.2: 如果应答内容不为空，则选择应答里面ID最大的提议的value
+phase2a.2: 如果应答内容不为空，则选择应答里面ID最大的提议的value
 
 phase2b: acceptor将决议同步给learner
 
 Multi Paxos中leader用于避免活锁，但leader的存在会带来其他问题，一是如何选举和保持唯一leader(虽然无leader或多leader不影响一致性，但影响决议进程progress)，二是充当leader的节点会承担更多压力，如何均衡节点的负载。Mencius<sup>[1]</sup>提出节点轮流担任leader，以达到均衡负载的目的；租约(lease)可以帮助实现唯一leader，但leader故障情况下可导致服务短期不可用。
 
-**Fast Paxos**
+## **Fast Paxos**
 
 在Multi Paxos中，proposer -> leader -> acceptor -> learner，从提议到完成决议共经过3次通信，能不能减少通信步骤？
 
 对Multi Paxos phase2a，如果可以自由提议value，则可以让proposer直接发起提议、leader退出通信过程，变为proposer -> acceptor -> learner，这就是Fast Paxos<sup>[2]</sup>的由来。
 
-![](https://images2015.cnblogs.com/blog/116770/201612/116770-20161218102011683-1409659558.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20161218102011683-1409659558.png)
 
 Multi Paxos里提议都由leader提出，因而不存在一次决议出现多个value，Fast Paxos里由proposer直接提议，一次决议里可能有多个proposer提议、出现多个value，即出现提议冲突(collision)。leader起到初始化决议进程(progress)和解决冲突的作用，当冲突发生时leader重新参与决议过程、回退到3次通信步骤。
 
 Paxos自身隐含的一个特性也可以达到减少通信步骤的目标，如果acceptor上一次确定(chosen)的提议来自proposerA，则当次决议proposerA可以直接提议减少一次通信步骤。如果想实现这样的效果，需要在proposer、acceptor记录上一次决议确定(chosen)的历史，用以在提议前知道哪个proposer的提议上一次被确定、当次决议能不能节省一次通信步骤。
 
-**EPaxos**
+## **EPaxos**
 
 除了从减少通信步骤的角度提高Paxos决议效率外，还有其他方面可以降低Paxos决议时延，比如Generalized Paxos<sup>[3]</sup>提出不冲突的提议(例如对不同key的写请求)可以同时决议、以降低Paxos时延。
 
@@ -64,27 +72,24 @@ Paxos自身隐含的一个特性也可以达到减少通信步骤的目标，如
 
 为达到这些目标，EPaxos的实现有几个要点。一是EPaxos中没有全局的leader，而是每一次提议发起提议的proposer作为当次提议的leader(command leader)；二是不相互影响(interfere)的提议可以同时提交；三是跳过prepare，直接进入accept阶段。EPaxos决议的过程如下：
 
-![](https://images2015.cnblogs.com/blog/116770/201612/116770-20161218173608104-1507680298.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20161218173608104-1507680298.png)
 
 左侧展示了互不影响的两个update请求的决议过程，右侧展示了相互影响的两个update请求的决议。Multi Paxos、Mencius、EPaxos时延和吞吐量对比：
 
-![](https://images2015.cnblogs.com/blog/116770/201612/116770-20161218180622104-945213222.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/116770-20161218180622104-945213222.png)
 
 为判断决议是否相互影响，实现EPaxos得记录决议之间的依赖关系。
 
-**小结**
+## **小结**
 
 以上介绍了几个基于Paxos的变种，Mencius中节点轮流做leader、均衡节点负载，Fast Paxos减少一次通信步骤，Generalized Paxos允许互不影响的决议同时进行，EPaxos无全局leader、各节点平等分担负载。
 
 优化无止境，对Paxos也一样，应用在不同场景和不同范围的Paxos变种和优化将继续不断出现。
 
-[1] [Mencius: Building Efficient Replicated State Machines for WANs](http://cseweb.ucsd.edu/classes/wi09/cse223a/mencius.pdf), Yanhua Mao,Flavio P. Junqueira,Keith Marzullo, 2018
-
-[2] [Fast Paxos](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/tr-2005-112.pdf), Leslie Lamport, 2005
-
-[3] [Generalized Consensus and Paxos](http://diyhpl.us/~bryan/papers2/distributed/distributed-systems/generalized-consensus-and-paxos.2004.pdf), Leslie Lamport, 2004
-
-[4] [There Is More Consensus in Egalitarian Parliaments](http://sigops.org/sosp/sosp13/papers/p358-moraru.pdf), Iulian Moraru, David G. Andersen, Michael Kaminsky, 2013
+[1][Mencius: Building Efficient Replicated State Machines for WANs](http://cseweb.ucsd.edu/classes/wi09/cse223a/mencius.pdf),Yanhua Mao,Flavio P. Junqueira,Keith Marzullo, 2018
 
+[2][Fast Paxos](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/tr-2005-112.pdf),Leslie Lamport, 2005
 
+[3][Generalized Consensus and Paxos](http://diyhpl.us/~bryan/papers2/distributed/distributed-systems/generalized-consensus-and-paxos.2004.pdf),Leslie Lamport, 2004
 
+[4][There Is More Consensus in Egalitarian Parliaments](http://sigops.org/sosp/sosp13/papers/p358-moraru.pdf),Iulian Moraru, David G. Andersen, Michael Kaminsky, 2013
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25710\357\274\232LVS\345\256\236\347\216\260\350\264\237\350\275\275\345\235\207\350\241\241\347\232\204\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232LVS\345\256\236\347\216\260\350\264\237\350\275\275\345\235\207\350\241\241\347\232\204\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
similarity index 72%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25710\357\274\232LVS\345\256\236\347\216\260\350\264\237\350\275\275\345\235\207\350\241\241\347\232\204\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232LVS\345\256\236\347\216\260\350\264\237\350\275\275\345\235\207\350\241\241\347\232\204\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
index 9b4fe9e..6983151 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25710\357\274\232LVS\345\256\236\347\216\260\350\264\237\350\275\275\345\235\207\350\241\241\347\232\204\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232LVS\345\256\236\347\216\260\350\264\237\350\275\275\345\235\207\350\241\241\347\232\204\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265.md"
@@ -1,4 +1,5 @@
-# Table of Contents
+
+# 目录
 
 * [负载均衡的原理](#负载均衡的原理)
   * [隐藏真实服务器](#隐藏真实服务器)
@@ -24,11 +25,13 @@
 本文内容参考网络，侵删
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本文也将同步到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -38,6 +41,7 @@
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
 <!-- more -->
+
 # 负载均衡的原理
 
 
@@ -47,15 +51,15 @@
 
 还好张大胖也注意到了这个问题，他早有准备，一脸无奈地说： “唉，我昨天检查了一下系统，现在的访问量已经越来越大了，无论是CPU，还是硬盘、内存都不堪重负了，高峰期的响应速度越来越慢。”
 
-顿了一下，他试探地问道：“老板，能不能买个好机器？ 把现在的‘老破小’服务器给替换掉。我听说IBM的服务器挺好的，性能强劲，要不来一台？” （码农翻身注：这叫垂直扩展 Scale Up）
+顿了一下，他试探地问道：“老板，能不能买个好机器？ 把现在的‘老破小’服务器给替换掉。我听说IBM的服务器挺好的，性能强劲，要不来一台？”（码农翻身注：这叫垂直扩展 Scale Up）
 
-“好你个头，你知道那机器得多贵吗？! 我们小公司，用不起啊！” 抠门的老板立刻否决。 “这……” 大胖表示黔驴技穷了。 “你去和CTO Bill 商量下， 明天给我弄个方案出来。”
+“好你个头，你知道那机器得多贵吗？! 我们小公司，用不起啊！” 抠门的老板立刻否决。“这……” 大胖表示黔驴技穷了。“你去和CTO Bill 商量下， 明天给我弄个方案出来。”
 
 老板不管过程，只要结果。
 
 ## 隐藏真实服务器
 
-大胖悻悻地去找Bill。 他将老板的指示声情并茂地做了传达。
+大胖悻悻地去找Bill。他将老板的指示声情并茂地做了传达。
 
 Bill笑了：“我最近也在思考这件事，想和你商量一下，看看能不能买几台便宜的服务器，把系统多部署几份，横向扩展(Scale Out)一下。 ”
 
@@ -63,13 +67,13 @@ Bill笑了：“我最近也在思考这件事，想和你商量一下，看看
 
 “可是，” 张大胖问道 ，“机器多了，每个机器一个IP， 用户可能就迷糊了，到底访问哪一个？”
 
-![](https://img-blog.csdn.net/20180514232034408?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE3OTg2Mzg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407213404.png)
 
 “肯定不能把这些服务器暴露出去，从客户角度看来，最好是只有一个服务器。” Bill 说道。
 
 张大胖眼前一亮， 突然有了主意：“有了！我们有个中间层啊，对，就是DNS，我们可以设置一下，让我们网站的域名映射到多个服务器的IP，用户面对的是我们系统的域名，然后我们可以采用一种轮询的方式， 用户1的机器做域名解析的时候，DNS返回IP1, 用户2的机器做域名解析的时候，DNS返回IP2…… 这样不就可以实现各个机器的负载相对均衡了吗？”
 
-![](https://img-blog.csdn.net/20180514232152982?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE3OTg2Mzg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407213411.png)
 
 Bill 思考片刻，发现了漏洞：“这样做有个很要命的问题，由于DNS这个分层的系统中有缓存，用户端的机器也有缓存，如果某个机器出故障，域名解析仍然会返回那个出问题机器的IP，那所有访问该机器的用户都会出问题， 即使我们把这个机器的IP从DNS中删除也不行， 这就麻烦了。”
 
@@ -83,7 +87,7 @@ Bill 思考片刻，发现了漏洞：“这样做有个很要命的问题，由
 
 张大胖仔细审视这个图。
 
-![](https://img-blog.csdn.net/20180514232342333?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE3OTg2Mzg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407213424.png)
 
 Load Balancer 简称LB ， 有两个IP，一个对外（115.39.19.22），一个对内(192.168.0.100)。用户看到的是那个对外的IP。 后面的真正提供服务的服务器有三个，称为RS1, RS2,RS3， 他们的网关都指向LB。
 
@@ -91,7 +95,7 @@ Load Balancer 简称LB ， 有两个IP，一个对外（115.39.19.22），一个
 
 “你把计算机网络都忘了吧？ 就是用户发过来的数据包嘛！ 你看这个层层封装的数据包，用户发了一个HTTP的请求，想要访问我们网站的首页，这个HTTP请求被放到一个TCP报文中，再被放到一个IP数据报中， 最终的目的地就是我们的Load Balancer（115.39.19.22）。”
 
-![](https://img-blog.csdn.net/20180514232512231?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE3OTg2Mzg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407213439.png)
 
 （注： 客户发给LB的数据包， 没有画出数据链路层的帧）
 
@@ -99,13 +103,13 @@ Load Balancer 简称LB ， 有两个IP，一个对外（115.39.19.22），一个
 
 Bill 说： “可以偷天换日，比如Load Balancer想把这个数据包发给RS1（192.168.0.10）, 就可以做点手脚，把这个数据包改成这样， 然后这个IP数据包就可以转发给RS1去处理了。”
 
-![](https://img-blog.csdn.net/20180514232647304?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE3OTg2Mzg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407213504.png)
 
 （LB动了手脚，把目的地IP和端口改为RS1的）
 
 “RS1处理完了，要返回首页的HTML，还要把HTTP报文层层封装：” 张大胖明白怎么回事了：
 
-![](https://img-blog.csdn.net/20180514232808225?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE3OTg2Mzg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407213510.png)
 
 （RS1处理完了，要发送结果给客户端）
 
@@ -113,7 +117,7 @@ Bill 说： “可以偷天换日，比如Load Balancer想把这个数据包发
 
 (LB再次动手脚，把源地址和端口改成自己的， 让客户端毫无察觉)
 
-张大胖总结了一下数据的流向： 客户端 –> Load Balancer –> RS –> Load Balancer –> 客户端
+张大胖总结了一下数据的流向：客户端 –> Load Balancer –> RS –> Load Balancer –> 客户端
 
 他兴奋地说：“这招瞒天过海真是妙啊，客户端根本就感受不到后面有好几台服务器在工作，它一直以为只有Load Balancer在干活。”
 
@@ -125,7 +129,7 @@ Bill此刻在思考Load Balancer 怎么样才能选取后面的各个真实的
 
 最少连接： 哪个服务器处理的连接少，就发给谁。
 
-加权最少连接：在最少连接的基础上，也加上权重 …… 还有些其他的算法和策略，以后慢慢想。
+加权最少连接：在最少连接的基础上，也加上权重……还有些其他的算法和策略，以后慢慢想。
 
 ## 四层还是七层?
 
@@ -161,7 +165,7 @@ Bill 吩咐张大胖组织人力把这个负载均衡软件给开发出来。
 
 “首先让所有的服务器都有同一个IP， 我们把他称为VIP吧（如图中115.39.19.22）。”
 
-![](https://img-blog.csdn.net/20180514233332949?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE3OTg2Mzg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407213522.png)
 
 张大胖通过第一版Load Balancer的开发，积累了丰富的经验。
 
@@ -169,7 +173,7 @@ Bill 吩咐张大胖组织人力把这个负载均衡软件给开发出来。
 
 “注意，IP数据包其实是通过数据链路层发过来的，你看看这个图。”
 
-![](https://img-blog.csdn.net/2018051423361187?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE3OTg2Mzg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407213528.png)
 
 张大胖看到了客户端的HTTP报文再次被封装储层TCP报文，端口号是80， 然后IP数据报中的目的地是115.39.19.22(VIP)。
 
@@ -183,7 +187,7 @@ Bill 说道：“我们只让Load Balancer 响应这个VIP地址（115.39.19.22
 
 既然Load Balancer得到了这个IP数据包， 它就可以用某个策略从RS1, RS2,RS3中选取一个服务器，例如RS1（192.168.0.10），把IP数据报原封不动， 封装成数据链路层的包（目的地是RS1的MAC地址），直接转发就可以了。
 
-![](https://img-blog.csdn.net/20180514233636667?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE3OTg2Mzg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407213534.png)
 
 RS1（192.168.0.10）这个服务器收到了数据包，拆开一看，目的地IP是115.39.19.22，是自己的IP， 那就可以处理了。
 
@@ -203,7 +207,7 @@ Bill 说道：“怎么样？ 这个办法还可以吧？”
 
 他高兴地说：“不错，我着手带人去实现了。”
 
-后记： 本文所描述的，其实就是著名开源软件LVS的原理，上面讲的两种负载均衡的方式，就是LVS的NAT和DR。 LVS是章文嵩博士在1998年5月成立的自由软件项目，现在已经是Linux内核的一部分。想想那时候我还在不亦乐乎地折腾个人网页，学会安装和使用Linux 没多久 , 服务器端开发也仅限于ASP，像LVS这种负载均衡的概念压根就没有听说过。 编程语言可以学，差距也能弥补，但是这种境界和眼光的差距，简直就是巨大的鸿沟，难以跨越啊！ 读故事笔记：关于LVS的文章也读过几篇，往往只是记住了概念，不能设身处地的思考为何而来，刘欣老师每每都能以人物设定的场景，让我再次回到那个年代去思考、推演，还原当时如何一步步的演进成后来的LVS。
+后记：本文所描述的，其实就是著名开源软件LVS的原理，上面讲的两种负载均衡的方式，就是LVS的NAT和DR。LVS是章文嵩博士在1998年5月成立的自由软件项目，现在已经是Linux内核的一部分。想想那时候我还在不亦乐乎地折腾个人网页，学会安装和使用Linux 没多久 , 服务器端开发也仅限于ASP，像LVS这种负载均衡的概念压根就没有听说过。编程语言可以学，差距也能弥补，但是这种境界和眼光的差距，简直就是巨大的鸿沟，难以跨越啊！读故事笔记：关于LVS的文章也读过几篇，往往只是记住了概念，不能设身处地的思考为何而来，刘欣老师每每都能以人物设定的场景，让我再次回到那个年代去思考、推演，还原当时如何一步步的演进成后来的LVS。
 
 本人也混迹软件开发十几年，多数时间都是做着行业领域的软件开发，自我安慰是做着xx行业与计算机行业的交叉领域，实则一直未能深入计算机系统领域。行业应用软件开发，行业知识本身就牵扯了太多了精力，软件开发更多选择一种合适的架构来完成系统的设计、开发和维护。如你要成为一个计算机高手，有机会还是应当就计算机某一个领域深入研究，如Linux内核、搜索、图形图像、数据库、分布式存储，当然还有人工智能等等。
 
@@ -217,43 +221,43 @@ Bill 说道：“怎么样？ 这个办法还可以吧？”
 
 当前大多数的互联网系统都使用了服务器集群技术，集群即**将相同服务部署在多台服务器上构成一个集群整体对外提供服务**，这些集群可以是Web应用服务器集群，也可以是数据库服务器集群，还可以是分布式缓存服务器集群等等。
 
-在实际应用中，在Web服务器集群之前总会有一台负载均衡服务器，负载均衡设备的任务就是作为Web服务器流量的入口，挑选最合适的一台Web服务器，将客户端的请求转发给它处理，实现客户端到真实服务端的透明转发。最近几年很火的「云计算」以及分布式架构，本质上也是将后端服务器作为计算资源、存储资源，由某台管理服务器封装成一个服务对外提供，客户端不需要关心真正提供服务的是哪台机器，在它看来，就好像它面对的是一台拥有近乎无限能力的服务器，而本质上，真正提供服务的，是后端的集群。 软件负载解决的两个核心问题是：**选谁、转发**，其中最著名的是LVS（Linux Virtual Server）。
+在实际应用中，在Web服务器集群之前总会有一台负载均衡服务器，负载均衡设备的任务就是作为Web服务器流量的入口，挑选最合适的一台Web服务器，将客户端的请求转发给它处理，实现客户端到真实服务端的透明转发。最近几年很火的「云计算」以及分布式架构，本质上也是将后端服务器作为计算资源、存储资源，由某台管理服务器封装成一个服务对外提供，客户端不需要关心真正提供服务的是哪台机器，在它看来，就好像它面对的是一台拥有近乎无限能力的服务器，而本质上，真正提供服务的，是后端的集群。软件负载解决的两个核心问题是：**选谁、转发**，其中最著名的是LVS（Linux Virtual Server）。
 
-![](https://upload-images.jianshu.io/upload_images/1845730-5f905fa709e1df07.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/583)
+![img](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1845730-5f905fa709e1df07.png)
 
 一个典型的互联网应用的拓扑结构是这样的：
 
-![](https://upload-images.jianshu.io/upload_images/1845730-bd11059c51ee2830.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/468)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1845730-bd11059c51ee2830.png)
 
 # 2 负载均衡分类
 
 现在我们知道，负载均衡就是一种计算机网络技术，用来在多个计算机（计算机集群）、网络连接、CPU、磁碟驱动器或其他资源中分配负载，以达到最佳化资源使用、最大化吞吐率、最小化响应时间、同时避免过载的目的。那么，这种计算机技术的实现方式有多种。大致可以分为以下几种，其中最常用的是**四层和七层负载均衡**：
 
-**二层负载均衡** 负载均衡服务器对外依然**提供一个VIP（虚IP）**，集群中不同的机器采用**相同IP地址**，但是机器的**MAC地址不一样**。当负载均衡服务器接受到请求之后，通过**改写报文的目标MAC地址**的方式将请求转发到目标机器实现负载均衡。
+**二层负载均衡**负载均衡服务器对外依然**提供一个VIP（虚IP）**，集群中不同的机器采用**相同IP地址**，但是机器的**MAC地址不一样**。当负载均衡服务器接受到请求之后，通过**改写报文的目标MAC地址**的方式将请求转发到目标机器实现负载均衡。
 
-**三层负载均衡** 和二层负载均衡类似，负载均衡服务器对外依然提供一个VIP（虚IP），但是集群中不同的机器**采用不同的IP地址**。当负载均衡服务器接受到请求之后，根据不同的**负载均衡算法**，通过IP将请求转发至不同的真实服务器。
+**三层负载均衡**和二层负载均衡类似，负载均衡服务器对外依然提供一个VIP（虚IP），但是集群中不同的机器**采用不同的IP地址**。当负载均衡服务器接受到请求之后，根据不同的**负载均衡算法**，通过IP将请求转发至不同的真实服务器。
 
-**四层负载均衡** 四层负载均衡工作在OSI模型的**传输层**，由于在传输层，只有TCP/UDP协议，这两种协议中除了包含源IP、目标IP以外，还包含源端口号及目的端口号。四层负载均衡服务器在接受到客户端请求后，以后通过**修改数据包的地址信息（IP+端口号）**将流量转发到应用服务器。
+**四层负载均衡**四层负载均衡工作在OSI模型的**传输层**，由于在传输层，只有TCP/UDP协议，这两种协议中除了包含源IP、目标IP以外，还包含源端口号及目的端口号。四层负载均衡服务器在接受到客户端请求后，以后通过**修改数据包的地址信息（IP+端口号）**将流量转发到应用服务器。
 
-**七层负载均衡** 七层负载均衡工作在OSI模型的**应用层**，应用层协议较多，常用**http、radius、dns**等。**七层负载就可以基于这些协议来负载**。这些应用层协议中会包含很多有意义的内容。比如同一个Web服务器的负载均衡，除了**根据IP加端口进行负载外，还可根据七层的URL、浏览器类别、语言来决定是否要进行负载均衡**。
+**七层负载均衡**七层负载均衡工作在OSI模型的**应用层**，应用层协议较多，常用**http、radius、dns**等。**七层负载就可以基于这些协议来负载**。这些应用层协议中会包含很多有意义的内容。比如同一个Web服务器的负载均衡，除了**根据IP加端口进行负载外，还可根据七层的URL、浏览器类别、语言来决定是否要进行负载均衡**。
 
-![](https://upload-images.jianshu.io/upload_images/1845730-9c384abf51199902.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/426)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1845730-9c384abf51199902.png)
 
 对于一般的应用来说，有了Nginx就够了。Nginx可以用于七层负载均衡。但是对于一些大的网站，一般会采用DNS+四层负载+七层负载的方式进行多层次负载均衡。
 
-![](https://upload-images.jianshu.io/upload_images/1845730-9343234e816150c4.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1845730-9343234e816150c4.png)
 
 # 3 常用负载均衡工具
 
-硬件负载均衡性能优越，功能全面，但是价格昂贵，一般适合初期或者土豪级公司长期使用。因此软件负载均衡在互联网领域大量使用。常用的软件负载均衡软件有Nginx，Lvs，HaProxy等。 Nginx/LVS/HAProxy是目前使用最广泛的三种负载均衡软件。
+硬件负载均衡性能优越，功能全面，但是价格昂贵，一般适合初期或者土豪级公司长期使用。因此软件负载均衡在互联网领域大量使用。常用的软件负载均衡软件有Nginx，Lvs，HaProxy等。Nginx/LVS/HAProxy是目前使用最广泛的三种负载均衡软件。
 
 ## 3.1 LVS
 
-LVS（Linux Virtual Server），也就是Linux虚拟服务器, 是一个由章文嵩博士发起的自由软件项目。使用LVS技术要达到的目标是：通过LVS提供的负载均衡技术和Linux操作系统实现一个高性能、高可用的服务器群集，它具有良好可靠性、可扩展性和可操作性。从而以低廉的成本实现最优的服务性能。 LVS主要用来做**四层负载均衡。**
+LVS（Linux Virtual Server），也就是Linux虚拟服务器, 是一个由章文嵩博士发起的自由软件项目。使用LVS技术要达到的目标是：通过LVS提供的负载均衡技术和Linux操作系统实现一个高性能、高可用的服务器群集，它具有良好可靠性、可扩展性和可操作性。从而以低廉的成本实现最优的服务性能。LVS主要用来做**四层负载均衡。**
 
-**LVS架构** LVS架设的服务器集群系统有三个部分组成：最前端的负载均衡层（Loader Balancer），中间的服务器群组层，用Server Array表示，最底层的数据共享存储层，用Shared Storage表示。在用户看来所有的应用都是透明的，用户只是在使用一个虚拟服务器提供的高性能服务。
+**LVS架构**LVS架设的服务器集群系统有三个部分组成：最前端的负载均衡层（Loader Balancer），中间的服务器群组层，用Server Array表示，最底层的数据共享存储层，用Shared Storage表示。在用户看来所有的应用都是透明的，用户只是在使用一个虚拟服务器提供的高性能服务。
 
-![](https://upload-images.jianshu.io/upload_images/1845730-501f50d9626ed5c3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/553)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1845730-501f50d9626ed5c3.png)
 
 LVS的体系架构.png
 
@@ -269,21 +273,21 @@ Shared Storage层：是为**所有Real Server提供共享存储空间和内容
 
 ## 3.2 Nginx
 
-Nginx（发音同engine x）是一个网页服务器，它能反向代理HTTP, HTTPS, SMTP, POP3, IMAP的协议链接，以及一个负载均衡器和一个HTTP缓存。 Nginx主要用来做**七层负载均衡**。 并发性能：官方支持每秒**5万**并发，实际国内一般到每秒2万并发，有优化到每秒10万并发的。具体性能看应用场景。
+Nginx（发音同engine x）是一个网页服务器，它能反向代理HTTP, HTTPS, SMTP, POP3, IMAP的协议链接，以及一个负载均衡器和一个HTTP缓存。Nginx主要用来做**七层负载均衡**。并发性能：官方支持每秒**5万**并发，实际国内一般到每秒2万并发，有优化到每秒10万并发的。具体性能看应用场景。
 
 特点
 
-模块化设计：良好的扩展性，可以通过模块方式进行功能扩展。 高可靠性：主控进程和worker是同步实现的，一个worker出现问题，会立刻启动另一个worker。 内存消耗低：一万个长连接（keep-alive）,仅消耗2.5MB内存。 支持热部署：不用停止服务器，实现更新配置文件，更换日志文件、更新服务器程序版本。 并发能力强：官方数据每秒支持5万并发； 功能丰富：优秀的反向代理功能和灵活的负载均衡策略 Nginx的基本工作模式
+模块化设计：良好的扩展性，可以通过模块方式进行功能扩展。高可靠性：主控进程和worker是同步实现的，一个worker出现问题，会立刻启动另一个worker。内存消耗低：一万个长连接（keep-alive）,仅消耗2.5MB内存。支持热部署：不用停止服务器，实现更新配置文件，更换日志文件、更新服务器程序版本。并发能力强：官方数据每秒支持5万并发；功能丰富：优秀的反向代理功能和灵活的负载均衡策略Nginx的基本工作模式
 
-![](https://upload-images.jianshu.io/upload_images/1845730-82b386d1049c5348.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1845730-82b386d1049c5348.jpg)
 
 Nginx的基本工作模式.jpg
 
-一个master进程，生成一个或者多个worker进程。但是这里**master是使用root身份启动的**，因为nginx要工作在80端口。而只有管理员才有权限启动小于低于1023的端口。**master主要是负责的作用只是启动worker，加载配置文件，负责系统的平滑升级**。其它的工作是交给worker。那么当worker被启动之后，也只是负责一些web最简单的工作，而其他的工作都是由worker中调用的模块来实现的。 **模块之间是以流水线的方式实现功能的**。流水线，指的是一个用户请求，由多个模块组合各自的功能依次实现完成的。比如：第一个模块只负责分析请求首部，第二个模块只负责查找数据，第三个模块只负责压缩数据，依次完成各自工作。来**实现整个工作的完成**。 他们是如何实现热部署的呢？其实是这样的，我们前面说master不负责具体的工作，而是调用worker工作，他只是负责读取配置文件，因此当一个模块修改或者配置文件发生变化，是由master进行读取，因此此时不会影响到worker工作**。在master进行读取配置文件之后，不会立即把修改的配置文件告知worker。而是让被修改的worker继续使用老的配置文件工作，当worker工作完毕之后，直接杀死这个子进程，更换新的子进程，使用新的规则。**
+一个master进程，生成一个或者多个worker进程。但是这里**master是使用root身份启动的**，因为nginx要工作在80端口。而只有管理员才有权限启动小于低于1023的端口。**master主要是负责的作用只是启动worker，加载配置文件，负责系统的平滑升级**。其它的工作是交给worker。那么当worker被启动之后，也只是负责一些web最简单的工作，而其他的工作都是由worker中调用的模块来实现的。**模块之间是以流水线的方式实现功能的**。流水线，指的是一个用户请求，由多个模块组合各自的功能依次实现完成的。比如：第一个模块只负责分析请求首部，第二个模块只负责查找数据，第三个模块只负责压缩数据，依次完成各自工作。来**实现整个工作的完成**。他们是如何实现热部署的呢？其实是这样的，我们前面说master不负责具体的工作，而是调用worker工作，他只是负责读取配置文件，因此当一个模块修改或者配置文件发生变化，是由master进行读取，因此此时不会影响到worker工作**。在master进行读取配置文件之后，不会立即把修改的配置文件告知worker。而是让被修改的worker继续使用老的配置文件工作，当worker工作完毕之后，直接杀死这个子进程，更换新的子进程，使用新的规则。**
 
 ## 3.3 HAProxy
 
-HAProxy也是使用较多的一款负载均衡软件。HAProxy提供高可用性、负载均衡以及基于TCP和HTTP应用的代理，支持虚拟主机，是免费、快速并且可靠的一种解决方案。特别适用于那些**负载特大的web站点。**运行模式使得它可以很简单安全的整合到当前的架构中，同时可以保护你的web服务器不被暴露到网络上。 HAProxy是一个使用C语言编写的自由及开放源代码软件，其提供高可用性、负载均衡，以及基于TCP和HTTP的应用程序代理。 Haproxy主要用来做七层负载均衡。
+HAProxy也是使用较多的一款负载均衡软件。HAProxy提供高可用性、负载均衡以及基于TCP和HTTP应用的代理，支持虚拟主机，是免费、快速并且可靠的一种解决方案。特别适用于那些**负载特大的web站点。**运行模式使得它可以很简单安全的整合到当前的架构中，同时可以保护你的web服务器不被暴露到网络上。HAProxy是一个使用C语言编写的自由及开放源代码软件，其提供高可用性、负载均衡，以及基于TCP和HTTP的应用程序代理。Haproxy主要用来做七层负载均衡。
 
 # 4 常见负载均衡算法
 
@@ -293,19 +297,19 @@ HAProxy也是使用较多的一款负载均衡软件。HAProxy提供高可用性
 
 动态负载均衡算法包括: 最少连接数,最快响应速度，观察方法，预测法，动态性能分配，动态服务器补充，服务质量，服务类型，规则模式。
 
-**轮询（Round Robin）**：顺序循环将请求一次顺序循环地连接每个服务器。当其中某个服务器发生第二到第7 层的故障，BIG-IP 就把其从顺序循环队列中拿出，不参加下一次的轮询，直到其恢复正常。 以轮询的方式依次请求调度不同的服务器； 实现时，一般为服务器带上权重；这样有两个好处： 针对服务器的性能差异可分配不同的负载； 当需要将某个结点剔除时，只需要将其权重设置为0即可； 优点：实现简单、高效；易水平扩展； 缺点：请求到目的结点的不确定，造成其无法适用于有写的场景（缓存，数据库写） 应用场景：数据库或应用服务层中只有读的场景； 随机方式：请求随机分布到各个结点；在数据足够大的场景能达到一个均衡分布； 优点：实现简单、易水平扩展； 缺点：同Round Robin，无法用于有写的场景； **应用场景：数据库负载均衡，也是只有读的场景**；
+**轮询（Round Robin）**：顺序循环将请求一次顺序循环地连接每个服务器。当其中某个服务器发生第二到第7 层的故障，BIG-IP 就把其从顺序循环队列中拿出，不参加下一次的轮询，直到其恢复正常。以轮询的方式依次请求调度不同的服务器； 实现时，一般为服务器带上权重；这样有两个好处：针对服务器的性能差异可分配不同的负载；当需要将某个结点剔除时，只需要将其权重设置为0即可；优点：实现简单、高效；易水平扩展；缺点：请求到目的结点的不确定，造成其无法适用于有写的场景（缓存，数据库写）应用场景：数据库或应用服务层中只有读的场景；随机方式：请求随机分布到各个结点；在数据足够大的场景能达到一个均衡分布；优点：实现简单、易水平扩展；缺点：同Round Robin，无法用于有写的场景；**应用场景：数据库负载均衡，也是只有读的场景**；
 
-**哈希方式**：根据key来计算需要落在的结点上，可以保证一个同一个键一定落在相同的服务器上； 优点：相同key一定落在同一个结点上，这样就可用于有写有读的缓存场景； 缺点：在某个结点故障后，会导致哈希键重新分布，造成命中率大幅度下降； 解决：一致性哈希 or 使用keepalived保证任何一个结点的高可用性，故障后会有其它结点顶上来； 应用场景：缓存，有读有写；
+**哈希方式**：根据key来计算需要落在的结点上，可以保证一个同一个键一定落在相同的服务器上；优点：相同key一定落在同一个结点上，这样就可用于有写有读的缓存场景；缺点：在某个结点故障后，会导致哈希键重新分布，造成命中率大幅度下降；解决：一致性哈希 or 使用keepalived保证任何一个结点的高可用性，故障后会有其它结点顶上来；应用场景：缓存，有读有写；
 
-**一致性哈希**：在服务器一个结点出现故障时，受影响的只有这个结点上的key，最大程度的保证命中率； 如twemproxy中的ketama方案； 生产实现中还可以规划指定子key哈希，从而保证局部相似特征的键能分布在同一个服务器上； 优点：结点故障后命中率下降有限； 应用场景：缓存；
+**一致性哈希**：在服务器一个结点出现故障时，受影响的只有这个结点上的key，最大程度的保证命中率； 如twemproxy中的ketama方案； 生产实现中还可以规划指定子key哈希，从而保证局部相似特征的键能分布在同一个服务器上；优点：结点故障后命中率下降有限；应用场景：缓存；
 
-**根据键的范围来负载**：根据键的范围来负载，前1亿个键都存放到第一个服务器，1~2亿在第二个结点； 优点：水平扩展容易，存储不够用时，加服务器存放后续新增数据； 缺点：负载不均；数据库的分布不均衡；（数据有冷热区分，一般最近注册的用户更加活跃，这样造成后续的服务器非常繁忙，而前期的结点空闲很多） **适用场景：数据库分片负载均衡；**
+**根据键的范围来负载**：根据键的范围来负载，前1亿个键都存放到第一个服务器，1~2亿在第二个结点；优点：水平扩展容易，存储不够用时，加服务器存放后续新增数据；缺点：负载不均；数据库的分布不均衡；（数据有冷热区分，一般最近注册的用户更加活跃，这样造成后续的服务器非常繁忙，而前期的结点空闲很多）**适用场景：数据库分片负载均衡；**
 
-**根据键对服务器结点数取模来负载**：根据键对服务器结点数取模来负载；比如有4台服务器，key取模为0的落在第一个结点，1落在第二个结点上。 优点：数据冷热分布均衡，数据库结点负载均衡分布； 缺点：水平扩展较难； 适用场景：**数据库分片负载均衡**；
+**根据键对服务器结点数取模来负载**：根据键对服务器结点数取模来负载；比如有4台服务器，key取模为0的落在第一个结点，1落在第二个结点上。优点：数据冷热分布均衡，数据库结点负载均衡分布；缺点：水平扩展较难；适用场景：**数据库分片负载均衡**；
 
-**纯动态结点负载均衡**：根据CPU、IO、网络的处理能力来决策接下来的请求如何调度； 优点：充分利用服务器的资源，保证个结点上负载处理均衡； 缺点：实现起来复杂，真实使用较少；
+**纯动态结点负载均衡**：根据CPU、IO、网络的处理能力来决策接下来的请求如何调度；优点：充分利用服务器的资源，保证个结点上负载处理均衡；缺点：实现起来复杂，真实使用较少；
 
-**不用主动负载均衡**：使用消息队列转为异步模型，将负载均衡的问题消灭；负载均衡是一种推模型，一直向你发数据，那么，将所有的用户请求发到消息队列中，**所有的下游结点谁空闲**，谁上来取数据处理；转为拉模型之后，消除了对下行结点负载的问题； 优点：通过消息队列的缓冲，保护后端系统，请求剧增时不会冲垮后端服务器； 水平扩展容易，加入新结点后，直接取queue即可； 缺点：不具有实时性； 应用场景：**不需要实时返回的场景**； 比如，12036下订单后，立刻返回提示信息：您的订单进去排队了...等处理完毕后，再异步通知；
+**不用主动负载均衡**：使用消息队列转为异步模型，将负载均衡的问题消灭；负载均衡是一种推模型，一直向你发数据，那么，将所有的用户请求发到消息队列中，**所有的下游结点谁空闲**，谁上来取数据处理；转为拉模型之后，消除了对下行结点负载的问题；优点：通过消息队列的缓冲，保护后端系统，请求剧增时不会冲垮后端服务器；水平扩展容易，加入新结点后，直接取queue即可；缺点：不具有实时性；应用场景：**不需要实时返回的场景**；比如，12036下订单后，立刻返回提示信息：您的订单进去排队了...等处理完毕后，再异步通知；
 
 **比率（Ratio）**：给每个服务器分配一个**加权值**为比例，根椐这个比例，把用户的请求分配到每个服务器。当其中某个服务器发生第二到第7 层的故障，BIG-IP 就把其从服务器队列中拿出，不参加下一次的用户请求的分配, 直到其恢复正常。
 
@@ -332,8 +336,8 @@ HAProxy也是使用较多的一款负载均衡软件。HAProxy提供高可用性
 # 负载均衡的几种算法Java实现代码
 
 ## 轮询
-
-<pre> package com.boer.tdf.act.test;
+````
+ package com.boer.tdf.act.test;
  import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
@@ -342,7 +346,7 @@ import java.util.Set;
  * 負載均衡算法，輪詢法.
  */
 public class TestRoundRobin {
- static Map<String,Integer> serverWeigthMap  = new HashMap<String,Integer>();
+ static Map<String,Integer> serverWeigthMap = new HashMap<String,Integer>();
  static {
  serverWeigthMap.put("192.168.1.12", 1);
  serverWeigthMap.put("192.168.1.13", 1);
@@ -353,10 +357,10 @@ public class TestRoundRobin {
  serverWeigthMap.put("192.168.1.18", 1);
  serverWeigthMap.put("192.168.1.19", 2);
  }
- Integer  pos = 0;
- public  String roundRobin() {
+ Integer pos = 0;
+ public String roundRobin() {
  // 重新建立一個map,避免出現由於服務器上線和下線導致的並發問題
- Map<String,Integer> serverMap  = new HashMap<String,Integer>();
+ Map<String,Integer> serverMap = new HashMap<String,Integer>();
  serverMap.putAll(serverWeigthMap);
  // 獲取ip列表list
  Set<String> keySet = serverMap.keySet();
@@ -403,17 +407,18 @@ public class TestRoundRobin {
  192.168.1.16
  */
  }
-​</pre>
 
-## 加权随机负载均衡算法
+````
 
-<pre> package com.boer.tdf.act.test;
+## 加权随机负载均衡算法
+````
+ package com.boer.tdf.act.test;
  import java.util.*;
  /**
  * 加权随机负载均衡算法.
  */
 public class TestWeightRandom {
- static Map<String,Integer> serverWeigthMap  = new HashMap<String,Integer>();
+ static Map<String,Integer> serverWeigthMap = new HashMap<String,Integer>();
  static {
  serverWeigthMap.put("192.168.1.12", 1);
  serverWeigthMap.put("192.168.1.13", 1);
@@ -427,7 +432,7 @@ public class TestWeightRandom {
  public static String weightRandom()
  {
  // 重新建立一個map,避免出現由於服務器上線和下線導致的並發問題
- Map<String,Integer> serverMap  = new HashMap<String,Integer>();
+ Map<String,Integer> serverMap = new HashMap<String,Integer>();
  serverMap.putAll(serverWeigthMap);
  // 獲取ip列表list
  Set<String> keySet = serverMap.keySet();
@@ -454,17 +459,18 @@ public class TestWeightRandom {
  */
  }
  }
-​</pre>
+````
+````
 
 ## 随机负载均衡算法
-
-<pre> package com.boer.tdf.act.test;
+````
+ package com.boer.tdf.act.test;
  import java.util.*;
  /**
  * 随机负载均衡算法.
  */
 public class TestRandom {
- static Map<String,Integer> serverWeigthMap  = new HashMap<String,Integer>();
+ static Map<String,Integer> serverWeigthMap = new HashMap<String,Integer>();
  static {
  serverWeigthMap.put("192.168.1.12", 1);
  serverWeigthMap.put("192.168.1.13", 1);
@@ -477,7 +483,7 @@ public class TestRandom {
  }
  public static String random() {
  // 重新建立一個map,避免出現由於服務器上線和下線導致的並發問題
- Map<String,Integer> serverMap  = new HashMap<String,Integer>();
+ Map<String,Integer> serverMap = new HashMap<String,Integer>();
  serverMap.putAll(serverWeigthMap);
  // 獲取ip列表list
  Set<String> keySet = serverMap.keySet();
@@ -497,11 +503,12 @@ public class TestRandom {
  * 192.168.1.16
  */
  }
-​</pre>
+````
 
-## 负载均衡 ip_hash算法
 
-<pre> package com.boer.tdf.act.test;
+## 负载均衡 ip_hash算法
+````
+ package com.boer.tdf.act.test;
  import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
@@ -510,7 +517,7 @@ import java.util.Set;
  * 负载均衡 ip_hash算法.
  */
 public class TestIpHash {
- static Map<String,Integer> serverWeigthMap  = new HashMap<String,Integer>();
+ static Map<String,Integer> serverWeigthMap = new HashMap<String,Integer>();
  static {
  serverWeigthMap.put("192.168.1.12", 1);
  serverWeigthMap.put("192.168.1.13", 1);
@@ -528,7 +535,7 @@ public class TestIpHash {
  */
  public static String ipHash(String remoteIp) {
  // 重新建立一個map,避免出現由於服務器上線和下線導致的並發問題
- Map<String,Integer> serverMap  = new HashMap<String,Integer>();
+ Map<String,Integer> serverMap = new HashMap<String,Integer>();
  serverMap.putAll(serverWeigthMap);
  // 獲取ip列表list
  Set<String> keySet = serverMap.keySet();
@@ -547,4 +554,6 @@ public class TestIpHash {
  * 192.168.1.18
  */
  }
- }</pre>
+ }
+
+````
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25714\357\274\232Spring Boot\344\275\277\347\224\250\346\263\250\350\247\243\351\233\206\346\210\220Redis\347\274\223\345\255\230.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232SpringBoot\344\275\277\347\224\250\346\263\250\350\247\243\351\233\206\346\210\220Redis\347\274\223\345\255\230.md"
similarity index 99%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25714\357\274\232Spring Boot\344\275\277\347\224\250\346\263\250\350\247\243\351\233\206\346\210\220Redis\347\274\223\345\255\230.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232SpringBoot\344\275\277\347\224\250\346\263\250\350\247\243\351\233\206\346\210\220Redis\347\274\223\345\255\230.md"
index fbc86b4..adb2c2c 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25714\357\274\232Spring Boot\344\275\277\347\224\250\346\263\250\350\247\243\351\233\206\346\210\220Redis\347\274\223\345\255\230.md"	
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232SpringBoot\344\275\277\347\224\250\346\263\250\350\247\243\351\233\206\346\210\220Redis\347\274\223\345\255\230.md"
@@ -1,4 +1,6 @@
-# Table of Contents
+
+
+# 目录
 
 * [Redis配置](#redis配置)
 * [连接超时时间（毫秒）](#连接超时时间（毫秒）)
@@ -37,7 +39,7 @@ Spring Boot 熟悉后，集成一个外部扩展是一件很容易的事，集
 
 二、创建 RedisClient.java
 注意该类存放的package
-
+````
     package org.springframework.data.redis.connection.jedis;
     
     import java.io.ByteArrayInputStream;
@@ -316,10 +318,11 @@ Spring Boot 熟悉后，集成一个外部扩展是一件很容易的事，集
             T doInvoker(Jedis jedis);
         }
     }
-
+````
 三、创建Redis配置类
+
     RedisConfig.java
-    
+````    
     package com.shanhy.example.redis;
     
     import org.springframework.context.annotation.Bean;
@@ -408,10 +411,10 @@ Spring Boot 熟悉后，集成一个外部扩展是一件很容易的事，集
         }
     
     }
-
+````
 四、创建测试方法
 下面代码随便放一个Controller里
-
+````
     @Autowired
     private RedisTemplate<String, Object> redisTemplate;
 
@@ -438,10 +441,10 @@ Spring Boot 熟悉后，集成一个外部扩展是一件很容易的事，集
 
         return "OK";
     }
-
+````
 五、配置文件配置Redis
     application.yml
-    
+````    
     spring:
       # Redis配置
       redis:
@@ -455,10 +458,9 @@ Spring Boot 熟悉后，集成一个外部扩展是一件很容易的事，集
           min-idle: 5
           max-active: 20
           max-wait: 2
-
+````
 这样就完成了Redis的配置，可以正常使用 redisTemplate 了。
 
-atoop/article/details/71275331
 
 ### 一、创建 Caching 配置类
 
diff --git "a/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232ZAB\345\215\217\350\256\256\346\246\202\350\277\260\344\270\216\351\200\211\344\270\273\346\265\201\347\250\213\350\257\246\350\247\243.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232ZAB\345\215\217\350\256\256\346\246\202\350\277\260\344\270\216\351\200\211\344\270\273\346\265\201\347\250\213\350\257\246\350\247\243.md"
new file mode 100644
index 0000000..5212a27
--- /dev/null
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232ZAB\345\215\217\350\256\256\346\246\202\350\277\260\344\270\216\351\200\211\344\270\273\346\265\201\347\250\213\350\257\246\350\247\243.md"
@@ -0,0 +1,379 @@
+# 目录
+
+  * [ZAB协议](#zab协议)
+  * [消息广播模式](#消息广播模式)
+  * [崩溃恢复](#崩溃恢复)
+    * [数据同步](#数据同步)
+  * [ZAB协议原理](#zab协议原理)
+  * [Zookeeper设计目标](#zookeeper设计目标)
+* [ZAB与FastLeaderElection选主算法流程详解](#zab与fastleaderelection选主算法流程详解)
+  * [选择机制中的概念](#选择机制中的概念)
+    * [服务器ID](#服务器id)
+    * [数据ID](#数据id)
+    * [逻辑时钟](#逻辑时钟)
+    * [选举状态](#选举状态)
+  * [选举消息内容](#选举消息内容)
+  * [选举流程图](#选举流程图)
+    * [判断是否已经胜出](#判断是否已经胜出)
+  * [选举流程简述](#选举流程简述)
+  * [几种领导选举场景](#几种领导选举场景)
+    * [集群启动领导选举](#集群启动领导选举)
+    * [Follower重启](#follower重启)
+    * [Leader重启](#leader重启)
+* [一致性保证](#一致性保证)
+  * [Commit过的数据不丢失](#commit过的数据不丢失)
+  * [未Commit过的消息对客户端不可见")未Commit过的消息对客户端不可见](#未commit过的消息对客户端不可见未commit过的消息对客户端不可见)
+* [总结](#总结)
+
+
+本文内容参考网络，侵删
+
+本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
+> https://github.com/h2pl/Java-Tutorial
+
+喜欢的话麻烦点下Star哈
+
+本文也将同步到我的个人博客：
+
+> www.how2playlife.com
+
+更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
+
+该系列博文会告诉你什么是分布式系统，这对后端工程师来说是很重要的一门学问，我们会逐步了解常见的分布式技术、以及一些较为常见的分布式系统概念，同时也需要进一步了解zookeeper、分布式事务、分布式锁、负载均衡等技术，以便让你更完整地了解分布式技术的具体实战方法，为真正应用分布式技术做好准备。
+
+如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
+
+<!-- more -->  
+
+## ZAB协议
+
+1.  ZAB协议是专门为zookeeper实现分布式协调功能而设计。zookeeper主要是根据ZAB协议是实现分布式系统数据一致性。
+2.  zookeeper根据ZAB协议建立了主备模型完成zookeeper集群中数据的同步。这里所说的主备系统架构模型是指，在zookeeper集群中，只有一台leader负责处理外部客户端的事物请求(或写操作)，然后leader服务器将客户端的写操作数据同步到所有的follower节点中。  
+    ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407210824.png)
+3.  ZAB的协议核心是在整个zookeeper集群中只有一个节点即Leader将客户端的写操作转化为事物(或提议proposal)。Leader节点再数据写完之后，将向所有的follower节点发送数据广播请求(或数据复制)，等待所有的follower节点反馈。在ZAB协议中，只要超过半数follower节点反馈OK，Leader节点就会向所有的follower服务器发送commit消息。即将leader节点上的数据同步到follower节点之上。  
+    ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407210834.png)
+4.  ZAB协议中主要有两种模式，第一是消息广播模式；第二是崩溃恢复模式
+
+## 消息广播模式
+
+1.  在zookeeper集群中数据副本的传递策略就是采用消息广播模式。zookeeper中数据副本的同步方式与二阶段提交相似但是却又不同。二阶段提交的要求协调者必须等到所有的参与者全部反馈ACK确认消息后，再发送commit消息。要求所有的参与者要么全部成功要么全部失败。二阶段提交会产生严重阻塞问题。
+2.  ZAB协议中Leader等待follower的ACK反馈是指”只要半数以上的follower成功反馈即可，不需要收到全部follower反馈”
+3.  图中展示了消息广播的具体流程图  
+    ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407210854.png)
+4.  zookeeper中消息广播的具体步骤如下：  
+    4.1\. 客户端发起一个写操作请求  
+    4.2\. Leader服务器将客户端的request请求转化为事物proposql提案，同时为每个proposal分配一个全局唯一的ID，即ZXID。  
+    4.3\. leader服务器与每个follower之间都有一个队列，leader将消息发送到该队列  
+    4.4\. follower机器从队列中取出消息处理完(写入本地事物日志中)毕后，向leader服务器发送ACK确认。  
+    4.5\. leader服务器收到半数以上的follower的ACK后，即认为可以发送commit  
+    4.6\. leader向所有的follower服务器发送commit消息。
+5.  zookeeper采用ZAB协议的核心就是只要有一台服务器提交了proposal，就要确保所有的服务器最终都能正确提交proposal。这也是CAP/BASE最终实现一致性的一个体现。
+6.  leader服务器与每个follower之间都有一个单独的队列进行收发消息，使用队列消息可以做到异步解耦。leader和follower之间只要往队列中发送了消息即可。如果使用同步方式容易引起阻塞。性能上要下降很多。
+
+## 崩溃恢复
+
+1.  zookeeper集群中为保证任何所有进程能够有序的顺序执行，只能是leader服务器接受写请求，即使是follower服务器接受到客户端的请求，也会转发到leader服务器进行处理。
+2.  如果leader服务器发生崩溃，则zab协议要求zookeeper集群进行崩溃恢复和leader服务器选举。
+3.  ZAB协议崩溃恢复要求满足如下2个要求：  
+    3.1.确保已经被leader提交的proposal必须最终被所有的follower服务器提交。  
+    3.2.确保丢弃已经被leader出的但是没有被提交的proposal。
+4.  根据上述要求，新选举出来的leader不能包含未提交的proposal，即新选举的leader必须都是已经提交了的proposal的follower服务器节点。同时，新选举的leader节点中含有最高的ZXID。这样做的好处就是可以避免了leader服务器检查proposal的提交和丢弃工作。
+5.  leader服务器发生崩溃时分为如下场景：  
+    5.1\. leader在提出proposal时未提交之前崩溃，则经过崩溃恢复之后，新选举的leader一定不能是刚才的leader。因为这个leader存在未提交的proposal。  
+    5.2 leader在发送commit消息之后，崩溃。即消息已经发送到队列中。经过崩溃恢复之后，参与选举的follower服务器(刚才崩溃的leader有可能已经恢复运行，也属于follower节点范畴)中有的节点已经是消费了队列中所有的commit消息。即该follower节点将会被选举为最新的leader。剩下动作就是数据同步过程。
+
+### 数据同步
+
+1.  在zookeeper集群中新的leader选举成功之后，leader会将自身的提交的最大proposal的事物ZXID发送给其他的follower节点。follower节点会根据leader的消息进行回退或者是数据同步操作。最终目的要保证集群中所有节点的数据副本保持一致。
+2.  数据同步完之后，zookeeper集群如何保证新选举的leader分配的ZXID是全局唯一呢？这个就要从ZXID的设计谈起。  
+    2.1 ZXID是一个长度64位的数字，其中低32位是按照数字递增，即每次客户端发起一个proposal,低32位的数字简单加1。高32位是leader周期的epoch编号，至于这个编号如何产生(我也没有搞明白)，每当选举出一个新的leader时，新的leader就从本地事物日志中取出ZXID,然后解析出高32位的epoch编号，进行加1，再将低32位的全部设置为0。这样就保证了每次新选举的leader后，保证了ZXID的唯一性而且是保证递增的。  
+    ![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407210906.png)
+
+## ZAB协议原理
+
+1.  ZAB协议要求每个leader都要经历三个阶段，即发现，同步，广播。
+2.  发现：即要求zookeeper集群必须选择出一个leader进程，同时leader会维护一个follower可用列表。将来客户端可以这follower中的节点进行通信。
+3.  同步：leader要负责将本身的数据与follower完成同步，做到多副本存储。这样也是体现了CAP中高可用和分区容错。follower将队列中未处理完的请求消费完成后，写入本地事物日志中。
+4.  广播：leader可以接受客户端新的proposal请求，将新的proposal请求广播给所有的follower。
+
+## Zookeeper设计目标
+
+1.  zookeeper作为当今最流行的分布式系统应用协调框架，采用zab协议的最大目标就是建立一个高可用可扩展的分布式数据主备系统。即在任何时刻只要leader发生宕机，都能保证分布式系统数据的可靠性和最终一致性。
+2.  深刻理解ZAB协议，才能更好的理解zookeeper对于分布式系统建设的重要性。以及为什么采用zookeeper就能保证分布式系统中数据最终一致性，服务的高可用性。
+
+Zab与Paxos  
+Zab的作者认为Zab与paxos并不相同，只所以没有采用Paxos是因为Paxos保证不了全序顺序：  
+Because multiple leaders can propose a value for a given instance two problems arise.  
+First, proposals can conflict. Paxos uses ballots to detect and resolve conflicting proposals.  
+Second, it is not enough to know that a given instance number has been committed, processes must also be able to fi gure out which value has been committed.  
+Paxos算法的确是不关心请求之间的逻辑顺序，而只考虑数据之间的全序，但很少有人直接使用paxos算法，都会经过一定的简化、优化。
+
+Paxos算法优化  
+Paxos算法在出现竞争的情况下，其收敛速度很慢，甚至可能出现活锁的情况，例如当有三个及三个以上的proposer在发送prepare请求后，很难有一个proposer收到半数以上的回复而不断地执行第一阶段的协议。因此，为了避免竞争，加快收敛的速度，在算法中引入了一个Leader这个角色，在正常情况下同时应该最多只能有一个参与者扮演Leader角色，而其它的参与者则扮演Acceptor的角色。  
+在这种优化算法中，只有Leader可以提出议案，从而避免了竞争使得算法能够快速地收敛而趋于一致；而为了保证Leader的健壮性，又引入了Leader选举，再考虑到同步的阶段，渐渐的你会发现对Paxos算法的简化和优化已经和上面介绍的ZAB协议很相似了。
+
+总结  
+Google的粗粒度锁服务Chubby的设计开发者Burrows曾经说过：“所有一致性协议本质上要么是Paxos要么是其变体”。这句话还是有一定道理的，ZAB本质上就是Paxos的一种简化形式。
+
+# ZAB与FastLeaderElection选主算法流程详解
+
+这篇主要分析leader的选主机制，zookeeper提供了三种方式：
+
+*   LeaderElection
+*   AuthFastLeaderElection
+*   FastLeaderElection
+
+默认的算法是FastLeaderElection，所以这篇主要分析它的选举机制。
+
+## 选择机制中的概念
+
+### 服务器ID
+
+比如有三台服务器，编号分别是1,2,3。
+
+> 编号越大在选择算法中的权重越大。
+
+### 数据ID
+
+服务器中存放的最大数据ID.
+
+> 值越大说明数据越新，在选举算法中数据越新权重越大。
+
+### 逻辑时钟
+
+或者叫投票的次数，同一轮投票过程中的逻辑时钟值是相同的。每投完一次票这个数据就会增加，然后与接收到的其它服务器返回的投票信息中的数值相比，根据不同的值做出不同的判断。
+
+### 选举状态
+
+*   LOOKING，竞选状态。
+*   FOLLOWING，随从状态，同步leader状态，参与投票。
+*   OBSERVING，观察状态,同步leader状态，不参与投票。
+*   LEADING，领导者状态。
+
+## 选举消息内容
+
+在投票完成后，需要将投票信息发送给集群中的所有服务器，它包含如下内容。
+
+*   服务器ID
+*   数据ID
+*   逻辑时钟
+*   选举状态
+
+## 选举流程图
+
+因为每个服务器都是独立的，在启动时均从初始状态开始参与选举，下面是简易流程图。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/17071-20170220211539679-433574967.jpg)
+
+
+
+下面详细解释一下这个流程：
+
+首先给出几个名词定义：
+
+（1）Serverid：在配置server时，给定的服务器的标示id。
+
+（2）Zxid:服务器在运行时产生的数据id，zxid越大，表示数据越新。
+
+（3）Epoch：选举的轮数，即逻辑时钟。随着选举的轮数++
+
+（4）Server状态：LOOKING,FOLLOWING,OBSERVING,LEADING
+
+步骤：
+
+一、Server刚启动（宕机恢复或者刚启动）准备加入集群，此时读取自身的zxid等信息。
+
+二、所有Server加入集群时都会推荐自己为leader，然后将（leader id 、 zixd 、 epoch）作为广播信息，广播到集群中所有的服务器(Server)。然后等待集群中的服务器返回信息。
+
+三、收到集群中其他服务器返回的信息，此时要分为两类：该服务器处于looking状态，或者其他状态。
+
+（1）服务器处于looking状态
+
+首先判断逻辑时钟 Epoch:  
+a)如果接收到Epoch大于自己目前的逻辑时钟（说明自己所保存的逻辑时钟落伍了）。更新本机逻辑时钟Epoch，同时 Clear其他服务发送来的选举数据（这些数据已经OUT了）。然后判断是否需要更新当前自己的选举情况（一开始选择的leader id 是自己）
+
+判断规则rules judging：保存的zxid最大值和leader Serverid来进行判断的。先看数据zxid,数据zxid大者胜出;其次再判断leaderServerid, leader Serverid大者胜出；然后再将自身最新的选举结果(也就是上面提到的三种数据（leader Serverid，Zxid，Epoch）广播给其他server)
+
+b)如果接收到的Epoch小于目前的逻辑时钟。说明对方处于一个比较OUT的选举轮数，这时只需要将自己的 （leader Serverid，Zxid，Epoch）发送给他即可。
+
+c)如果接收到的Epoch等于目前的逻辑时钟。再根据a)中的判断规则，将自身的最新选举结果广播给其他 server。
+
+同时Server还要处理2种情况：
+
+a)如果Server接收到了其他所有服务器的选举信息，那么则根据这些选举信息确定自己的状态（Following,Leading），结束Looking，退出选举。
+
+b)即使没有收到所有服务器的选举信息，也可以判断一下根据以上过程之后最新的选举leader是不是得到了超过半数以上服务器的支持，如果是则尝试接受最新数据，倘若没有最新的数据到来，说明大家都已经默认了这个结果,同样也设置角色退出选举过程。
+
+（2）服务器处于其他状态（Following, Leading）
+
+a)如果逻辑时钟Epoch相同,将该数据保存到recvset,如果所接收服务器宣称自己是leader,那么将判断是不是有半数以上的服务器选举它,如果是则设置选举状态退出选举过程
+
+b)否则这是一条与当前逻辑时钟不符合的消息，那么说明在另一个选举过程中已经有了选举结果，于是将该选举结果加入到outofelection集合中，再根据outofelection来判断是否可以结束选举,如果可以也是保存逻辑时钟，设置选举状态，退出选举过程。
+
+以上就是FAST选举过程。
+
+Zookeeper具体的启动日志如下图所示：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407210921.png)![](https://img-blog.csdn.net/20161028191618720?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+
+以上就是我自己配置的Zookeeper选主日志，从一开始LOOKING,然后new election, my id = 1, proposedzxid=0x0 也就是选自己为Leader,之后广播选举并重复之前Fast选主算法，最终确定Leader。
+
+### 判断是否已经胜出
+
+默认是采用投票数大于半数则胜出的逻辑。
+
+## 选举流程简述
+
+目前有5台服务器，每台服务器均没有数据，它们的编号分别是1,2,3,4,5,按编号依次启动，它们的选择举过程如下：
+
+*   服务器1启动，给自己投票，然后发投票信息，由于其它机器还没有启动所以它收不到反馈信息，服务器1的状态一直属于Looking。
+*   服务器2启动，给自己投票，同时与之前启动的服务器1交换结果，由于服务器2的编号大所以服务器2胜出，但此时投票数没有大于半数，所以两个服务器的状态依然是LOOKING。
+*   服务器3启动，给自己投票，同时与之前启动的服务器1,2交换信息，由于服务器3的编号最大所以服务器3胜出，此时投票数正好大于半数，所以服务器3成为领导者，服务器1,2成为小弟。
+*   服务器4启动，给自己投票，同时与之前启动的服务器1,2,3交换信息，尽管服务器4的编号大，但之前服务器3已经胜出，所以服务器4只能成为小弟。
+*   服务器5启动，后面的逻辑同服务器4成为小弟。
+
+## 几种领导选举场景
+
+### 集群启动领导选举
+
+**_初始投票给自己_**
+
+集群刚启动时，所有服务器的logicClock都为1，zxid都为0。
+
+各服务器初始化后，都投票给自己，并将自己的一票存入自己的票箱，如下图所示。
+
+![fsdfsdfsdsdfsdfsfsdf](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/start_election_1.png)
+
+
+在上图中，(1, 1, 0)第一位数代表投出该选票的服务器的logicClock，第二位数代表被推荐的服务器的myid，第三位代表被推荐的服务器的最大的zxid。由于该步骤中所有选票都投给自己，所以第二位的myid即是自己的myid，第三位的zxid即是自己的zxid。
+
+此时各自的票箱中只有自己投给自己的一票。
+
+**_更新选票_**  
+服务器收到外部投票后，进行选票PK，相应更新自己的选票并广播出去，并将合适的选票存入自己的票箱，如下图所示。
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407211056.png)
+
+
+
+
+服务器1收到服务器2的选票（1, 2, 0）和服务器3的选票（1, 3, 0）后，由于所有的logicClock都相等，所有的zxid都相等，因此根据myid判断应该将自己的选票按照服务器3的选票更新为（1, 3, 0），并将自己的票箱全部清空，再将服务器3的选票与自己的选票存入自己的票箱，接着将自己更新后的选票广播出去。此时服务器1票箱内的选票为(1, 3)，(3, 3)。
+
+同理，服务器2收到服务器3的选票后也将自己的选票更新为（1, 3, 0）并存入票箱然后广播。此时服务器2票箱内的选票为(2, 3)，(3, ,3)。
+
+服务器3根据上述规则，无须更新选票，自身的票箱内选票仍为（3, 3）。
+
+服务器1与服务器2更新后的选票广播出去后，由于三个服务器最新选票都相同，最后三者的票箱内都包含三张投给服务器3的选票。
+
+**_根据选票确定角色_**  
+根据上述选票，三个服务器一致认为此时服务器3应该是Leader。因此服务器1和2都进入FOLLOWING状态，而服务器3进入LEADING状态。之后Leader发起并维护与Follower间的心跳。
+
+![Cluster start election step 3](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/start_election_3.png)
+
+
+### Follower重启
+
+**_Follower重启投票给自己_**  
+Follower重启，或者发生网络分区后找不到Leader，会进入LOOKING状态并发起新的一轮投票。
+
+![Follower restart election step 1](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/follower_restart_election_1.png)
+
+**_发现已有Leader后成为Follower_**  
+服务器3收到服务器1的投票后，将自己的状态LEADING以及选票返回给服务器1。服务器2收到服务器1的投票后，将自己的状态FOLLOWING及选票返回给服务器1。此时服务器1知道服务器3是Leader，并且通过服务器2与服务器3的选票可以确定服务器3确实得到了超过半数的选票。因此服务器1进入FOLLOWING状态。
+
+![Follower restart election step 2](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/follower_restart_election_2.png)
+
+
+### Leader重启
+
+**_Follower发起新投票_**  
+Leader（服务器3）宕机后，Follower（服务器1和2）发现Leader不工作了，因此进入LOOKING状态并发起新的一轮投票，并且都将票投给自己。
+
+![Leader restart election step 1](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/leader_restart_election_1.png)
+
+
+**_广播更新选票_**  
+服务器1和2根据外部投票确定是否要更新自身的选票。这里有两种情况
+
+*   服务器1和2的zxid相同。例如在服务器3宕机前服务器1与2完全与之同步。此时选票的更新主要取决于myid的大小
+*   服务器1和2的zxid不同。在旧Leader宕机之前，其所主导的写操作，只需过半服务器确认即可，而不需所有服务器确认。换句话说，服务器1和2可能一个与旧Leader同步（即zxid与之相同）另一个不同步（即zxid比之小）。此时选票的更新主要取决于谁的zxid较大
+
+在上图中，服务器1的zxid为11，而服务器2的zxid为10，因此服务器2将自身选票更新为（3, 1, 11），如下图所示。
+
+![Leader restart election step 2](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/leader_restart_election_2.png)
+
+**_选出新Leader_**  
+经过上一步选票更新后，服务器1与服务器2均将选票投给服务器1，因此服务器2成为Follower，而服务器1成为新的Leader并维护与服务器2的心跳。
+
+![Leader restart election step 3](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/leader_restart_election_3.png)
+
+**_旧Leader恢复后发起选举_**  
+旧的Leader恢复后，进入LOOKING状态并发起新一轮领导选举，并将选票投给自己。此时服务器1会将自己的LEADING状态及选票（3, 1, 11）返回给服务器3，而服务器2将自己的FOLLOWING状态及选票（3, 1, 11）返回给服务器3。如下图所示。
+
+![Leader restart election step 4](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/leader_restart_election_4.png)
+
+**_旧Leader成为Follower_**  
+服务器3了解到Leader为服务器1，且根据选票了解到服务器1确实得到过半服务器的选票，因此自己进入FOLLOWING状态。
+
+![Leader restart election step 5](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/leader_restart_election_5.png)
+
+
+# 一致性保证
+
+ZAB协议保证了在Leader选举的过程中，已经被Commit的数据不会丢失，未被Commit的数据对客户端不可见。
+
+## Commit过的数据不丢失
+
+**_Failover前状态_**
+为更好演示Leader Failover过程，本例中共使用5个Zookeeper服务器。A作为Leader，共收到P1、P2、P3三条消息，并且Commit了1和2，且总体顺序为P1、P2、C1、P3、C2。根据顺序性原则，其它Follower收到的消息的顺序肯定与之相同。其中B与A完全同步，C收到P1、P2、C1，D收到P1、P2，E收到P1，如下图所示。
+
+![Leader Failover step 1](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/recovery_1.png)
+
+
+这里要注意
+
+*   由于A没有C3，意味着收到P3的服务器的总个数不会超过一半，也即包含A在内最多只有两台服务器收到P3。在这里A和B收到P3，其它服务器均未收到P3
+*   由于A已写入C1、C2，说明它已经Commit了P1、P2，因此整个集群有超过一半的服务器，即最少三个服务器收到P1、P2。在这里所有服务器都收到了P1，除E外其它服务器也都收到了P2
+
+**_选出新Leader_**  
+旧Leader也即A宕机后，其它服务器根据上述FastLeaderElection算法选出B作为新的Leader。C、D和E成为Follower且以B为Leader后，会主动将自己最大的zxid发送给B，B会将Follower的zxid与自身zxid间的所有被Commit过的消息同步给Follower，如下图所示。
+
+![Leader Failover step 2](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/recovery_2.png)
+
+
+在上图中
+
+*   P1和P2都被A Commit，因此B会通过同步保证P1、P2、C1与C2都存在于C、D和E中
+*   P3由于未被A Commit，同时幸存的所有服务器中P3未存在于大多数据服务器中，因此它不会被同步到其它Follower
+
+**_通知Follower可对外服务_**  
+同步完数据后，B会向D、C和E发送NEWLEADER命令并等待大多数服务器的ACK（下图中D和E已返回ACK，加上B自身，已经占集群的大多数），然后向所有服务器广播UPTODATE命令。收到该命令后的服务器即可对外提供服务。
+
+![Leader Failover step 3](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/recovery_3.png)
+
+
+## 未Commit过的消息对客户端不可见")未Commit过的消息对客户端不可见
+
+在上例中，P3未被A Commit过，同时因为没有过半的服务器收到P3，因此B也未Commit P3（如果有过半服务器收到P3，即使A未Commit P3，B会主动Commit P3，即C3），所以它不会将P3广播出去。
+
+具体做法是，B在成为Leader后，先判断自身未Commit的消息（本例中即P3）是否存在于大多数服务器中从而决定是否要将其Commit。然后B可得出自身所包含的被Commit过的消息中的最小zxid（记为min_zxid）与最大zxid（记为max_zxid）。C、D和E向B发送自身Commit过的最大消息zxid（记为max_zxid）以及未被Commit过的所有消息（记为zxid_set）。B根据这些信息作出如下操作
+
+*   如果Follower的max_zxid与Leader的max_zxid相等，说明该Follower与Leader完全同步，无须同步任何数据
+*   如果Follower的max_zxid在Leader的(min_zxid，max_zxid)范围内，Leader会通过TRUNC命令通知Follower将其zxid_set中大于Follower的max_zxid（如果有）的所有消息全部删除
+
+上述操作保证了未被Commit过的消息不会被Commit从而对外不可见。
+
+上述例子中Follower上并不存在未被Commit的消息。但可考虑这种情况，如果将上述例子中的服务器数量从五增加到七，服务器F包含P1、P2、C1、P3，服务器G包含P1、P2。此时服务器F、A和B都包含P3，但是因为票数未过半，因此B作为Leader不会Commit P3，而会通过TRUNC命令通知F删除P3。如下图所示。
+
+![Leader Failover step 4](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/recovery_4.png)
+
+
+# 总结
+
+*   由于使用主从复制模式，所有的写操作都要由Leader主导完成，而读操作可通过任意节点完成，因此Zookeeper读性能远好于写性能，更适合读多写少的场景
+*   虽然使用主从复制模式，同一时间只有一个Leader，但是Failover机制保证了集群不存在单点失败（SPOF）的问题
+*   ZAB协议保证了Failover过程中的数据一致性
+*   服务器收到数据后先写本地文件再进行处理，保证了数据的持久性
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2576\357\274\232Zookeeper\345\205\270\345\236\213\345\272\224\347\224\250\345\234\272\346\231\257\345\217\212\345\256\236\350\267\265.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232Zookeeper\345\205\270\345\236\213\345\272\224\347\224\250\345\234\272\346\231\257\345\217\212\345\256\236\350\267\265.md"
similarity index 81%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2576\357\274\232Zookeeper\345\205\270\345\236\213\345\272\224\347\224\250\345\234\272\346\231\257\345\217\212\345\256\236\350\267\265.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232Zookeeper\345\205\270\345\236\213\345\272\224\347\224\250\345\234\272\346\231\257\345\217\212\345\256\236\350\267\265.md"
index d382758..e007cd6 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2576\357\274\232Zookeeper\345\205\270\345\236\213\345\272\224\347\224\250\345\234\272\346\231\257\345\217\212\345\256\236\350\267\265.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232Zookeeper\345\205\270\345\236\213\345\272\224\347\224\250\345\234\272\346\231\257\345\217\212\345\256\236\350\267\265.md"
@@ -1,4 +1,5 @@
-# Table of Contents
+
+# 目录
 
 * [一.ZooKeeper典型应用场景实践](#一zookeeper典型应用场景实践)
 * [1 Zookeeper数据模型](#1-zookeeper数据模型)
@@ -13,22 +14,24 @@
   * [3.6 负载均衡](#36-负载均衡)
   * [3.7 分布式通知/协调](#37-分布式通知协调)
   * [二:典型场景描述总结](#二典型场景描述总结)
-      * [**数据发布与订阅**(配置管理)](#数据发布与订阅配置管理)
-      * [**负载均衡**](#负载均衡)
-      * [**分布通知/协调**](#分布通知协调)
-      * [**命名服务**](#命名服务)
-      * [**分布式锁**](#分布式锁)
-      * [**集群管理**](#集群管理)
-      * [**分布式队列**](#分布式队列)
+    * [**数据发布与订阅**(配置管理)](#数据发布与订阅配置管理)
+    * [**负载均衡**](#负载均衡)
+    * [**分布通知/协调**](#分布通知协调)
+    * [**命名服务**](#命名服务)
+    * [**分布式锁**](#分布式锁)
+    * [**集群管理**](#集群管理)
+    * [**分布式队列**](#分布式队列)
 
 本文内容参考网络，侵删
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本文也将同步到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -49,7 +52,7 @@ ZooKeeper是一个`高可用的分布式数据管理与系统协调框架`。`
 
 Zookeeper 会维护`一个具有层次关系的数据结构`，它非常类似于一个标准的文件系统，如图所示：
 
-[![](https://static.oschina.net/uploads/img/201511/17163447_w7k1.png)](https://static.oschina.net/uploads/img/201511/17163447_w7k1.png)
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/17163447_w7k1.png)](https://static.oschina.net/uploads/img/201511/17163447_w7k1.png)
 
 **图中的每个节点称为一个znode. 每个znode由3部分组成：**
 
@@ -63,7 +66,7 @@ Zookeeper 会维护`一个具有层次关系的数据结构`，它非常类似
 
 1.  每个子目录项如 NameService 都被称作为 znode，这个 znode 是被它所在的路径唯一标识，如 Server1 这个 znode 的标识为 /NameService/Server1；
 
-2.  znode 可以有子节点目录，并且每个 znode 可以存储数据，注意 `EPHEMERAL 类型的目录节点不能有子节点目录`；
+2.  znode 可以有子节点目录，并且每个 znode 可以存储数据，注意`EPHEMERAL 类型的目录节点不能有子节点目录`；
 
 3.  znode 是有版本的，每个 znode 中存储的数据可以有多个版本，`也就是一个访问路径中可以存储多份数据`；
 
@@ -71,13 +74,13 @@ Zookeeper 会维护`一个具有层次关系的数据结构`，它非常类似
 
 5.  znode 的`目录名可以自动编号`，如 App1 已经存在，再创建的话，将会自动命名为 App2；
 
-6.  znode `可以被监控，包括这个目录节点中存储的数据的修改，子节点目录的变化等`，一旦变化可以通知设置监控的客户端，`这个是 Zookeeper 的核心特性`，Zookeeper 的很多功能都是基于这个特性实现的，后面在典型的应用场景中会有实例介绍；
+6.  znode`可以被监控，包括这个目录节点中存储的数据的修改，子节点目录的变化等`，一旦变化可以通知设置监控的客户端，`这个是 Zookeeper 的核心特性`，Zookeeper 的很多功能都是基于这个特性实现的，后面在典型的应用场景中会有实例介绍；
 
 **znode节点的状态信息：**
 
-使用get命令获取指定节点的数据时, `同时也将返回该节点的状态信息, 称为Stat`. 其包含如下字段:
+使用get命令获取指定节点的数据时,`同时也将返回该节点的状态信息, 称为Stat`. 其包含如下字段:
 
-<pre>czxid. 节点创建时的zxid；
+czxid. 节点创建时的zxid；
 mzxid. 节点最新一次更新发生时的zxid；
 ctime. 节点创建时的时间戳；
 mtime. 节点最新一次更新发生时的时间戳；
@@ -87,13 +90,13 @@ aclVersion. 节点ACL(授权信息)的更新次数；
 ephemeralOwner. 如果该节点为ephemeral节点, ephemeralOwner值表示与该节点绑定的session id. 如果该节点不是              ephemeral节点, ephemeralOwner值为0\. 至于什么是ephemeral节点；
 dataLength. 节点数据的字节数；
 numChildren. 子节点个数；
-​</pre>
+
 
 **zxid：**
 
 znode节点的状态信息中包含czxid和mzxid, 那么什么是zxid呢?
 
-`ZooKeeper状态的每一次改变, 都对应着一个递增的Transaction id, 该id称为zxid`. 由于zxid的递增性质, 如果zxid1小于zxid2, 那么zxid1肯定先于zxid2发生. `创建任意节点, 或者更新任意节点的数据, 或者删除任意节点, 都会导致Zookeeper状态发生改变, 从而导致zxid的值增加`.
+`ZooKeeper状态的每一次改变, 都对应着一个递增的Transaction id, 该id称为zxid`. 由于zxid的递增性质, 如果zxid1小于zxid2, 那么zxid1肯定先于zxid2发生.`创建任意节点, 或者更新任意节点的数据, 或者删除任意节点, 都会导致Zookeeper状态发生改变, 从而导致zxid的值增加`.
 
 **session：**
 
@@ -105,21 +108,22 @@ znode节点的状态信息中包含czxid和mzxid, 那么什么是zxid呢?
 
 `persistent. persistent节点不和特定的session绑定`, 不会随着创建该节点的session的结束而消失, 而是**一直存在, 除非该节点被显式删除**.
 
-`ephemeral. ephemeral(临时)节点是临时性的, 如果创建该节点的session结束了, 该节点就会被自动删除`. `ephemeral节点不能拥有子节点`. 虽然ephemeral节点与创建它的session绑定, 但只要该节点没有被删除, 其他session就可以读写该节点中关联的数据. `使用-e参数指定创建ephemeral节点`.
+`ephemeral. ephemeral(临时)节点是临时性的, 如果创建该节点的session结束了, 该节点就会被自动删除`.`ephemeral节点不能拥有子节点`. 虽然ephemeral节点与创建它的session绑定, 但只要该节点没有被删除, 其他session就可以读写该节点中关联的数据.`使用-e参数指定创建ephemeral节点`.
 
-<pre>create -e /xing/ei world</pre>
+create -e /xing/ei world
 
-`sequence. 严格的说, sequence(顺序)并非节点类型中的一种`. **sequence节点既可以是ephemeral的, 也可以是persistent的**. `创建sequence节点时, ZooKeeper server会在指定的节点名称后加上一个数字序列, 该数字序列是递增的`. 因此可以**多次创建相同的sequence节点, 而得到不同的节点**. `使用-s参数指定创建sequence节点`.
+`sequence. 严格的说, sequence(顺序)并非节点类型中的一种`.**sequence节点既可以是ephemeral的, 也可以是persistent的**.`创建sequence节点时, ZooKeeper server会在指定的节点名称后加上一个数字序列, 该数字序列是递增的`. 因此可以**多次创建相同的sequence节点, 而得到不同的节点**.`使用-s参数指定创建sequence节点`.
 
-<pre>[zk: localhost:4180(CONNECTED) 0] create -s /xing/item world  
-Created /xing/item0000000001  
-[zk: localhost:4180(CONNECTED) 1] create -s /xing/item world  
-Created /xing/item0000000002  
-[zk: localhost:4180(CONNECTED) 2] create -s /xing/item world  
-Created /xing/item0000000003  
-[zk: localhost:4180(CONNECTED) 3] create -s /xing/item world  
+````
+[zk: localhost:4180(CONNECTED) 0] create -s /xing/item world 
+Created /xing/item0000000001 
+[zk: localhost:4180(CONNECTED) 1] create -s /xing/item world 
+Created /xing/item0000000002 
+[zk: localhost:4180(CONNECTED) 2] create -s /xing/item world 
+Created /xing/item0000000003 
+[zk: localhost:4180(CONNECTED) 3] create -s /xing/item world 
 Created /xing/item0000000004
-​</pre>
+````
 
 **watch：**
 
@@ -127,16 +131,17 @@ Created /xing/item0000000004
 
 ls命令. ls命令的第一个参数指定znode, 第二个参数如果为true, 则说明监听该znode的**子节点的增减**, 以及该znode**本身的删除**事件.
 
-<pre>[zk: localhost:4180(CONNECTED) 21] ls /xing true
+````
+[zk: localhost:4180(CONNECTED) 21] ls /xing true
 []
 [zk: localhost:4180(CONNECTED) 22] create /xing/item item000
 WATCHER::
  WatchedEvent state:SyncConnected type:NodeChildrenChanged path:/xing
-Created /xing/item</pre>
+Created /xing/item
 
 `get命令. get命令的第一个参数指定znode, 第二个参数如果为true, 则说明监听该znode的更新和删除事件`.
 
-<pre>[zk: localhost:4180(CONNECTED) 39] get /xing true
+[zk: localhost:4180(CONNECTED) 39] get /xing true
 world
 cZxid = 0x100000066
 ctime = Fri May 17 22:30:01 CST 2013
@@ -154,21 +159,22 @@ Created /xing/item
 [zk: localhost:4180(CONNECTED) 41] rmr /xing
 WATCHER::
  WatchedEvent state:SyncConnected type:NodeDeleted path:/xing
-​</pre>
+````
 
 # 2 如何使用Zookeeper
 
-Zookeeper 作为一个分布式的服务框架，`主要用来解决分布式集群中应用系统的一致性问题`，它能提供基于类似于文件系统的目录节点树方式的数据存储，但是 `Zookeeper 并不是用来专门存储数据的，它的作用主要是用来维护和监控你存储的数据的状态变化`。`通过监控这些数据状态的变化，从而可以达到基于数据的集群管理`，后面将会详细介绍 Zookeeper 能够解决的一些典型问题，这里先介绍一下，Zookeeper 的操作接口和简单使用示例。
+Zookeeper 作为一个分布式的服务框架，`主要用来解决分布式集群中应用系统的一致性问题`，它能提供基于类似于文件系统的目录节点树方式的数据存储，但是`Zookeeper 并不是用来专门存储数据的，它的作用主要是用来维护和监控你存储的数据的状态变化`。`通过监控这些数据状态的变化，从而可以达到基于数据的集群管理`，后面将会详细介绍 Zookeeper 能够解决的一些典型问题，这里先介绍一下，Zookeeper 的操作接口和简单使用示例。
 
 ## 2.1 常用接口操作
 
-客户端要连接 Zookeeper 服务器可以通过创建 `org.apache.zookeeper.ZooKeeper` 的一个实例对象，然后调用这个类提供的接口来和服务器交互。
+客户端要连接 Zookeeper 服务器可以通过创建`org.apache.zookeeper.ZooKeeper`的一个实例对象，然后调用这个类提供的接口来和服务器交互。
 
-前面说了 `ZooKeeper 主要是用来维护和监控一个目录节点树中存储的数据的状态`，所有我们能够操作 ZooKeeper 的也和操作目录节点树大体一样，如创建一个目录节点，给某个目录节点设置数据，获取某个目录节点的所有子目录节点，给某个目录节点设置权限和监控这个目录节点的状态变化。
+前面说了`ZooKeeper 主要是用来维护和监控一个目录节点树中存储的数据的状态`，所有我们能够操作 ZooKeeper 的也和操作目录节点树大体一样，如创建一个目录节点，给某个目录节点设置数据，获取某个目录节点的所有子目录节点，给某个目录节点设置权限和监控这个目录节点的状态变化。
 
 **ZooKeeper 基本的操作示例：**
 
-<pre>public class ZkDemo {
+````
+public class ZkDemo {
  public static void main(String[] args) throws IOException, KeeperException, InterruptedException {
  // 创建一个与服务器的连接
  ZooKeeper zk = new ZooKeeper("127.0.0.1:2180", 60000, new Watcher() {
@@ -186,10 +192,10 @@ Zookeeper 作为一个分布式的服务框架，`主要用来解决分布式集
  if (zk.exists("/node", true) == null) {
  // 创建一个给定的目录节点 path, 并给它设置数据；
  // CreateMode 标识有四种形式的目录节点，分别是：
- //     PERSISTENT：持久化目录节点，这个目录节点存储的数据不会丢失；
- //     PERSISTENT_SEQUENTIAL：顺序自动编号的目录节点，这种目录节点会根据当前已近存在的节点数自动加 1，然后返回给客户端已经成功创建的目录节点名；
- //     EPHEMERAL：临时目录节点，一旦创建这个节点的客户端与服务器端口也就是 session 超时，这种节点会被自动删除；
- //     EPHEMERAL_SEQUENTIAL：临时自动编号节点
+ //   PERSISTENT：持久化目录节点，这个目录节点存储的数据不会丢失；
+ //   PERSISTENT_SEQUENTIAL：顺序自动编号的目录节点，这种目录节点会根据当前已近存在的节点数自动加 1，然后返回给客户端已经成功创建的目录节点名；
+ //   EPHEMERAL：临时目录节点，一旦创建这个节点的客户端与服务器端口也就是 session 超时，这种节点会被自动删除；
+ //   EPHEMERAL_SEQUENTIAL：临时自动编号节点
  zk.create("/node", "conan".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  System.out.println("create /node conan");
  // 查看/node节点数据
@@ -224,7 +230,7 @@ Zookeeper 作为一个分布式的服务框架，`主要用来解决分布式集
  zk.close();
  }
 }
-​</pre>
+````
 
 # 3 ZooKeeper 典型的应用场景
 
@@ -234,7 +240,7 @@ Zookeeper 从设计模式角度来看，是一个`基于观察者模式设计的
 
 ## 3.1 统一命名服务（Name Service）
 
-分布式应用中，通常需要有一套完整的命名规则，既能够产生唯一的名称又便于人识别和记住，通常情况下用树形的名称结构是一个理想的选择，**树形的名称结构是一个有层次的目录结构，既对人友好又不会重复**。说到这里你可能想到了 JNDI，没错 Zookeeper 的 Name Service **与 JNDI 能够完成的功能是差不多的**，它们都是将有层次的目录结构关联到一定资源上，但是 Zookeeper 的 Name Service 更加是广泛意义上的关联，也许你并不需要将名称关联到特定资源上，你可能只需要一个不会重复名称，**就像数据库中产生一个唯一的数字主键一样**。
+分布式应用中，通常需要有一套完整的命名规则，既能够产生唯一的名称又便于人识别和记住，通常情况下用树形的名称结构是一个理想的选择，**树形的名称结构是一个有层次的目录结构，既对人友好又不会重复**。说到这里你可能想到了 JNDI，没错 Zookeeper 的 Name Service**与 JNDI 能够完成的功能是差不多的**，它们都是将有层次的目录结构关联到一定资源上，但是 Zookeeper 的 Name Service 更加是广泛意义上的关联，也许你并不需要将名称关联到特定资源上，你可能只需要一个不会重复名称，**就像数据库中产生一个唯一的数字主键一样**。
 
 `Name Service 已经是 Zookeeper 内置的功能`，你只要调用 Zookeeper 的 API 就能实现。如调用 create 接口就可以很容易创建一个目录节点。
 
@@ -256,7 +262,7 @@ Zookeeper 从设计模式角度来看，是一个`基于观察者模式设计的
 
 像这样的配置信息完全可以交给 Zookeeper 来管理，`将配置信息保存在 Zookeeper 的某个目录节点中，然后将所有需要修改的应用机器监控配置信息的状态，一旦配置信息发生变化，每台应用机器就会收到 Zookeeper 的通知，然后从 Zookeeper 获取新的配置信息应用到系统中`。
 
-[![](https://static.oschina.net/uploads/img/201511/18093533_GnwN.png)](https://static.oschina.net/uploads/img/201511/18093533_GnwN.png)
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/18093533_GnwN.png)](https://static.oschina.net/uploads/img/201511/18093533_GnwN.png)
 
 **发布与订阅模型，即所谓的配置中心**，顾名思义就是**发布者将数据发布到ZK节点上，供订阅者动态获取数据**，`实现配置信息的集中式管理和动态更新`。例如全局的配置信息，服务式服务框架的服务地址列表等就非常适合使用。
 
@@ -276,13 +282,13 @@ Zookeeper 从设计模式角度来看，是一个`基于观察者模式设计的
 
 Zookeeper 能够很容易的实现集群管理的功能，如有多台 Server 组成一个服务集群，那么`必须要一个“总管”知道当前集群中每台机器的服务状态，一旦有机器不能提供服务，集群中其它集群必须知道`，从而做出调整重新分配服务策略。同样`当增加集群的服务能力时，就会增加一台或多台 Server，同样也必须让“总管”知道`。
 
-Zookeeper 不仅能够帮你维护当前的集群中机器的服务状态，而且能够帮你选出一个“总管”，让这个总管来管理集群，这就是 `Zookeeper 的另一个功能 Leader Election`。
+Zookeeper 不仅能够帮你维护当前的集群中机器的服务状态，而且能够帮你选出一个“总管”，让这个总管来管理集群，这就是`Zookeeper 的另一个功能 Leader Election`。
 
-它们的实现方式都是在 **Zookeeper 上创建一个 EPHEMERAL 类型的目录节点`，然后`每个 Server 在它们创建目录节点的父目录节点上调用 getChildren(String path, boolean watch) 方法并设置 watch 为 true`，由于是 EPHEMERAL 目录节点，当创建它的 Server 死去，这个目录节点也随之被删除，所以 Children 将会变化，这时 getChildren上的 Watch 将会被调用，所以其它 Server 就知道已经有某台 Server 死去了**。新增 Server 也是同样的原理。
+它们的实现方式都是在**Zookeeper 上创建一个 EPHEMERAL 类型的目录节点`，然后`每个 Server 在它们创建目录节点的父目录节点上调用 getChildren(String path, boolean watch) 方法并设置 watch 为 true`，由于是 EPHEMERAL 目录节点，当创建它的 Server 死去，这个目录节点也随之被删除，所以 Children 将会变化，这时 getChildren上的 Watch 将会被调用，所以其它 Server 就知道已经有某台 Server 死去了**。新增 Server 也是同样的原理。
 
-Zookeeper 如何实现 Leader Election，也就是选出一个 Master Server。和前面的一样`每台 Server 创建一个 EPHEMERAL 目录节点，不同的是它还是一个 SEQUENTIAL 目录节点，所以它是个 EPHEMERAL_SEQUENTIAL 目录节点`。之所以它是 **EPHEMERAL_SEQUENTIAL** 目录节点，是因为我们可以给每台 Server 编号，我们可以`选择当前是最小编号的 Server 为 Master`，假如这个最小编号的 Server 死去，由于是 EPHEMERAL 节点，`死去的 Server 对应的节点也被删除，所以当前的节点列表中又出现一个最小编号的节点，我们就选择这个节点为当前 Master`。这样就实现了动态选择 Master，避免了传统意义上单 Master 容易出现单点故障的问题。
+Zookeeper 如何实现 Leader Election，也就是选出一个 Master Server。和前面的一样`每台 Server 创建一个 EPHEMERAL 目录节点，不同的是它还是一个 SEQUENTIAL 目录节点，所以它是个 EPHEMERAL_SEQUENTIAL 目录节点`。之所以它是**EPHEMERAL_SEQUENTIAL**目录节点，是因为我们可以给每台 Server 编号，我们可以`选择当前是最小编号的 Server 为 Master`，假如这个最小编号的 Server 死去，由于是 EPHEMERAL 节点，`死去的 Server 对应的节点也被删除，所以当前的节点列表中又出现一个最小编号的节点，我们就选择这个节点为当前 Master`。这样就实现了动态选择 Master，避免了传统意义上单 Master 容易出现单点故障的问题。
 
-[![](https://static.oschina.net/uploads/img/201511/18095931_70Ol.png)](https://static.oschina.net/uploads/img/201511/18095931_70Ol.png)
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/18095931_70Ol.png)](https://static.oschina.net/uploads/img/201511/18095931_70Ol.png)
 
 **1\. 集群机器监控**
 
@@ -308,13 +314,13 @@ Zookeeper 如何实现 Leader Election，也就是选出一个 Master Server。
 
 另外，这种场景演化一下，就是`动态Master选举`。这就要用到`EPHEMERAL_SEQUENTIAL类型节点的特性了`。
 
-上文中提到，所有客户端创建请求，最终只有一个能够创建成功。在这里稍微变化下，就是**允许所有请求都能够创建成功，但是得有个创建顺序**，于是所有的请求最终在ZK上创建结果的一种可能情况是这样： /currentMaster/{sessionId}-1 ,/currentMaster/{sessionId}-2,/currentMaster/{sessionId}-3 ….. `每次选取序列号最小的那个机器作为Master，如果这个机器挂了，由于他创建的节点会马上消失，那么之后最小的那个机器就是Master了`。
+上文中提到，所有客户端创建请求，最终只有一个能够创建成功。在这里稍微变化下，就是**允许所有请求都能够创建成功，但是得有个创建顺序**，于是所有的请求最终在ZK上创建结果的一种可能情况是这样： /currentMaster/{sessionId}-1 ,/currentMaster/{sessionId}-2,/currentMaster/{sessionId}-3 …..`每次选取序列号最小的那个机器作为Master，如果这个机器挂了，由于他创建的节点会马上消失，那么之后最小的那个机器就是Master了`。
 
 **3\. 在搜索系统中，如果集群中每个机器都生成一份全量索引，不仅耗时，而且不能保证彼此之间索引数据一致。**因此让集群中的Master来进行全量索引的生成，然后同步到集群中其它机器。另外，Master选举的容灾措施是，可以随时进行手动指定master，就是说应用在zk在无法获取master信息时，可以通过比如http方式，向一个地方获取master。
 
 **4\. 在Hbase中，也是使用ZooKeeper来实现动态HMaster的选举。**在Hbase实现中，会在ZK上存储一些ROOT表的地址和HMaster的地址，HRegionServer也会把自己以临时节点（Ephemeral）的方式注册到Zookeeper中，使得HMaster可以随时感知到各个HRegionServer的存活状态，同时，一旦HMaster出现问题，会重新选举出一个HMaster来运行，从而避免了HMaster的单点问题。
 
-[![](https://static.oschina.net/uploads/img/201511/18102032_cFyc.png)](https://static.oschina.net/uploads/img/201511/18102032_cFyc.png)
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/18102032_cFyc.png)](https://static.oschina.net/uploads/img/201511/18102032_cFyc.png)
 
 ## 3.4 共享锁（Locks）
 
@@ -326,9 +332,9 @@ Zookeeper 如何实现 Leader Election，也就是选出一个 Master Server。
 
 2.  **控制时序，就是所有视图来获取这个锁的客户端，最终都是会被安排执行，只是有个全局时序了**。做法和上面基本类似，只是这里 /distribute_lock 已经预先存在，客户端在它下面创建临时有序节点（这个可以通过节点的属性控制：CreateMode.EPHEMERAL_SEQUENTIAL来指定）。**Zk的父节点（/distribute_lock）维持一份sequence,保证子节点创建的时序性，从而也形成了每个客户端的全局时序。**
 
-[![](https://static.oschina.net/uploads/img/201511/18103433_BJs7.png)](https://static.oschina.net/uploads/img/201511/18103433_BJs7.png)
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/18103433_BJs7.png)](https://static.oschina.net/uploads/img/201511/18103433_BJs7.png)
 
-[![](https://static.oschina.net/uploads/img/201511/18103709_c4c3.png)](https://static.oschina.net/uploads/img/201511/18103709_c4c3.png)
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/18103709_c4c3.png)](https://static.oschina.net/uploads/img/201511/18103709_c4c3.png)
 
 ## 3.5 队列管理
 
@@ -342,15 +348,15 @@ Zookeeper 可以处理两种类型的队列：
 
 创建一个父目录 /synchronizing，每个成员都监控标志（Set Watch）位目录 /synchronizing/start 是否存在，然后每个成员都加入这个队列，**加入队列的方式**就是创建 /synchronizing/member_i 的**临时目录节点**，然后每个成员获取 / synchronizing 目录的所有目录节点，也就是 member_i。判断 i 的值是否已经是成员的个数，如果小于成员个数等待 /synchronizing/start 的出现，`如果已经相等就创建 /synchronizing/start`。
 
-[![](https://static.oschina.net/uploads/img/201511/18104311_7kNc.png)](https://static.oschina.net/uploads/img/201511/18104311_7kNc.png)
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/18104311_7kNc.png)](https://static.oschina.net/uploads/img/201511/18104311_7kNc.png)
 
-[![](https://static.oschina.net/uploads/img/201511/18104433_Rdxx.png)](https://static.oschina.net/uploads/img/201511/18104433_Rdxx.png)
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/18104433_Rdxx.png)](https://static.oschina.net/uploads/img/201511/18104433_Rdxx.png)
 
 **FIFO 队列用 Zookeeper 实现思路如下：**
 
 实现的思路也非常简单，就是在特定的目录下**创建 SEQUENTIAL 类型的子目录 /queue_i**，这样就能保证所有成员加入队列时都是有编号的`，出队列时通过 getChildren( ) 方法可以返回当前所有的队列中的元素，然后消费其中最小的一个，这样就能保证 FIFO。
 
-[![](https://static.oschina.net/uploads/img/201511/18104614_ncNj.png)](https://static.oschina.net/uploads/img/201511/18104614_ncNj.png)
+[![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/18104614_ncNj.png)
 
 ## 3.6 负载均衡
 
@@ -362,13 +368,13 @@ Zookeeper 可以处理两种类型的队列：
 
 `消费负载均衡`： 在消费过程中，一个消费者会消费一个或多个分区中的消息，但是一个分区只会由一个消费者来消费。MetaQ的消费策略是：
 
-1.  每个分区针对同一个group只挂载一个消费者。
+1. 每个分区针对同一个group只挂载一个消费者。
 
-2.  如果同一个group的消费者数目大于分区数目，则多出来的消费者将不参与消费。
+2. 如果同一个group的消费者数目大于分区数目，则多出来的消费者将不参与消费。
 
-3.  如果同一个group的消费者数目小于分区数目，则有部分消费者需要额外承担消费任务。
+3. 如果同一个group的消费者数目小于分区数目，则有部分消费者需要额外承担消费任务。
 
-    在某个消费者故障或者重启等情况下，其他消费者会感知到这一变化（通过 zookeeper watch消费者列表），然后重新进行负载均衡，保证所有的分区都有消费者进行消费。
+   在某个消费者故障或者重启等情况下，其他消费者会感知到这一变化（通过 zookeeper watch消费者列表），然后重新进行负载均衡，保证所有的分区都有消费者进行消费。
 
 ## 3.7 分布式通知/协调
 
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2575\357\274\232Zookeeper\347\232\204\351\205\215\347\275\256\344\270\216\351\233\206\347\276\244\347\256\241\347\220\206\345\256\236\346\210\230.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232Zookeeper\347\232\204\351\205\215\347\275\256\344\270\216\351\233\206\347\276\244\347\256\241\347\220\206\345\256\236\346\210\230.md"
similarity index 68%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2575\357\274\232Zookeeper\347\232\204\351\205\215\347\275\256\344\270\216\351\233\206\347\276\244\347\256\241\347\220\206\345\256\236\346\210\230.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232Zookeeper\347\232\204\351\205\215\347\275\256\344\270\216\351\233\206\347\276\244\347\256\241\347\220\206\345\256\236\346\210\230.md"
index f624388..a810400 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2575\357\274\232Zookeeper\347\232\204\351\205\215\347\275\256\344\270\216\351\233\206\347\276\244\347\256\241\347\220\206\345\256\236\346\210\230.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232Zookeeper\347\232\204\351\205\215\347\275\256\344\270\216\351\233\206\347\276\244\347\256\241\347\220\206\345\256\236\346\210\230.md"
@@ -1,27 +1,31 @@
-# Table of Contents
 
-  * [4.1 配置文件](#41-配置文件)
-  * [4.2 服务端命令](#42-服务端命令)
-  * [4.3 客户端命令](#43-客户端命令)
+
+# 目录
+
+* [4.1 配置文件](#41-配置文件)
+* [4.2 服务端命令](#42-服务端命令)
+* [4.3 客户端命令](#43-客户端命令)
     * [4.3.1 查看节点列表](#431-查看节点列表)
     * [4.3.2 创建新节点](#432-创建新节点)
     * [4.3.3 查看节点数据](#433-查看节点数据)
     * [4.3.4 修改节点数据](#434-修改节点数据)
     * [4.3.5 删除节点](#435-删除节点)
-  * [4.4 ZooKeeper四字命令](#44-zookeeper四字命令)
-  * [5.1 集群配置](#51-集群配置)
-  * [5.2 集群启动](#52-集群启动)
-  * [5.3 集群容灾](#53-集群容灾)
+* [4.4 ZooKeeper四字命令](#44-zookeeper四字命令)
+* [5.1 集群配置](#51-集群配置)
+* [5.2 集群启动](#52-集群启动)
+* [5.3 集群容灾](#53-集群容灾)
 
 
 本文内容参考网络，侵删
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本文也将同步到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -54,7 +58,7 @@ syncLimit=5
 
 dataDir=/tmp/zookeeper
 
-顾名思义就是 **ZooKeeper保存数据的目录**，用于存放内存数据库快照的文件夹，同时用于集群的myid文件也存在这个文件夹里。默认情况下，ZooKeeper 将写数据的日志文件也保存在这个目录里。注意：一个配置文件只能包含一个dataDir字样，即使它被注释掉了。
+顾名思义就是**ZooKeeper保存数据的目录**，用于存放内存数据库快照的文件夹，同时用于集群的myid文件也存在这个文件夹里。默认情况下，ZooKeeper 将写数据的日志文件也保存在这个目录里。注意：一个配置文件只能包含一个dataDir字样，即使它被注释掉了。
 
 clientPort=2181
 
@@ -76,7 +80,7 @@ autopurge.purgeInterval=1
 
 利用“zkServer.sh help”命令，可以查看支持的参数：
 
-![](https://img-blog.csdn.net/20161026094506241?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212604.png)
 
 可见，“zkServer.sh”可以附带的参数有：
 
@@ -92,21 +96,21 @@ autopurge.purgeInterval=1
 
 例如，使用命令“**zkServer.sh start**”启动ZooKeeper服务端，该命令后面可以附带参数，用于指定配置文件的路径，比如“zkServer.sh start ../conf/ZooKeeper.cfg”,代表使用ZooKeeper.cfg作为配置文件，如果不指定路径，默认加载“conf/zoo.cfg”文件：
 
-![](https://img-blog.csdn.net/20161026094527607?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212614.png)
 
 使用**“zkServer.sh stop**”停止服务端：
 
-![](https://img-blog.csdn.net/20161026094541826?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212621.png)
 
 ## 4.3 客户端命令
 
 使用命令“**zkCli.sh -server 127.0.0.1:2181**”可以连接到IP为“127.0.0.1”，端口为“2181”的ZooKeeper服务器。如果连接本机的2181端口，则后面的参数可以省略。如：
 
-![](https://img-blog.csdn.net/20161026094633014?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212629.png)
 
 此时，输入“help”可以查看命令参数：
 
-![](https://img-blog.csdn.net/20161026094654858?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212637.png)
 
 ### 4.3.1 查看节点列表
 
@@ -114,7 +118,7 @@ autopurge.purgeInterval=1
 
 “**ls path**”用于查看路径path下的所有直接子节点：
 
-![](https://img-blog.csdn.net/20161026094740687?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212645.png)
 
 可见，系统初始化的时候，根节点下会自动创建一个名为“zookeeper”的节点，用于存储ZooKeeper的管理信息。所以用户不能再根节点下创建同名的子节点。
 
@@ -128,7 +132,7 @@ autopurge.purgeInterval=1
 
 create /firstNode HelloWorld
 
-![](https://img-blog.csdn.net/20161026094755539?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212654.png)
 
 ### 4.3.3 查看节点数据
 
@@ -136,19 +140,19 @@ create /firstNode HelloWorld
 
 get /firstNode
 
-![](https://img-blog.csdn.net/20161026094814110?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212702.png)
 
 除了返回节点存储的数据之外，还有一系列的元信息，如代表节点创建时间的“cZxid”、“ctime”（两种表示方法）；节点的修改时间“mZxid”、“mtime”等。
 
 ### 4.3.4 修改节点数据
 
-“**set path data** ”用于将path节点下的数据更改为data。
+“**set path data**”用于将path节点下的数据更改为data。
 
 如，将“/firstNode”下的数据更改为“WorldHello”：
 
 set /firstNode WorldHello
 
-![](https://img-blog.csdn.net/20161026095005321?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+
 
 ### 4.3.5 删除节点
 
@@ -158,7 +162,7 @@ set /firstNode WorldHello
 
 delete /firstNode
 
-![](https://img-blog.csdn.net/20161026094832782?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212739.png)
 
 此外，还有用于设置节点ACL、查看节点状态等其他命令，需要时可以查阅相关手册。
 
@@ -206,7 +210,7 @@ wchs
 
 wchc
 
-通过 **session** 列出服务器 watch 的详细信息，它的输出是一个与 watch 相关的会话的列表
+通过**session**列出服务器 watch 的详细信息，它的输出是一个与 watch 相关的会话的列表
 
 wchp
 
@@ -226,7 +230,7 @@ nc为“NetCat”工具提供的命令，通常的Linux发行版中都带有NetC
 
 该命令的意思为，将“conf”命令传递给127.0.0.1的2181端口（即本机的ZooKeeper服务端口），并将响应打印出来：
 
-![](https://img-blog.csdn.net/20161026095053040?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212748.png)
 
 在一台机器上运营一个ZooKeeper实例，称之为单机（Standalone）模式。单机模式有个致命的缺陷，一旦唯一的实例挂了，依赖ZooKeeper的应用全得完蛋。
 
@@ -240,65 +244,68 @@ nc为“NetCat”工具提供的命令，通常的Linux发行版中都带有NetC
 
 首先，需要为三个实例创建不同的配置文件：
 
-<pre>zk1.cfg的配置项如下：
-​
+zk1.cfg的配置项如下：
+````
  tickTime=2000
-​
+
  initLimit=10
-​
+
  syncLimit=5
-​
+
  dataDir=/zk1/dataDir
-​
+
  clientPort=2181
-​
+
  server.1=127.0.0.1:2888:3888
-​
+
  server.2=127.0.0.1:2889:3889
-​
- server.3=127.0.0.1:2890:3890</pre>
 
-<pre>zk2.cfg的配置项如下：
-​
+ server.3=127.0.0.1:2890:3890
+````
+
+zk2.cfg的配置项如下：
+````
  tickTime=2000
-​
+
  initLimit=10
-​
+
  syncLimit=5
-​
+
  dataDir=/zk2/dataDir
-​
+
  clientPort=2182
-​
+
  server.1=127.0.0.1:2888:3888
-​
+
  server.2=127.0.0.1:2889:3889
-​
- server.3=127.0.0.1:2890:3890</pre>
 
-<pre>zk3.cfg的配置项如下：
-​
+ server.3=127.0.0.1:2890:3890
+````
+
+zk3.cfg的配置项如下：
+````
 tickTime=2000
-​
+
 initLimit=10
-​
+
 syncLimit=5
-​
+
 dataDir=/zk3/dataDir
-​
+
 clientPort=2183
-​
+
 server.1=127.0.0.1:2888:3888
-​
+
 server.2=127.0.0.1:2889:3889
-​
-server.3=127.0.0.1:2890:3890</pre>
+
+server.3=127.0.0.1:2890:3890
+````
 
 因为部署在同一台机器上，所以每个实例的dataDir、clientPort要做区分，其余配置保持一致。
 
 需要注意的是，集群中所有的实例作为一个整体对外提供服务，集群中每个实例之间都互相连接，所以，每个配置文件中都要列出所有实例的映射关系。
 
-在每个配置文件的末尾，有几行“server.A=B：C：D”这样的配置，其中， **A** 是一个数字，表示这个是**第几号服务器**；B 是这个服务器的 **ip 地址**；C 表示的是这个**服务器与集群中的 Leader 服务器交换信息的端口**；D 表示的是万一集群中的 Leader 服务器挂了，需要一个端口来重新进行选举，选出一个新的 Leader，而这个端口就是用来执行**选举时服务器相互通信的端口**。如果是伪集群的配置方式，由于 B 都是一样，所以不同的 Zookeeper 实例通信端口号不能一样，所以要给它们分配不同的端口号。
+在每个配置文件的末尾，有几行“server.A=B：C：D”这样的配置，其中，**A**是一个数字，表示这个是**第几号服务器**；B 是这个服务器的**ip 地址**；C 表示的是这个**服务器与集群中的 Leader 服务器交换信息的端口**；D 表示的是万一集群中的 Leader 服务器挂了，需要一个端口来重新进行选举，选出一个新的 Leader，而这个端口就是用来执行**选举时服务器相互通信的端口**。如果是伪集群的配置方式，由于 B 都是一样，所以不同的 Zookeeper 实例通信端口号不能一样，所以要给它们分配不同的端口号。
 
 除了修改 zoo.cfg 配置文件，集群模式下还要配置一个**myid**文件，这个文件**在 dataDir 目录下，文件里只有一个数据，就是 A 的值**(第几号服务器)，Zookeeper 启动时会读取这个文件，拿到里面的数据与配置信息比较从而判断到底是那个 Server。
 
@@ -308,25 +315,25 @@ server.3=127.0.0.1:2890:3890</pre>
 
 依次启动三个实例：
 
-![](https://img-blog.csdn.net/20161027092116131?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212755.png)
 
 查看Server状态：
 
-![](https://img-blog.csdn.net/20161027092128275?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212802.png)
 
 可见，现在的集群中，zk2充当着Leader角色，而zk1与zk3充当着Follower角色。
 
 使用三个客户端连接三个Server，在zk1的客户端下，新增“/newNode”节点，储存数据“zk1”：
 
-![](https://img-blog.csdn.net/20161027092143725?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212808.png)
 
 在zk2的客户端与查看该节点：
 
-![](https://img-blog.csdn.net/20161027092201291?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212816.png)
 
 在zk3的客户端与查看该节点：
 
-![](https://img-blog.csdn.net/20161027092213463?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212822.png)
 
 可见，集群中的Server保持着数据同步。
 
@@ -334,12 +341,12 @@ server.3=127.0.0.1:2890:3890</pre>
 
 如果我们把身为Leader的zk2关闭，会发生什么呢？
 
-![](https://img-blog.csdn.net/20161027092228400?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212828.png)
 
 可见，集群自动完成了切换，zk3变成了Leader。实际应用中，如果集群中的Leader宕机了，或者Leader与超过半数的Follower失去联系，都会触发ZooKeeper的选举流程，选举出新的Leader之后继续对外服务。
 
 如果我们再把zk3关闭，会发生什么呢？
 
-![](https://img-blog.csdn.net/20161027092241119?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407212836.png))
 
 可见，关闭zk3以后，由于集群中的可用Server只剩下一台（达不到集群总数的半数以上），**集群将处于不可用的状态。**
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25719\357\274\232\344\275\277\347\224\250RocketMQ\344\272\213\345\212\241\346\266\210\346\201\257\350\247\243\345\206\263\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\344\275\277\347\224\250RocketMQ\344\272\213\345\212\241\346\266\210\346\201\257\350\247\243\345\206\263\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"
similarity index 90%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25719\357\274\232\344\275\277\347\224\250RocketMQ\344\272\213\345\212\241\346\266\210\346\201\257\350\247\243\345\206\263\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\344\275\277\347\224\250RocketMQ\344\272\213\345\212\241\346\266\210\346\201\257\350\247\243\345\206\263\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"
index 2c577d9..decea79 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25719\357\274\232\344\275\277\347\224\250RocketMQ\344\272\213\345\212\241\346\266\210\346\201\257\350\247\243\345\206\263\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\344\275\277\347\224\250RocketMQ\344\272\213\345\212\241\346\266\210\346\201\257\350\247\243\345\206\263\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"
@@ -1,4 +1,5 @@
-# Table of Contents
+
+# 目录
 
 * [初步认识RocketMQ的核心模块](#初步认识rocketmq的核心模块)
 * [错误的方案0](#错误的方案0)
@@ -12,11 +13,13 @@
 本文内容参考网络，侵删
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本文也将同步到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -29,18 +32,10 @@
 
 # 初步认识RocketMQ的核心模块
 
-
-
-
-
-![](https://upload-images.jianshu.io/upload_images/4943997-9842b6eec46bd737.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/328)
-
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/4943997-9842b6eec46bd737.png)
 
 rocketmq模块
 
-
-
 **rocketmq-broker：接受生产者发来的消息并存储（通过调用rocketmq-store），消费者从这里取得消息。**
 
 **rocketmq-client：提供发送、接受消息的客户端API。**
@@ -57,21 +52,16 @@ rocketmq模块
 
 **rocketmq-tools：命令行工具**
 
-
-
 [分布式消息队列RocketMQ--事务消息--解决分布式事务](https://www.cnblogs.com/ZJOE80/p/7810533.html)
 
 
-
-
-
 说到分布式事务，就会谈到那个经典的”账号转账”问题：2个账号，分布处于2个不同的DB，或者说2个不同的子系统里面，A要扣钱，B要加钱，如何保证原子性？
 
 一般的思路都是通过消息中间件来实现“最终一致性”：A系统扣钱，然后发条消息给中间件，B系统接收此消息，进行加钱。
 
 但这里面有个问题：A是先update DB，后发送消息呢？ 还是先发送消息，后update DB？
 
-假设先update DB成功，发送消息网络失败，重发又失败，怎么办？ 
+假设先update DB成功，发送消息网络失败，重发又失败，怎么办？
 假设先发送消息成功，update DB失败。消息已经发出去了，又不能撤回，怎么办？
 
 所以，这里下个结论： 只要发送消息和update DB这2个操作不是原子的，无论谁先谁后，都是有问题的。
@@ -86,17 +76,17 @@ rocketmq模块
 
 （1）网络的2将军问题：发送消息失败，发送方并不知道是消息中间件真的没有收到消息呢？还是消息已经收到了，只是返回response的时候失败了？
 
-         如果是已经收到消息了，而发送端认为没有收到，执行update db的回滚操作。则会导致A账号的钱没有扣，B账号的钱却加了。
+    如果是已经收到消息了，而发送端认为没有收到，执行update db的回滚操作。则会导致A账号的钱没有扣，B账号的钱却加了。
 
 （2）把网络调用放在DB事务里面，可能会因为网络的延时，导致DB长事务。严重的，会block整个DB。这个风险很大。
 
-         基于以上分析，我们知道，这个方案其实是错误的！
+    基于以上分析，我们知道，这个方案其实是错误的！
 
 # 方案1–业务方自己实现
 
 假设消息中间件没有提供“事务消息”功能，比如你用的是Kafka。那如何解决这个问题呢？
 
-解决方案如下： 
+解决方案如下：
 （1）Producer端准备1张消息表，把update DB和insert message这2个操作，放在一个DB事务里面。
 
 （2）准备一个后台程序，源源不断的把消息表中的message传送给消息中间件。失败了，不断重试重传。允许消息重复，但消息不会丢，顺序也不会打乱。
@@ -115,9 +105,9 @@ rocketmq模块
 
 具体来说，就是把消息的发送分成了2个阶段：Prepare阶段和确认阶段。
 
-具体来说，上面的2个步骤，被分解成3个步骤： 
-(1) 发送Prepared消息 
-(2) update DB 
+具体来说，上面的2个步骤，被分解成3个步骤：
+(1) 发送Prepared消息
+(2) update DB
 (3) 根据update DB结果成功或失败，Confirm或者取消Prepared消息。
 
 可能有人会问了，前2步执行成功了，最后1步失败了怎么办？这里就涉及到了RocketMQ的关键点：RocketMQ会定期（默认是1分钟）扫描所有的Prepared消息，询问发送方，到底是要确认这条消息发出去？还是取消此条消息？
@@ -143,7 +133,9 @@ SendResult sendResult = producer.sendMessageInTransaction(msg, tranExecuter, nul
 producer.shutdown();
 
 ```
+
 然后执行本地事务，具体代码如下
+
 ```
 public TransactionSendResult sendMessageInTransaction(.....)  {
     // 逻辑代码，非实际代码
@@ -157,11 +149,11 @@ public TransactionSendResult sendMessageInTransaction(.....)  {
 }
 ```
 
-![](https://img-blog.csdn.net/20180624145825253?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MjQ4ODg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407220221.png)
 
 上面所说的消息中间件上注册的listener，超时以后会回调producer的接口以确定事务执行情况
 
-![](https://img-blog.csdn.net/20180624145955411?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MjQ4ODg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407220230.png)
 
 总结：对比方案2和方案1，RocketMQ最大的改变，其实就是把“扫描消息表”这个事情，不让业务方做，而是消息中间件帮着做了。
 
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25712\357\274\232\345\210\206\345\270\203\345\274\217ID\347\224\237\346\210\220\346\226\271\346\241\210.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217ID\347\224\237\346\210\220\346\226\271\346\241\210.md"
similarity index 90%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25712\357\274\232\345\210\206\345\270\203\345\274\217ID\347\224\237\346\210\220\346\226\271\346\241\210.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217ID\347\224\237\346\210\220\346\226\271\346\241\210.md"
index b783cfb..1563d5a 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25712\357\274\232\345\210\206\345\270\203\345\274\217ID\347\224\237\346\210\220\346\226\271\346\241\210.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217ID\347\224\237\346\210\220\346\226\271\346\241\210.md"
@@ -1,6 +1,12 @@
-# Table of Contents
+# 目录
+
+  * [**一、需求缘起**](#一、需求缘起)
+  * [**二、常见方法、不足与优化**](#二、常见方法、不足与优化)
+  * [**方法二：单点批量ID生成服务**](#方法二：单点批量id生成服务)
+  * [**方法三：uuid/guid**](#方法三：uuidguid)
+  * [**方法四：取当前毫秒数**](#方法四：取当前毫秒数)
+
 
-  * [分布式ID生成器 | 架构师之路](#分布式id生成器--架构师之路)
 
 本文内容参考网络，侵删
 
@@ -18,12 +24,11 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
-## 分布式ID生成器 | 架构师之路
+<!-- more -->  
 
-转自： 58沈剑 架构师之路 2017-06-25
+转自：58沈剑架构师之路2017-06-25
 
-**一、需求缘起**
+## **一、需求缘起**
 
 几乎所有的业务系统，都有生成一个唯一记录标识的需求，例如：
 
@@ -65,9 +70,9 @@ select message-id/ (order by message-id)/limit 100
 
 这也是本文要讨论的核心问题：**如何高效生成趋势有序的全局唯一ID。**
 
-**二、常见方法、不足与优化**
+## **二、常见方法、不足与优化**
 
-**方法一：使用数据库的 auto_increment 来生成全局唯一递增ID**
+**方法一：使用数据库的auto_increment来生成全局唯一递增ID**
 
 **优点：**
 
@@ -91,7 +96,7 @@ select message-id/ (order by message-id)/limit 100
 
 *   数据水平切分，保证各主库生成的ID不重复
 
-![](http://img.mp.itc.cn/upload/20170625/74f8cc978f9046e38e613d4d0d30698d.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/74f8cc978f9046e38e613d4d0d30698d.jpg)
 
 如上图所述，由1个写库变成3个写库，**每个写库设置不同的auto_increment初始值，以及相同的增长步长**，以保证每个数据库生成的ID是不同的（上图中库0生成0,3,6,9…，库1生成1,4,7,10，库2生成2,5,8,11…）
 
@@ -103,13 +108,13 @@ select message-id/ (order by message-id)/limit 100
 
 为了解决上述两个问题，引出了第二个常见的方案。
 
-**方法二：单点批量ID生成服务**
+## **方法二：单点批量ID生成服务**
 
 分布式系统之所以难，很重要的原因之一是“没有一个全局时钟，难以保证绝对的时序”，要想保证绝对的时序，还是只能使用单点服务，用本地时钟保证“绝对时序”。
 
 数据库写压力大，是因为每次生成ID都访问了数据库，可以使用批量的方式降低数据库写压力。
 
-![](http://img.mp.itc.cn/upload/20170625/93ae092c4e8c4d3aa92a59afa81abb53.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/93ae092c4e8c4d3aa92a59afa81abb53.jpg)
 
 如上图所述，数据库使用双master保证可用性，数据库中只存储当前ID的最大值，例如0。
 
@@ -135,7 +140,7 @@ ID生成服务假设每次批量拉取6个ID，服务访问数据库，将当前
 
 单点服务的常用高可用优化方案是“备用服务”，也叫“影子服务”，所以我们能用以下方法优化上述缺点（1）：
 
-![](http://img.mp.itc.cn/upload/20170625/449c222f7c344209af44df830479ddde.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/449c222f7c344209af44df830479ddde.jpg)
 
 如上图，对外提供的服务是主服务，有一个影子服务时刻处于备用状态，当主服务挂了的时候影子服务顶上。
 
@@ -143,7 +148,7 @@ ID生成服务假设每次批量拉取6个ID，服务访问数据库，将当前
 
 另外，ID-gen-service也可以实施水平扩展，以解决上述缺点（3），但会引发一致性问题，具体解决方案详见《》。
 
-**方法三：uuid/guid**
+## **方法三：uuid/guid**
 
 不管是通过数据库，还是通过服务来生成ID，业务方Application都需要进行一次远程调用，比较耗时。
 
@@ -165,7 +170,7 @@ string ID =GenUUID();
 
 *   uuid过长，往往用字符串表示，作为主键建立索引查询效率低，常见优化方案为“转化为两个uint64整数存储”或者“折半存储”（折半后不能保证唯一性）
 
-**方法四：取当前毫秒数**
+## **方法四：取当前毫秒数**
 
 uuid是一个本地算法，生成性能高，但无法保证趋势递增，且作为字符串ID检索效率低，有没有一种能保证递增的本地算法呢？
 
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25711\357\274\232\345\210\206\345\270\203\345\274\217session\350\247\243\345\206\263\346\226\271\346\241\210\344\270\216\344\270\200\350\207\264\346\200\247hash.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217session\350\247\243\345\206\263\346\226\271\346\241\210\344\270\216\344\270\200\350\207\264\346\200\247hash.md"
similarity index 87%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25711\357\274\232\345\210\206\345\270\203\345\274\217session\350\247\243\345\206\263\346\226\271\346\241\210\344\270\216\344\270\200\350\207\264\346\200\247hash.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217session\350\247\243\345\206\263\346\226\271\346\241\210\344\270\216\344\270\200\350\207\264\346\200\247hash.md"
index 503f9a4..50e6f52 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25711\357\274\232\345\210\206\345\270\203\345\274\217session\350\247\243\345\206\263\346\226\271\346\241\210\344\270\216\344\270\200\350\207\264\346\200\247hash.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217session\350\247\243\345\206\263\346\226\271\346\241\210\344\270\216\344\270\200\350\207\264\346\200\247hash.md"
@@ -1,14 +1,20 @@
-# Table of Contents
+# 目录
 
 * [一、问题的提出](#一、问题的提出)
-  * [1\. 什么是Session？](#1-什么是session？)
-  * [2\. 什么是Session一致性问题？](#2-什么是session一致性问题？)
+  * [1. 什么是Session？](#1-什么是session？)
+  * [2. 什么是Session一致性问题？](#2-什么是session一致性问题？)
 * [二、Session一致性解决方案](#二、session一致性解决方案)
-  * [1\. Session Stiky](#1-session-stiky)
-  * [2\. Session Replication](#2-session-replication)
-  * [3\. Session数据集中存储](#3-session数据集中存储)
-  * [4\. Cookie Based](#4-cookie-based)
+  * [1. Session Stiky](#1-session-stiky)
+  * [2. Session Replication](#2-session-replication)
+  * [3. Session数据集中存储](#3-session数据集中存储)
+  * [4. Cookie Based](#4-cookie-based)
 * [三、总结](#三、总结)
+  * [一致性Hash概述](#一致性hash概述)
+  * [一致性hash的特性](#一致性hash的特性)
+  * [虚拟节点](#虚拟节点)
+  * [均匀一致性hash](#均匀一致性hash)
+  * [总结](#总结)
+
 
 
 本文内容参考网络，侵删
@@ -27,15 +33,15 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 # 一、问题的提出
 
-## 1\. 什么是Session？
+## 1. 什么是Session？
 
-用户使用网站的服务，需要使用浏览器与Web服务器进行多次交互。HTTP协议本身是无状态的，需要基于HTTP协议支持会话状态（Session State）的机制。具体的实现方式是：在会话开始时，分配一个
+用户使用网站的服务，需要使用浏览器与Web服务器进行多次交互。HTTP协议本身是无状态的，需要基于HTTP协议支持会话状态（Session State）的机制。具体的实现方式是：在会话开始时，分配一个  
 唯一的会话标识（SessionID），并通过Cookie将这个标识告诉浏览器，以后每次请求的时候，浏览器都会带上这个会话标识SessionID来告诉Web服务器这个请求是属于哪个会话的。在Web服务器上，各个会话都有独立的存储，保存不同会话的信息。如果遇到禁用Cookie的情况，一般的做法就是把这个会话标识放到URL的参数中。
 
-## 2\. 什么是Session一致性问题？
+## 2. 什么是Session一致性问题？
 
 当Web服务器从一台变为多台时，就会出现Session一致性问题。
 
@@ -45,7 +51,7 @@
 
 # 二、Session一致性解决方案
 
-## 1\. Session Stiky
+## 1. Session Stiky
 
 在单机的情况下，会话保存在单机上，请求也是由这个机器处理，因此不会有问题。当Web服务器变为多台以后，如果保证同一个会话的请求都在同一个Web服务器上处理，则对该会话来说，与之前单机的情况是一样的。
 
@@ -63,7 +69,7 @@
 
 打个比方来说，对于Session Stiky，如果说Web服务器是我们每次吃饭的饭店，会话数据就是我们吃饭用的碗筷。要保证每次吃饭都用自己的碗筷，我就把餐具存在某一家，并且每次都去这家店吃，这是个不错的主意。
 
-## 2\. Session Replication
+## 2. Session Replication
 
 如果我们继续以去饭店吃饭类比，那么除了前面的方式之外，如果我在每个店都存放一套自己的餐具，就可以更加自由地选择饭店。Session Replication就是这样一种方式，如下图所示。
 
@@ -79,7 +85,7 @@
 
 这就是Session Replication方案。这个方案是靠应用容器来完成Session的复制从而使得应用解决Session问题的，应用本身并不关心这个事情。不过，这个方案并不适合集群机器数多的场景。如果只有几台机器，用该方案是可以的。
 
-## 3\. Session数据集中存储
+## 3. Session数据集中存储
 
 同样是希望同一个会话的请求可以发到不同的Web服务器上，前面的Session Replication是一种方案，还有一种方案就是把Session数据集中存储起来，然后不同Web服务器从同样的地方来获取Session。其大概的结构如下图所示：
 
@@ -94,7 +100,7 @@
 
 相对于Session Replication，当Web服务器数量比较大时、Session数比较多的时候，集中存储方案的优势是非常明显的。
 
-## 4\. Cookie Based
+## 4. Cookie Based
 
 对于Cookie Based方案，它对同一个会话的不同请求也是不限制具体处理机器的。与Session Replication和Session数据集中管理的方案不同，这个方案是通过Cookie来传递Session数据的。具体如下图所示。
 
@@ -114,25 +120,24 @@
 综合而言，上述所有方案都是解决session问题的方案，对于大型网站来说，Session Sticky和Session集中管理是比较好的方案。
 
 
-一、前言
+
 
 在解决分布式系统中负载均衡的问题时候可以使用Hash算法让固定的一部分请求落到同一台服务器上，这样每台服务器固定处理一部分请求（并维护这些请求的信息），起到负载均衡的作用。
 
 但是普通的余数hash（hash(比如用户id)%服务器机器数）算法伸缩性很差，当新增或者下线服务器机器时候，用户id与服务器的映射关系会大量失效。一致性hash则利用hash环对其进行了改进。
 
-二、一致性Hash概述
+## 一致性Hash概述
 
 为了能直观的理解一致性hash原理，这里结合一个简单的例子来讲解，假设有4台服务器，地址为ip1,ip2,ip3,ip4。
 
 一致性hash是首先计算四个ip地址对应的hash值hash(ip1),hash(ip2),hash(ip3),hash(ip3)，计算出来的hash值是0~最大正整数直接的一个值，这四个值在一致性hash环上呈现如下图：
 
-![](https://ss2.baidu.com/6ONYsjip0QIZ8tyhnq/it/u=2593891421,1964184427&fm=173&app=49&f=JPEG?w=640&h=496&s=0D867D32415B45CE0CF9ADDA000050B1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407214157.png)
 
 
 
-hash环上顺时针从整数0开始，一直到最大正整数，我们根据四个ip计算的hash值肯定会落到这个hash环上的某一个点，至此我们把服务器的四个ip映射到了一致性hash环当用户在客户端进行请求时候，首先根据hash(用户id)计算路由规则（hash值），然后看hash值落到了hash环的那个地方，根据hash值在hash环上的位置顺时针找距离最近的ip作为路由ip.
-
-![](https://ss2.baidu.com/6ONYsjip0QIZ8tyhnq/it/u=255229169,3112842859&fm=173&app=49&f=JPEG?w=640&h=484&s=1CC47D32599269C60C71ACCA000050B1)
+hash环上顺时针从整数0开始，一直到最大正整数，我们根据四个ip计算的hash值肯定会落到这个hash环上的某一个点，至此我们把服务器的四个ip映射到了一致性hash环当用户在客户端进行请求时候，首先根据hash(用户id)计算路由规则（hash值），然后看hash值落到了hash环的那个地方，根据hash值在hash环上的位置顺时针找距离最近的ip作为路由ip.  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407214219.png)
 
 
 
@@ -142,7 +147,7 @@ hash环上顺时针从整数0开始，一直到最大正整数，我们根据四
 
 当ip2的服务器挂了的时候，一致性hash环大致如下图：
 
-![](https://ss1.baidu.com/6ONXsjip0QIZ8tyhnq/it/u=677396536,3784543717&fm=173&app=49&f=JPEG?w=640&h=452&s=0C847D32019269C61C79BCDA000080B1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407214245.png)
 
 
 
@@ -152,27 +157,26 @@ hash环上顺时针从整数0开始，一直到最大正整数，我们根据四
 
 当新增一个ip5的服务器后，一致性hash环大致如下图：
 
-![](https://ss0.baidu.com/6ONWsjip0QIZ8tyhnq/it/u=1963410234,1960362096&fm=173&app=49&f=JPEG?w=640&h=507&s=61C47D32499269CE4EF96CCA000080B1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407214301.png)
 
 
 
 根据顺时针规则可知之前user1的请求应该被ip1服务器处理，现在被新增的ip5服务器处理，其他用户的请求处理服务器不变，也就是新增的服务器顺时针最近的服务器的一部分请求会被新增的服务器所替代。
 
-三、一致性hash的特性
+## 一致性hash的特性
 
 单调性(Monotonicity)，单调性是指如果已经有一些请求通过哈希分派到了相应的服务器进行处理，又有新的服务器加入到系统中时候，应保证原有的请求可以被映射到原有的或者新的服务器中去，而不会被映射到原来的其它服务器上去。 这个通过上面新增服务器ip5可以证明，新增ip5后，原来被ip1处理的user6现在还是被ip1处理，原来被ip1处理的user5现在被新增的ip5处理。分散性(Spread)：分布式环境中，客户端请求时候可能不知道所有服务器的存在，可能只知道其中一部分服务器，在客户端看来他看到的部分服务器会形成一个完整的hash环。如果多个客户端都把部分服务器作为一个完整hash环，那么可能会导致，同一个用户的请求被路由到不同的服务器进行处理。这种情况显然是应该避免的，因为它不能保证同一个用户的请求落到同一个服务器。所谓分散性是指上述情况发生的严重程度。平衡性(Balance)：平衡性也就是说负载均衡，是指客户端hash后的请求应该能够分散到不同的服务器上去。一致性hash可以做到每个服务器都进行处理请求，但是不能保证每个服务器处理的请求的数量大致相同，如下图
 
-![](https://ss1.baidu.com/6ONXsjip0QIZ8tyhnq/it/u=134719927,415275374&fm=173&app=49&f=JPEG?w=640&h=509&s=1DC47D32195A61CE5CD9DDDA0000A0B1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407214309.png)
 
 
 
 服务器ip1,ip2,ip3经过hash后落到了一致性hash环上，从图中hash值分布可知ip1会负责处理大概80%的请求，而ip2和ip3则只会负责处理大概20%的请求，虽然三个机器都在处理请求，但是明显每个机器的负载不均衡，这样称为一致性hash的倾斜，虚拟节点的出现就是为了解决这个问题。
 
-五、虚拟节点
-
-当服务器节点比较少的时候会出现上节所说的一致性hash倾斜的问题，一个解决方法是多加机器，但是加机器是有成本的，那么就加虚拟节点，比如上面三个机器，每个机器引入1个虚拟节点后的一致性hash环的图如下：
+## 虚拟节点
 
-![](https://ss2.baidu.com/6ONYsjip0QIZ8tyhnq/it/u=2945843696,3879552818&fm=173&app=49&f=JPEG?w=640&h=499&s=44867D32595AEDCE4E714CCA0000C0B1)
+当服务器节点比较少的时候会出现上节所说的一致性hash倾斜的问题，一个解决方法是多加机器，但是加机器是有成本的，那么就加虚拟节点，比如上面三个机器，每个机器引入1个虚拟节点后的一致性hash环的图如下：  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407214322.png)
 
 
 
@@ -180,24 +184,20 @@ hash环上顺时针从整数0开始，一直到最大正整数，我们根据四
 
 可知当物理机器数目为M，虚拟节点为N的时候，实际hash环上节点个数为M*（N+1）。比如当客户端计算的hash值处于ip2和ip3或者处于ip2-1和ip3-1之间时候使用ip3服务器进行处理。
 
-六、均匀一致性hash
-
-上节我们使用虚拟节点后的图看起来比较均衡，但是如果生成虚拟节点的算法不够好很可能会得到下面的环：
-
-![](https://ss0.baidu.com/6ONWsjip0QIZ8tyhnq/it/u=725945433,2343916262&fm=173&app=49&f=JPEG?w=640&h=478&s=19C47D32091A60CE4EF54CCA000070B1)
+## 均匀一致性hash
 
+上节我们使用虚拟节点后的图看起来比较均衡，但是如果生成虚拟节点的算法不够好很可能会得到下面的环：  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407214331.png)
 
 
 可知每个服务节点引入1个虚拟节点后，情况相比没有引入前均衡性有所改善，但是并不均衡。
 
-均衡的一致性hash应该是如下图：
-
-![](https://ss0.baidu.com/6ONWsjip0QIZ8tyhnq/it/u=1456000641,676791436&fm=173&app=49&f=JPEG?w=640&h=533&s=44C47D32195AE4CE0C714DCA0000C0B1)
-
+均衡的一致性hash应该是如下图：  
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407214345.png)
 
 
 均匀一致性hash的目标是如果服务器有N台，客户端的hash值有M个，那么每个服务器应该处理大概M/N个用户的。也就是每台服务器负载尽量均衡。dubbo提供的一致性hash负载均衡算法就是不均匀的，我们自己实现了dubbo的spi扩展实现了均匀一致性hash.
 
-七、总结
+## 总结
 
 在分布式系统中一致性hash起着不可忽略的地位，无论是分布式缓存，还是分布式Rpc框架的负载均衡策略都有所使用。
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2572\357\274\232\345\210\206\345\270\203\345\274\217\344\270\200\350\207\264\346\200\247\345\215\217\350\256\256\344\270\216Paxos\357\274\214Raft\347\256\227\346\263\225.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217\344\270\200\350\207\264\346\200\247\345\215\217\350\256\256\344\270\216Paxos\357\274\214Raft\347\256\227\346\263\225.md"
similarity index 87%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2572\357\274\232\345\210\206\345\270\203\345\274\217\344\270\200\350\207\264\346\200\247\345\215\217\350\256\256\344\270\216Paxos\357\274\214Raft\347\256\227\346\263\225.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217\344\270\200\350\207\264\346\200\247\345\215\217\350\256\256\344\270\216Paxos\357\274\214Raft\347\256\227\346\263\225.md"
index dd353fb..c4a809d 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2572\357\274\232\345\210\206\345\270\203\345\274\217\344\270\200\350\207\264\346\200\247\345\215\217\350\256\256\344\270\216Paxos\357\274\214Raft\347\256\227\346\263\225.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217\344\270\200\350\207\264\346\200\247\345\215\217\350\256\256\344\270\216Paxos\357\274\214Raft\347\256\227\346\263\225.md"
@@ -1,27 +1,31 @@
-# Table of Contents
 
-  * [2PC](#2pc)
+
+# 目录
+
+* [2PC](#2pc)
     * [1. 分布式事务](#1-分布式事务)
     * [2. XA规范](#2-xa规范)
     * [3. 二阶段提交（2PC）](#3-二阶段提交（2pc）)
     * [小结](#小结)
-  * [3PC](#3pc)
+* [3PC](#3pc)
     * [1. 三阶段提交的定义](#1-三阶段提交的定义)
     * [2. 三阶段提交的过程](#2-三阶段提交的过程)
     * [3. 小结](#3-小结)
-  * [四、Paxos](#四、paxos)
-  * [BasicPaxos与FastPaxos](#basicpaxos与fastpaxos)
-  * [五、Raft](#五、raft)
+* [四、Paxos](#四、paxos)
+* [BasicPaxos与FastPaxos](#basicpaxos与fastpaxos)
+* [五、Raft](#五、raft)
 
 
 本文内容参考网络，侵删
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本文也将同步到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -33,7 +37,9 @@
 <!-- more -->
 
 本文较为粗略地讲述了一致性协议与两种一致性算法，更加系统的理论可以参考后面的分布式系统理论专题文章。
+
 ## 2PC
+
 由于BASE理论需要在一致性和可用性方面做出权衡，因此涌现了很多关于一致性的算法和协议。其中比较著名的有二阶提交协议（2 Phase Commitment Protocol），三阶提交协议（3 Phase Commitment Protocol）和Paxos算法。
 本文要介绍的2PC协议，分为两个阶段提交一个事务。并通过协调者和各个参与者的配合，实现分布式一致性。
 
@@ -43,14 +49,18 @@
 角色	XA概念	作用
 协调者	事务管理器	协调各个参与者，对分布式事务进行提交或回滚
 参与者	资源管理器	分布式集群中的节点
+
 ### 1. 分布式事务
+
 分布式事务是指会涉及到操作多个数据库的事务，其实就是将对同一库事务的概念扩大到了对多个库的事务。目的是为了保证分布式系统中的数据一致性。
 
 分布式事务处理的关键是：
 
 需要记录事务在任何节点所做的所有动作；
 事务进行的所有操作要么全部提交，要么全部回滚。
+
 ### 2. XA规范
+
 2.1. XA规范的组成
 XA规范是由 X/Open组织（即现在的 Open Group ）定义的分布式事务处理模型。 X/Open DTP 模型（ 1994 ）包括：
 
@@ -78,6 +88,7 @@ XA规范的流程，大致如图所示：
 
 
 ### 3. 二阶段提交（2PC）
+
 3.1. 二阶段提交的定义
 二阶段提交的算法思路可以概括为：每个参与者将操作成败通知协调者，再由协调者根据所有参与者的反馈情报，决定各参与者是否要提交操作还是中止操作。
 
@@ -158,12 +169,14 @@ d. 事务中断确认
 如果在二阶段提交的提交询问阶段中，参与者出现故障，导致协调者始终无法获取到所有参与者的确认信息，这时协调者只能依靠其自身的超时机制，判断是否需要中断事务。显然，这种策略过于保守。换句话说，二阶段提交协议没有设计较为完善的容错机制，任意一个节点是失败都会导致整个事务的失败。
 
 ### 小结
+
 对于2PC协议存在的同步阻塞、单点问题，将在下一篇文章的3PC协议中引入解决方案。
 
 
 
 
 ## 3PC
+
 由于二阶段提交存在着诸如同步阻塞、单点问题、脑裂等缺陷。所以，研究者们在二阶段提交的基础上做了改进，提出了三阶段提交。
 
 
@@ -173,6 +186,7 @@ d. 事务中断确认
 在第一阶段和第二阶段中插入一个准备阶段，保证了在最后提交阶段之前各参与节点的状态是一致的。
 
 ### 1. 三阶段提交的定义
+
 三阶段提交（Three-phase commit），也叫三阶段提交协议（Three-phase commit protocol），是二阶段提交（2PC）的改进版本。
 
 所谓的三个阶段分别是：询问，然后再锁资源，最后真正提交。
@@ -180,7 +194,9 @@ d. 事务中断确认
 第一阶段：CanCommit
 第二阶段：PreCommit
 第三阶段：Do Commit
+
 ### 2. 三阶段提交的过程
+
 2.1. 阶段一：CanCommit
 3PC的CanCommit阶段其实和2PC的准备阶段很像。协调者向参与者发送commit请求，参与者如果可以提交就返回Yes响应，否则返回No响应。
 
@@ -257,6 +273,7 @@ d. 中断事务
 协调者接收到参与者反馈的 ACK 消息之后，完成事务的中断。
 
 ### 3. 小结
+
 3.1. 三阶段提交的优点
 相对于二阶段提交，三阶段提交主要解决的单点故障问题，并减少了阻塞的时间。
 
@@ -269,6 +286,7 @@ d. 中断事务
 
 
 ## 四、Paxos
+
 用于达成共识性问题，即对多个节点产生的值，该算法能保证只选出唯一一个值。
 
 主要有三类节点：
@@ -310,13 +328,14 @@ Acceptor 接收到接受请求时，如果序号大于等于该 Acceptor 承诺
 
 
 约束条件
+
 1. 正确性
-指只有一个提议值会生效。
+   指只有一个提议值会生效。
 
 因为 Paxos 协议要求每个生效的提议被多数 Acceptor 接收，并且 Acceptor 不会接受两个不同的提议，因此可以保证正确性。
 
 2. 可终止性
-指最后总会有一个提议生效。
+   指最后总会有一个提议生效。
 
 Paxos 协议能够让 Proposer 发送的提议朝着能被大多数 Acceptor 接受的那个提议靠拢，因此能够保证可终止性。
 
@@ -324,15 +343,15 @@ Paxos 协议能够让 Proposer 发送的提议朝着能被大多数 Acceptor 接
 
 ## BasicPaxos与FastPaxos
 
-1 Paxos算法
-1.1 基本定义
+1Paxos算法
+1.1基本定义
 算法中的参与者主要分为三个角色，同时每个参与者又可兼领多个角色:
 
-⑴proposer 提出提案，提案信息包括提案编号和提议的value;
+⑴proposer提出提案，提案信息包括提案编号和提议的value;
 
-⑵acceptor 收到提案后可以接受(accept)提案;
+⑵acceptor收到提案后可以接受(accept)提案;
 
-⑶learner 只能"学习"被批准的提案;
+⑶learner只能"学习"被批准的提案;
 
 算法保重一致性的基本语义:
 
@@ -346,68 +365,68 @@ Paxos 协议能够让 Proposer 发送的提议朝着能被大多数 Acceptor 接
 
 ⑴P1:一个acceptor必须接受(accept)第一次收到的提案;
 
-⑵P2a:一旦一个具有value v的提案被批准(chosen)，那么之后任何acceptor 再次接受(accept)的提案必须具有value v;
+⑵P2a:一旦一个具有valuev的提案被批准(chosen)，那么之后任何acceptor再次接受(accept)的提案必须具有valuev;
 
-⑶P2b:一旦一个具有value v的提案被批准(chosen)，那么以后任何 proposer 提出的提案必须具有value v;
+⑶P2b:一旦一个具有valuev的提案被批准(chosen)，那么以后任何proposer提出的提案必须具有valuev;
 
-⑷P2c:如果一个编号为n的提案具有value v，那么存在一个多数派，要么他们中所有人都没有接受(accept)编号小于n的任何提案，要么他们已经接受(accpet)的所有编号小于n的提案中编号最大的那个提案具有value v;
+⑷P2c:如果一个编号为n的提案具有valuev，那么存在一个多数派，要么他们中所有人都没有接受(accept)编号小于n的任何提案，要么他们已经接受(accpet)的所有编号小于n的提案中编号最大的那个提案具有valuev;
 
-1.2 基本算法(basic paxos)
+1.2基本算法(basicpaxos)
 算法(决议的提出与批准)主要分为两个阶段:
 
-1. prepare阶段： 
+1.prepare阶段：
 
-(1). 当Porposer希望提出方案V1，首先发出prepare请求至大多数Acceptor。Prepare请求内容为序列号<SN1>;
+(1).当Porposer希望提出方案V1，首先发出prepare请求至大多数Acceptor。Prepare请求内容为序列号<SN1>;
 
-(2). 当Acceptor接收到prepare请求<SN1>时，检查自身上次回复过的prepare请求<SN2>
+(2).当Acceptor接收到prepare请求<SN1>时，检查自身上次回复过的prepare请求<SN2>
 
-a). 如果SN2>SN1，则忽略此请求，直接结束本次批准过程;
+a).如果SN2>SN1，则忽略此请求，直接结束本次批准过程;
 
-b). 否则检查上次批准的accept请求<SNx，Vx>，并且回复<SNx，Vx>；如果之前没有进行过批准，则简单回复<OK>;
+b).否则检查上次批准的accept请求<SNx，Vx>，并且回复<SNx，Vx>；如果之前没有进行过批准，则简单回复<OK>;
 
-2. accept批准阶段： 
+2.accept批准阶段：
 
-(1a). 经过一段时间，收到一些Acceptor回复，回复可分为以下几种:
+(1a).经过一段时间，收到一些Acceptor回复，回复可分为以下几种:
 
-a). 回复数量满足多数派，并且所有的回复都是<OK>，则Porposer发出accept请求，请求内容为议案<SN1，V1>;
+a).回复数量满足多数派，并且所有的回复都是<OK>，则Porposer发出accept请求，请求内容为议案<SN1，V1>;
 
-b). 回复数量满足多数派，但有的回复为：<SN2，V2>，<SN3，V3>……则Porposer找到所有回复中超过半数的那个，假设为<SNx，Vx>，则发出accept请求，请求内容为议案<SN1，Vx>;
+b).回复数量满足多数派，但有的回复为：<SN2，V2>，<SN3，V3>……则Porposer找到所有回复中超过半数的那个，假设为<SNx，Vx>，则发出accept请求，请求内容为议案<SN1，Vx>;
 
-c). 回复数量不满足多数派，Proposer尝试增加序列号为SN1+，转1继续执行;
+c).回复数量不满足多数派，Proposer尝试增加序列号为SN1+，转1继续执行;
 
-         (1b). 经过一段时间，收到一些Acceptor回复，回复可分为以下几种:
+(1b).经过一段时间，收到一些Acceptor回复，回复可分为以下几种:
 
-a). 回复数量满足多数派，则确认V1被接受;
+a).回复数量满足多数派，则确认V1被接受;
 
-b). 回复数量不满足多数派，V1未被接受，Proposer增加序列号为SN1+，转1继续执行;
+b).回复数量不满足多数派，V1未被接受，Proposer增加序列号为SN1+，转1继续执行;
 
-(2). 在不违背自己向其他proposer的承诺的前提下，acceptor收到accept 请求后即接受并回复这个请求。
+(2).在不违背自己向其他proposer的承诺的前提下，acceptor收到accept请求后即接受并回复这个请求。
 
-1.3 算法优化(fast paxos)
+1.3算法优化(fastpaxos)
 Paxos算法在出现竞争的情况下，其收敛速度很慢，甚至可能出现活锁的情况，例如当有三个及三个以上的proposer在发送prepare请求后，很难有一个proposer收到半数以上的回复而不断地执行第一阶段的协议。因此，为了避免竞争，加快收敛的速度，在算法中引入了一个Leader这个角色，在正常情况下同时应该最多只能有一个参与者扮演Leader角色，而其它的参与者则扮演Acceptor的角色，同时所有的人又都扮演Learner的角色。
 
 在这种优化算法中，只有Leader可以提出议案，从而避免了竞争使得算法能够快速地收敛而趋于一致，此时的paxos算法在本质上就退变为两阶段提交协议。但在异常情况下，系统可能会出现多Leader的情况，但这并不会破坏算法对一致性的保证，此时多个Leader都可以提出自己的提案，优化的算法就退化成了原始的paxos算法。
 
 一个Leader的工作流程主要有分为三个阶段：
 
-(1).学习阶段 向其它的参与者学习自己不知道的数据(决议);
+(1).学习阶段向其它的参与者学习自己不知道的数据(决议);
 
-(2).同步阶段 让绝大多数参与者保持数据(决议)的一致性;
+(2).同步阶段让绝大多数参与者保持数据(决议)的一致性;
 
-(3).服务阶段 为客户端服务，提议案;
+(3).服务阶段为客户端服务，提议案;
 
-![image](https://img-blog.csdn.net/20130902213600156?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveGhoMTk4Nzgx/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407205423.png)
 
-1.3.1 学习阶段
+1.3.1学习阶段
 当一个参与者成为了Leader之后，它应该需要知道绝大多数的paxos实例，因此就会马上启动一个主动学习的过程。假设当前的新Leader早就知道了1-134、138和139的paxos实例，那么它会执行135-137和大于139的paxos实例的第一阶段。如果只检测到135和140的paxos实例有确定的值，那它最后就会知道1-135以及138-140的paxos实例。
 
-1.3.2 同步阶段
+1.3.2同步阶段
 此时的Leader已经知道了1-135、138-140的paxos实例，那么它就会重新执行1-135的paxos实例，以保证绝大多数参与者在1-135的paxos实例上是保持一致的。至于139-140的paxos实例，它并不马上执行138-140的paxos实例，而是等到在服务阶段填充了136、137的paxos实例之后再执行。这里之所以要填充间隔，是为了避免以后的Leader总是要学习这些间隔中的paxos实例，而这些paxos实例又没有对应的确定值。
 
-1.3.4 服务阶段
+1.3.4服务阶段
 Leader将用户的请求转化为对应的paxos实例，当然，它可以并发的执行多个paxos实例，当这个Leader出现异常之后，就很有可能造成paxos实例出现间断。
 
-1.3.5 问题
+1.3.5问题
 (1).Leader的选举原则
 
 (2).Acceptor如何感知当前Leader的失败，客户如何知道当前的Leader
@@ -418,6 +437,7 @@ Leader将用户的请求转化为对应的paxos实例，当然，它可以并发
 
 
 ## 五、Raft
+
 Raft 和 Paxos 类似，但是更容易理解，也更容易实现。
 
 Raft 主要是用来竞选主节点。
diff --git "a/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241\345\270\270\347\224\250\350\247\243\345\206\263\346\226\271\346\241\210.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241\345\270\270\347\224\250\350\247\243\345\206\263\346\226\271\346\241\210.md"
new file mode 100644
index 0000000..77adff5
--- /dev/null
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241\345\270\270\347\224\250\350\247\243\345\206\263\346\226\271\346\241\210.md"
@@ -0,0 +1,171 @@
+# 目录
+
+* [一、概述](#一、概述)
+* [二、理论](#二、理论)
+  * [2.1、二阶段提交](#21、二阶段提交)
+  * [2.2、三阶段提交](#22、三阶段提交)
+  * [2.3、TCC柔性事务](#23、tcc柔性事务)
+  * [2.4、Seata](#24、seata)
+* [三、应用场景](#三、应用场景)
+* [四、总结](#四、总结)
+* [五、参考源码](#五、参考源码)
+
+
+
+> 数据不会无缘无故丢失，也不会莫名其妙增加
+
+# 一、概述
+
+1、曾几何时，知了在一家小公司做项目的时候，都是一个服务打天下，所以涉及到数据一致性的问题，都是直接用本地事务处理。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407215926.png)
+
+2、随着时间的推移，用户量增大了，发现一个Java服务扛不住了，于是技术大佬决定对于系统进行升级。根据系统的业务对于单体的一个服务进行拆分，然后对于开发人员也进行划分，一个开发人员只开发和维护一个或几个服务中的问题，大家各司其职，分工合作。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407215943.png)
+
+3、当然服务拆分不是一蹴而就的，这是一个耗时耗力的庞大工程，大多数系统都是进行多轮拆分，而后慢慢形成一个稳定的系统。
+
+遵守一个核心思想：**先按总体业务进行一轮拆分，后面再根据拆分后的服务模块，进行一个细致的拆分。**
+
+4、随着服务拆分之后，用户量是抗住了，但是发现数据都在不同的服务中存取，这就引出了一个新的问题：**跨服务器，如何保证数据的一致性？**当然，跨服务的分布式系统中不仅仅这个问题，还有其他的一些列问题，如：服务可用性、服务容错性、服务间调用的网络问题等等，这里只讨论数据一致性问题。
+
+5、说到数据一致性，大致分为三种：强一致性、弱一致性、最终一致性。
+
+* <section>**强一致性**：数据一旦写入，在任一时刻都能读取到最新的值。</section>
+
+* <section>**弱一致性**：当写入一个数据的时候，其他地方去读这些数据，可能查到的数据不是最新的</section>
+
+* <section>**最终一致性**：它是弱一致性的一个变种，不追求系统任意时刻数据要达到一致，但是在一定时间后，数据最终要达到一致。</section>
+
+从这三种一致型的模型上来说，我们可以看到，弱一致性和最终一致性一般来说是异步冗余的，而强一致性是同步冗余的，异步处理带来了更好的性能，但也需要处理数据的补偿。同步意味着简单，但也必然会降低系统的性能。
+
+# 二、理论
+
+上述说的数据一致性问题，其实也就是在说分布式事务的问题，现在有一些解决方案，相信大家多多少少都看到过，这里带大家回顾下。
+
+## 2.1、二阶段提交
+
+2PC是一种强一致性设计方案，通过引入一个**事务协调器**来协调各个本地事务（也称为事务参与者）的提交和回滚。2PC主要分为2个阶段：
+
+**1、第一阶段**：事务协调器会向每个事务参与者发起一个开启事务的命令，每个事务参与者执行准备操作，然后再向事务协调器回复是否准备完成。但是**不会提交本地事务，**但是这个阶段资源是需要被锁住的。
+
+**2、第二阶段：**事务协调器收到每个事务参与者的回复后，统计每个参与者的回复，如果每个参与者都回复“可以提交”，那么事务协调器会发送提交命令，参与者正式提交本地事务，释放所有资源，结束全局事务。但是有一个参与者回复“拒绝提交”，那么事务协调器发送回滚命令，所有参与者都回滚本地事务，待全部回滚完成，释放资源，取消全局事务。事务提交流程
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407215950.png)
+
+事务回滚流程
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407220002.png)
+
+
+
+当然2PC存在的问题这里也提一下，一个是**同步阻塞**，这个会消耗性能。另一个是**协调器故障**问题，一旦协调器发生故障，那么所有的参与者处理资源锁定状态，那么所有参与者都会被阻塞。
+
+## 2.2、三阶段提交
+
+3PC主要是在2PC的基础上做了改进，主要为了解决2PC的阻塞问题。它主要是将2PC的第一阶段分为2个步骤，先准备，再锁定资源，并且引入了超时机制（这也意味着会造成数据不一致）。
+
+3PC的三个阶段包括：`CanCommit`、`PreCommit `和 `DoCommit` 具体细节就不展开赘述了，就一个核心观点：**在CanCommit的时候并不锁定资源，除非所有参与者都同意了，才开始锁资源**。
+
+## 2.3、TCC柔性事务
+
+相比较前面的2PC和3PC，TCC和那哥俩的本质区别就是它是业务层面的分布式事务，而2PC和3PC是数据库层面的。
+
+TCC是三个单词的缩写：`Try`、`Confirm`、`Cancel`，也分为这三个流程。
+
+Try：尝试，即尝试预留资源，锁定资源
+
+Confirm：确认，即执行预留的资源，如果执行失败会重试
+
+Cancel：取消，撤销预留的资源，如果执行失败会重试
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407220009.png)
+
+从上图可知，TCC对于业务的侵入是很大的，而且紧紧的耦合在一起。TCC相比较2PC和3PC，试用范围更广，可实现跨库，跨不同系统去实现分布式事务。缺点是要在业务代码中去开发大量的逻辑实现这三个步骤，需要和代码耦合在一起，提高开发成本。
+
+**事务日志**：在TCC模式中，事务发起者和事务参与者都会去记录事务日志（事务状态、信息等）。这个事务日志是整个分布式事务出现意外情况（宕机、重启、网络中断等），实现提交和回滚的关键。
+
+**幂等性**：在TCC第二阶段，confirm或者cancel的时候，这两个操作都需要保证幂等性。一旦由于网络等原因导致执行失败，就会发起不断重试。
+
+**防悬挂**：由于网络的不可靠性，有异常情况的时候，try请求可能比cancel请求更晚到达。cancel可能会执行空回滚，但是try请求被执行的时候也不会预留资源。
+
+## 2.4、Seata
+
+关于seata这里就不多提了，用的最多的是AT模式，上回知了逐步分析过，配置完后只需要在事务发起的方法上添加`@GlobalTransactional`注解就可以开启全局事务，对于业务无侵入，低耦合。感兴趣的话请参考之前讨论Seata的内容。
+
+# 三、应用场景
+
+知了之前在一家公司遇到过这样的业务场景；用户通过页面投保，提交一笔订单过来，这个订单通过上游服务，处理保单相关的业务逻辑，最后流入下游服务，处理业绩、人员晋升、分润处理等等业务。对于这个场景，两边处理的业务逻辑不在同一个服务中，接入的是不同的数据库。涉及到数据一致性问题，需要用到分布式事务。
+
+对于上面介绍的几种方案，只是讨论了理论和思路，下面我来总结下这个业务场景中运用的一种实现方案。采用了本地消息表+MQ异步消息的方案实现了事务最终一致性，也符合当时的业务场景，相对强一致性，实现的性能较高。下面是该方案的思路图
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407220016.png)
+
+1. <section>真实业务处理的状态可能会有多种，因此需要明确哪种状态需要定时任务补偿</section>
+
+2. <section>假如某条单据一直无法处理结束，定时任务也不能无限制下发，所以本地消息表需要增加轮次的概念，重试多少次后告警，人工介入处理</section>
+
+3. <section>因为MQ和定时任务的存在，难免会出现重复请求，因此下游要做好幂等防重，否则会出现重复数据，导致数据不一致</section>
+
+对于落地实现，话不多说，直接上代码。先定义两张表tb_order和tb_notice_message，分别存订单信息和本地事务信息
+
+```
+CREATE TABLE `tb_order` (  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键id',  `user_id` int(11) NOT NULL COMMENT '下单人id',  `order_no` varchar(255) CHARACTER SET latin1 NOT NULL COMMENT '订单编号',  `insurance_amount` decimal(16,2) NOT NULL COMMENT '保额',  `order_amount` decimal(16,2) DEFAULT NULL COMMENT '保费',  `create_time` datetime DEFAULT NULL COMMENT '创建时间',  `update_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',  `is_delete` tinyint(4) DEFAULT '0' COMMENT '删除标识：0-不删除；1-删除',  PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4;
+```
+
+```
+CREATE TABLE `tb_notice_message` (  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键id',  `type` tinyint(4) NOT NULL COMMENT '业务类型：1-下单',  `status` tinyint(4) NOT NULL DEFAULT '1' COMMENT '状态：1-待处理，2-已处理，3-预警',  `data` varchar(255) NOT NULL COMMENT '信息',  `retry_count` tinyint(4) DEFAULT '0' COMMENT '重试次数',  `create_time` datetime NOT NULL COMMENT '创建时间',  `update_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',  `is_delete` tinyint(4) NOT NULL DEFAULT '0' COMMENT '删除标识：0-不删除；1-删除',  PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4;
+```
+
+处理订单service，这里可以用到我们之前说过的**装饰器模式**，去装饰这个service。把保存本地事务，发送mq消息，交给装饰器类去做，而service只需要关心业务逻辑即可，也符合**开闭原则**。
+
+```
+/** * @author 往事如风 * @version 1.0 * @date 2022/12/13 10:58 * @description */@Service@Slf4j@AllArgsConstructorpublic class OrderService implements BaseHandler<Object, Order> {    private final OrderMapper orderMapper;    /**     * 订单处理方法：只处理订单关联逻辑     * @param o     * @return     */    @Override    public Order handle(Object o) {        // 订单信息        Order order = Order.builder()                .orderNo("2345678")                .createTime(LocalDateTime.now())                .userId(1)                .insuranceAmount(new BigDecimal(2000000))                .orderAmount(new BigDecimal(5000))                .build();        orderMapper.insert(order);        return order;    }}
+```
+
+新增`OrderService`的装饰类`OrderServiceDecorate`，负责对订单逻辑的扩展，这里是添加本地事务消息，以及发送MQ信息，扩展方法添加了`Transactional`注解，确保订单逻辑和本地事务消息的数据在同一个事务中进行，确保原子性。其中事务消息标记处理中，待下游服务处理完业务逻辑，再更新处理完成。
+
+```
+/** * @author 往事如风 * @version 1.0 * @date 2022/12/14 18:48 * @description */@Slf4j@AllArgsConstructor@Decorate(scene = SceneConstants.ORDER, type = DecorateConstants.CREATE_ORDER)public class OrderServiceDecorate extends AbstractHandler {    private final NoticeMessageMapper noticeMessageMapper;    private final RabbitTemplate rabbitTemplate;    /**     * 装饰方法：对订单处理逻辑进行扩展     * @param o     * @return     */    @Override    @Transactional    public Object handle(Object o) {        // 调用service方法，实现保单逻辑        Order order = (Order) service.handle(o);        // 扩展：1、保存事务消息，2、发送MQ消息        // 本地事务消息        String data = "{\"orderNo\":\"2345678\", \"userId\":1, \"insuranceAmount\":2000000, \"orderAmount\":5000}";        NoticeMessage noticeMessage = NoticeMessage.builder()                .retryCount(0)                .data(data)                .status(1)                .type(1)                .createTime(LocalDateTime.now())                .build();        noticeMessageMapper.insert(noticeMessage);        // 发送mq消息        log.info("发送mq消息....");        rabbitTemplate.convertAndSend("trans", "trans.queue.key", JSONUtil.toJsonStr(noticeMessage));        return null;    }}
+```
+
+关于这个装饰者模式，之前有讲到过，可以看下之前发布的内容。
+
+下游服务监听消息，处理完自己的业务逻辑后（如：业绩、分润、晋升等），需要发送MQ，上游服务监听消息，更新本地事务状态为已处理。这需要注意的是下游服务需要做幂等处理，防止异常情况下，上游服务数据的重试。
+
+```
+/** * @author 往事如风 * @version 1.0 * @date 2022/12/13 18:07 * @description */@Component@Slf4j@RabbitListener(queues = "trans.queue")public class FenRunListener {    @Autowired    private RabbitTemplate rabbitTemplate;    @RabbitHandler    public void orderHandler(String msg) {        log.info("监听到订单消息:{}", msg);        // 需要注意幂等，幂等逻辑        log.info("下游服务业务逻辑。。。。。");        JSONObject json = JSONUtil.parseObj(msg);        rabbitTemplate.convertAndSend("trans", "trans.update.order.queue.key", json.getInt("id"));    }}
+```
+
+这里插个题外话，关于幂等的处理，我这里大致有两种思路 1、比如根据订单号查一下记录是否存在，存在就直接返回成功。2、redis存一个唯一的请求号，处理完再删除，不存在请求号的直接返回成功，可以写个AOP去处理，与业务隔离。言归正传，上游服务消息监听，下游发送MQ消息，更新本地事务消息为已处理，分布式事务流程结束。
+
+```
+/** * @author 往事如风 * @version 1.0 * @date 2022/12/13 18:29 * @description */@Component@Slf4j@RabbitListener(queues = "trans.update.order.queue")public class OrderListener {    @Autowired    private NoticeMessageMapper noticeMessageMapper;    @RabbitHandler    public void updateOrder(Integer msgId) {        log.info("监听消息，更新本地事务消息，消息id:{}", msgId);        NoticeMessage msg = NoticeMessage.builder().status(2).id(msgId).updateTime(LocalDateTime.now()).build();        noticeMessageMapper.updateById(msg);    }}
+```
+
+存在异常情况时，会通过定时任务，轮询的往MQ中发送消息，尽最大努力去让下游服务达到数据一致，当然重试也要设置上限；若达到上限以后还一直是失败，那不得不考虑是下游服务自身存在问题了（有可能就是代码逻辑存在问题）。
+
+```
+/** * @author 往事如风 * @version 1.0 * @date 2022/12/14 10:25 * @description */@Configuration@EnableScheduling@AllArgsConstructor@Slf4jpublic class RetryOrderJob {    private final RabbitTemplate rabbitTemplate;    private final NoticeMessageMapper noticeMessageMapper;    /**     * 最大自动重试次数     */    private final Integer MAX_RETRY_COUNT = 5;    @Scheduled(cron = "0/20 * * * * ? ")    public void retry() {        log.info("定时任务，重试异常订单");        LambdaQueryWrapper<NoticeMessage> wrapper = Wrappers.lambdaQuery(NoticeMessage.class);        wrapper.eq(NoticeMessage::getStatus, 1);        List<NoticeMessage> noticeMessages = noticeMessageMapper.selectList(wrapper);        for (NoticeMessage noticeMessage : noticeMessages) {            // 重新发送mq消息            rabbitTemplate.convertAndSend("trans", "trans.queue.key", JSONUtil.toJsonStr(noticeMessage));            // 重试次数+1            noticeMessage.setRetryCount(noticeMessage.getRetryCount() + 1);            noticeMessageMapper.updateById(noticeMessage);            // 判断重试次数，等于最长限制次数，直接更新为报警状态            if (MAX_RETRY_COUNT.equals(noticeMessage.getRetryCount())) {                noticeMessage.setStatus(3);                noticeMessageMapper.updateById(noticeMessage);                // 发送告警，通知对应人员                // 告警逻辑（短信、邮件、企微群，等等）....            }        }    }}
+```
+
+其实这里有个问题，一个上游服务对应多个下游服务的时候。这个时候往往不能存一条本地消息记录。
+
+1. <section>这里可以在消息表多加个字段next_server_count，表示一个订单发起方，需要调用的下游服务数量。上游服务监听的时候，每次会与下游的回调都减去1，直到数值是0的时候，再更新状态是已处理。但是要控制并发，这个字段是被多个下游服务共享的。</section>
+
+2. <section>还有一种处理方案是为每个下游服务，都记录一条事务消息，用type字段去区分，标记类型。实现上游和下游对于事务消息的一对一关系。</section>
+
+3. <section>最后，达到最大重试次数以后，可以将消息加入到一个告警列表，这个告警列表可以展示在管理后台或其他监控系统中，展示一些必要的信息，去供公司内部人员去人工介入，处理这种异常的数据，使得数据达到最终一致性。</section>
+
+# 四、总结
+
+其实分布式事务没有一个完美的处理方案，只能说是尽量去满足业务需求，满足数据一致。如果程序不能处理了，最后由人工去兜底，做数据的补偿方案。
+
+# 五、参考源码
+
+```
+编程文档：https://gitee.com/cicadasmile/butte-java-note应用仓库：https://gitee.com/cicadasmile/butte-flyer-parent
+```
+
+本文转载自 https://mp.weixin.qq.com/s/xa9Giv9xdSM3AahwN3WckQ
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2571\357\274\232\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\232\204\344\270\200\344\272\233\345\237\272\346\234\254\346\246\202\345\277\265.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\232\204\344\270\200\344\272\233\345\237\272\346\234\254\346\246\202\345\277\265.md"
similarity index 96%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2571\357\274\232\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\232\204\344\270\200\344\272\233\345\237\272\346\234\254\346\246\202\345\277\265.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\232\204\344\270\200\344\272\233\345\237\272\346\234\254\346\246\202\345\277\265.md"
index 1564a3c..e3e51ac 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2571\357\274\232\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\232\204\344\270\200\344\272\233\345\237\272\346\234\254\346\246\202\345\277\265.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\206\345\270\203\345\274\217\347\263\273\347\273\237\347\232\204\344\270\200\344\272\233\345\237\272\346\234\254\346\246\202\345\277\265.md"
@@ -1,5 +1,5 @@
-# Table of Contents
 
+# 目录
   * [1、分布式](#1、分布式)
   * [2、集群（Cluster）](#2、集群（cluster）)
   * [3、负载均衡（Load Balancer）](#3、负载均衡（load-balancer）)
@@ -56,9 +56,9 @@
 
 
 本文较为粗略地讲述了CAP与BASE理论，以及分布式系统需要解决的一些问题，更加系统的理论可以参考后面的分布式系统理论专题文章。更加详细的实践内容也可以参考本专题的剩余文章
- 
 
- 
+
+
 
 ## 1、分布式
 
@@ -66,13 +66,13 @@
 
 
 
- 
+
 
 将不同的业务分部在不同的地方，就构成了一个分布式的系统，现在问题来了，系统A是整个分布式系统的脸面，用户直接访问，用户访问量大的时候要么是速度巨慢，要么直接挂掉，怎么办？
 
 由于系统A只有一份，所以会引起单点失败。。。
 
- 
+
 
 ## 2、集群（Cluster）
 
@@ -86,7 +86,7 @@
 
 如果所有人都访问服务器1.1，那服务器1.1会被累死，剩下两个闲死，成了浪费钱的摆设
 
- 
+
 
 ## 3、负载均衡（Load Balancer）
 
@@ -98,7 +98,7 @@
 
 后来小明发现，这个负载均衡的服务器虽然工作内容简单，就是拿到请求，分发请求，但是它还是有可能挂掉，单点失败还是会出现。
 
- 
+
 
 没办法，只好把负载均衡也搞成一个集群，bug和系统A的集群有两点不同：
 
@@ -108,15 +108,15 @@
 
 
 
- 
+
 
 ## 4、弹性
 
 如果3个系统A的实例还是满足不了大量请求，例如双十一，可以申请增加服务器，双十一过后，新增的服务器闲置，成了摆设，于是小明决定尝试云计算，在云端可以轻松的创建，删除虚拟的服务器，那样就可以轻松的随着用户的请求动图的增减服务器了。
 
- 
 
- ## 5、失效转移
+
+## 5、失效转移
 
 上面的系统看起来很美好，但是做了一个不切实际的假设：
 
@@ -124,7 +124,7 @@
 
 但是现实是，大部分服务都是有状态的，例如购物车。
 
- 
+
 
 用户访问系统，在服务器上创建了一个购物车，并向其中加了几个商品，然后服务器1.1挂掉了，用户后续访问就找不到服务器1.1了，这时候就要做失效转移，让另外几个服务器去接管，去处理用户的请求。
 
@@ -132,27 +132,27 @@
 
 还有更严重的，假设用户登录过得信息保存到了该服务器1.1上登录的，用户登录过的信息保存到了该服务器的session中，现在这个服务器挂了，用的session就不见了，会把用户踢到了登录界面，让用户再次登录！
 
- 
+
 
 处理不好状态的问题，集群的威力就大打折扣，无法完成真正的失效转移，甚至无法使用。
 
- 
+
 
 ## 怎么办？
 
 一种办法是把状态信息在集群的各个服务器之间复制，让集群的各个服务器达成一致，谁来干这个事情？只能像Webspher，Weblogic这样的应用服务器了。
 
- 
+
 
 还有一种办法， 就是把状态信息几种存储在一个地方，让集群服务器的各个服务器都能访问到：
 
 
 
- 
+
 
 小明听说Redis不错，那就用Redis来保存吧！
 
- 
+
 
 ## 认识分布式架构
 认识分布式架构
@@ -208,15 +208,15 @@
 
 节点故障则是分布式环境下另一个比较常见的问题，指的是组成分布式系统的服务器节点出现的宕机或“僵死”现象。
 
- 
 
- 
+
+
 
 ## 分布式理论(一) - CAP定理
 前言
 CAP原则又称CAP定理，指的是在一个分布式系统中，Consistency（一致性）、 Availability（可用性）、Partition tolerance（分区容错性）这三个基本需求，最多只能同时满足其中的2个。
 
- 
+
 
 
 
@@ -234,11 +234,11 @@ Partition tolerance（分区容错性）	分布式系统在遇到任何网络分
 ### 2. CAP原则论证
 CAP的基本场景，网络中有两个节点N1和N2，可以简单的理解N1和N2分别是两台计算机，他们之间网络可以连通，N1中有一个应用程序A，和一个数据库V，N2也有一个应用程序B和一个数据库V。现在，A和B是分布式系统的两个部分，V是分布式系统的数据存储的两个子数据库。
 
- 
 
 
 
- 
+
+
 
 在满足一致性的时候，N1和N2中的数据是一样的，V0=V0。
 在满足可用性的时候，用户不管是请求N1或者N2，都会得到立即响应。
@@ -246,11 +246,11 @@ CAP的基本场景，网络中有两个节点N1和N2，可以简单的理解N1
 
 这是分布式系统正常运转的流程，用户向N1机器请求数据更新，程序A更新数据库V0为V1。分布式系统将数据进行同步操作M，将V1同步的N2中V0，使得N2中的数据V0也更新为V1，N2中的数据再响应N2的请求。
 
- 
 
 
 
- 
+
+
 
 根据CAP原则定义，系统的一致性、可用性和分区容错性细分如下：
 
@@ -368,7 +368,7 @@ BASE理论是Basically Available(基本可用)，Soft State（软状态）和Eve
 在分布式事务操作的另一方从消息队列中读取一个消息，并执行消息中的操作。
 
 
- 
+
 
 2. 分析
 本地消息表利用了本地事务来实现分布式事务，并且使用了消息队列来保证最终一致性。
@@ -414,7 +414,7 @@ Zookeeper 提供了一种树形结构级的命名空间，/app1/p_1 节点表示
 
 
 
- 
+
 
 （二）节点类型
 
@@ -447,7 +447,7 @@ Zookeeper 提供了一种树形结构级的命名空间，/app1/p_1 节点表示
 
 
 
- 
+
 
 1. Sticky Sessions
 需要配置负载均衡器，使得一个用户的所有请求都路由到一个服务器节点上，这样就可以把用户的 Session 存放在该服务器节点中。
@@ -456,7 +456,7 @@ Zookeeper 提供了一种树形结构级的命名空间，/app1/p_1 节点表示
 
 
 
- 
+
 
 2. Session Replication
 在服务器节点之间进行 Session 同步操作，这样的话用户可以访问任何一个服务器节点。
@@ -465,7 +465,7 @@ Zookeeper 提供了一种树形结构级的命名空间，/app1/p_1 节点表示
 
 
 
- 
+
 
 3. Persistent DataStore
 将 Session 信息持久化到一个数据库中。
@@ -474,7 +474,7 @@ Zookeeper 提供了一种树形结构级的命名空间，/app1/p_1 节点表示
 
 
 
- 
+
 
 4. In-Memory DataStore
 可以使用 Redis 和 Memcached 这种内存型数据库对 Session 进行存储，可以大大提高 Session 的读写效率。内存型数据库同样可以持久化数据到磁盘中来保证数据的安全性。
@@ -486,47 +486,47 @@ Zookeeper 提供了一种树形结构级的命名空间，/app1/p_1 节点表示
 
 
 
- 
+
 
 该算法比较适合每个服务器的性能差不多的场景，如果有性能存在差异的情况下，那么性能较差的服务器可能无法承担过大的负载（下图的 Server 2）。
 
 
 
- 
+
 
 2. 加权轮询（Weighted Round Robbin）
 加权轮询是在轮询的基础上，根据服务器的性能差异，为服务器赋予一定的权值。例如下图中，服务器 1 被赋予的权值为 5，服务器 2 被赋予的权值为 1，那么 (1, 2, 3, 4, 5) 请求会被发送到服务器 1，(6) 请求会被发送到服务器 2。
 
 
 
- 
+
 
 3. 最少连接（least Connections）
 由于每个请求的连接时间不一样，使用轮询或者加权轮询算法的话，可能会让一台服务器当前连接数过大，而另一台服务器的连接过小，造成负载不均衡。例如下图中，(1, 3, 5) 请求会被发送到服务器 1，但是 (1, 3) 很快就断开连接，此时只有 (5) 请求连接服务器 1；(2, 4, 6) 请求被发送到服务器 2，只有 (2) 的连接断开。该系统继续运行时，服务器 2 会承担过大的负载。
 
 
 
- 
+
 
 最少连接算法就是将请求发送给当前最少连接数的服务器上。例如下图中，服务器 1 当前连接数最小，那么新到来的请求 6 就会被发送到服务器 1 上。
 
 
 
- 
+
 
 4. 加权最少连接（Weighted Least Connection）
 在最少连接的基础上，根据服务器的性能为每台服务器分配权重，再根据权重计算出每台服务器能处理的连接数。
 
 
 
- 
+
 
 5. 随机算法（Random）
 把请求随机发送到服务器上。和轮询算法类似，该算法比较适合服务器性能差不多的场景。
 
 
 
- 
+
 
 6. 源地址哈希法 (IP Hash)
 源地址哈希通过对客户端 IP 哈希计算得到的一个数值，用该数值对服务器数量进行取模运算，取模结果便是目标服务器的序号。
@@ -535,7 +535,7 @@ Zookeeper 提供了一种树形结构级的命名空间，/app1/p_1 节点表示
 缺点：不利于集群扩展，后台服务器数量变更都会影响 hash 结果。可以采用一致性 Hash 改进。
 
 
- 
+
 
 实现
 1. HTTP 重定向
@@ -547,7 +547,7 @@ HTTP 重定向负载均衡服务器收到 HTTP 请求之后会返回服务器的
 如果负载均衡器宕机，就无法访问该站点。
 
 
- 
+
 
 2. DNS 重定向
 使用 DNS 作为负载均衡器，根据负载情况返回不同服务器的 IP 地址。大型网站基本使用了这种方式做为第一级负载均衡手段，然后在内部使用其它方式做第二级负载均衡。
@@ -557,21 +557,21 @@ HTTP 重定向负载均衡服务器收到 HTTP 请求之后会返回服务器的
 DNS 查找表可能会被客户端缓存起来，那么之后的所有请求都会被重定向到同一个服务器。
 
 
- 
+
 
 3. 修改 MAC 地址
 使用 LVS（Linux Virtual Server）这种链路层负载均衡器，根据负载情况修改请求的 MAC 地址。
 
 
 
- 
+
 
 4. 修改 IP 地址
 在网络层修改请求的目的 IP 地址。
 
 
 
- 
+
 
 5. 代理自动配置
 正向代理与反向代理的区别：
@@ -582,7 +582,7 @@ PAC 服务器是用来判断一个请求是否要经过代理。
 
 
 
- 
+
 
 #### 高可用之“脑裂”
 
@@ -598,16 +598,16 @@ HeartBeat运行于备用主机上的Heartbeat可以通过以太网连接检测
 
 --------------
 
-      在“双机热备”高可用（HA）系统中，当联系2个节点的“心跳线”断开时，本来为一整体、动作协调的HA系统，就分裂成为2个独立的个体。由于相互失去了联系，都以为是对方出了故障，2个节点上的HA软件像“裂脑人”一样，“本能”地争抢“共享资源”、争起“应用服务”，就会发生严重后果：或者共享资源被瓜分、2边“服务”都起不来了；或者2边“服务”都起来了，但同时读写“共享存储”，导致数据损坏（常见如数据库轮询着的联机日志出错）。
-      
+ 在“双机热备”高可用（HA）系统中，当联系2个节点的“心跳线”断开时，本来为一整体、动作协调的HA系统，就分裂成为2个独立的个体。由于相互失去了联系，都以为是对方出了故障，2个节点上的HA软件像“裂脑人”一样，“本能”地争抢“共享资源”、争起“应用服务”，就会发生严重后果：或者共享资源被瓜分、2边“服务”都起不来了；或者2边“服务”都起来了，但同时读写“共享存储”，导致数据损坏（常见如数据库轮询着的联机日志出错）。
+ 
 运行于备用主机上的Heartbeat可以通过以太网连接检测主服务器的运行状态，一旦其无法检测到主服务器的“心跳”则自动接管主服务器的资源。通常情况下，主、备服务器间的心跳连接是一个独立的物理连接，这个连接可以是串行线缆、一个由“交叉线”实现的以太网连接。Heartbeat甚至可同时通过多个物理连接检测主服务器的工作状态，而其只要能通过其中一个连接收到主服务器处于活动状态的信息，就会认为主服务器处于正常状态。从实践经验的角度来说，建议为Heartbeat配置多条独立的物理连接，以避免Heartbeat通信线路本身存在单点故障。
 
 1、串行电缆：被认为是比以太网连接安全性稍好些的连接方式，因为hacker无法通过串行连接运行诸如telnet、ssh或rsh类的程序，从而可以降低其通过已劫持的服务器再次侵入备份服务器的几率。但串行线缆受限于可用长度，因此主、备服务器的距离必须非常短。
 2、以太网连接：使用此方式可以消除串行线缆的在长度方面限制，并且可以通过此连接在主备服务器间同步文件系统，从而减少了从正常通信连接带宽的占用。
 
-        基于冗余的角度考虑，应该在主、备服务器使用两个物理连接传输heartbeat的控制信息；这样可以避免在一个网络或线缆故障时导致两个节点同时认为自已是唯一处于活动状态的服务器从而出现争用资源的情况，这种争用资源的场景即是所谓的“脑裂”（split-brain）或“partitioned cluster”。在两个节点共享同一个物理设备资源的情况下，脑裂会产生相当可怕的后果。
+ 基于冗余的角度考虑，应该在主、备服务器使用两个物理连接传输heartbeat的控制信息；这样可以避免在一个网络或线缆故障时导致两个节点同时认为自已是唯一处于活动状态的服务器从而出现争用资源的情况，这种争用资源的场景即是所谓的“脑裂”（split-brain）或“partitioned cluster”。在两个节点共享同一个物理设备资源的情况下，脑裂会产生相当可怕的后果。
 
-        为了避免出现脑裂，可采用下面的预防措施：
+ 为了避免出现脑裂，可采用下面的预防措施：
 添加冗余的心跳线，例如双线条线。尽量减少“裂脑”发生机会。
 启用磁盘锁。正在服务一方锁住共享磁盘，“裂脑”发生时，让对方完全“抢不走”共享磁盘资源。但使用锁磁盘也会有一个不小的问题，如果占用共享盘的一方不主动“解锁”，另一方就永远得不到共享磁盘。现实中假如服务节点突然死机或崩溃，就不可能执行解锁命令。后备节点也就接管不了共享资源和应用服务。于是有人在HA中设计了“智能”锁。即，正在服务的一方只在发现心跳线全部断开（察觉不到对端）时才启用磁盘锁。平时就不上锁了。
 
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2573\357\274\232\345\210\235\346\216\242\345\210\206\345\270\203\345\274\217\345\215\217\350\260\203\346\234\215\345\212\241zookeeper.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\235\346\216\242\345\210\206\345\270\203\345\274\217\345\215\217\350\260\203\346\234\215\345\212\241zookeeper.md"
similarity index 67%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2573\357\274\232\345\210\235\346\216\242\345\210\206\345\270\203\345\274\217\345\215\217\350\260\203\346\234\215\345\212\241zookeeper.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\235\346\216\242\345\210\206\345\270\203\345\274\217\345\215\217\350\260\203\346\234\215\345\212\241zookeeper.md"
index 8f4190f..45da3d8 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2573\357\274\232\345\210\235\346\216\242\345\210\206\345\270\203\345\274\217\345\215\217\350\260\203\346\234\215\345\212\241zookeeper.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\345\210\235\346\216\242\345\210\206\345\270\203\345\274\217\345\215\217\350\260\203\346\234\215\345\212\241zookeeper.md"
@@ -1,17 +1,26 @@
-# Table of Contents
+# 目录
 
+* [目录](#目录)
+  * [小梁的邮件](#小梁的邮件)
+  * [小王的Master选举](#小王的master选举)
+  * [小蔡的分布式锁](#小蔡的分布式锁)
+  * [Zookeeper](#zookeeper)
 
 
+# 目录
+
 本文转自：微信公众号【码农翻身】
 
 本文内容参考网络，侵删
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本文也将同步到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -28,21 +37,11 @@
 
 公司的IT系统早已经从单机转向了分布式，分布式系统带来了巨大的挑战。这周一刚上班，张大胖的邮箱里已经塞满了紧急邮件。
 
-<section data-tools="135编辑器" data-id="87856" data-width="97%">
-
-<section>
-
-<section data-original-title="" title="">1</section>
-
-<section data-bgless="lighten" data-brushtype="text" data-bglessp="20%">小梁的邮件</section>
-
-</section>
-
-</section>
+## 小梁的邮件
 
 小梁的邮件里说了一个RPC调用的问题，本来公司的架构组开发了一个RPC框架让各个组去使用，但是各开发小组纷纷抱怨：这个RPC框架不支持动态的服务注册和发现。
 
-![](http://mmbiz.qpic.cn/mmbiz_png/KyXfCrME6UKd9Mnu73usOhicg51ian3Fe5fLYYRMevVm4dOmuTE6iafA6Vbmmk79sy2bAehicuAcYTnkxgaByemTgA/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/640.webp)
 
 张大胖一看这个图就明白怎么回事了，为了支持高并发，OrderService被部署了4份，每个客户端都保存了一份服务提供者的列表，但是这个列表是静态的（在配置文件中写死的），如果服务的提供者发生了变化，例如有些机器down了，或者又新增了OrderService的实例，客户端根本不知道，可能还在傻乎乎地尝试那些已经坏掉的实例呢！
 
@@ -54,37 +53,27 @@
 
 张大胖想到，应该有个注册中心，首先给这些服务命名（例如orderService），其次那些OrderService 都可以在这里注册一下，客户端就到这里来查询，只需要给出名称orderService，注册中心就可以给出一个可以使用的url， 再也不怕服务提供者的动态增减了。
 
-![](http://mmbiz.qpic.cn/mmbiz_png/KyXfCrME6UKd9Mnu73usOhicg51ian3Fe5z0u0F1aVrHveOrJAL2uHBCSgyOyRSuN9FleCVsgRt83IU8k9WLqJ4Q/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/640.webp)
 
 不知道是不是下意识的行为，**张大胖把这个注册中心的数据结构设计成为了一个树形结构**：
 
-![](http://mmbiz.qpic.cn/mmbiz_png/KyXfCrME6UKd9Mnu73usOhicg51ian3Fe5AxQdKMZn78xhphe1513aQSLODMYJtdpjXLJIMWUJsayHI30NMnSLjQ/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/640.webp)
 
 /orderService 表达了一个服务的概念， 下面的每个节点表示了一个服务的实例。 例如/orderService/node2表示的order service 的第二个实例， 每个节点上可以记录下该实例的url , 这样就可以查询了。
 
 当然这个注册中心必须得能和各个服务实例通信，如果某个服务实例不幸down掉了，那它在树结构中对于的节点也必须删除， 这样客户端就查询不到了。
 
-![](http://mmbiz.qpic.cn/mmbiz_png/KyXfCrME6UKd9Mnu73usOhicg51ian3Fe5VcUosHROr9bJ9YnaVHKLFCLDb4TicIunmE7O74MpAuticCV6gZ0QJ0Lw/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407205952.png)
 
 嗯，可以在注册中心和各个服务实例直接建立Session, 让各个服务实例定期地发送心跳，如果过了特定时间收不到心跳，就认为这个服务实例挂掉了，Session 过期， 把它从树形结构中删除。
 
 张大胖把自己的想法回复了小梁，接着看小王的邮件。
 
-<section data-tools="135编辑器" data-id="87856" data-width="97%">
-
-<section>
-
-<section data-original-title="" title="">2</section>
-
-<section data-bgless="lighten" data-brushtype="text" data-bglessp="20%">小王的Master选举</section>
-
-</section>
+## 小王的Master选举
 
-</section>
+小王邮件中说的是三个Batch Job的协调问题，这三个Batch Job 部署在三台机器上，但是这三个Batch Job同一个时刻只能有一个运行，如果其中某个不幸down掉，剩下的两个就需要做个选举，选出来的那个Batch Job 需要“继承遗志”，继续工作。
 
-小王邮件中说的是三个Batch Job的协调问题，这三个Batch Job 部署在三台机器上，但是这三个Batch Job同一个时刻只能有一个运行，如果其中某个不幸down掉，剩下的两个就需要做个选举，选出来的那个Batch Job 需要“继承遗志”，继续工作。 
-
-![](http://mmbiz.qpic.cn/mmbiz_png/KyXfCrME6UKd9Mnu73usOhicg51ian3Fe5FFBdQicHU2FftFHvIV4s79DggopkKntamHBLiaHpDxgm9rQCfFw1VVTQ/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/640.webp)
 
 其实这就是一个Master的选举问题，张大胖一眼就看出了本质。
 
@@ -94,19 +83,19 @@
 
 可是如果抢到Master的那个Batch Job挂掉了，别人永远就抢不到了！ 因为记录已经存在了， 别的Batch Job 没法插入数据了！
 
-嗯，还得加上定期更新的机制，如果一段时间内没有更新就认为Master死掉了，别的Batch Job可以继续抢.....  不过这么做好麻烦！
+嗯，还得加上定期更新的机制，如果一段时间内没有更新就认为Master死掉了，别的Batch Job可以继续抢..... 不过这么做好麻烦！
 
-换个思路，让他们也去一个注册中心去大吼一声：“我是master!”， 谁的声音大谁是Master 。 
+换个思路，让他们也去一个注册中心去大吼一声：“我是master!”， 谁的声音大谁是Master 。
 
 其实不是吼一声，三个Batch Job启动以后，都去注册中心争抢着去创建一个树的节点（例如/master ），谁创建成功谁就是Master （**当然注册中心必须保证只能创建成功一次，其他请求就失败了**），其他两个Batch Job就对这个节点虎视眈眈地监控，如果这个节点被删除，就开始新一轮争抢，去创建那个/master节点。
 
-![](https://mmbiz.qpic.cn/mmbiz_png/KyXfCrME6UKd9Mnu73usOhicg51ian3Fe5ib7FGxyPbOmEov7CQO9zENULcS75yU5aF8uwGzR6UkkxhR6PibOfBe8A/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407210038.png)
 
-什么时候节点会被删除呢？ 对，就是当前Master的机器down掉了 ！ 很明显，注册中心也需要和各个机器通信，看看他们是否活着。 
+什么时候节点会被删除呢？ 对，就是当前Master的机器down掉了 ！ 很明显，注册中心也需要和各个机器通信，看看他们是否活着。
 
-![](http://mmbiz.qpic.cn/mmbiz_png/KyXfCrME6UKd9Mnu73usOhicg51ian3Fe50WADQoBaq3gF2S6O39JIbsxtQ31700jkZOJCbqnJic9G3zY4qOuk42A/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407210049.png)
 
-等等，这里还有一个复杂的情况， **如果机器1并没有死掉，只是和注册中心长时间连接不上**，注册中心会发现Session超时，会把机器1创建的/master删除。 让机器2和机器3去抢，如果机器3成为了master, 开始运行Batch Job,   但是机器1并不知道自己被解除了Master的职务， 还在努力的运行Batch Job，这就冲突了！
+等等，这里还有一个复杂的情况， **如果机器1并没有死掉，只是和注册中心长时间连接不上**，注册中心会发现Session超时，会把机器1创建的/master删除。 让机器2和机器3去抢，如果机器3成为了master, 开始运行Batch Job, 但是机器1并不知道自己被解除了Master的职务， 还在努力的运行Batch Job，这就冲突了！
 
 看来机器1必须得能感知到和注册中心的连接断开了，需要停止Batch Job才行，等到和注册中心再次连接上以后，才知道自己已经不是master了，老老实实地等下一次机会吧。
 
@@ -114,81 +103,61 @@
 
 先把思路给小王回复一下吧。接着看小蔡的邮件。
 
-<section data-tools="135编辑器" data-id="87856" data-width="97%">
-
-<section>
-
-<section data-original-title="" title="">3</section>
-
-<section data-bgless="lighten" data-brushtype="text" data-bglessp="20%">小蔡的分布式锁</section>
-
-</section>
-
-</section>
+## 小蔡的分布式锁
 
-小蔡的邮件里说的问题更加麻烦，有多个不同的系统（当然是分布在不同的机器上！），要对同一个资源操作。 
+小蔡的邮件里说的问题更加麻烦，有多个不同的系统（当然是分布在不同的机器上！），要对同一个资源操作。
 
-![](http://mmbiz.qpic.cn/mmbiz_png/KyXfCrME6UKd9Mnu73usOhicg51ian3Fe5icAn5dPKpfqgWSbSlQPqibpTdfZmACoic8RKCib07J6zuWHsZTQsbLriahw/0?wx_fmt=png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407210101.png)
 
 这要是在一个机器上，使用某个语言内置的锁就可以搞定，例如Java的synchronized ， 但是现在是分布式啊，程序都跑在不同机器的不同进程中， synchcronized一点用都没有了！
 
-这是个分布式锁的问题啊！ 
+这是个分布式锁的问题啊！
 
-能不能考虑下Master选举问题中的方式，让大家去抢？ 谁能抢先在注册中心创建一个**/distribute_lock**的节点就表示抢到这个锁了，然后读写资源，读写完以后就把**/distribute_lock**节点删除，大家再来抢。 
+能不能考虑下Master选举问题中的方式，让大家去抢？ 谁能抢先在注册中心创建一个**/distribute_lock**的节点就表示抢到这个锁了，然后读写资源，读写完以后就把**/distribute_lock**节点删除，大家再来抢。
 
 可是这样的话某个系统可能会多次抢到，不太公平。
 
 如果让这些系统在注册中心的/distribute_lock下都创建子节点， 然后给每个系统一个编号，会是这个样子：
 
-![](http://mmbiz.qpic.cn/mmbiz_png/KyXfCrME6UKd9Mnu73usOhicg51ian3Fe5GiazbJbrzqIlwibl0nqch7JalQpQW36XRJtrUTkDynCNguia3xGBUCoLQ/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407210111.png)
 
 然后各个系统去检查自己的编号，谁的编号小就认为谁持有了锁， 例如系统1。
 
 系统1持有了锁，就可以对共享资源进行操作了， 操作完成以后process_01这个节点删除， 再创建一个新的节点（编号变成process_04了）：
 
-![](http://mmbiz.qpic.cn/mmbiz_png/KyXfCrME6UKd9Mnu73usOhicg51ian3Fe53xzzA70V6IaMQPibVrHgmuD3DvxibWBbk1RJmgv3ic1r1bqFtAcXOAuibQ/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407210450.png)
 
 其他系统一看，编号为01的删除了，再看看谁是最小的吧，是process_02，那就认为系统2持有了锁，可以对共享资源操作了。 操作完成以后也要把process_02节点删除，创建新的节点。这时候process_03就是最小的了，可以持有锁了。
 
-![](http://mmbiz.qpic.cn/mmbiz_png/KyXfCrME6UKd9Mnu73usOhicg51ian3Fe5Rb9XljeaCYiaibbocUuIJ4SPejxKbUyEt85WZkju8dPrdfiaXPnmaE3QQ/640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407210132.png)
 
-这样循环往复下去......  分布式锁就可以实现了！
+这样循环往复下去...... 分布式锁就可以实现了！
 
-看看，我设计的这个集中式的树形结构很不错吧，能解决各种各样的问题！ 张大胖不由得意起来。
+看看，我设计的这个集中式的树形结构很不错吧，能解决各种各样的问题！张大胖不由得意起来。
 
 好，先把这个想法告诉小蔡，实现细节下午开个会讨论。
 
-<section data-tools="135编辑器" data-id="87856" data-width="97%">
-
-<section>
-
-<section data-original-title="" title="">4</section>
-
-<section data-bgless="lighten" data-brushtype="text" data-bglessp="20%">Zookeeper</section>
-
-</section>
-
-</section>
+## Zookeeper
 
 正准备回复小蔡的时候，大胖突然意识到，自己漏了一个重要的点，那就是**注册中心的高可用性**，如果注册中心只有那么一台机器，一旦挂掉，整个系统就玩完了。
 
-这个注册中心也得有多台机器来保证高可用性，那个自己颇为得意的树形结构也需要在多个机器之间同步啊，要是有机器挂掉怎么办？ 通信超时怎么办？ 树形结构的数据怎么在各个机器之间保证强一致性？ 
+这个注册中心也得有多台机器来保证高可用性，那个自己颇为得意的树形结构也需要在多个机器之间同步啊，要是有机器挂掉怎么办？ 通信超时怎么办？ 树形结构的数据怎么在各个机器之间保证强一致性？
 
 小王、小梁、小蔡的原始问题没有解决，单单是这个注册中心就要了命了。 以自己公司的技术实力，搞出一套这样的注册中心简直是Mission Impossible !
 
-大胖赶紧上网搜索，看看有没有类似的解决方案，让大胖感到万分幸运的是，果然有一个，叫做**Zookeeper** ！ 
+大胖赶紧上网搜索，看看有没有类似的解决方案，让大胖感到万分幸运的是，果然有一个，叫做**Zookeeper** ！
 
-Zookeeper 所使用的树形结构和自己想象的非常类似，更重要的是，人家实现了树形结构数据在多台机器之间的可靠复制，达到了数据在多台机器之间的一致性。并且这多台机器中如果有部分挂掉了/或者由于网络原因无法连接上了， 整个系统还可以工作。 
+Zookeeper 所使用的树形结构和自己想象的非常类似，更重要的是，人家实现了树形结构数据在多台机器之间的可靠复制，达到了数据在多台机器之间的一致性。并且这多台机器中如果有部分挂掉了/或者由于网络原因无法连接上了， 整个系统还可以工作。
 
 大胖赶快去看Zookeeper的关键概念和API：
 
-1.  **Session** ： 表示某个客户系统（例如Batch Job）和ZooKeeper之间的连接会话,  Batch Job连上ZooKeeper以后会周期性地发送心跳信息， 如果Zookeepr在特定时间内收不到心跳，就会认为这个Batch Job已经死掉了, Session 就会结束。
+1. **Session** ： 表示某个客户系统（例如Batch Job）和ZooKeeper之间的连接会话, Batch Job连上ZooKeeper以后会周期性地发送心跳信息， 如果Zookeepr在特定时间内收不到心跳，就会认为这个Batch Job已经死掉了, Session 就会结束。
 
-2\. **znode** :  树形结构中的每个节点叫做znode， 按类型可以分为**永久的znode**（除非主动删除，否则一直存在），**临时的znode**（Session结束就会删除）和 **顺序znode**（就是小蔡的分布式锁中的process_01,process_02.....）。
+2\. **znode** : 树形结构中的每个节点叫做znode， 按类型可以分为**永久的znode**（除非主动删除，否则一直存在），**临时的znode**（Session结束就会删除）和 **顺序znode**（就是小蔡的分布式锁中的process_01,process_02.....）。
 
-3.  **Watch** ： 某个客户系统（例如Batch Job）可以监控znode， znode节点的变化（删除，修改数据等）都可以通知Batch Job， 这样Batch Job可以采取相应的动作，例如争抢着去创建节点。
+3. **Watch** ： 某个客户系统（例如Batch Job）可以监控znode， znode节点的变化（删除，修改数据等）都可以通知Batch Job， 这样Batch Job可以采取相应的动作，例如争抢着去创建节点。
 
-嗯，这些概念和接口应该可以满足我们的要求了， 就是它了，下午召集大家开会开始学习Zookeeper吧。 
+嗯，这些概念和接口应该可以满足我们的要求了， 就是它了，下午召集大家开会开始学习Zookeeper吧。
 
 _后记：本文从使用者的角度描述了Zookeeper有什么用处，至于它内部是如何工作，那是另外一个Big topic了，我们以后再讲。___
 
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25717\357\274\232\346\265\205\346\236\220\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\346\265\205\346\236\220\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"
similarity index 95%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25717\357\274\232\346\265\205\346\236\220\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\346\265\205\346\236\220\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"
index 0b540f5..3f1f40d 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25717\357\274\232\346\265\205\346\236\220\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\346\265\205\346\236\220\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241.md"
@@ -1,7 +1,21 @@
-# Table of Contents
+# 目录
 
+* [目录](#目录)
+  * [什么是事务？](#什么是事务？)
+  * [事务的四大特性 ACID](#事务的四大特性-acid)
+  * [事务的隔离级别](#事务的隔离级别)
+  * [事务并发执行会出现的问题](#事务并发执行会出现的问题)
+  * [数据库的四种隔离级别](#数据库的四种隔离级别)
+  * [什么是分布式事务？](#什么是分布式事务？)
+  * [CAP理论](#cap理论)
+  * [BASE理论](#base理论)
+  * [分布式事务协议](#分布式事务协议)
+    * [2PC](#2pc)
+    * [3PC](#3pc)
 
 
+# 目录
+
 本文转载自 linkedkeeper.com
 
 本文内容参考网络，侵删
@@ -24,10 +38,10 @@
 
 众所周知，数据库能实现本地事务，也就是在同一个数据库中，你可以允许一组操作要么全都正确执行，要么全都不执行。这里特别强调了本地事务，也就是目前的数据库只能支持同一个数据库中的事务。但现在的系统往往采用微服务架构，业务系统拥有独立的数据库，因此就出现了跨多个数据库的事务需求，这种事务即为“分布式事务”。那么在目前数据库不支持跨库事务的情况下，我们应该如何实现分布式事务呢？本文首先会为大家梳理分布式事务的基本概念和理论基础，然后介绍几种目前常用的分布式事务解决方案。废话不多说，那就开始吧～
 
-什么是事务？
+## 什么是事务？
 事务由一组操作构成，我们希望这组操作能够全部正确执行，如果这一组操作中的任意一个步骤发生错误，那么就需要回滚之前已经完成的操作。也就是同一个事务中的所有操作，要么全都正确执行，要么全都不要执行。
 
-事务的四大特性 ACID
+## 事务的四大特性 ACID
 说到事务，就不得不提一下事务著名的四大特性。
 
 原子性原子性要求，事务是一个不可分割的执行单元，事务中的所有操作要么全都执行，要么全都不执行。
@@ -40,12 +54,12 @@
 
 注意：事务只能保证数据库的高可靠性，即数据库本身发生问题后，事务提交后的数据仍然能恢复；而如果不是数据库本身的故障，如硬盘损坏了，那么事务提交的数据可能就丢失了。这属于『高可用性』的范畴。因此，事务只能保证数据库的『高可靠性』，而『高可用性』需要整个系统共同配合实现。
 
-事务的隔离级别
+## 事务的隔离级别
 这里扩展一下，对事务的隔离性做一个详细的解释。
 
 在事务的四大特性ACID中，要求的隔离性是一种严格意义上的隔离，也就是多个事务是串行执行的，彼此之间不会受到任何干扰。这确实能够完全保证数据的安全性，但在实际业务系统中，这种方式性能不高。因此，数据库定义了四种隔离级别，隔离级别和数据库的性能是呈反比的，隔离级别越低，数据库性能越高，而隔离级别越高，数据库性能越差。
 
-事务并发执行会出现的问题
+## 事务并发执行会出现的问题
 我们先来看一下在不同的隔离级别下，数据库可能会出现的问题：
 
 更新丢失当有两个并发执行的事务，更新同一行数据，那么有可能一个事务会把另一个事务的更新覆盖掉。当数据库没有加任何锁操作的情况下会发生。
@@ -58,7 +72,7 @@
 幻读：事务1在两次查询的过程中，事务2对该表进行了插入、删除操作，从而事务1第二次查询的结果发生了变化。
 不可重复读 与 脏读 的区别？脏读读到的是尚未提交的数据，而不可重复读读到的是已经提交的数据，只不过在两次读的过程中数据被另一个事务改过了。
 
-数据库的四种隔离级别
+## 数据库的四种隔离级别
 数据库一共有如下四种隔离级别：
 
 Read uncommitted 读未提交在该级别下，一个事务对一行数据修改的过程中，不允许另一个事务对该行数据进行修改，但允许另一个事务对该行数据读。因此本级别下，不会出现更新丢失，但会出现脏读、不可重复读。
@@ -71,7 +85,7 @@ Serializable 序列化该级别要求所有事务都必须串行执行，因此
 
 隔离级别越高，越能保证数据的完整性和一致性，但是对并发性能的影响也越大。对于多数应用程序，可以优先考虑把数据库系统的隔离级别设为Read Committed。它能够避免脏读取，而且具有较好的并发性能。尽管它会导致不可重复读、幻读和第二类丢失更新这些并发问题，在可能出现这类问题的个别场合，可以由应用程序采用悲观锁或乐观锁来控制。
 
-什么是分布式事务？
+## 什么是分布式事务？
 到此为止，所介绍的事务都是基于单数据库的本地事务，目前的数据库仅支持单库事务，并不支持跨库事务。而随着微服务架构的普及，一个大型业务系统往往由若干个子系统构成，这些子系统又拥有各自独立的数据库。往往一个业务流程需要由多个子系统共同完成，而且这些操作可能需要在一个事务中完成。在微服务系统中，这些业务场景是普遍存在的。此时，我们就需要在数据库之上通过某种手段，实现支持跨数据库的事务支持，这也就是大家常说的“分布式事务”。
 
 这里举一个分布式事务的典型例子——用户下单过程。当我们的系统采用了微服务架构后，一个电商系统往往被拆分成如下几个子系统：商品系统、订单系统、支付系统、积分系统等。整个下单的过程如下：
@@ -82,7 +96,7 @@ Serializable 序列化该级别要求所有事务都必须串行执行，因此
 当支付完成后，由积分系统为该用户增加积分
 上述步骤2、3、4需要在一个事务中完成。对于传统单体应用而言，实现事务非常简单，只需将这三个步骤放在一个方法A中，再用Spring的@Transactional注解标识该方法即可。Spring通过数据库的事务支持，保证这些步骤要么全都执行完成，要么全都不执行。但在这个微服务架构中，这三个步骤涉及三个系统，涉及三个数据库，此时我们必须在数据库和应用系统之间，通过某项黑科技，实现分布式事务的支持。
 
-CAP理论
+## CAP理论
 CAP理论说的是：在一个分布式系统中，最多只能满足C、A、P中的两个需求。
 
 CAP的含义：
@@ -102,7 +116,7 @@ CAP理论告诉我们，在分布式系统中，C、A、P三个条件中我们
 
 此外，可用性对业务系统也尤为重要。在大谈用户体验的今天，如果业务系统时常出现“系统异常”、响应时间过长等情况，这使得用户对系统的好感度大打折扣，在互联网行业竞争激烈的今天，相同领域的竞争者不甚枚举，系统的间歇性不可用会立马导致用户流向竞争对手。因此，我们只能通过牺牲一致性来换取系统的可用性和分区容错性。这也就是下面要介绍的BASE理论。
 
-BASE理论
+## BASE理论
 CAP理论告诉我们一个悲惨但不得不接受的事实——我们只能在C、A、P中选择两个条件。而对于业务系统而言，我们往往选择牺牲一致性来换取系统的可用性和分区容错性。不过这里要指出的是，所谓的“牺牲一致性”并不是完全放弃数据一致性，而是牺牲强一致性换取弱一致性。下面来介绍下BASE理论。
 
 BA：Basic Available 基本可用
@@ -114,7 +128,7 @@ E：Eventual Consisstency：最终一致性同一数据的不同副本的状态
 酸碱平衡
 ACID能够保证事务的强一致性，即数据是实时一致的。这在本地事务中是没有问题的，在分布式事务中，强一致性会极大影响分布式系统的性能，因此分布式系统中遵循BASE理论即可。但分布式系统的不同业务场景对一致性的要求也不同。如交易场景下，就要求强一致性，此时就需要遵循ACID理论，而在注册成功后发送短信验证码等场景下，并不需要实时一致，因此遵循BASE理论即可。因此要根据具体业务场景，在ACID和BASE之间寻求平衡。
 
-分布式事务协议
+## 分布式事务协议
 下面介绍几种实现分布式事务的协议。
 
 
@@ -122,7 +136,7 @@ ACID能够保证事务的强一致性，即数据是实时一致的。这在本
 
 为了解决分布式一致性问题，前人在性能和数据一致性的反反复复权衡过程中总结了许多典型的协议和算法。其中比较著名的有二阶提交协议（2 Phase Commitment Protocol），三阶提交协议（3 Phase Commitment Protocol）。
 
-2PC
+### 2PC
 
 分布式事务最常用的解决方案就是二阶段提交。在分布式系统中，每个节点虽然可以知晓自己的操作时成功或者失败，却无法知道其他节点的操作的成功或失败。当一个事务跨越多个节点时，为了保持事务的ACID特性，需要引入一个作为协调者的组件来统一掌控所有参与者节点的操作结果并最终指示这些节点是否要把操作结果进行真正的提交。
 
@@ -178,7 +192,7 @@ ACID能够保证事务的强一致性，即数据是实时一致的。这在本
 
 数据不一致性：两阶段提交协议虽然为分布式数据强一致性所设计，但仍然存在数据不一致性的可能，比如在第二阶段中，假设协调者发出了事务commit的通知，但是因为网络问题该通知仅被一部分参与者所收到并执行了commit操作，其余的参与者则因为没有收到通知一直处于阻塞状态，这时候就产生了数据的不一致性。
 
-3PC
+### 3PC
 
 针对两阶段提交存在的问题，三阶段提交协议通过引入一个“预询盘”阶段，以及超时策略来减少整个集群的阻塞时间，提升系统性能。三阶段提交的三个阶段分别为：can_commit，pre_commit，do_commit。
 
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25721\357\274\232\346\265\205\350\260\210\345\210\206\345\270\203\345\274\217\346\266\210\346\201\257\346\212\200\346\234\257 Kafka.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\346\265\205\350\260\210\345\210\206\345\270\203\345\274\217\346\266\210\346\201\257\346\212\200\346\234\257Kafka.md"
similarity index 84%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25721\357\274\232\346\265\205\350\260\210\345\210\206\345\270\203\345\274\217\346\266\210\346\201\257\346\212\200\346\234\257 Kafka.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\346\265\205\350\260\210\345\210\206\345\270\203\345\274\217\346\266\210\346\201\257\346\212\200\346\234\257Kafka.md"
index 3f9149f..28fc2ff 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25721\357\274\232\346\265\205\350\260\210\345\210\206\345\270\203\345\274\217\346\266\210\346\201\257\346\212\200\346\234\257 Kafka.md"	
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\346\265\205\350\260\210\345\210\206\345\270\203\345\274\217\346\266\210\346\201\257\346\212\200\346\234\257Kafka.md"
@@ -1,8 +1,21 @@
-# Table of Contents
+# 目录
 
+* [目录](#目录)
+  * [**Kafka的基本介绍**](#kafka的基本介绍)
+  * [**Kafka的设计原理分析**](#kafka的设计原理分析)
+  * [**Kafka数据传输的事务特点**](#kafka数据传输的事务特点)
+  * [**Kafka消息存储格式**](#kafka消息存储格式)
+  * [**副本（replication）策略**](#副本（replication）策略)
+  * [**Kafka消息分组，消息消费原理**](#kafka消息分组，消息消费原理)
+  * [**Push vs. Pull**](#push-vs-pull)
+  * [**Kafak顺序写入与数据读取**](#kafak顺序写入与数据读取)
+  * [**消费者（读取数据）**](#消费者（读取数据）)
+  * [**Reference**](#reference)
 
 
-本文转载自 linkedkeeper.com
+# 目录
+
+本文转载自 linkedkeeper.com  
 本文内容参考网络，侵删
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -19,7 +32,7 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 
 本文主要介绍了这几部分内容：
 
@@ -35,7 +48,7 @@
 
 6push和pull的区别，顺序写入和消息读取，零拷贝机制
 
-**Kafka的基本介绍**
+## **Kafka的基本介绍**
 
 Kafka是最初由Linkedin公司开发，是一个分布式、分区的、多副本的、多订阅者，基于zookeeper协调的分布式日志系统（也可以当做MQ系统），常见可以用于web/nginx日志、访问日志，消息服务等等，Linkedin于2010年贡献给了Apache基金会并成为顶级开源项目。
 
@@ -51,12 +64,11 @@ Kafka主要设计目标如下：
 
 *   同时支持离线数据处理和实时数据处理。
 
-**Kafka的设计原理分析**
-
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_3573ea93-7e93-49b4-9779-6765b4fb0878.jpg)
+## **Kafka的设计原理分析**
 
-一个典型的kafka集群中包含若干producer，若干broker，若干consumer，以及一个Zookeeper集群。Kafka通过Zookeeper管理集群配置，选举leader，以及在consumer group发生变化时进行rebalance。producer使用push模式将消息发布到broker，consumer使用pull模式从broker订阅并消费消息。 　
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_3573ea93-7e93-49b4-9779-6765b4fb0878.jpg)
 
+一个典型的kafka集群中包含若干producer，若干broker，若干consumer，以及一个Zookeeper集群。Kafka通过Zookeeper管理集群配置，选举leader，以及在consumer group发生变化时进行rebalance。producer使用push模式将消息发布到broker，consumer使用pull模式从broker订阅并消费消息。 　  
 Kafka专用术语：
 
 *   Broker：消息中间件处理结点，一个Kafka节点就是一个broker，多个broker可以组成一个Kafka集群。
@@ -75,7 +87,7 @@ Kafka专用术语：
 
 *   Consumer Group：每个Consumer属于一个特定的Consumer Group。
 
-**Kafka数据传输的事务特点**
+## **Kafka数据传输的事务特点**
 
 *   at most once：最多一次，这个和JMS中"非持久化"消息类似，发送一次，无论成败，将不会重发。消费者fetch消息，然后保存offset，然后处理消息；当client保存offset之后，但是在消息处理过程中出现了异常，导致部分消息未能继续处理。那么此后"未处理"的消息将不能被fetch到，这就是"at most once"。
 
@@ -85,17 +97,17 @@ Kafka专用术语：
 
 通常情况下"at-least-once"是我们首选。
 
-**Kafka消息存储格式**
+## **Kafka消息存储格式**
 
 **Topic & Partition**
 
 一个topic可以认为一个一类消息，每个topic将被分成多个partition，每个partition在存储层面是append log文件。
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_ab744f92-5ee7-4856-aa95-dea5978bc622.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_ab744f92-5ee7-4856-aa95-dea5978bc622.jpg)
 
 在Kafka文件存储中，同一个topic下有多个不同partition，每个partition为一个目录，partiton命名规则为topic名称+有序序号，第一个partiton序号从0开始，序号最大值为partitions数量减1。
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_db460b0e-81c1-432d-94c5-6113e24deb06.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_db460b0e-81c1-432d-94c5-6113e24deb06.jpg)
 
 *   每个partion（目录）相当于一个巨型文件被平均分配到多个大小相等segment（段）数据文件中。但每个段segment file消息数量不一定相等，这种特性方便old segment file快速被删除。
 
@@ -107,11 +119,11 @@ Kafka专用术语：
 
 *   segment文件命名规则：partion全局的第一个segment从0开始，后续每个segment文件名为上一个segment文件最后一条消息的offset值。数值最大为64位long大小，19位数字字符长度，没有数字用0填充。
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_5c910b0a-7769-4b61-8ef7-f203c6cc6ebf.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_5c910b0a-7769-4b61-8ef7-f203c6cc6ebf.jpg)
 
 segment中index与data file对应关系物理结构如下：
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_7a05abe1-0f8e-42e3-8967-d1b2c08df29d.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_7a05abe1-0f8e-42e3-8967-d1b2c08df29d.jpg)
 
 上图中索引文件存储大量元数据，数据文件存储大量消息，索引文件中元数据指向对应数据文件中message的物理偏移地址。
 
@@ -119,26 +131,26 @@ segment中index与data file对应关系物理结构如下：
 
 了解到segment data file由许多message组成，下面详细说明message物理结构如下：
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_ea153317-4c86-4880-bbf5-f6e3cc674da8.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_ea153317-4c86-4880-bbf5-f6e3cc674da8.jpg)
 
 参数说明：
 
 
 
-| 关键字 | 解释说明 |
-| --- | --- |
-| 8 byte offset | 在parition(分区)内的每条消息都有一个有序的id号，这个id号被称为偏移(offset),它可以唯一确定每条消息在parition(分区)内的位置。即offset表示partiion的第多少message |
-| 4 byte message size | message大小 |
-| 4 byte CRC32 | 用crc32校验message |
-| 1 byte “magic" | 表示本次发布Kafka服务程序协议版本号 |
-| 1 byte “attributes" | 表示为独立版本、或标识压缩类型、或编码类型。 |
-| 4 byte key length | 表示key的长度,当key为-1时，K byte key字段不填 |
-| K byte key | 可选 |
-| value bytes payload | 表示实际消息数据。 |
+| 关键字 | 解释说明 |  
+| --- | --- |  
+| 8 byte offset | 在parition(分区)内的每条消息都有一个有序的id号，这个id号被称为偏移(offset),它可以唯一确定每条消息在parition(分区)内的位置。即offset表示partiion的第多少message |  
+| 4 byte message size | message大小 |  
+| 4 byte CRC32 | 用crc32校验message |  
+| 1 byte “magic" | 表示本次发布Kafka服务程序协议版本号 |  
+| 1 byte “attributes" | 表示为独立版本、或标识压缩类型、或编码类型。 |  
+| 4 byte key length | 表示key的长度,当key为-1时，K byte key字段不填 |  
+| K byte key | 可选 |  
+| value bytes payload | 表示实际消息数据。 |  
 
 
 
-**副本（replication）策略**
+## **副本（replication）策略**
 
 Kafka的高可靠性的保障来源于其健壮的副本（replication）策略。
 
@@ -148,7 +160,7 @@ kafka在0.8版本前没有提供Partition的Replication机制，一旦Broker宕
 
 引入Replication之后，同一个Partition可能会有多个Replica，而这时需要在这些Replication之间选出一个Leader，Producer和Consumer只与这个Leader交互，其它Replica作为Follower从Leader中复制数据。
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_977192fb-57c2-4b1f-a224-34a5225ec343.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_977192fb-57c2-4b1f-a224-34a5225ec343.jpg)
 
 2) 副本放置策略
 
@@ -164,7 +176,7 @@ Kafka分配Replica的算法如下：
 
 假设集群一共有4个brokers，一个topic有4个partition，每个Partition有3个副本。下图是每个Broker上的副本分配情况。
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_e2fe9558-b7c4-4d40-bd0d-d58d594b01a2.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_e2fe9558-b7c4-4d40-bd0d-d58d594b01a2.jpg)
 
 3) 同步策略
 
@@ -176,7 +188,7 @@ Consumer读消息也是从Leader读取，只有被commit过的消息才会暴露
 
 Kafka Replication的数据流如下图所示：
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_040045e5-02e6-4086-819c-146dc37f2db2.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_040045e5-02e6-4086-819c-146dc37f2db2.jpg)
 
 对于Kafka而言，定义一个Broker是否“活着”包含两个条件：
 
@@ -198,15 +210,15 @@ Leader选举本质上是一个分布式锁，有两种方式实现基于ZooKeepe
 
 Majority Vote的选举策略和ZooKeeper中的Zab选举是类似的，实际上ZooKeeper内部本身就实现了少数服从多数的选举策略。kafka中对于Partition的leader副本的选举采用了第一种方法：为Partition分配副本，指定一个ZNode临时节点，第一个成功创建节点的副本就是Leader节点，其他副本会在这个ZNode节点上注册Watcher监听器，一旦Leader宕机，对应的临时节点就会被自动删除，这时注册在该节点上的所有Follower都会收到监听器事件，它们都会尝试创建该节点，只有创建成功的那个follower才会成为Leader（ZooKeeper保证对于一个节点只有一个客户端能创建成功），其他follower继续重新注册监听事件。
 
-**Kafka消息分组，消息消费原理**
+## **Kafka消息分组，消息消费原理**
 
 同一Topic的一条消息只能被同一个Consumer Group内的一个Consumer消费，但多个Consumer Group可同时消费这一消息。
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_dfba985b-057b-4d5f-adbb-b2590a5af87d.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_dfba985b-057b-4d5f-adbb-b2590a5af87d.jpg)
 
 这是Kafka用来实现一个Topic消息的广播（发给所有的Consumer）和单播（发给某一个Consumer）的手段。一个Topic可以对应多个Consumer Group。如果需要实现广播，只要每个Consumer有一个独立的Group就可以了。要实现单播只要所有的Consumer在同一个Group里。用Consumer Group还可以将Consumer进行自由的分组而不需要多次发送消息到不同的Topic。
 
-**Push vs. Pull**
+## **Push vs. Pull**
 
 作为一个消息系统，Kafka遵循了传统的方式，选择由Producer向broker push消息并由Consumer从broker pull消息。
 
@@ -214,7 +226,7 @@ push模式很难适应消费速率不同的消费者，因为消息发送速率
 
 对于Kafka而言，pull模式更合适。pull模式可简化broker的设计，Consumer可自主控制消费消息的速率，同时Consumer可以自己控制消费方式——即可批量消费也可逐条消费，同时还能选择不同的提交方式从而实现不同的传输语义。
 
-**Kafak顺序写入与数据读取**
+## **Kafak顺序写入与数据读取**
 
 生产者（producer）是负责向Kafka提交数据的，Kafka会把收到的消息都写入到硬盘中，它绝对不会丢失数据。为了优化写入速度Kafak采用了两个技术，顺序写入和MMFile。
 
@@ -224,29 +236,29 @@ push模式很难适应消费速率不同的消费者，因为消息发送速率
 
 每条消息都被append到该Partition中，属于顺序写磁盘，因此效率非常高。
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_969b4966-9981-47c9-a743-4e4b882339bb.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_969b4966-9981-47c9-a743-4e4b882339bb.jpg)
 
 对于传统的message queue而言，一般会删除已经被消费的消息，而Kafka是不会删除数据的，它会把所有的数据都保留下来，每个消费者（Consumer）对每个Topic都有一个offset用来表示读取到了第几条数据。
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_4e1d6df1-c2c0-432c-8463-dc43f18444eb.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_4e1d6df1-c2c0-432c-8463-dc43f18444eb.jpg)
 
 即便是顺序写入硬盘，硬盘的访问速度还是不可能追上内存。所以Kafka的数据并不是实时的写入硬盘，它充分利用了现代操作系统分页存储来利用内存提高I/O效率。
 
 在Linux Kernal 2.2之后出现了一种叫做“零拷贝(zero-copy)”系统调用机制，就是跳过“用户缓冲区”的拷贝，建立一个磁盘空间和内存空间的直接映射，数据不再复制到“用户态缓冲区”系统上下文切换减少2次，可以提升一倍性能。
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_de0c3ea1-f84f-4ef9-b223-0ef531165b81.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_de0c3ea1-f84f-4ef9-b223-0ef531165b81.jpg)
 
 通过mmap，进程像读写硬盘一样读写内存（当然是虚拟机内存）。使用这种方式可以获取很大的I/O提升，省去了用户空间到内核空间复制的开销（调用文件的read会把数据先放到内核空间的内存中，然后再复制到用户空间的内存中。）
 
-**消费者（读取数据）**
+## **消费者（读取数据）**
 
 试想一下，一个Web Server传送一个静态文件，如何优化？答案是zero copy。传统模式下我们从硬盘读取一个文件是这样的。
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_94a51a2c-afa2-47e4-975d-1857bd769487.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_94a51a2c-afa2-47e4-975d-1857bd769487.jpg)
 
 先复制到内核空间（read是系统调用，放到了DMA，所以用内核空间），然后复制到用户空间（1、2）；从用户空间重新复制到内核空间（你用的socket是系统调用，所以它也有自己的内核空间），最后发送给网卡（3、4）。
 
-![](http://misc.linkedkeeper.com/misc/img/blog/201707/linkedkeeper0_e89b49e9-369c-4deb-b9b0-f58f02b33430.jpg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/linkedkeeper0_e89b49e9-369c-4deb-b9b0-f58f02b33430.jpg)
 
 Zero Copy中直接从内核空间（DMA的）到内核空间（Socket的），然后发送网卡。这个技术非常普遍，Nginx也是用的这种技术。
 
@@ -266,7 +278,7 @@ Zero Copy中直接从内核空间（DMA的）到内核空间（Socket的），
 
 *   [浅谈分布式服务协调技术 Zookeeper](http://www.linkedkeeper.com/detail/blog.action?bid=1014)
 
-**Reference**
+## **Reference**
 
 http://www.cnblogs.com/liuming1992/p/6423007.html
 
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25716\357\274\232\346\265\205\350\260\210\345\210\206\345\270\203\345\274\217\351\224\201\347\232\204\345\207\240\347\247\215\346\226\271\346\241\210.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\346\265\205\350\260\210\345\210\206\345\270\203\345\274\217\351\224\201\347\232\204\345\207\240\347\247\215\346\226\271\346\241\210.md"
similarity index 93%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25716\357\274\232\346\265\205\350\260\210\345\210\206\345\270\203\345\274\217\351\224\201\347\232\204\345\207\240\347\247\215\346\226\271\346\241\210.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\346\265\205\350\260\210\345\210\206\345\270\203\345\274\217\351\224\201\347\232\204\345\207\240\347\247\215\346\226\271\346\241\210.md"
index 5ea423c..b9e4ea5 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25716\357\274\232\346\265\205\350\260\210\345\210\206\345\270\203\345\274\217\351\224\201\347\232\204\345\207\240\347\247\215\346\226\271\346\241\210.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\346\265\205\350\260\210\345\210\206\345\270\203\345\274\217\351\224\201\347\232\204\345\207\240\347\247\215\346\226\271\346\241\210.md"
@@ -1,5 +1,16 @@
-# Table of Contents
+# 目录
 
+* [目录](#目录)
+  * [前言](#前言)
+  * [分布式一致性问题](#分布式一致性问题)
+  * [分布式锁需要具备哪些条件](#分布式锁需要具备哪些条件)
+  * [分布式锁实现方式](#分布式锁实现方式)
+  * [解决上述问题有两种方案](#解决上述问题有两种方案)
+  * [zookeeper分布式锁](#zookeeper分布式锁)
+  * [小结](#小结)
+
+
+# 目录
 
 本文内容参考网络，侵删
 
@@ -21,13 +32,13 @@
 
 本文转载自 linkedkeeper.com
 
-前言
+## 前言
 
 随着互联网技术的不断发展，数据量的不断增加，业务逻辑日趋复杂，在这种背景下，传统的集中式系统已经无法满足我们的业务需求，分布式系统被应用在更多的场景，而在分布式系统中访问共享资源就需要一种互斥机制，来防止彼此之间的互相干扰，以保证一致性，在这种情况下，我们就需要用到分布式锁。
 
 
 
-分布式一致性问题
+## 分布式一致性问题
 
 首先我们先来看一个小例子：
 
@@ -37,7 +48,7 @@
 
 
 
-分布式锁需要具备哪些条件
+## 分布式锁需要具备哪些条件
 
 1. 获取锁和释放锁的性能要好
 
@@ -51,7 +62,7 @@
 
 
 
-分布式锁实现方式
+## 分布式锁实现方式
 
 一、数据库锁
 
@@ -81,9 +92,9 @@
 
 基于setnx（set if not exist）的特点，当缓存里key不存在时，才会去set，否则直接返回false。如果返回true则获取到锁，否则获取锁失败，为了防止死锁，我们再用expire命令对这个key设置一个超时时间来避免。但是这里看似完美，实则有缺陷，当我们setnx成功后，线程发生异常中断，expire还没来的及设置，那么就会产生死锁。
 
-解决上述问题有两种方案
+## 解决上述问题有两种方案
 
-第一种是采用redis2.6.12版本以后的set，它提供了一系列选项
+1. 第一种是采用redis2.6.12版本以后的set，它提供了一系列选项
 
 EX seconds – 设置键key的过期时间，单位时秒
 
@@ -131,7 +142,7 @@ redlock算法相对于单节点redis锁可靠性要更高，但是实现起来
 
 
 
-zookeeper分布式锁
+## zookeeper分布式锁
 
 关于zookeeper的分布式锁实现在之前讲述zookeeper的时候已经介绍了。这里不再赘述、
 
@@ -165,7 +176,7 @@ zookeeper是一个为分布式应用提供一致性服务的软件，它内部
 
 
 
-小结
+## 小结
 
 在分布式系统中，共享资源互斥访问问题非常普遍，而针对访问共享资源的互斥问题，常用的解决方案就是使用分布式锁，这里只介绍了几种常用的分布式锁，分布式锁的实现方式还有有很多种，根据业务选择合适的分布式锁，下面对上述几种锁进行一下比较：
 
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25720\357\274\232\346\266\210\346\201\257\351\230\237\345\210\227\345\233\240\344\275\225\350\200\214\347\224\237.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\346\266\210\346\201\257\351\230\237\345\210\227\345\233\240\344\275\225\350\200\214\347\224\237.md"
similarity index 89%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25720\357\274\232\346\266\210\346\201\257\351\230\237\345\210\227\345\233\240\344\275\225\350\200\214\347\224\237.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\346\266\210\346\201\257\351\230\237\345\210\227\345\233\240\344\275\225\350\200\214\347\224\237.md"
index bfdfe76..b47f00d 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25720\357\274\232\346\266\210\346\201\257\351\230\237\345\210\227\345\233\240\344\275\225\350\200\214\347\224\237.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\346\266\210\346\201\257\351\230\237\345\210\227\345\233\240\344\275\225\350\200\214\347\224\237.md"
@@ -1,35 +1,35 @@
-# Table of Contents
 
+# 目录
 * [何时需要消息队列](#何时需要消息队列)
-  * [解耦](#解耦)
-  * [最终一致性](#最终一致性)
-  * [广播](#广播)
-  * [错峰与流控](#错峰与流控)
-  * [消息队列的流派之争](#消息队列的流派之争)
-  * [MQ是什么](#mq是什么)
-  * [MQ的流派](#mq的流派)
-    * [有broker](#有broker)
-    * [无broker](#无broker)
-  * [MQ只能异步吗](#mq只能异步吗)
-  * [总结](#总结)
+    * [解耦](#解耦)
+    * [最终一致性](#最终一致性)
+    * [广播](#广播)
+    * [错峰与流控](#错峰与流控)
+    * [消息队列的流派之争](#消息队列的流派之争)
+    * [MQ是什么](#mq是什么)
+    * [MQ的流派](#mq的流派)
+        * [有broker](#有broker)
+        * [无broker](#无broker)
+    * [MQ只能异步吗](#mq只能异步吗)
+    * [总结](#总结)
 * [如何设计一个消息队列](#如何设计一个消息队列)
-  * [综述](#综述)
-  * [实现队列基本功能](#实现队列基本功能)
-    * [RPC通信协议](#rpc通信协议)
-    * [高可用](#高可用)
-    * [服务端承载消息堆积的能力](#服务端承载消息堆积的能力)
-    * [存储子系统的选择](#存储子系统的选择)
-    * [消费关系解析](#消费关系解析)
-  * [队列高级特性设计](#队列高级特性设计)
-    * [可靠投递（最终一致性）](#可靠投递（最终一致性）)
-      * [消费确认](#消费确认)
-      * [重复消息和顺序消息](#重复消息和顺序消息)
-    * [事务](#事务)
-    * [性能相关](#性能相关)
-      * [异步/同步](#异步同步)
-  * [push还是pull](#push还是pull)
-    * [慢消费](#慢消费)
-    * [消息延迟与忙等](#消息延迟与忙等)
+    * [综述](#综述)
+    * [实现队列基本功能](#实现队列基本功能)
+        * [RPC通信协议](#rpc通信协议)
+        * [高可用](#高可用)
+        * [服务端承载消息堆积的能力](#服务端承载消息堆积的能力)
+        * [存储子系统的选择](#存储子系统的选择)
+        * [消费关系解析](#消费关系解析)
+    * [队列高级特性设计](#队列高级特性设计)
+        * [可靠投递（最终一致性）](#可靠投递（最终一致性）)
+            * [消费确认](#消费确认)
+            * [重复消息和顺序消息](#重复消息和顺序消息)
+        * [事务](#事务)
+        * [性能相关](#性能相关)
+            * [异步/同步](#异步同步)
+    * [push还是pull](#push还是pull)
+        * [慢消费](#慢消费)
+        * [消息延迟与忙等](#消息延迟与忙等)
 * [总结](#总结-1)
 
 
@@ -38,11 +38,13 @@
 本文内容参考网络，侵删
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本文也将同步到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -135,21 +137,29 @@ Message Queue（MQ），消息队列中间件。很多人都说：MQ通过将消
 
 这个流派通常有一台服务器作为Broker，所有的消息都通过它中转。生产者把消息发送给它就结束自己的任务了，Broker则把消息主动推送给消费者（或者消费者主动轮询）。
 
-*   重Topic流
+* 重Topic流
+
+  kafka、JMS就属于这个流派，生产者会发送key和数据到Broker，由Broker比较key之后决定给那个消费者。这种模式是我们最常见的模式，是我们对MQ最多的印象。在这种模式下一个topic往往是一个比较大的概念，甚至一个系统中就可能只有一个topic，topic某种意义上就是queue，生产者发送key相当于说：“hi，把数据放到`key`的队列中”。
 
-    kafka、JMS就属于这个流派，生产者会发送key和数据到Broker，由Broker比较key之后决定给那个消费者。这种模式是我们最常见的模式，是我们对MQ最多的印象。在这种模式下一个topic往往是一个比较大的概念，甚至一个系统中就可能只有一个topic，topic某种意义上就是queue，生产者发送key相当于说：“hi，把数据放到`key`的队列中”。
 
-    
 
 
 
-![](http://mmbiz.qpic.cn/mmbiz/nfxUjuI2HXgoqXTTkAeYIrvHvZnPs0K3Knr0bUqAA2SRKcS3bzmSlEhXcn3Mbn1xea8XAF5lcickacNoBgwTMkg/640?wx_fmt=jpeg&tp=webp&wxfrom=5&wx_lazy=1) 如上图所示，Broker定义了三个队列，key1，key2，key3，生产者发送数据的时候会发送key1和data，Broker在推送数据的时候则推送data（也可能把key带上）。虽然架构一样但是kafka的性能要比jms的性能不知道高到多少倍，所以基本这种类型的MQ只有kafka一种备选方案。如果你需要一条暴力的数据流（在乎性能而非灵活性）那么kafka是最好的选择。
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407220345.png)
+
+如上图所示，Broker定义了三个队列，key1，key2，key3，生产者发送数据的时候会发送key1和data，Broker在推送数据的时候则推送data（也可能把key带上）。虽然架构一样但是kafka的性能要比jms的性能不知道高到多少倍，所以基本这种类型的MQ只有kafka一种备选方案。如果你需要一条暴力的数据流（在乎性能而非灵活性)那么kafka是最好的选择。
 
 *   轻Topic流
 
 这种的代表是RabbitMQ（或者说是AMQP）。生产者发送key和数据，消费者定义订阅的队列，Broker收到数据之后会通过一定的逻辑计算出key对应的队列，然后把数据交给队列。
 
-![](http://mmbiz.qpic.cn/mmbiz/nfxUjuI2HXgoqXTTkAeYIrvHvZnPs0K3pxP3R7oprRbc4biarSTznrVrYYjp8ThunSNEUy6L3oOFBzPg662dYCA/640?wx_fmt=jpeg&tp=webp&wxfrom=5&wx_lazy=1) 注意到了吗？这种模式下解耦了key和queue，在这种架构中queue是非常轻量级的（在RabbitMQ中它的上限取决于你的内存），消费者关心的只是自己的queue；生产者不必关心数据最终给谁只要指定key就行了，中间的那层映射在AMQP中叫exchange（交换机）。AMQP中有四种种exchange——Direct exchange：key就等于queue；Fanout exchange：无视key，给所有的queue都来一份；Topic exchange：key可以用“宽字符”模糊匹配queue；最后一个厉害了Headers exchange：无视key，通过查看消息的头部元数据来决定发给那个queue（AMQP头部元数据非常丰富而且可以自定义）。这种结构的架构给通讯带来了很大的灵活性，我们能想到的通讯方式都可以用这四种exchange表达出来。如果你需要一个企业数据总线（在乎灵活性）那么RabbitMQ绝对的值得一用。
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407220359.png)
+
+
+
+注意到了吗？这种模式下解耦了key和queue，在这种架构中queue是非常轻量级的（在RabbitMQ中它的上限取决于你的内存），消费者关心的只是自己的queue；生产者不必关心数据最终给谁只要指定key就行了，中间的那层映射在AMQP中叫exchange（交换机）。AMQP中有四种种exchange——Direct exchange：key就等于queue；Fanout exchange：无视key，给所有的queue都来一份；Topic exchange：key可以用“宽字符”模糊匹配queue；最后一个厉害了Headers exchange：无视key，通过查看消息的头部元数据来决定发给那个queue（AMQP头部元数据非常丰富而且可以自定义）。这种结构的架构给通讯带来了很大的灵活性，我们能想到的通讯方式都可以用这四种exchange表达出来。如果你需要一个企业数据总线（在乎灵活性）那么RabbitMQ绝对的值得一用。
 
 ### 无broker
 
@@ -159,11 +169,21 @@ Message Queue（MQ），消息队列中间件。很多人都说：MQ通过将消
 
 
 
-![](http://mmbiz.qpic.cn/mmbiz/nfxUjuI2HXgoqXTTkAeYIrvHvZnPs0K3zb0dGjficoT7xroHtCVtUiacqcjD962AjucHJ6THaIDIET0CdCGqg8XA/640?wx_fmt=jpeg&tp=webp&wxfrom=5&wx_lazy=1) 节点之间通讯的消息都是发送到彼此的队列中，每个节点都既是生产者又是消费者。ZeroMQ做的事情就是封装出一套类似于scoket的API可以完成发送数据，读取数据。如果你仔细想一下其实ZeroMQ是这样的
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407220411.png)
+
 
 
+节点之间通讯的消息都是发送到彼此的队列中，每个节点都既是生产者又是消费者。ZeroMQ做的事情就是封装出一套类似于scoket的API可以完成发送数据，读取数据。如果你仔细想一下其实ZeroMQ是这样的
 
-![](http://mmbiz.qpic.cn/mmbiz/nfxUjuI2HXgoqXTTkAeYIrvHvZnPs0K3yyebow7bggRB6CbYZ0gr9WsTTEPiafabCiajz9TnmCp3YzycSE10PEQA/640?wx_fmt=jpeg&tp=webp&wxfrom=5&wx_lazy=1) 顿悟了吗？Actor模型，ZeroMQ其实就是一个跨语言的、重量级的Actor模型邮箱库。你可以把自己的程序想象成一个actor，zeromq就是提供邮箱功能的库；zeromq可以实现同一台机器的IPC通讯也可以实现不同机器的TCP、UDP通讯。如果你需要一个强大的、灵活、野蛮的通讯能力，别犹豫zeromq。
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407220426.png)
+
+
+
+
+
+顿悟了吗？Actor模型，ZeroMQ其实就是一个跨语言的、重量级的Actor模型邮箱库。你可以把自己的程序想象成一个actor，zeromq就是提供邮箱功能的库；zeromq可以实现同一台机器的IPC通讯也可以实现不同机器的TCP、UDP通讯。如果你需要一个强大的、灵活、野蛮的通讯能力，别犹豫zeromq。
 
 ## MQ只能异步吗
 
@@ -185,15 +205,13 @@ kafka，zeromq，rabbitmq代表了三种完全不同风格的MQ架构；关注
 
 如果你拿zeromq来做大数据量的传输功能，不是生产者的内存“爆掉”就是消费者被“压死”；如果你用kafka做通讯总线那绝对的不会快只能更慢；你想要rabbitmq实现分布式，那真的是难为它。
 
-
-
 # 如何设计一个消息队列
 
 ## 综述
 
 我们现在明确了消息队列的使用场景，下一步就是如何设计实现一个消息队列了。
-![](https://tech.meituan.com/img/mq-design/mq-design.png)
-基于消息的系统模型，不一定需要broker(消息队列服务端)。市面上的的Akka（actor模型）、ZeroMQ等，其实都是基于消息的系统设计范式，但是没有broker。
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407220539.png)
+基于消息的系统模型，不一定需要broker(消息队列服务端)。市面上的的Akka（actor模型)、ZeroMQ等，其实都是基于消息的系统设计范式，但是没有broker。
 我们之所以要设计一个消息队列，并且配备broker，无外乎要做两件事情：
 
 1.  消息的转储，在更合适的时间点投递，或者通过一系列手段辅助消息最终能送达消费机。
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25715\357\274\232\347\274\223\345\255\230\346\233\264\346\226\260\347\232\204\345\245\227\350\267\257.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\347\274\223\345\255\230\346\233\264\346\226\260\347\232\204\345\245\227\350\267\257.md"
similarity index 87%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25715\357\274\232\347\274\223\345\255\230\346\233\264\346\226\260\347\232\204\345\245\227\350\267\257.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\347\274\223\345\255\230\346\233\264\346\226\260\347\232\204\345\245\227\350\267\257.md"
index 3709ac4..22c4550 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25715\357\274\232\347\274\223\345\255\230\346\233\264\346\226\260\347\232\204\345\245\227\350\267\257.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\347\274\223\345\255\230\346\233\264\346\226\260\347\232\204\345\245\227\350\267\257.md"
@@ -1,12 +1,13 @@
-# Table of Contents
 
-* [缓存更新的套路](#缓存更新的套路)
-      * [Cache Aside Pattern](#cache-aside-pattern)
-      * [Read/Write Through Pattern](#readwrite-through-pattern)
-        * [Read Through](#read-through)
-        * [Write Through](#write-through)
-      * [Write Behind Caching Pattern](#write-behind-caching-pattern)
-      * [再多唠叨一些](#再多唠叨一些)
+# 目录
+
+* [缓存更新的套路](#缓存更新的套路)  
+  * [Cache Aside Pattern](#cache-aside-pattern)  
+  * [Read/Write Through Pattern](#readwrite-through-pattern)  
+  * [Read Through](#read-through)  
+  * [Write Through](#write-through)  
+  * [Write Behind Caching Pattern](#write-behind-caching-pattern)  
+  * [再多唠叨一些](#再多唠叨一些)
 
 本文内容参考网络，侵删
 
@@ -24,7 +25,7 @@
 
 如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
 
-<!-- more -->
+<!-- more -->  
 
 本文转载自 linkedkeeper.com
 
@@ -50,9 +51,9 @@
 
 *   **更新**：先把数据存到数据库中，成功后，再让缓存失效。
 
-![Cache-Aside-Design-Pattern-Flow-Diagram](https://coolshell.cn/wp-content/uploads/2016/07/Cache-Aside-Design-Pattern-Flow-Diagram-e1470471723210.png)
+![Cache-Aside-Design-Pattern-Flow-Diagram](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/Cache-Aside-Design-Pattern-Flow-Diagram-e1470471723210.png)
 
-![Updating-Data-using-the-Cache-Aside-Pattern-Flow-Diagram-1](https://coolshell.cn/wp-content/uploads/2016/07/Updating-Data-using-the-Cache-Aside-Pattern-Flow-Diagram-1-e1470471761402.png)
+![Updating-Data-using-the-Cache-Aside-Pattern-Flow-Diagram-1](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/Updating-Data-using-the-Cache-Aside-Pattern-Flow-Diagram-1-e1470471761402.png)
 
 注意，我们的更新是先更新数据库，成功后，让缓存失效。那么，这种方式是否可以没有文章前面提到过的那个问题呢？我们可以脑补一下。
 
@@ -80,7 +81,7 @@ Write Through 套路和Read Through相仿，不过是在更新数据时发生。
 
 下图自来Wikipedia的[Cache词条](https://en.wikipedia.org/wiki/Cache_(computing))。其中的Memory你可以理解为就是我们例子里的数据库。
 
-![Write-through_with_no-write-allocation](https://coolshell.cn/wp-content/uploads/2016/07/460px-Write-through_with_no-write-allocation.svg_.png)
+![Write-through_with_no-write-allocation](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/460px-Write-through_with_no-write-allocation.svg_.png)
 
 #### Write Behind Caching Pattern
 
@@ -94,7 +95,7 @@ Write Back套路，一句说就是，在更新数据的时候，只更新缓存
 
 在wikipedia上有一张write back的流程图，基本逻辑如下：
 
-![Write-back_with_write-allocation](https://coolshell.cn/wp-content/uploads/2016/07/Write-back_with_write-allocation.png)
+![Write-back_with_write-allocation](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/Write-back_with_write-allocation.png)
 
 #### 再多唠叨一些
 
@@ -104,6 +105,6 @@ Write Back套路，一句说就是，在更新数据的时候，只更新缓存
 
 3）在软件开发或设计中，我非常建议在之前先去参考一下已有的设计和思路，**看看相应的guideline，best practice或design pattern，吃透了已有的这些东西，再决定是否要重新发明轮子**。千万不要似是而非地，想当然的做软件设计。
 
-4）上面，我们没有考虑缓存（Cache）和持久层（Repository）的整体事务的问题。比如，更新Cache成功，更新数据库失败了怎么吗？或是反过来。关于这个事，如果你需要强一致性，你需要使用“两阶段提交协议”——prepare, commit/rollback，比如Java 7 的[XAResource](http://docs.oracle.com/javaee/7/api/javax/transaction/xa/XAResource.html)，还有MySQL 5.7的 [XA Transaction](http://dev.mysql.com/doc/refman/5.7/en/xa.html)，有些cache也支持XA，比如[EhCache](http://www.ehcache.org/documentation/3.0/xa.html)。当然，XA这样的强一致性的玩法会导致性能下降，关于分布式的事务的相关话题，你可以看看《[分布式系统的事务处理](https://coolshell.cn/articles/10910.html)》一文。
+4）上面，我们没有考虑缓存（Cache）和持久层（Repository）的整体事务的问题。比如，更新Cache成功，更新数据库失败了怎么吗？或是反过来。关于这个事，如果你需要强一致性，你需要使用“两阶段提交协议”——prepare, commit/rollback，比如Java 7 的[XAResource](http://docs.oracle.com/javaee/7/api/javax/transaction/xa/XAResource.html)，还有MySQL 5.7的[XA Transaction](http://dev.mysql.com/doc/refman/5.7/en/xa.html)，有些cache也支持XA，比如[EhCache](http://www.ehcache.org/documentation/3.0/xa.html)。当然，XA这样的强一致性的玩法会导致性能下降，关于分布式的事务的相关话题，你可以看看《[分布式系统的事务处理](https://coolshell.cn/articles/10910.html)》一文。
 
 （全文完）
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25713\357\274\232\347\274\223\345\255\230\347\232\204\351\202\243\344\272\233\344\272\213.md" "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\347\274\223\345\255\230\347\232\204\351\202\243\344\272\233\344\272\213.md"
similarity index 95%
rename from "docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25713\357\274\232\347\274\223\345\255\230\347\232\204\351\202\243\344\272\233\344\272\213.md"
rename to "docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\347\274\223\345\255\230\347\232\204\351\202\243\344\272\233\344\272\213.md"
index 724a514..86fb26e 100644
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25713\357\274\232\347\274\223\345\255\230\347\232\204\351\202\243\344\272\233\344\272\213.md"
+++ "b/docs/distributed/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\357\274\232\347\274\223\345\255\230\347\232\204\351\202\243\344\272\233\344\272\213.md"
@@ -1,35 +1,37 @@
-# Table of Contents
+# 目录
 
 * [缓存和它的那些淘汰算法们](#缓存和它的那些淘汰算法们)
 * [缓存技术杂谈](#缓存技术杂谈)
 * [缓存特征](#缓存特征)
-      * [命中率](#命中率)
-      * [最大元素（或最大空间）](#最大元素（或最大空间）)
-      * [清空策略](#清空策略)
+  * [命中率](#命中率)
+  * [最大元素（或最大空间）](#最大元素（或最大空间）)
+  * [清空策略](#清空策略)
 * [缓存介质](#缓存介质)
 * [缓存分类和应用场景](#缓存分类和应用场景)
-  * [本地缓存](#本地缓存)
-    * [编程直接实现缓存](#编程直接实现缓存)
-    * [Ehcache](#ehcache)
-  * [分布式缓存](#分布式缓存)
-    * [memcached缓存](#memcached缓存)
-    * [Redis缓存](#redis缓存)
+    * [本地缓存](#本地缓存)
+        * [编程直接实现缓存](#编程直接实现缓存)
+        * [Ehcache](#ehcache)
+    * [分布式缓存](#分布式缓存)
+        * [memcached缓存](#memcached缓存)
+        * [Redis缓存](#redis缓存)
 * [缓存常见问题](#缓存常见问题)
-  * [一、缓存雪崩](#一、缓存雪崩)
-  * [二、缓存穿透](#二、缓存穿透)
-  * [三、缓存预热](#三、缓存预热)
-  * [四、缓存更新](#四、缓存更新)
-  * [五、缓存降级](#五、缓存降级)
-  * [六、总结](#六、总结)
+    * [一、缓存雪崩](#一、缓存雪崩)
+    * [二、缓存穿透](#二、缓存穿透)
+    * [三、缓存预热](#三、缓存预热)
+    * [四、缓存更新](#四、缓存更新)
+    * [五、缓存降级](#五、缓存降级)
+    * [六、总结](#六、总结)
 
 本文内容参考网络，侵删
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
+
 > https://github.com/h2pl/Java-Tutorial
 
 喜欢的话麻烦点下Star哈
 
 本文也将同步到我的个人博客：
+
 > www.how2playlife.com
 
 更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
@@ -394,17 +396,17 @@ Second Chance：
 
 如上描述，缓存的存储空间有限制，当缓存空间被用满时，如何保证在稳定服务的同时有效提升命中率？这就由缓存清空策略来处理，设计适合自身数据特征的清空策略能有效提升命中率。常见的一般策略有：
 
-*   FIFO(first in first out)
+* FIFO(first in first out)
 
-    先进先出策略，最先进入缓存的数据在缓存空间不够的情况下（超出最大元素限制）会被优先被清除掉，以腾出新的空间接受新的数据。策略算法主要比较缓存元素的创建时间。在数据实效性要求场景下可选择该类策略，优先保障最新数据可用。
+  先进先出策略，最先进入缓存的数据在缓存空间不够的情况下（超出最大元素限制）会被优先被清除掉，以腾出新的空间接受新的数据。策略算法主要比较缓存元素的创建时间。在数据实效性要求场景下可选择该类策略，优先保障最新数据可用。
 
-*   LFU(less frequently used)
+* LFU(less frequently used)
 
-    最少使用策略，无论是否过期，根据元素的被使用次数判断，清除使用次数较少的元素释放空间。策略算法主要比较元素的hitCount（命中次数）。在保证高频数据有效性场景下，可选择这类策略。
+  最少使用策略，无论是否过期，根据元素的被使用次数判断，清除使用次数较少的元素释放空间。策略算法主要比较元素的hitCount（命中次数）。在保证高频数据有效性场景下，可选择这类策略。
 
-*   LRU(least recently used)
+* LRU(least recently used)
 
-    最近最少使用策略，无论是否过期，根据元素最后一次被使用的时间戳，清除最远使用时间戳的元素释放空间。策略算法主要比较元素最近一次被get使用时间。在热点数据场景下较适用，优先保证热点数据的有效性。
+  最近最少使用策略，无论是否过期，根据元素最后一次被使用的时间戳，清除最远使用时间戳的元素释放空间。策略算法主要比较元素最近一次被get使用时间。在热点数据场景下较适用，优先保证热点数据的有效性。
 
 除此之外，还有一些简单策略比如：
 
@@ -470,7 +472,8 @@ a. 成员变量或局部变量实现
 b. 静态变量实现
 
 最常用的单例实现静态资源缓存，代码示例如下：
-    
+
+
           public class CityUtils {
           private static final HttpClient httpClient = ServerHolder.createClientWithPool(); 
           private static Map<Integer, String> cityIdNameMap = new HashMap<Integer, String>();
@@ -584,11 +587,11 @@ Redis是一个远程内存数据库（非关系型数据库），性能强劲，
 
 缓存正常从Redis中获取，示意图如下：
 
-![这里写图片描述](https://img-blog.csdn.net/20180312200437182?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdTAxMDg3MDUxOA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407214616.png)
 
 缓存失效瞬间示意图如下：
 
-![这里写图片描述](https://img-blog.csdn.net/20180312200640916?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdTAxMDg3MDUxOA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230407214625.png)
 
 缓存失效时的雪崩效应对底层系统的冲击非常可怕！大多数系统设计者考虑用加锁或者队列的方式保证来保证不会有大量的线程对数据库一次性进行读写，从而避免失效时大量的并发请求落到底层存储系统上。还有一个简单方案就时讲缓存失效时间分散开，比如我们可以在原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。
 
diff --git "a/docs/distrubuted/\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\345\256\236\350\267\265\346\200\273\347\273\223.md" "b/docs/distributed/\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\345\256\236\350\267\265\346\200\273\347\273\223.md"
similarity index 84%
rename from "docs/distrubuted/\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\345\256\236\350\267\265\346\200\273\347\273\223.md"
rename to "docs/distributed/\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\345\256\236\350\267\265\346\200\273\347\273\223.md"
index 2c7c65f..8fb1dc1 100644
--- "a/docs/distrubuted/\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\345\256\236\350\267\265\346\200\273\347\273\223.md"
+++ "b/docs/distributed/\345\210\206\345\270\203\345\274\217\346\212\200\346\234\257\345\256\236\350\267\265\346\200\273\347\273\223.md"
@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
 * [分布式技术](#分布式技术)
   * [分布式数据和nosql](#分布式数据和nosql)
   * [缓存 分布式缓存](#缓存-分布式缓存)
@@ -25,26 +24,13 @@
     * [第三层 服务层来拦截（反正就是不要让请求落到数据库上去）消息队列+缓存](#第三层-服务层来拦截（反正就是不要让请求落到数据库上去）消息队列缓存)
     * [好了，最后是数据库层](#好了，最后是数据库层)
     * [总结](#总结)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-
----
-title: 分布式技术实践总结
-date: 2018-07-08 22:15:36
-tags:
-	- 分布式系统
-categories:
-	- 后端
-	- 技术总结
----
+
 本文基于之前的分布式系统理论系列文章总结而成，本部分主要是实践内容，详细内容可见我的专栏：分布式系统理论与实践
 
 https://blog.csdn.net/column/details/24090.html
 
 本文主要是按照我自己的理解以及参考之前文章综合而成的，其中可能会有一些错误，还请见谅，也请指出。
-<!-- more -->
+<!-- more -->  
 
 # 分布式技术
 
@@ -64,7 +50,7 @@ https://blog.csdn.net/column/details/24090.html
 
 3 分表分库，横向拆分数据表放到多个表中或者多个库中，一般多个表或者多个库会使用不同节点部署，也就是一种分布式方案，提高并发的读写量。
 
-Nosql的话就比较多了，redis，memcache等。
+Nosql的话就比较多了，redis，memcache等。  
 当然hbase也是，hbase按照region将数据文件分布在hdfs上，并且hdfs提供高可用和备份，同时hbase的regionserver也保证高可用，于是hbase的分布式方案也是比较成熟的。
 
 ## 缓存 分布式缓存
@@ -79,23 +65,19 @@ redis作为新兴的内存数据库，提供了比memcache更多的数据结构
 ### redis的部署方案：
 
 > 1 redis的主从复制结构，和MySQL类似，使用日志aof或者持久化文件rdb进行主从同步。
-> 
+>
 > 2 读写分离，也可以做，但一般不需要。因为redis够快。
-> 
+>
 > 3 redis的哨兵方案，主节点配置哨兵，每当宕机时自动完成主从切换。
-> 
+>
 > 4 redis的集群方案，p2p的Redis Cluster部署了多台Redis服务器，每台Redis拥有全局的分片信息，所以任意节点都可以对外提供服务，当然每个节点只保存一部分分片，所以某台机器宕机时不会影响整个集群，当然每个节点也有slave，哨兵自动进行故障切换。
-> 
+>
 > 5 codis方案，codis屏蔽了集群的内部实现，可以不更改redis api的情况下使用代理的方式提供集群访问。并且使用 group的概念封装一组节点。
 
 ### 缓存需要解决的问题：
 
-    命中：缓存有数据
-    不命中：去数据库读取
-    失效：过期
-    替换：缓存淘汰算法。
-    
-    一般有lru，fifo，随机缓存等。
+    命中：缓存有数据  
+    不命中：去数据库读取    失效：过期    替换：缓存淘汰算法。        一般有lru，fifo，随机缓存等。  
 
 ### 缓存更新的方法
 
@@ -108,9 +90,8 @@ redis作为新兴的内存数据库，提供了比memcache更多的数据结构
 
 ### 缓存在springboot中的使用
 
-    springboot支持将缓存的curd操作配置在注解中，只需要在对应方法上配置好键和更新策略。
-    
-    则redis会根据该方法的操作类型执行对应操作，非常方便。
+    springboot支持将缓存的curd操作配置在注解中，只需要在对应方法上配置好键和更新策略。  
+        则redis会根据该方法的操作类型执行对应操作，非常方便。  
 ### 一致性哈希
 
 分布式部署时，经常要面对的问题是，一个服务集群由谁来提供给这个客户度服务，需要一种算法来完成这一步映射。
@@ -120,9 +101,9 @@ redis作为新兴的内存数据库，提供了比memcache更多的数据结构
 这种方法的缺点在于，当取余的值集中在某一范围时，就容易集中访问某些机器，导致热点问题。
 
 > 于是memcache推出了一个叫做一致性哈希的算法，一个哈希环，环上支持2^32次方个节点，也就是包含了所有的ip。
-> 
+>
 > 然后我们把主机通过hash值分布到这个环上，请求到来时会映射到某一个节点，如果该节点没有主机，则顺时针寻找真正主机。
-> 
+>
 > 当节点加入或者节点删除时，并不会影响服务的可用性，只是某些请求会被映射到别的节点。
 
 但是当请求集中到某个区域时，会产生倾斜，我们引入了虚拟节点来改善这个问题，虚拟节点对应到真实节点，所以加入虚拟节点可以更好地转移请求。
@@ -130,7 +111,7 @@ redis作为新兴的内存数据库，提供了比memcache更多的数据结构
 
 ## session和分布式session
 
-session是web应用必备的一个结构。
+session是web应用必备的一个结构。  
 一般有几种方案来管理session。
 
 1 web应用保存session到内存中，但是宕机会丢失
@@ -160,50 +141,46 @@ Nginx
 七层的负载均衡也就是http负载均衡，主要使用Nginx完成。
 
 > 配置Nginx进行反向代理的url，然后转发请求到上游服务器，请求进来时自动转发到上游服务器，通过url进行负载均衡，所以是七层负载均衡。既然是七层负载，那么上游服务器提供了http服务，也可以解析该请求。
-> 
+>
 > 四层负载均衡主要是tcp请求的负载均衡，因为tcp请求是绑定到一个端口上的，所以我们根据端口进行请求转发到上游服务器的。既然是四层负载，上游服务器监听该端口的服务就可以处理该请求。
 
 LVS
 
 LVS术语定义：
 
-    DS：Director Server，前端负载均衡器节点（后文用Director称呼）；
-    
-    RS：Real Server，后端真实服务器；
-    
-    VIP：用户请求的目标的IP地址，一般是公网IP地址；
-    
-    DIP：Director Server IP，Director和Real Server通讯的内网IP地址；
-    
-    RIP：Real Server IP，Director和Real Server通讯的内网IP地址；
+    DS：Director Server，前端负载均衡器节点（后文用Director称呼）；  
+        RS：Real Server，后端真实服务器；  
+        VIP：用户请求的目标的IP地址，一般是公网IP地址；  
+        DIP：Director Server IP，Director和Real Server通讯的内网IP地址；  
+        RIP：Real Server IP，Director和Real Server通讯的内网IP地址；  
 
 LVS有三种实现负载均衡的方式
 
 NAT 四层负载均衡
 
 > NAT支持四层负载均衡，NAT中只有DS提供公网ip，并且VIP绑定在DS的mac地址上，客户端只能访问DS。同时DS和RS通过内网ip进行网络连接。当TCP数据报到达DS时，DS修改数据报，指向RS的ip和port。进行转发即可。
-> 
+>
 > 同时，RS处理完请求后，由于网关时DS，所以仍然要返回给DS处理。
-> 
-> 
+>
+>
 > NAT模式中，RS返回数据包是返回给Director，Director再返回给客户端；事实上这跟NAT网络协议没什么关系。
 
 DR 二层负载均衡
 
 
-> DR模式中，DS负责接收请求。接收请求后把数据报的mac地址改成指向RS的mac地址，并且由于三台机器拥有同样的vip地址。
+> DR模式中，DS负责接收请求。接收请求后把数据报的mac地址改成指向RS的mac地址，并且由于三台机器拥有同样的vip地址。  
 > 所以RS接收请求后认为该数据报应该由自己处理并相应。
-> 
+>
 > 同时为了避免RS再把相应转发会DS，我们禁用了对DS的arp，所以此时RS就会通过vip把响应通过vip网关返回给客户端。
-> 
-> Director通过修改请求中目标地址MAC为选定的RS实现数据转发，这就要求Diretor和Real Server必须在同一个广播域内，也就是他们的mac地址是可达的。
+>
+> Director通过修改请求中目标地址MAC为选定的RS实现数据转发，这就要求Diretor和Real Server必须在同一个广播域内，也就是他们的mac地址是可达的。  
 > DR（Direct Routing）模式中，RS返回数据是直接返回给客户端（通过额外的路由）；
-> 
+>
 
 TUN
 
 > TUN中使用了IP隧道技术，客户端请求发给DS时，DS会通过隧道技术把数据报通过隧道发给实际的RS，然后RS解析数据以后可以直接响应给客户端，因为他有客户端的ip地址。这就不要求DS和RS在同一网段了，当然前提是RS有公网ip。
-> 
+>
 > TUN（IP Tunneling）模式中，RS返回的数据也是直接返回给客户端，这种模式通过Overlay协议（把一个IP数据包封装到另一个数据包内部叫Overlay）避免了DR的限制。
 
 ## zookeeper
@@ -211,21 +188,21 @@ TUN
 zookeeper集群自身的特性：
 
 > 1 一个zookeeper服务器集群，一开始就会进行选主，主节点挂掉后也会进行选主。
-> 
+>
 > 使用zab协议中的选主机制进行选主，也就是每个节点进行一次提议，刚开始提议自己，如果有新的提议则覆盖自己原来的提议，不断重复，直到有节点获得过半的投票。完成一轮选主。
-> 
+>
 > 2 选主结束后，开始进行消息广播和数据同步，保证每一台服务器的数据都和leader同步。
-> 
+>
 > 3 开始提供服务，客户端向leader发送请求，leader首先发出提议，当有半数以上节点响应时，leader会发送commit信息，于是所有节点执行该操作。当有机器宕机时重启后会和leader同步。这是一个类似2pc的提交方式。
 
 zookeeper提供了分布式环境中常用的服务
 
 > 1 配置服务，多个机器可以通过文件节点共享配置。
-> 
+>
 > 2 选主服务，通过添加顺序节点，可以进行选主。
-> 
+>
 > 3 分布式锁，顺序节点和watcher
-> 
+>
 > 4 全局id，使用机器号+时间戳可以生成一个transactionid，是全局唯一的。
 
 
@@ -236,15 +213,15 @@ zookeeper提供了分布式环境中常用的服务
 成熟的方案有：
 
 > 1 TCC 补偿式事务，对每一个步骤都有一个补偿措施。
-> 
+>
 > 2 全局事务实现。
-> 
+>
 > 3 事务消息：rocketmq的事务实现，先发消息到队列中，然后本地执行事务并通知消息队列，若成功则消息主动推给另一个服务，直到服务二执行成功，消息从队列中删除。如果超时不成功，则消息要求事务A回滚。
-> 
+>
 > 如果过程中失败了，本地事务也会回滚。消息队列可以回调本地接口判断事务是否执行成功，防止超时。
-> 
-> 4 本地实现消息表：
-> 本地实现消息表并且和事务记录存在一起，自己实现消息的轮询发送。
+>
+> 4 本地实现消息表：  
+> 本地实现消息表并且和事务记录存在一起，自己实现消息的轮询发送。  
 > 首先把本地事务操作和消息增加放在一个事务里执行，然后轮询消息表进行发送，如果执行成功则消息达到服务B，通知其执行。执行成功后消息被删除，否则回滚事务删除消息。
 
 ## 分布式锁问题
@@ -253,23 +230,17 @@ zookeeper提供了分布式环境中常用的服务
 
 ### MySQL实现分布式锁
 
-    insert加锁，锁没有失效时间，容易产生死锁
+    insert加锁，锁没有失效时间，容易产生死锁  
 
 ### redis实现分布式锁
 
-    1. 基于setnx、expire两个命令来实现
-    
-    基于setnx（set if not exist）的特点，当缓存里key不存在时，才会去set，否则直接返回false。
-    
-    如果返回true则获取到锁，否则获取锁失败，为了防止死锁，我们再用expire命令对这个key设置一个超时时间来避免。
-    
-    但是这里看似完美，实则有缺陷，当我们setnx成功后，线程发生异常中断，expire还没来的及设置，那么就会产生死锁。
-    
-    2 使用getset实现，可以判断自己是否获得了锁，但是可能会出现并发的原子性问题。拆分成两个操作。
-    
-    3 避免原子性问题可以使用lua脚本保证事务的原子性。
-    
-    4 上述都是单点的redis，如果是分布式环境的redis集群，可以使用redlock，要求节点向半数以上redis机器请求锁。才算成功。
+    1. 基于setnx、expire两个命令来实现  
+        基于setnx（set if not exist）的特点，当缓存里key不存在时，才会去set，否则直接返回false。  
+        如果返回true则获取到锁，否则获取锁失败，为了防止死锁，我们再用expire命令对这个key设置一个超时时间来避免。  
+        但是这里看似完美，实则有缺陷，当我们setnx成功后，线程发生异常中断，expire还没来的及设置，那么就会产生死锁。  
+    2 使用getset实现，可以判断自己是否获得了锁，但是可能会出现并发的原子性问题。拆分成两个操作。  
+    3 避免原子性问题可以使用lua脚本保证事务的原子性。  
+    4 上述都是单点的redis，如果是分布式环境的redis集群，可以使用redlock，要求节点向半数以上redis机器请求锁。才算成功。  
 
 ### zookeeper实现分布式锁
 
@@ -277,25 +248,16 @@ zookeeper提供了分布式环境中常用的服务
 
 小结
 
-在分布式系统中，共享资源互斥访问问题非常普遍，而针对访问共享资源的互斥问题，常用的解决方案就是使用分布式锁，这里只介绍了几种常用的分布式锁，分布式锁的实现方式还有有很多种，根据业务选择合适的分布式锁，下面对上述几种锁进行一下比较：
-    
-    数据库锁：
-    
-    优点：直接使用数据库，使用简单。
-    
-    缺点：分布式系统大多数瓶颈都在数据库，使用数据库锁会增加数据库负担。
-    
-    缓存锁：
-    
-    优点：性能高，实现起来较为方便，在允许偶发的锁失效情况，不影响系统正常使用，建议采用缓存锁。
-    
-    缺点：通过锁超时机制不是十分可靠，当线程获得锁后，处理时间过长导致锁超时，就失效了锁的作用。
-    
-    zookeeper锁：
-    
-    优点：不依靠超时时间释放锁；可靠性高；系统要求高可靠性时，建议采用zookeeper锁。
-    
-    缺点：性能比不上缓存锁，因为要频繁的创建节点删除节点。并且zookeeper只能单点写入。而Redis可以并发写入。
+在分布式系统中，共享资源互斥访问问题非常普遍，而针对访问共享资源的互斥问题，常用的解决方案就是使用分布式锁，这里只介绍了几种常用的分布式锁，分布式锁的实现方式还有有很多种，根据业务选择合适的分布式锁，下面对上述几种锁进行一下比较：  
+数据库锁：  
+优点：直接使用数据库，使用简单。  
+缺点：分布式系统大多数瓶颈都在数据库，使用数据库锁会增加数据库负担。  
+缓存锁：  
+优点：性能高，实现起来较为方便，在允许偶发的锁失效情况，不影响系统正常使用，建议采用缓存锁。  
+缺点：通过锁超时机制不是十分可靠，当线程获得锁后，处理时间过长导致锁超时，就失效了锁的作用。  
+zookeeper锁：  
+优点：不依靠超时时间释放锁；可靠性高；系统要求高可靠性时，建议采用zookeeper锁。  
+缺点：性能比不上缓存锁，因为要频繁的创建节点删除节点。并且zookeeper只能单点写入。而Redis可以并发写入。
 
 ## 消息队列
 
@@ -344,24 +306,17 @@ kafka：
 
 
 
-    优点：
-    
-    简单，使用数据库已有的功能
-    
-    能够保证唯一性
-    
-    能够保证递增性
-    
-    步长固定
-
-
-​    
-​    
-    缺点：
-    
-    可用性难以保证：数据库常见架构是一主多从+读写分离，生成自增ID是写请求，主库挂了就玩不转了
-    
-    扩展性差，性能有上限：因为写入是单点，数据库主库的写性能决定ID的生成性能上限，并且难以扩展
+    优点：  
+        简单，使用数据库已有的功能  
+        能够保证唯一性  
+        能够保证递增性  
+        步长固定  
+  
+  
+          
+    缺点：  
+        可用性难以保证：数据库常见架构是一主多从+读写分离，生成自增ID是写请求，主库挂了就玩不转了  
+        扩展性差，性能有上限：因为写入是单点，数据库主库的写性能决定ID的生成性能上限，并且难以扩展  
 
 
 方法三：uuid/guid
@@ -425,7 +380,7 @@ uint64 ID = GenTimeMS();
 
 缺点：
 
-如果并发量超过1000，会生成重复的ID  
+如果并发量超过1000，会生成重复的ID
 
 
 方法五：类snowflake算法
@@ -446,7 +401,7 @@ snowflake是twitter开源的分布式ID生成算法，其核心思想为，一
 
 ## 秒杀系统
 
-![image](http://i2.51cto.com/images/blog/201803/11/9eda905930f00090d55b5ae3f6796d2b.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=)
+![image](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/9eda905930f00090d55b5ae3f6796d2b.png)
 
 
 ### 第一层，客户端怎么优化（浏览器层，APP层）
@@ -458,7 +413,7 @@ snowflake是twitter开源的分布式ID生成算法，其核心思想为，一
 ### 第二层，站点层面的请求拦截
 
 > 怎么拦截？怎么防止程序员写for循环调用，有去重依据么？ip？cookie-id？…想复杂了，这类业务都需要登录，用uid即可。在站点层面，对uid进行请求计数和去重，甚至不需要统一存储计数，直接站点层内存存储（这样计数会不准，但最简单）。一个uid，5秒只准透过1个请求，这样又能拦住99%的for循环请求。
-> 
+>
 > 5s只透过一个请求，其余的请求怎么办？缓存，页面缓存，同一个uid，限制访问频度，做页面缓存，x秒内到达站点层的请求，均返回同一页面。同一个item的查询，例如车次，做页面缓存，x秒内到达站点层的请求，均返回同一页面。如此限流，既能保证用户有良好的用户体验（没有返回404）又能保证系统的健壮性（利用页面缓存，把请求拦截在站点层了）。
 
 好，这个方式拦住了写for循环发http请求的程序员，有些高端程序员（黑客）控制了10w个肉鸡，手里有10w个uid，同时发请求（先不考虑实名制的问题，小米抢手机不需要实名制），这下怎么办，站点层按照uid限流拦不住了。
@@ -476,7 +431,6 @@ snowflake是twitter开源的分布式ID生成算法，其核心思想为，一
 
 如果均成功再放下一批，如果库存不够则队列里的写请求全部返回“已售完”。
 
- 
 
 对于读请求，怎么优化？cache抗，不管是memcached还是redis，单机抗个每秒10w应该都是没什么问题的。如此限流，只有非常少的写请求，和非常少的读缓存mis的请求会透到数据层去，又有99.9%的请求被拦住了。
 
@@ -488,7 +442,7 @@ snowflake是twitter开源的分布式ID生成算法，其核心思想为，一
 全部透到数据库，100w个下单，0个成功，请求有效率0%。透3k个到数据，全部成功，请求有效率100%。
 
 
-![image](http://i2.51cto.com/images/blog/201803/11/bf7107f82e635020a43f12aa4a8dc856.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=)
+![image](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/bf7107f82e635020a43f12aa4a8dc856.png)
 
 ### 总结
 上文应该描述的非常清楚了，没什么总结了，对于秒杀系统，再次重复下我个人经验的两个架构优化思路：
@@ -517,12 +471,11 @@ snowflake是twitter开源的分布式ID生成算法，其核心思想为，一
 
 **Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
 
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
+![我的公众号](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20190805090108984.jpg)
 
 ### 个人公众号：黄小斜
 
 作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
 
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
+**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。      
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20190829222750556.jpg)
\ No newline at end of file
diff --git "a/docs/distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272\346\200\273\347\273\223.md" "b/docs/distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272\346\200\273\347\273\223.md"
new file mode 100644
index 0000000..9e341f3
--- /dev/null
+++ "b/docs/distributed/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272\346\200\273\347\273\223.md"
@@ -0,0 +1,75 @@
+# 目录
+
+  * [六、Raft](#六、raft)
+    * [单个 Candidate 的竞选](#单个-candidate-的竞选)
+    * [多个 Candidate 竞选](#多个-candidate-竞选)
+    * [数据同步](#数据同步)
+  * [参考](#参考)
+
+
+## 六、Raft
+
+Raft 也是分布式一致性协议，主要是用来竞选主节点。
+
+*   [Raft: Understandable Distributed Consensus](http://thesecretlivesofdata.com/raft)
+
+### 单个 Candidate 的竞选
+
+有三种节点：Follower、Candidate 和 Leader。Leader 会周期性的发送心跳包给 Follower。每个 Follower 都设置了一个随机的竞选超时时间，一般为 150ms~300ms，如果在这个时间内没有收到 Leader 的心跳包，就会变成 Candidate，进入竞选阶段。
+
+*   下图展示一个分布式系统的最初阶段，此时只有 Follower 没有 Leader。Node A 等待一个随机的竞选超时时间之后，没收到 Leader 发来的心跳包，因此进入竞选阶段。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/68747470733a2f2f63732d6e6f7465732d313235363130393739362e636f732e61702d6775616e677a686f752e6d7971636c6f75642e636f6d2f3131313532313131383031353839382e676966%20(1).gif)
+
+*   此时 Node A 发送投票请求给其它所有节点。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/68747470733a2f2f63732d6e6f7465732d313235363130393739362e636f732e61702d6775616e677a686f752e6d7971636c6f75642e636f6d2f3131313532313131383434353533382e676966.gif)
+
+*   其它节点会对请求进行回复，如果超过一半的节点回复了，那么该 Candidate 就会变成 Leader。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/68747470733a2f2f63732d6e6f7465732d313235363130393739362e636f732e61702d6775616e677a686f752e6d7971636c6f75642e636f6d2f3131313532313131383438333033392e676966.gif)
+
+*   之后 Leader 会周期性地发送心跳包给 Follower，Follower 接收到心跳包，会重新开始计时。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/68747470733a2f2f63732d6e6f7465732d313235363130393739362e636f732e61702d6775616e677a686f752e6d7971636c6f75642e636f6d2f3131313532313131383634303733382e676966.gif)
+
+### 多个 Candidate 竞选
+
+*   如果有多个 Follower 成为 Candidate，并且所获得票数相同，那么就需要重新开始投票。例如下图中 Node B 和 Node D 都获得两票，需要重新开始投票。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/68747470733a2f2f63732d6e6f7465732d313235363130393739362e636f732e61702d6775616e677a686f752e6d7971636c6f75642e636f6d2f3131313532313131393230333334372e676966.gif)
+
+*   由于每个节点设置的随机竞选超时时间不同，因此下一次再次出现多个 Candidate 并获得同样票数的概率很低。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/68747470733a2f2f63732d6e6f7465732d313235363130393739362e636f732e61702d6775616e677a686f752e6d7971636c6f75642e636f6d2f3131313532313131393336383731342e676966.gif)
+
+### 数据同步
+
+*   来自客户端的修改都会被传入 Leader。注意该修改还未被提交，只是写入日志中。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/68747470733a2f2f63732d6e6f7465732d313235363130393739362e636f732e61702d6775616e677a686f752e6d7971636c6f75642e636f6d2f37313535303431343130373537362e676966.gif)
+
+*   Leader 会把修改复制到所有 Follower。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/68747470733a2f2f63732d6e6f7465732d313235363130393739362e636f732e61702d6775616e677a686f752e6d7971636c6f75642e636f6d2f39313535303431343133313333312e676966.gif)
+
+*   Leader 会等待大多数的 Follower 也进行了修改，然后才将修改提交。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/68747470733a2f2f63732d6e6f7465732d313235363130393739362e636f732e61702d6775616e677a686f752e6d7971636c6f75642e636f6d2f39313535303431343133313333312e676966.gif)
+
+*   此时 Leader 会通知的所有 Follower 让它们也提交修改，此时所有节点的值达成一致。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/68747470733a2f2f63732d6e6f7465732d313235363130393739362e636f732e61702d6775616e677a686f752e6d7971636c6f75642e636f6d2f39313535303431343133313333312e676966.gif)
+
+## 参考
+
+- 倪超. 从 Paxos 到 ZooKeeper : 分布式一致性原理与实践 [M]. 电子工业出版社, 2015.
+- [Distributed locks with Redis](https://redis.io/topics/distlock)
+- [浅谈分布式锁](http://www.linkedkeeper.com/detail/blog.action?bid=1023)
+- [基于 Zookeeper 的分布式锁](http://www.dengshenyu.com/java/分布式系统/2017/10/23/zookeeper-distributed-lock.html)
+- [聊聊分布式事务，再说说解决方案](https://www.cnblogs.com/savorboard/p/distributed-system-transaction-consistency.html)
+- [分布式系统的事务处理](https://coolshell.cn/articles/10910.html)
+- [深入理解分布式事务](https://juejin.im/entry/577c6f220a2b5800573492be)
+- [What is CAP theorem in distributed database system?](http://www.colooshiki.com/index.php/2017/04/20/what-is-cap-theorem-in-distributed-database-system/)
+- [NEAT ALGORITHMS - PAXOS](http://harry.me/blog/2014/12/27/neat-algorithms-paxos/)
+- [Paxos By Example](https://angus.nyc/2012/paxos-by-example/)
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25718\357\274\232\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241\345\270\270\347\224\250\350\247\243\345\206\263\346\226\271\346\241\210.md" "b/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25718\357\274\232\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241\345\270\270\347\224\250\350\247\243\345\206\263\346\226\271\346\241\210.md"
deleted file mode 100644
index 6458851..0000000
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\25718\357\274\232\345\210\206\345\270\203\345\274\217\344\272\213\345\212\241\345\270\270\347\224\250\350\247\243\345\206\263\346\226\271\346\241\210.md"
+++ /dev/null
@@ -1,233 +0,0 @@
-# Table of Contents
-
-  * [分布式事务的解决方案](#分布式事务的解决方案)
-    * [方案1：全局事务（DTP模型）](#方案1：全局事务（dtp模型）)
-    * [实际方案：基于XA协议的两阶段提交](#实际方案：基于xa协议的两阶段提交)
-    * [方案2：基于可靠消息服务的分布式事务（事务消息中间件）](#方案2：基于可靠消息服务的分布式事务（事务消息中间件）)
-    * [方案3：最大努力通知（定期校对）也叫本地消息表](#方案3：最大努力通知（定期校对）也叫本地消息表)
-    * [方案4：TCC（两阶段型、补偿型）](#方案4：tcc（两阶段型、补偿型）)
-    * [[](http://wuwenliang.net/2017/03/25/%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1%E4%B9%8B%E8%81%8A%E8%81%8ATCC/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#TCC%E7%9A%84%E6%9C%BA%E5%88%B6 "TCC的机制")TCC的机制](#[]httpwuwenliangnet20170325e58886e5b883e5bc8fe4ba8be58aa1e4b98be8818ae8818atcchmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoiotcce79a84e69cbae588b6-tcc的机制tcc的机制)
-    * [[](http://wuwenliang.net/2017/03/25/%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1%E4%B9%8B%E8%81%8A%E8%81%8ATCC/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E4%B8%80%E4%B8%AA%E5%AE%8C%E6%95%B4%E7%9A%84TCC%E4%BA%8B%E5%8A%A1%E5%8F%82%E4%B8%8E%E6%96%B9%E5%8C%85%E6%8B%AC%E4%B8%89%E9%83%A8%E5%88%86%EF%BC%9A "一个完整的TCC事务参与方包括三部分：")一个完整的TCC事务参与方包括三部分：](#[]httpwuwenliangnet20170325e58886e5b883e5bc8fe4ba8be58aa1e4b98be8818ae8818atcchmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioe4b880e4b8aae5ae8ce695b4e79a84tcce4ba8be58aa1e58f82e4b88ee696b9e58c85e68bace4b889e983a8e58886efbc9a-一个完整的tcc事务参与方包括三部分：一个完整的tcc事务参与方包括三部分：)
-    * [[](http://wuwenliang.net/2017/03/25/%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1%E4%B9%8B%E8%81%8A%E8%81%8ATCC/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#TCC%E7%9A%84%E4%BC%98%E7%82%B9%E5%92%8C%E9%99%90%E5%88%B6 "TCC的优点和限制")TCC的优点和限制](#[]httpwuwenliangnet20170325e58886e5b883e5bc8fe4ba8be58aa1e4b98be8818ae8818atcchmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoiotcce79a84e4bc98e782b9e5928ce99990e588b6-tcc的优点和限制tcc的优点和限制)
-    * [[](http://wuwenliang.net/2017/03/25/%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1%E4%B9%8B%E8%81%8A%E8%81%8ATCC/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E4%B8%80%E4%B8%AA%E6%A1%88%E4%BE%8B%E7%90%86%E8%A7%A3 "一个案例理解")一个案例理解](#[]httpwuwenliangnet20170325e58886e5b883e5bc8fe4ba8be58aa1e4b98be8818ae8818atcchmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioe4b880e4b8aae6a188e4be8be79086e8a7a3-一个案例理解一个案例理解)
-
-
-本文转载自 linkedkeeper.com
-
-本文内容参考网络，侵删
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-本文也将同步到我的个人博客：
-> www.how2playlife.com
-
-更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
-
-该系列博文会告诉你什么是分布式系统，这对后端工程师来说是很重要的一门学问，我们会逐步了解常见的分布式技术、以及一些较为常见的分布式系统概念，同时也需要进一步了解zookeeper、分布式事务、分布式锁、负载均衡等技术，以便让你更完整地了解分布式技术的具体实战方法，为真正应用分布式技术做好准备。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-## 分布式事务的解决方案
-
-分布式事务的解决方案有如下几种：
-
-*   全局消息
-*   基于可靠消息服务的分布式事务
-*   TCC
-*   最大努力通知
-
-### 方案1：全局事务（DTP模型）
-
-全局事务基于DTP模型实现。DTP是由X/Open组织提出的一种分布式事务模型——X/Open Distributed Transaction Processing Reference Model。它规定了要实现分布式事务，需要三种角色：
-
-*   AP：Application 应用系统它就是我们开发的业务系统，在我们开发的过程中，可以使用资源管理器提供的事务接口来实现分布式事务。
-
-*   TM：Transaction Manager 事务管理器
-
-    *   分布式事务的实现由事务管理器来完成，它会提供分布式事务的操作接口供我们的业务系统调用。这些接口称为TX接口。
-    *   事务管理器还管理着所有的资源管理器，通过它们提供的XA接口来同一调度这些资源管理器，以实现分布式事务。
-    *   DTP只是一套实现分布式事务的规范，并没有定义具体如何实现分布式事务，TM可以采用2PC、3PC、Paxos等协议实现分布式事务。
-*   RM：Resource Manager 资源管理器
-
-    *   能够提供数据服务的对象都可以是资源管理器，比如：数据库、消息中间件、缓存等。大部分场景下，数据库即为分布式事务中的资源管理器。
-    *   资源管理器能够提供单数据库的事务能力，它们通过XA接口，将本数据库的提交、回滚等能力提供给事务管理器调用，以帮助事务管理器实现分布式的事务管理。
-    *   XA是DTP模型定义的接口，用于向事务管理器提供该资源管理器(该数据库)的提交、回滚等能力。
-    *   DTP只是一套实现分布式事务的规范，RM具体的实现是由数据库厂商来完成的。
-
-### 实际方案：基于XA协议的两阶段提交
-
-XA是一个分布式事务协议，由Tuxedo提出。XA中大致分为两部分：事务管理器和本地资源管理器。其中本地资源管理器往往由数据库实现，比如Oracle、DB2这些商业数据库都实现了XA接口，而事务管理器作为全局的调度者，负责各个本地资源的提交和回滚。XA实现分布式事务的原理如下：
-
-![](http://static.codeceo.com/images/2016/07/distri-trans-03.png "distri-trans-03")
-
-总的来说，XA协议比较简单，而且一旦商业数据库实现了XA协议，使用分布式事务的成本也比较低。但是，XA也有致命的缺点，那就是性能不理想，特别是在交易下单链路，往往并发量很高，XA无法满足高并发场景。XA目前在商业数据库支持的比较理想，在mysql数据库中支持的不太理想，mysql的XA实现，没有记录prepare阶段日志，主备切换回导致主库与备库数据不一致。许多nosql也没有支持XA，这让XA的应用场景变得非常狭隘。
-
-### 方案2：基于可靠消息服务的分布式事务（事务消息中间件）
-
-这种实现分布式事务的方式需要通过消息中间件来实现。假设有A和B两个系统，分别可以处理任务A和任务B。此时系统A中存在一个业务流程，需要将任务A和任务B在同一个事务中处理。下面来介绍基于消息中间件来实现这种分布式事务。
-
-![title](https://user-gold-cdn.xitu.io/2018/3/10/1620fc30782107d1?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-*   在系统A处理任务A前，首先向消息中间件发送一条消息
-*   消息中间件收到后将该条消息持久化，但并不投递。此时下游系统B仍然不知道该条消息的存在。
-*   消息中间件持久化成功后，便向系统A返回一个确认应答；
-*   系统A收到确认应答后，则可以开始处理任务A；
-*   任务A处理完成后，向消息中间件发送Commit请求。该请求发送完成后，对系统A而言，该事务的处理过程就结束了，此时它可以处理别的任务了。但commit消息可能会在传输途中丢失，从而消息中间件并不会向系统B投递这条消息，从而系统就会出现不一致性。这个问题由消息中间件的事务回查机制完成，下文会介绍。
-*   消息中间件收到Commit指令后，便向系统B投递该消息，从而触发任务B的执行；
-*   当任务B执行完成后，系统B向消息中间件返回一个确认应答，告诉消息中间件该消息已经成功消费，此时，这个分布式事务完成。
-
-> 上述过程可以得出如下几个结论：
-
-1.  消息中间件扮演者分布式事务协调者的角色。
-2.  系统A完成任务A后，到任务B执行完成之间，会存在一定的时间差。在这个时间差内，整个系统处于数据不一致的状态，但这短暂的不一致性是可以接受的，因为经过短暂的时间后，系统又可以保持数据一致性，满足BASE理论。
-
-上述过程中，如果任务A处理失败，那么需要进入回滚流程，如下图所示：
-
-![title](https://user-gold-cdn.xitu.io/2018/3/10/1620fc307be6c55d?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-*   若系统A在处理任务A时失败，那么就会向消息中间件发送Rollback请求。和发送Commit请求一样，系统A发完之后便可以认为回滚已经完成，它便可以去做其他的事情。
-*   消息中间件收到回滚请求后，直接将该消息丢弃，而不投递给系统B，从而不会触发系统B的任务B。
-
-> 此时系统又处于一致性状态，因为任务A和任务B都没有执行。
-
-上面所介绍的Commit和Rollback都属于理想情况，但在实际系统中，Commit和Rollback指令都有可能在传输途中丢失。那么当出现这种情况的时候，消息中间件是如何保证数据一致性呢？——答案就是超时询问机制。
-
-![title](https://user-gold-cdn.xitu.io/2018/3/10/1620fc307c2d185e?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-系统A除了实现正常的业务流程外，还需提供一个事务询问的接口，供消息中间件调用。当消息中间件收到一条事务型消息后便开始计时，如果到了超时时间也没收到系统A发来的Commit或Rollback指令的话，就会主动调用系统A提供的事务询问接口询问该系统目前的状态。该接口会返回三种结果：
-
-*   提交若获得的状态是“提交”，则将该消息投递给系统B。
-*   回滚若获得的状态是“回滚”，则直接将条消息丢弃。
-*   处理中若获得的状态是“处理中”，则继续等待。
-
-> 消息中间件的超时询问机制能够防止上游系统因在传输过程中丢失Commit/Rollback指令而导致的系统不一致情况，而且能降低上游系统的阻塞时间，上游系统只要发出Commit/Rollback指令后便可以处理其他任务，无需等待确认应答。而Commit/Rollback指令丢失的情况通过超时询问机制来弥补，这样大大降低上游系统的阻塞时间，提升系统的并发度。
-
-下面来说一说消息投递过程的可靠性保证。当上游系统执行完任务并向消息中间件提交了Commit指令后，便可以处理其他任务了，此时它可以认为事务已经完成，接下来消息中间件**一定会保证消息被下游系统成功消费掉！**那么这是怎么做到的呢？这由消息中间件的投递流程来保证。
-
-消息中间件向下游系统投递完消息后便进入阻塞等待状态，下游系统便立即进行任务的处理，任务处理完成后便向消息中间件返回应答。消息中间件收到确认应答后便认为该事务处理完毕！
-
-如果消息在投递过程中丢失，或消息的确认应答在返回途中丢失，那么消息中间件在等待确认应答超时之后就会重新投递，直到下游消费者返回消费成功响应为止。当然，一般消息中间件可以设置消息重试的次数和时间间隔，比如：当第一次投递失败后，每隔五分钟重试一次，一共重试3次。如果重试3次之后仍然投递失败，那么这条消息就需要人工干预。
-
-![title](https://user-gold-cdn.xitu.io/2018/3/10/1620fc3078194980?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)![title](https://user-gold-cdn.xitu.io/2018/3/10/1620fc308ece8d2a?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-> 有的同学可能要问：消息投递失败后为什么不回滚消息，而是不断尝试重新投递？
-
-这就涉及到整套分布式事务系统的实现成本问题。我们知道，当系统A将向消息中间件发送Commit指令后，它便去做别的事情了。如果此时消息投递失败，需要回滚的话，就需要让系统A事先提供回滚接口，这无疑增加了额外的开发成本，业务系统的复杂度也将提高。对于一个业务系统的设计目标是，在保证性能的前提下，最大限度地降低系统复杂度，从而能够降低系统的运维成本。
-
-> 不知大家是否发现，上游系统A向消息中间件提交Commit/Rollback消息采用的是异步方式，也就是当上游系统提交完消息后便可以去做别的事情，接下来提交、回滚就完全交给消息中间件来完成，并且完全信任消息中间件，认为它一定能正确地完成事务的提交或回滚。然而，消息中间件向下游系统投递消息的过程是同步的。也就是消息中间件将消息投递给下游系统后，它会阻塞等待，等下游系统成功处理完任务返回确认应答后才取消阻塞等待。为什么这两者在设计上是不一致的呢？
-
-首先，上游系统和消息中间件之间采用异步通信是为了提高系统并发度。业务系统直接和用户打交道，用户体验尤为重要，因此这种异步通信方式能够极大程度地降低用户等待时间。此外，异步通信相对于同步通信而言，没有了长时间的阻塞等待，因此系统的并发性也大大增加。但异步通信可能会引起Commit/Rollback指令丢失的问题，这就由消息中间件的超时询问机制来弥补。
-
-那么，消息中间件和下游系统之间为什么要采用同步通信呢？
-
-异步能提升系统性能，但随之会增加系统复杂度；而同步虽然降低系统并发度，但实现成本较低。因此，在对并发度要求不是很高的情况下，或者服务器资源较为充裕的情况下，我们可以选择同步来降低系统的复杂度。我们知道，消息中间件是一个独立于业务系统的第三方中间件，它不和任何业务系统产生直接的耦合，它也不和用户产生直接的关联，它一般部署在独立的服务器集群上，具有良好的可扩展性，所以不必太过于担心它的性能，如果处理速度无法满足我们的要求，可以增加机器来解决。而且，即使消息中间件处理速度有一定的延迟那也是可以接受的，因为前面所介绍的BASE理论就告诉我们了，我们追求的是最终一致性，而非实时一致性，因此消息中间件产生的时延导致事务短暂的不一致是可以接受的。
-
-### 方案3：最大努力通知（定期校对）也叫本地消息表
-
-最大努力通知也被称为定期校对，其实在方案二中已经包含，这里再单独介绍，主要是为了知识体系的完整性。这种方案也需要消息中间件的参与，其过程如下：
-
-![title](https://user-gold-cdn.xitu.io/2018/3/10/1620fc307c59ccfa?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)
-
-*   上游系统在完成任务后，向消息中间件同步地发送一条消息，确保消息中间件成功持久化这条消息，然后上游系统可以去做别的事情了；
-*   消息中间件收到消息后负责将该消息同步投递给相应的下游系统，并触发下游系统的任务执行；
-*   当下游系统处理成功后，向消息中间件反馈确认应答，消息中间件便可以将该条消息删除，从而该事务完成。
-
-上面是一个理想化的过程，但在实际场景中，往往会出现如下几种意外情况：
-
-1.  消息中间件向下游系统投递消息失败
-2.  上游系统向消息中间件发送消息失败
-
-对于第一种情况，消息中间件具有重试机制，我们可以在消息中间件中设置消息的重试次数和重试时间间隔，对于网络不稳定导致的消息投递失败的情况，往往重试几次后消息便可以成功投递，如果超过了重试的上限仍然投递失败，那么消息中间件不再投递该消息，而是记录在失败消息表中，消息中间件需要提供失败消息的查询接口，下游系统会定期查询失败消息，并将其消费，这就是所谓的“定期校对”。
-
-如果重复投递和定期校对都不能解决问题，往往是因为下游系统出现了严重的错误，此时就需要人工干预。
-
-对于第二种情况，需要在上游系统中建立消息重发机制。可以在上游系统建立一张本地消息表，并将 **任务处理过程** 和 **向本地消息表中插入消息** 这两个步骤放在一个本地事务中完成。如果向本地消息表插入消息失败，那么就会触发回滚，之前的任务处理结果就会被取消。如果这量步都执行成功，那么该本地事务就完成了。接下来会有一个专门的消息发送者不断地发送本地消息表中的消息，如果发送失败它会返回重试。当然，也要给消息发送者设置重试的上限，一般而言，达到重试上限仍然发送失败，那就意味着消息中间件出现严重的问题，此时也只有人工干预才能解决问题。
-
-对于不支持事务型消息的消息中间件，如果要实现分布式事务的话，就可以采用这种方式。它能够通过**重试机制**+**定期校对**实现分布式事务，但相比于第二种方案，它达到数据一致性的周期较长，而且还需要在上游系统中实现消息重试发布机制，以确保消息成功发布给消息中间件，这无疑增加了业务系统的开发成本，使得业务系统不够纯粹，并且这些额外的业务逻辑无疑会占用业务系统的硬件资源，从而影响性能。
-
-因此，尽量选择支持事务型消息的消息中间件来实现分布式事务，如RocketMQ。
-
-### 方案4：TCC（两阶段型、补偿型）
-
-
-
-跨应用的业务操作原子性要求，其实是比较常见的。比如在第三方支付场景中的组合支付，用户在电商网站购物后，要同时使用余额和
-红包支付该笔订单，而余额系统和红包系统分别是不同的应用系统，支付系统在调用这两个系统进行支付时，就需要保证余额扣减和红
-包使用要么同时成功，要么同时失败。
-
-TCC事务的出现正是为了解决应用拆分带来的跨应用业务操作原子性的问题。当然，由于常规的XA事务(2PC，2 Phase Commit, 两阶段提交)
-性能上不尽如人意，也有通过TCC事务来解决数据库拆分的使用场景(如账务拆分)，这个本文后续部分再详述。
-
-故从整个系统架构的角度来看，分布式事务的不同方案是存在层次结构的。
-
-### [](http://wuwenliang.net/2017/03/25/%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1%E4%B9%8B%E8%81%8A%E8%81%8ATCC/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#TCC%E7%9A%84%E6%9C%BA%E5%88%B6 "TCC的机制")TCC的机制
-
-明眼一看就知道，TCC应该是三个英文单词的首字母缩写而来。没错，TCC分别对应Try、Confirm和Cancel三种操作，
-这三种操作的业务含义如下：
-
-```
-Try：预留业务资源Confirm：确认执行业务操作Cancel：取消执行业务操作
-```
-
-稍稍对照下关系型数据库事务的三种操作：DML、Commit和Rollback，会发现和TCC有异曲同工之妙。在一个跨应用的业务操作中，
-Try操作是先把多个应用中的业务资源预留和锁定住，为后续的确认打下基础，类似的，DML操作要锁定数据库记录行，持有数据库资源；
-Confirm操作是在Try操作中涉及的所有应用均成功之后进行确认，使用预留的业务资源，和Commit类似；
-而Cancel则是当Try操作中涉及的所有应用没有全部成功，需要将已成功的应用进行取消(即Rollback回滚)。
-其中Confirm和Cancel操作是一对反向业务操作。
-
-简而言之，TCC是应用层的2PC(2 Phase Commit, 两阶段提交)，如果你将应用看做资源管理器的话。
-详细来说，TCC每项操作需要做的事情如下：
-
-1、Try：尝试执行业务。
-完成所有业务检查(一致性)
-预留必须业务资源(准隔离性)
-2、Confirm：确认执行业务。
-真正执行业务
-不做任何业务检查
-只使用Try阶段预留的业务资源
-3、Cancel：取消执行业务
-释放Try阶段预留的业务资源
-
-### [](http://wuwenliang.net/2017/03/25/%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1%E4%B9%8B%E8%81%8A%E8%81%8ATCC/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E4%B8%80%E4%B8%AA%E5%AE%8C%E6%95%B4%E7%9A%84TCC%E4%BA%8B%E5%8A%A1%E5%8F%82%E4%B8%8E%E6%96%B9%E5%8C%85%E6%8B%AC%E4%B8%89%E9%83%A8%E5%88%86%EF%BC%9A "一个完整的TCC事务参与方包括三部分：")一个完整的TCC事务参与方包括三部分：
-
-主业务服务：主业务服务为整个业务活动的发起方，如前面提到的组合支付场景，支付系统即是主业务服务。
-从业务服务：从业务服务负责提供TCC业务操作，是整个业务活动的操作方。从业务服务必须实现Try、Confirm和Cancel三个接口，
-供主业务服务调用。
-由于Confirm和Cancel操作可能被重复调用，故要求Confirm和Cancel两个接口必须是幂等的。前面的组合支付场景中的余额系统和
-红包系统即为从业务服务。
-业务活动管理器：业务活动管理器管理控制整个业务活动，包括记录维护TCC全局事务的事务状态和每个从业务服务的子事务状态，并在业务活动提交时确认所有的TCC型操作的confirm操作，在业务活动取消时调用所有TCC型操作的cancel操作。
-可见整个TCC事务对于主业务服务来说是透明的，其中业务活动管理器和从业务服务各自干了一部分工作。
-
-### [](http://wuwenliang.net/2017/03/25/%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1%E4%B9%8B%E8%81%8A%E8%81%8ATCC/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#TCC%E7%9A%84%E4%BC%98%E7%82%B9%E5%92%8C%E9%99%90%E5%88%B6 "TCC的优点和限制")TCC的优点和限制
-
-TCC事务的优点如下：
-解决了跨应用业务操作的原子性问题，在诸如组合支付、账务拆分场景非常实用。
-TCC实际上把数据库层的二阶段提交上提到了应用层来实现，对于数据库来说是一阶段提交，规避了数据库层的2PC性能低下问题。
-
-TCC事务的缺点，主要就一个：
-TCC的Try、Confirm和Cancel操作功能需业务提供，开发成本高。
-当然，对TCC事务的这个缺点是否是缺点，是一个见仁见智的事情。
-
-### [](http://wuwenliang.net/2017/03/25/%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1%E4%B9%8B%E8%81%8A%E8%81%8ATCC/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E4%B8%80%E4%B8%AA%E6%A1%88%E4%BE%8B%E7%90%86%E8%A7%A3 "一个案例理解")一个案例理解
-
-TCC说实话，TCC的理论有点让人费解。故接下来将以账务拆分为例，对TCC事务的流程做一个描述，希望对理解TCC有所帮助。
-账务拆分的业务场景如下，分别位于三个不同分库的帐户A、B、C，A和B一起向C转帐共80元：分布式事务之说说TCC事务
-
-1、Try：尝试执行业务。
-完成所有业务检查(一致性)：检查A、B、C的帐户状态是否正常，帐户A的余额是否不少于30元，帐户B的余额是否不少于50元。
-预留必须业务资源(准隔离性)：帐户A的冻结金额增加30元，帐户B的冻结金额增加50元，这样就保证不会出现其他并发进程扣减
-了这两个帐户的余额而导致在后续的真正转帐操作过程中，帐户A和B的可用余额不够的情况。
-
-2、Confirm：确认执行业务。
-真正执行业务：如果Try阶段帐户A、B、C状态正常，且帐户A、B余额够用，则执行帐户A给账户C转账30元、帐户B给账户C转账50元的
-转帐操作。
-不做任何业务检查：这时已经不需要做业务检查，Try阶段已经完成了业务检查。
-只使用Try阶段预留的业务资源：只需要使用Try阶段帐户A和帐户B冻结的金额即可。
-
-3、Cancel：取消执行业务
-释放Try阶段预留的业务资源：如果Try阶段部分成功，比如帐户A的余额够用，且冻结相应金额成功，帐户B的余额不够而冻结失败，则需要对帐户A做Cancel操作，将帐户A被冻结的金额解冻掉。
diff --git "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2574\357\274\232ZAB\345\215\217\350\256\256\346\246\202\350\277\260\344\270\216\351\200\211\344\270\273\346\265\201\347\250\213\350\257\246\350\247\243.md" "b/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2574\357\274\232ZAB\345\215\217\350\256\256\346\246\202\350\277\260\344\270\216\351\200\211\344\270\273\346\265\201\347\250\213\350\257\246\350\247\243.md"
deleted file mode 100644
index 562ebcb..0000000
--- "a/docs/distrubuted/practice/\346\220\236\346\207\202\345\210\206\345\270\203\345\274\217\346\212\200\346\234\2574\357\274\232ZAB\345\215\217\350\256\256\346\246\202\350\277\260\344\270\216\351\200\211\344\270\273\346\265\201\347\250\213\350\257\246\350\247\243.md"
+++ /dev/null
@@ -1,601 +0,0 @@
-# Table of Contents
-
-  * [ZAB协议](#zab协议)
-  * [消息广播模式](#消息广播模式)
-  * [崩溃恢复](#崩溃恢复)
-    * [数据同步](#数据同步)
-  * [ZAB协议原理](#zab协议原理)
-  * [Zookeeper设计目标](#zookeeper设计目标)
-* [ZAB与FastLeaderElection选主算法流程详解](#zab与fastleaderelection选主算法流程详解)
-  * [选择机制中的概念](#选择机制中的概念)
-    * [服务器ID](#服务器id)
-    * [数据ID](#数据id)
-    * [逻辑时钟](#逻辑时钟)
-    * [选举状态](#选举状态)
-  * [选举消息内容](#选举消息内容)
-  * [选举流程图](#选举流程图)
-  * [源码分析](#源码分析)
-    * [QuorumPeer](#quorumpeer)
-    * [FastLeaderElection](#fastleaderelection)
-    * [判断是否已经胜出](#判断是否已经胜出)
-  * [选举流程简述](#选举流程简述)
-  * [[](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E5%87%A0%E7%A7%8D%E9%A2%86%E5%AF%BC%E9%80%89%E4%B8%BE%E5%9C%BA%E6%99%AF "几种领导选举场景")几种领导选举场景](#[]httpwwwjasongjcomzookeeperfastleaderelectionhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioe587a0e7a78de9a286e5afbce98089e4b8bee59cbae699af-几种领导选举场景几种领导选举场景)
-    * [[](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E9%9B%86%E7%BE%A4%E5%90%AF%E5%8A%A8%E9%A2%86%E5%AF%BC%E9%80%89%E4%B8%BE "集群启动领导选举")集群启动领导选举](#[]httpwwwjasongjcomzookeeperfastleaderelectionhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioe99b86e7bea4e590afe58aa8e9a286e5afbce98089e4b8be-集群启动领导选举集群启动领导选举)
-    * [[](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#Follower%E9%87%8D%E5%90%AF "Follower重启")Follower重启](#[]httpwwwjasongjcomzookeeperfastleaderelectionhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoiofollowere9878de590af-follower重启follower重启)
-    * [[](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#Leader%E9%87%8D%E5%90%AF "Leader重启")Leader重启](#[]httpwwwjasongjcomzookeeperfastleaderelectionhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioleadere9878de590af-leader重启leader重启)
-* [[](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E4%B8%80%E8%87%B4%E6%80%A7%E4%BF%9D%E8%AF%81 "一致性保证")一致性保证](#[]httpwwwjasongjcomzookeeperfastleaderelectionhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioe4b880e887b4e680a7e4bf9de8af81-一致性保证一致性保证)
-  * [[](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#Commit%E8%BF%87%E7%9A%84%E6%95%B0%E6%8D%AE%E4%B8%8D%E4%B8%A2%E5%A4%B1 "Commit过的数据不丢失")Commit过的数据不丢失](#[]httpwwwjasongjcomzookeeperfastleaderelectionhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoiocommite8bf87e79a84e695b0e68daee4b88de4b8a2e5a4b1-commit过的数据不丢失commit过的数据不丢失)
-  * [[](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E6%9C%AACommit%E8%BF%87%E7%9A%84%E6%B6%88%E6%81%AF%E5%AF%B9%E5%AE%A2%E6%88%B7%E7%AB%AF%E4%B8%8D%E5%8F%AF%E8%A7%81 "未Commit过的消息对客户端不可见")未Commit过的消息对客户端不可见](#[]httpwwwjasongjcomzookeeperfastleaderelectionhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioe69caacommite8bf87e79a84e6b688e681afe5afb9e5aea2e688b7e7abafe4b88de58fafe8a781-未commit过的消息对客户端不可见未commit过的消息对客户端不可见)
-* [[](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E6%80%BB%E7%BB%93 "总结")总结](#[]httpwwwjasongjcomzookeeperfastleaderelectionhmsrtoutiaoioutm_mediumtoutiaoioutm_sourcetoutiaoioe680bbe7bb93-总结总结)
-
-
-本文内容参考网络，侵删
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-本文也将同步到我的个人博客：
-> www.how2playlife.com
-
-更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
-
-该系列博文会告诉你什么是分布式系统，这对后端工程师来说是很重要的一门学问，我们会逐步了解常见的分布式技术、以及一些较为常见的分布式系统概念，同时也需要进一步了解zookeeper、分布式事务、分布式锁、负载均衡等技术，以便让你更完整地了解分布式技术的具体实战方法，为真正应用分布式技术做好准备。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-## ZAB协议
-
-1.  ZAB协议是专门为zookeeper实现分布式协调功能而设计。zookeeper主要是根据ZAB协议是实现分布式系统数据一致性。
-2.  zookeeper根据ZAB协议建立了主备模型完成zookeeper集群中数据的同步。这里所说的主备系统架构模型是指，在zookeeper集群中，只有一台leader负责处理外部客户端的事物请求(或写操作)，然后leader服务器将客户端的写操作数据同步到所有的follower节点中。 
-    ![这里写图片描述](https://img-blog.csdn.net/20170825170158491?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvanVuY2hlbmJiMDQzMA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
-3.  ZAB的协议核心是在整个zookeeper集群中只有一个节点即Leader将客户端的写操作转化为事物(或提议proposal)。Leader节点再数据写完之后，将向所有的follower节点发送数据广播请求(或数据复制)，等待所有的follower节点反馈。在ZAB协议中，只要超过半数follower节点反馈OK，Leader节点就会向所有的follower服务器发送commit消息。即将leader节点上的数据同步到follower节点之上。 
-    ![这里写图片描述](https://img-blog.csdn.net/20170825173220443?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvanVuY2hlbmJiMDQzMA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
-4.  ZAB协议中主要有两种模式，第一是消息广播模式；第二是崩溃恢复模式
-
-## 消息广播模式
-
-1.  在zookeeper集群中数据副本的传递策略就是采用消息广播模式。zookeeper中数据副本的同步方式与二阶段提交相似但是却又不同。二阶段提交的要求协调者必须等到所有的参与者全部反馈ACK确认消息后，再发送commit消息。要求所有的参与者要么全部成功要么全部失败。二阶段提交会产生严重阻塞问题。
-2.  ZAB协议中Leader等待follower的ACK反馈是指”只要半数以上的follower成功反馈即可，不需要收到全部follower反馈”
-3.  图中展示了消息广播的具体流程图 
-    ![这里写图片描述](https://img-blog.csdn.net/20170830143129971?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvanVuY2hlbmJiMDQzMA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
-4.  zookeeper中消息广播的具体步骤如下： 
-    4.1\. 客户端发起一个写操作请求 
-    4.2\. Leader服务器将客户端的request请求转化为事物proposql提案，同时为每个proposal分配一个全局唯一的ID，即ZXID。 
-    4.3\. leader服务器与每个follower之间都有一个队列，leader将消息发送到该队列 
-    4.4\. follower机器从队列中取出消息处理完(写入本地事物日志中)毕后，向leader服务器发送ACK确认。 
-    4.5\. leader服务器收到半数以上的follower的ACK后，即认为可以发送commit 
-    4.6\. leader向所有的follower服务器发送commit消息。
-5.  zookeeper采用ZAB协议的核心就是只要有一台服务器提交了proposal，就要确保所有的服务器最终都能正确提交proposal。这也是CAP/BASE最终实现一致性的一个体现。
-6.  leader服务器与每个follower之间都有一个单独的队列进行收发消息，使用队列消息可以做到异步解耦。leader和follower之间只要往队列中发送了消息即可。如果使用同步方式容易引起阻塞。性能上要下降很多。
-
-## 崩溃恢复
-
-1.  zookeeper集群中为保证任何所有进程能够有序的顺序执行，只能是leader服务器接受写请求，即使是follower服务器接受到客户端的请求，也会转发到leader服务器进行处理。
-2.  如果leader服务器发生崩溃，则zab协议要求zookeeper集群进行崩溃恢复和leader服务器选举。
-3.  ZAB协议崩溃恢复要求满足如下2个要求： 
-    3.1. 确保已经被leader提交的proposal必须最终被所有的follower服务器提交。 
-    3.2. 确保丢弃已经被leader出的但是没有被提交的proposal。
-4.  根据上述要求，新选举出来的leader不能包含未提交的proposal，即新选举的leader必须都是已经提交了的proposal的follower服务器节点。同时，新选举的leader节点中含有最高的ZXID。这样做的好处就是可以避免了leader服务器检查proposal的提交和丢弃工作。
-5.  leader服务器发生崩溃时分为如下场景： 
-    5.1\. leader在提出proposal时未提交之前崩溃，则经过崩溃恢复之后，新选举的leader一定不能是刚才的leader。因为这个leader存在未提交的proposal。 
-    5.2 leader在发送commit消息之后，崩溃。即消息已经发送到队列中。经过崩溃恢复之后，参与选举的follower服务器(刚才崩溃的leader有可能已经恢复运行，也属于follower节点范畴)中有的节点已经是消费了队列中所有的commit消息。即该follower节点将会被选举为最新的leader。剩下动作就是数据同步过程。
-
-### 数据同步
-
-1.  在zookeeper集群中新的leader选举成功之后，leader会将自身的提交的最大proposal的事物ZXID发送给其他的follower节点。follower节点会根据leader的消息进行回退或者是数据同步操作。最终目的要保证集群中所有节点的数据副本保持一致。
-2.  数据同步完之后，zookeeper集群如何保证新选举的leader分配的ZXID是全局唯一呢？这个就要从ZXID的设计谈起。 
-    2.1 ZXID是一个长度64位的数字，其中低32位是按照数字递增，即每次客户端发起一个proposal,低32位的数字简单加1。高32位是leader周期的epoch编号，至于这个编号如何产生(我也没有搞明白)，每当选举出一个新的leader时，新的leader就从本地事物日志中取出ZXID,然后解析出高32位的epoch编号，进行加1，再将低32位的全部设置为0。这样就保证了每次新选举的leader后，保证了ZXID的唯一性而且是保证递增的。 
-    ![这里写图片描述](https://img-blog.csdn.net/20170830173303656?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvanVuY2hlbmJiMDQzMA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
-
-## ZAB协议原理
-
-1.  ZAB协议要求每个leader都要经历三个阶段，即发现，同步，广播。
-2.  发现：即要求zookeeper集群必须选择出一个leader进程，同时leader会维护一个follower可用列表。将来客户端可以这follower中的节点进行通信。
-3.  同步：leader要负责将本身的数据与follower完成同步，做到多副本存储。这样也是体现了CAP中高可用和分区容错。follower将队列中未处理完的请求消费完成后，写入本地事物日志中。
-4.  广播：leader可以接受客户端新的proposal请求，将新的proposal请求广播给所有的follower。
-
-## Zookeeper设计目标
-
-1.  zookeeper作为当今最流行的分布式系统应用协调框架，采用zab协议的最大目标就是建立一个高可用可扩展的分布式数据主备系统。即在任何时刻只要leader发生宕机，都能保证分布式系统数据的可靠性和最终一致性。
-2.  深刻理解ZAB协议，才能更好的理解zookeeper对于分布式系统建设的重要性。以及为什么采用zookeeper就能保证分布式系统中数据最终一致性，服务的高可用性。
-
-Zab与Paxos
-Zab的作者认为Zab与paxos并不相同，只所以没有采用Paxos是因为Paxos保证不了全序顺序：
-Because multiple leaders can propose a value for a given instance two problems arise.
-First, proposals can conflict. Paxos uses ballots to detect and resolve conflicting proposals.
-Second, it is not enough to know that a given instance number has been committed, processes must also be able to fi gure out which value has been committed.
-Paxos算法的确是不关心请求之间的逻辑顺序，而只考虑数据之间的全序，但很少有人直接使用paxos算法，都会经过一定的简化、优化。
-
-Paxos算法优化
-Paxos算法在出现竞争的情况下，其收敛速度很慢，甚至可能出现活锁的情况，例如当有三个及三个以上的proposer在发送prepare请求后，很难有一个proposer收到半数以上的回复而不断地执行第一阶段的协议。因此，为了避免竞争，加快收敛的速度，在算法中引入了一个Leader这个角色，在正常情况下同时应该最多只能有一个参与者扮演Leader角色，而其它的参与者则扮演Acceptor的角色。
-在这种优化算法中，只有Leader可以提出议案，从而避免了竞争使得算法能够快速地收敛而趋于一致；而为了保证Leader的健壮性，又引入了Leader选举，再考虑到同步的阶段，渐渐的你会发现对Paxos算法的简化和优化已经和上面介绍的ZAB协议很相似了。
-
-总结
-Google的粗粒度锁服务Chubby的设计开发者Burrows曾经说过：“所有一致性协议本质上要么是Paxos要么是其变体”。这句话还是有一定道理的，ZAB本质上就是Paxos的一种简化形式。
-
-# ZAB与FastLeaderElection选主算法流程详解
-
-这篇主要分析leader的选主机制，zookeeper提供了三种方式：
-
-*   LeaderElection
-*   AuthFastLeaderElection
-*   FastLeaderElection
-
-默认的算法是FastLeaderElection，所以这篇主要分析它的选举机制。
-
-## 选择机制中的概念
-
-### 服务器ID
-
-比如有三台服务器，编号分别是1,2,3。
-
-> 编号越大在选择算法中的权重越大。
-
-### 数据ID
-
-服务器中存放的最大数据ID.
-
-> 值越大说明数据越新，在选举算法中数据越新权重越大。
-
-### 逻辑时钟
-
-或者叫投票的次数，同一轮投票过程中的逻辑时钟值是相同的。每投完一次票这个数据就会增加，然后与接收到的其它服务器返回的投票信息中的数值相比，根据不同的值做出不同的判断。
-
-### 选举状态
-
-*   LOOKING，竞选状态。
-*   FOLLOWING，随从状态，同步leader状态，参与投票。
-*   OBSERVING，观察状态,同步leader状态，不参与投票。
-*   LEADING，领导者状态。
-
-## 选举消息内容
-
-在投票完成后，需要将投票信息发送给集群中的所有服务器，它包含如下内容。
-
-*   服务器ID
-*   数据ID
-*   逻辑时钟
-*   选举状态
-
-## 选举流程图
-
-因为每个服务器都是独立的，在启动时均从初始状态开始参与选举，下面是简易流程图。
-
-![](https://images2015.cnblogs.com/blog/17071/201702/17071-20170220211539679-433574967.jpg)
-
-
-
-下面详细解释一下这个流程：
-
-首先给出几个名词定义：
-
-（1）Serverid：在配置server时，给定的服务器的标示id。
-
-（2）Zxid:服务器在运行时产生的数据id，zxid越大，表示数据越新。
-
-（3）Epoch：选举的轮数，即逻辑时钟。随着选举的轮数++
-
-（4）Server状态：LOOKING,FOLLOWING,OBSERVING,LEADING
-
-步骤：
-
-一、  Server刚启动（宕机恢复或者刚启动）准备加入集群，此时读取自身的zxid等信息。
-
-二、  所有Server加入集群时都会推荐自己为leader，然后将（leader id 、 zixd 、 epoch）作为广播信息，广播到集群中所有的服务器(Server)。然后等待集群中的服务器返回信息。
-
-三、  收到集群中其他服务器返回的信息，此时要分为两类：该服务器处于looking状态，或者其他状态。
-
-（1）    服务器处于looking状态
-
-首先判断逻辑时钟 Epoch:
-
-a)     如果接收到Epoch大于自己目前的逻辑时钟（说明自己所保存的逻辑时钟落伍了）。更新本机逻辑时钟Epoch，同时 Clear其他服务发送来的选举数据（这些数据已经OUT了）。然后判断是否需要更新当前自己的选举情况（一开始选择的leader id 是自己）
-
-    判断规则rules judging：保存的zxid最大值和leader Serverid来进行判断的。先看数据zxid,数据zxid大者胜出;其次再判断leaderServerid, leader Serverid大者胜出；然后再将自身最新的选举结果(也就是上面提到的三种数据（leader Serverid，Zxid，Epoch）广播给其他server)
-
-b)     如果接收到的Epoch小于目前的逻辑时钟。说明对方处于一个比较OUT的选举轮数，这时只需要将自己的 （leader Serverid，Zxid，Epoch）发送给他即可。
-
-c)     如果接收到的Epoch等于目前的逻辑时钟。再根据a)中的判断规则，将自身的最新选举结果广播给其他 server。
-
-同时Server还要处理2种情况：
-
-a)    如果Server接收到了其他所有服务器的选举信息，那么则根据这些选举信息确定自己的状态（Following,Leading），结束Looking，退出选举。
-
-b)   即使没有收到所有服务器的选举信息，也可以判断一下根据以上过程之后最新的选举leader是不是得到了超过半数以上服务器的支持，如果是则尝试接受最新数据，倘若没有最新的数据到来，说明大家都已经默认了这个结果,同样也设置角色退出选举过程。
-
-（2）    服务器处于其他状态（Following, Leading）
-
-a)     如果逻辑时钟Epoch相同,将该数据保存到recvset,如果所接收服务器宣称自己是leader,那么将判断是不是有半数以上的服务器选举它,如果是则设置选举状态退出选举过程
-
-b)     否则这是一条与当前逻辑时钟不符合的消息，那么说明在另一个选举过程中已经有了选举结果，于是将该选举结果加入到outofelection集合中，再根据outofelection来判断是否可以结束选举,如果可以也是保存逻辑时钟，设置选举状态，退出选举过程。
-
-以上就是FAST选举过程。
-
-Zookeeper具体的启动日志如下图所示：
-
-![](https://blog.csdn.net/cnh294141800/article/details/52959028)![](https://blog.csdn.net/cnh294141800/article/details/52959028)![](https://img-blog.csdn.net/20161028191618720?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
-
-以上就是我自己配置的Zookeeper选主日志，从一开始LOOKING,然后new election, my id = 1, proposedzxid=0x0  也就是选自己为Leader,之后广播选举并重复之前Fast选主算法，最终确定Leader。
-
-## 源码分析
-
-### QuorumPeer
-
-主要看这个类，只有LOOKING状态才会去执行选举算法。每个服务器在启动时都会选择自己做为领导，然后将投票信息发送出去，循环一直到选举出领导为止。
-
-
-
-<pre>public void run() {
-        //.......
-
-        try {
-            while (running) {
-                switch (getPeerState()) {
-                case LOOKING:
-                    if (Boolean.getBoolean("readonlymode.enabled")) {
-                        //...
-                        try {
-                           //投票给自己...
-                            setCurrentVote(makeLEStrategy().lookForLeader());
-                        } catch (Exception e) {
-                            //...
-                        } finally {
-                            //...
-                        }
-                    } else {
-                        try {
-                           //...
-                            setCurrentVote(makeLEStrategy().lookForLeader());
-                        } catch (Exception e) {
-                            //...
-                        }                        
-                    }
-                    break;
-                case OBSERVING:
-                    //...
-                    break;
-                case FOLLOWING:
-                    //...
-                    break;
-                case LEADING:
-                    //...
-                    break;
-                }
-
-            }
-        } finally {
-            //...
-        }
-    }</pre>
-
-
-
-### FastLeaderElection
-
-它是zookeeper默认提供的选举算法，核心方法如下：具体的可以与本文上面的流程图对照。
-
-
-
-<pre>public Vote lookForLeader() throws InterruptedException {
-        //...
-        try {
-            HashMap<Long, Vote> recvset = new HashMap<Long, Vote>();
-
-            HashMap<Long, Vote> outofelection = new HashMap<Long, Vote>();
-
-            int notTimeout = finalizeWait;
-
-            synchronized(this){
-                //给自己投票
-                logicalclock.incrementAndGet();
-                updateProposal(getInitId(), getInitLastLoggedZxid(), getPeerEpoch());
-            }
-
-            //将投票信息发送给集群中的每个服务器
-            sendNotifications();
-
-            //循环，如果是竞选状态一直到选举出结果
-
-            while ((self.getPeerState() == ServerState.LOOKING) &&
-                    (!stop)){
-
-                Notification n = recvqueue.poll(notTimeout,
-                        TimeUnit.MILLISECONDS);
-
-                //没有收到投票信息
-                if(n == null){
-                    if(manager.haveDelivered()){
-                        sendNotifications();
-                    } else {
-                        manager.connectAll();
-                    }
-
-                    //...
-                } 
-                //收到投票信息
-                else if (self.getCurrentAndNextConfigVoters().contains(n.sid)) {
-
-                    switch (n.state) {
-                    case LOOKING:
-
-                        // 判断投票是否过时，如果过时就清除之前已经接收到的信息 
-                        if (n.electionEpoch > logicalclock.get()) {
-                            logicalclock.set(n.electionEpoch);
-                            recvset.clear();
-                            //更新投票信息
-                            if(totalOrderPredicate(n.leader, n.zxid, n.peerEpoch,
-                                    getInitId(), getInitLastLoggedZxid(), getPeerEpoch())) {
-                                updateProposal(n.leader, n.zxid, n.peerEpoch);
-                            } else {
-                                updateProposal(getInitId(),
-                                        getInitLastLoggedZxid(),
-                                        getPeerEpoch());
-                            }
-                            //发送投票信息
-                            sendNotifications();
-                        } else if (n.electionEpoch < logicalclock.get()) {
-                            //忽略
-                            break;
-                        } else if (totalOrderPredicate(n.leader, n.zxid, n.peerEpoch,
-                                proposedLeader, proposedZxid, proposedEpoch)) {
-                            //更新投票信息
-                            updateProposal(n.leader, n.zxid, n.peerEpoch);
-                            sendNotifications();
-                        }                     
-
-                        recvset.put(n.sid, new Vote(n.leader, n.zxid, n.electionEpoch, n.peerEpoch));
-                        //判断是否投票结束
-                        if (termPredicate(recvset,
-                                new Vote(proposedLeader, proposedZxid,
-                                        logicalclock.get(), proposedEpoch))) {
-
-                            // Verify if there is any change in the proposed leader
-                            while((n = recvqueue.poll(finalizeWait,
-                                    TimeUnit.MILLISECONDS)) != null){
-                                if(totalOrderPredicate(n.leader, n.zxid, n.peerEpoch,
-                                        proposedLeader, proposedZxid, proposedEpoch)){
-                                    recvqueue.put(n);
-                                    break;
-                                }
-                            }
-
-                            if (n == null) {
-                                self.setPeerState((proposedLeader == self.getId()) ?
-                                        ServerState.LEADING: learningState());
-
-                                Vote endVote = new Vote(proposedLeader,
-                                        proposedZxid, proposedEpoch);
-                                leaveInstance(endVote);
-                                return endVote;
-                            }
-                        }
-                        break;
-                    case OBSERVING:
-                        //忽略
-                        break;
-                    case FOLLOWING:
-                    case LEADING:
-                        //如果是同一轮投票
-                        if(n.electionEpoch == logicalclock.get()){
-                            recvset.put(n.sid, new Vote(n.leader, n.zxid, n.electionEpoch, n.peerEpoch));
-                            //判断是否投票结束
-                            if(termPredicate(recvset, new Vote(n.leader,
-                                            n.zxid, n.electionEpoch, n.peerEpoch, n.state))
-                                            && checkLeader(outofelection, n.leader, n.electionEpoch)) {
-                                self.setPeerState((n.leader == self.getId()) ?
-                                        ServerState.LEADING: learningState());
-
-                                Vote endVote = new Vote(n.leader, n.zxid, n.peerEpoch);
-                                leaveInstance(endVote);
-                                return endVote;
-                            }
-                        }
-
-                        //记录投票已经完成
-                        outofelection.put(n.sid, new Vote(n.leader, 
-                                IGNOREVALUE, IGNOREVALUE, n.peerEpoch, n.state));
-                        if (termPredicate(outofelection, new Vote(n.leader,
-                                IGNOREVALUE, IGNOREVALUE, n.peerEpoch, n.state))
-                                && checkLeader(outofelection, n.leader, IGNOREVALUE)) {
-                            synchronized(this){
-                                logicalclock.set(n.electionEpoch);
-                                self.setPeerState((n.leader == self.getId()) ?
-                                        ServerState.LEADING: learningState());
-                            }
-                            Vote endVote = new Vote(n.leader, n.zxid, n.peerEpoch);
-                            leaveInstance(endVote);
-                            return endVote;
-                        }
-                        break;
-                    default:
-                        //忽略
-                        break;
-                    }
-                } else {
-                    LOG.warn("Ignoring notification from non-cluster member " + n.sid);
-                }
-            }
-            return null;
-        } finally {
-            //...
-        }
-    }</pre>
-
-
-
-### 判断是否已经胜出
-
-默认是采用投票数大于半数则胜出的逻辑。
-
-## 选举流程简述
-
-目前有5台服务器，每台服务器均没有数据，它们的编号分别是1,2,3,4,5,按编号依次启动，它们的选择举过程如下：
-
-*   服务器1启动，给自己投票，然后发投票信息，由于其它机器还没有启动所以它收不到反馈信息，服务器1的状态一直属于Looking。
-*   服务器2启动，给自己投票，同时与之前启动的服务器1交换结果，由于服务器2的编号大所以服务器2胜出，但此时投票数没有大于半数，所以两个服务器的状态依然是LOOKING。
-*   服务器3启动，给自己投票，同时与之前启动的服务器1,2交换信息，由于服务器3的编号最大所以服务器3胜出，此时投票数正好大于半数，所以服务器3成为领导者，服务器1,2成为小弟。
-*   服务器4启动，给自己投票，同时与之前启动的服务器1,2,3交换信息，尽管服务器4的编号大，但之前服务器3已经胜出，所以服务器4只能成为小弟。
-*   服务器5启动，后面的逻辑同服务器4成为小弟。
-
-## [](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E5%87%A0%E7%A7%8D%E9%A2%86%E5%AF%BC%E9%80%89%E4%B8%BE%E5%9C%BA%E6%99%AF "几种领导选举场景")几种领导选举场景
-
-### [](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E9%9B%86%E7%BE%A4%E5%90%AF%E5%8A%A8%E9%A2%86%E5%AF%BC%E9%80%89%E4%B8%BE "集群启动领导选举")集群启动领导选举
-
-**_初始投票给自己_**
-集群刚启动时，所有服务器的logicClock都为1，zxid都为0。
-
-各服务器初始化后，都投票给自己，并将自己的一票存入自己的票箱，如下图所示。
-
-
-[![Cluster start election step 1](http://www.jasongj.com/img/zookeeper/1_architecture/start_election_1.png)](http://www.jasongj.com/img/zookeeper/1_architecture/start_election_1.png)
-
-
-在上图中，(1, 1, 0)第一位数代表投出该选票的服务器的logicClock，第二位数代表被推荐的服务器的myid，第三位代表被推荐的服务器的最大的zxid。由于该步骤中所有选票都投给自己，所以第二位的myid即是自己的myid，第三位的zxid即是自己的zxid。
-
-此时各自的票箱中只有自己投给自己的一票。
-
-**_更新选票_**
-服务器收到外部投票后，进行选票PK，相应更新自己的选票并广播出去，并将合适的选票存入自己的票箱，如下图所示。
-
-
-[![Cluster start election step 2](http://www.jasongj.com/img/zookeeper/1_architecture/start_election_2.png)](http://www.jasongj.com/img/zookeeper/1_architecture/start_election_2.png)
-
-
-服务器1收到服务器2的选票（1, 2, 0）和服务器3的选票（1, 3, 0）后，由于所有的logicClock都相等，所有的zxid都相等，因此根据myid判断应该将自己的选票按照服务器3的选票更新为（1, 3, 0），并将自己的票箱全部清空，再将服务器3的选票与自己的选票存入自己的票箱，接着将自己更新后的选票广播出去。此时服务器1票箱内的选票为(1, 3)，(3, 3)。
-
-同理，服务器2收到服务器3的选票后也将自己的选票更新为（1, 3, 0）并存入票箱然后广播。此时服务器2票箱内的选票为(2, 3)，(3, ,3)。
-
-服务器3根据上述规则，无须更新选票，自身的票箱内选票仍为（3, 3）。
-
-服务器1与服务器2更新后的选票广播出去后，由于三个服务器最新选票都相同，最后三者的票箱内都包含三张投给服务器3的选票。
-
-**_根据选票确定角色_**
-根据上述选票，三个服务器一致认为此时服务器3应该是Leader。因此服务器1和2都进入FOLLOWING状态，而服务器3进入LEADING状态。之后Leader发起并维护与Follower间的心跳。
-
-
-[![Cluster start election step 3](http://www.jasongj.com/img/zookeeper/1_architecture/start_election_3.png)](http://www.jasongj.com/img/zookeeper/1_architecture/start_election_3.png)
-
-
-### [](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#Follower%E9%87%8D%E5%90%AF "Follower重启")Follower重启
-
-**_Follower重启投票给自己_**
-Follower重启，或者发生网络分区后找不到Leader，会进入LOOKING状态并发起新的一轮投票。
-
-
-[![Follower restart election step 1](http://www.jasongj.com/img/zookeeper/1_architecture/follower_restart_election_1.png)](http://www.jasongj.com/img/zookeeper/1_architecture/follower_restart_election_1.png)
-
-
-**_发现已有Leader后成为Follower_**
-服务器3收到服务器1的投票后，将自己的状态LEADING以及选票返回给服务器1。服务器2收到服务器1的投票后，将自己的状态FOLLOWING及选票返回给服务器1。此时服务器1知道服务器3是Leader，并且通过服务器2与服务器3的选票可以确定服务器3确实得到了超过半数的选票。因此服务器1进入FOLLOWING状态。
-
-
-[![Follower restart election step 2](http://www.jasongj.com/img/zookeeper/1_architecture/follower_restart_election_2.png)](http://www.jasongj.com/img/zookeeper/1_architecture/follower_restart_election_2.png)
-
-
-### [](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#Leader%E9%87%8D%E5%90%AF "Leader重启")Leader重启
-
-**_Follower发起新投票_**
-Leader（服务器3）宕机后，Follower（服务器1和2）发现Leader不工作了，因此进入LOOKING状态并发起新的一轮投票，并且都将票投给自己。
-
-
-[![Leader restart election step 1](http://www.jasongj.com/img/zookeeper/1_architecture/leader_restart_election_1.png)](http://www.jasongj.com/img/zookeeper/1_architecture/leader_restart_election_1.png)
-
-
-**_广播更新选票_**
-服务器1和2根据外部投票确定是否要更新自身的选票。这里有两种情况
-
-*   服务器1和2的zxid相同。例如在服务器3宕机前服务器1与2完全与之同步。此时选票的更新主要取决于myid的大小
-*   服务器1和2的zxid不同。在旧Leader宕机之前，其所主导的写操作，只需过半服务器确认即可，而不需所有服务器确认。换句话说，服务器1和2可能一个与旧Leader同步（即zxid与之相同）另一个不同步（即zxid比之小）。此时选票的更新主要取决于谁的zxid较大
-
-在上图中，服务器1的zxid为11，而服务器2的zxid为10，因此服务器2将自身选票更新为（3, 1, 11），如下图所示。
-
-
-[![Leader restart election step 2](http://www.jasongj.com/img/zookeeper/1_architecture/leader_restart_election_2.png)](http://www.jasongj.com/img/zookeeper/1_architecture/leader_restart_election_2.png)
-
-
-**_选出新Leader_**
-经过上一步选票更新后，服务器1与服务器2均将选票投给服务器1，因此服务器2成为Follower，而服务器1成为新的Leader并维护与服务器2的心跳。
-
-
-[![Leader restart election step 3](http://www.jasongj.com/img/zookeeper/1_architecture/leader_restart_election_3.png)](http://www.jasongj.com/img/zookeeper/1_architecture/leader_restart_election_3.png)
-
-
-**_旧Leader恢复后发起选举_**
-旧的Leader恢复后，进入LOOKING状态并发起新一轮领导选举，并将选票投给自己。此时服务器1会将自己的LEADING状态及选票（3, 1, 11）返回给服务器3，而服务器2将自己的FOLLOWING状态及选票（3, 1, 11）返回给服务器3。如下图所示。
-
-
-[![Leader restart election step 4](http://www.jasongj.com/img/zookeeper/1_architecture/leader_restart_election_4.png)](http://www.jasongj.com/img/zookeeper/1_architecture/leader_restart_election_4.png)
-
-
-**_旧Leader成为Follower_**
-服务器3了解到Leader为服务器1，且根据选票了解到服务器1确实得到过半服务器的选票，因此自己进入FOLLOWING状态。
-
-
-[![Leader restart election step 5](http://www.jasongj.com/img/zookeeper/1_architecture/leader_restart_election_5.png)](http://www.jasongj.com/img/zookeeper/1_architecture/leader_restart_election_5.png)
-
-
-# [](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E4%B8%80%E8%87%B4%E6%80%A7%E4%BF%9D%E8%AF%81 "一致性保证")一致性保证
-
-ZAB协议保证了在Leader选举的过程中，已经被Commit的数据不会丢失，未被Commit的数据对客户端不可见。
-
-## [](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#Commit%E8%BF%87%E7%9A%84%E6%95%B0%E6%8D%AE%E4%B8%8D%E4%B8%A2%E5%A4%B1 "Commit过的数据不丢失")Commit过的数据不丢失
-
-**_Failover前状态_**
-为更好演示Leader Failover过程，本例中共使用5个Zookeeper服务器。A作为Leader，共收到P1、P2、P3三条消息，并且Commit了1和2，且总体顺序为P1、P2、C1、P3、C2。根据顺序性原则，其它Follower收到的消息的顺序肯定与之相同。其中B与A完全同步，C收到P1、P2、C1，D收到P1、P2，E收到P1，如下图所示。
-
-
-[![Leader Failover step 1](http://www.jasongj.com/img/zookeeper/1_architecture/recovery_1.png)](http://www.jasongj.com/img/zookeeper/1_architecture/recovery_1.png)
-
-
-这里要注意
-
-*   由于A没有C3，意味着收到P3的服务器的总个数不会超过一半，也即包含A在内最多只有两台服务器收到P3。在这里A和B收到P3，其它服务器均未收到P3
-*   由于A已写入C1、C2，说明它已经Commit了P1、P2，因此整个集群有超过一半的服务器，即最少三个服务器收到P1、P2。在这里所有服务器都收到了P1，除E外其它服务器也都收到了P2
-
-**_选出新Leader_**
-旧Leader也即A宕机后，其它服务器根据上述FastLeaderElection算法选出B作为新的Leader。C、D和E成为Follower且以B为Leader后，会主动将自己最大的zxid发送给B，B会将Follower的zxid与自身zxid间的所有被Commit过的消息同步给Follower，如下图所示。
-
-
-[![Leader Failover step 2](http://www.jasongj.com/img/zookeeper/1_architecture/recovery_2.png)](http://www.jasongj.com/img/zookeeper/1_architecture/recovery_2.png)
-
-
-在上图中
-
-*   P1和P2都被A Commit，因此B会通过同步保证P1、P2、C1与C2都存在于C、D和E中
-*   P3由于未被A Commit，同时幸存的所有服务器中P3未存在于大多数据服务器中，因此它不会被同步到其它Follower
-
-**_通知Follower可对外服务_**
-同步完数据后，B会向D、C和E发送NEWLEADER命令并等待大多数服务器的ACK（下图中D和E已返回ACK，加上B自身，已经占集群的大多数），然后向所有服务器广播UPTODATE命令。收到该命令后的服务器即可对外提供服务。
-
-
-[![Leader Failover step 3](http://www.jasongj.com/img/zookeeper/1_architecture/recovery_3.png)](http://www.jasongj.com/img/zookeeper/1_architecture/recovery_3.png)
-
-
-## [](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E6%9C%AACommit%E8%BF%87%E7%9A%84%E6%B6%88%E6%81%AF%E5%AF%B9%E5%AE%A2%E6%88%B7%E7%AB%AF%E4%B8%8D%E5%8F%AF%E8%A7%81 "未Commit过的消息对客户端不可见")未Commit过的消息对客户端不可见
-
-在上例中，P3未被A Commit过，同时因为没有过半的服务器收到P3，因此B也未Commit P3（如果有过半服务器收到P3，即使A未Commit P3，B会主动Commit P3，即C3），所以它不会将P3广播出去。
-
-具体做法是，B在成为Leader后，先判断自身未Commit的消息（本例中即P3）是否存在于大多数服务器中从而决定是否要将其Commit。然后B可得出自身所包含的被Commit过的消息中的最小zxid（记为min_zxid）与最大zxid（记为max_zxid）。C、D和E向B发送自身Commit过的最大消息zxid（记为max_zxid）以及未被Commit过的所有消息（记为zxid_set）。B根据这些信息作出如下操作
-
-*   如果Follower的max_zxid与Leader的max_zxid相等，说明该Follower与Leader完全同步，无须同步任何数据
-*   如果Follower的max_zxid在Leader的(min_zxid，max_zxid)范围内，Leader会通过TRUNC命令通知Follower将其zxid_set中大于Follower的max_zxid（如果有）的所有消息全部删除
-
-上述操作保证了未被Commit过的消息不会被Commit从而对外不可见。
-
-上述例子中Follower上并不存在未被Commit的消息。但可考虑这种情况，如果将上述例子中的服务器数量从五增加到七，服务器F包含P1、P2、C1、P3，服务器G包含P1、P2。此时服务器F、A和B都包含P3，但是因为票数未过半，因此B作为Leader不会Commit P3，而会通过TRUNC命令通知F删除P3。如下图所示。
-
-
-[![Leader Failover step 4](http://www.jasongj.com/img/zookeeper/1_architecture/recovery_4.png)](http://www.jasongj.com/img/zookeeper/1_architecture/recovery_4.png)
-
-
-# [](http://www.jasongj.com/zookeeper/fastleaderelection/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E6%80%BB%E7%BB%93 "总结")总结
-
-*   由于使用主从复制模式，所有的写操作都要由Leader主导完成，而读操作可通过任意节点完成，因此Zookeeper读性能远好于写性能，更适合读多写少的场景
-*   虽然使用主从复制模式，同一时间只有一个Leader，但是Failover机制保证了集群不存在单点失败（SPOF）的问题
-*   ZAB协议保证了Failover过程中的数据一致性
-*   服务器收到数据后先写本地文件再进行处理，保证了数据的持久性
-
diff --git "a/docs/distrubuted/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272\346\200\273\347\273\223.md" "b/docs/distrubuted/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272\346\200\273\347\273\223.md"
deleted file mode 100644
index a118bdc..0000000
--- "a/docs/distrubuted/\345\210\206\345\270\203\345\274\217\347\220\206\350\256\272\346\200\273\347\273\223.md"
+++ /dev/null
@@ -1,398 +0,0 @@
-# Table of Contents
-
-* [分布式理论](#分布式理论)
-  * [CAP](#cap)
-  * [BASE](#base)
-  * [分布式系统关键词](#分布式系统关键词)
-    * [时钟，时间，事件顺序](#时钟，时间，事件顺序)
-    * [Lamport timestamps](#lamport-timestamps)
-    * [Vector clock](#vector-clock)
-    * [Version vector](#version-vector)
-    * [选主，租约，多数派](#选主，租约，多数派)
-  * [一致性，2pc和3pc](#一致性，2pc和3pc)
-  * [一致性算法paxos](#一致性算法paxos)
-  * [raft和zab](#raft和zab)
-  * [单个 Candidate 的竞选](#单个-candidate-的竞选)
-  * [[](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E4%B8%80%E8%87%B4%E6%80%A7.md#%E5%A4%9A%E4%B8%AA-candidate-%E7%AB%9E%E9%80%89)多个 Candidate 竞选](#[]httpsgithubcomcyc2018interview-notebookblobmasternotese4b880e887b4e680a7mde5a49ae4b8aa-candidate-e7ab9ee98089多个-candidate-竞选)
-  * [[](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E4%B8%80%E8%87%B4%E6%80%A7.md#%E6%97%A5%E5%BF%97%E5%A4%8D%E5%88%B6)日志复制](#[]httpsgithubcomcyc2018interview-notebookblobmasternotese4b880e887b4e680a7mde697a5e5bf97e5a48de588b6日志复制)
-  * [zookeeper](#zookeeper)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-
----
-title: 分布式理论学习总结
-date: 2018-07-08 22:15:23
-tags:
-	- 分布式系统
-categories:
-	- 后端
-	- 技术总结
----
-本文基于之前的分布式系统理论系列文章总结而成,主要是理论部分，详细内容可见我的专栏：分布式系统理论与实践
-
-https://blog.csdn.net/column/details/24090.html
-
-本文主要是按照我自己的理解以及参考之前文章综合而成的，其中可能会有一些错误，还请见谅，也请指出。
-<!-- more -->
-
-# 分布式理论
-## CAP
-CAP定理讲的是三个性。consistency数据一致性，availability可用性，partition tolerance分区容错性。
-
-三者只能选其中两者。为什么呢，看看这三个性质意味着什么吧。
-
-首先看看分区容错性，分区容错性指的是网络出现分区（丢包，断网，超时等情况都属于网络分区）时，整个服务仍然可用。
-
-由于网络分区在实际环境下一定存在，所以必须首先被考虑。于是分区容错性是必须要保证的，否则一旦出现分区服务就不可用，那就没办法弄了。
-
-所以实际上是2选1的问题。在可用性和一致性中做出选择。
-
-在一个分布式环境下，多个节点一起对外提供服务，如果要保证可用性，那么一台机器宕机了仍然有其他机器能提供服务。
-但是宕机的机器重启以后就会发现数据和其他机器存在不一致，那么一致性就无法得到保证。
-
-如果保证一致性，如果有机器宕机，那么其他节点就不能工作了，否则一定会产生数据不一致。
-
-## BASE
-
-在这么严苛的规定下，CAP一般很难实现一个健壮的系统。于是提出了BASE来削弱这些要求。
-
-BASE是基本可用basically available，soft state软状态，eventually consistent最终一致性。
-
-基本可用就是允许服务在某些时候降级，比如淘宝在高峰时期会关闭退货等服务。
-
-软状态就是允许数据出现中间状态，比如支付宝提交转账以后并不是立刻到账，中间经过了多次消息传递和转发。
-
-最终一致性就是指数据最终要是一致的，比如多个节点的数据需要定期同步，支付宝转账最终一定会到账。
-
-## 分布式系统关键词
-
-### 时钟，时间，事件顺序  
-
-分布式系统的一个问题在与缺少全局时钟，所以大家没有一个统一的时间，就很难用时间去确定各个节点事件的发生顺序，为了保证事件的顺序执行，
-
-
-### Lamport timestamps
-
-Leslie Lamport 在1978年提出逻辑时钟的概念，并描述了一种逻辑时钟的表示方法，这个方法被称为Lamport时间戳(Lamport timestamps)[3]。
-
-![image](https://images2015.cnblogs.com/blog/116770/201605/116770-20160501174922566-1686627384.png)
-
-分布式系统中按是否存在节点交互可分为三类事件，一类发生于节点内部，二是发送事件，三是接收事件。Lamport时间戳原理如下：
-
-    每个事件对应一个Lamport时间戳，初始值为0
-    如果事件在节点内发生，时间戳加1
-    如果事件属于发送事件，时间戳加1并在消息中带上该时间戳
-    如果事件属于接收事件，时间戳 = Max(本地时间戳，消息中的时间戳) + 1
-
-这样的话，节点内的事件有序，发送事件有序，接收事件一定在发送事件以后发生。再加上人为的一些规定，因此根据时间戳可以确定一个全序排列。
-
-### Vector clock
-
-Lamport时间戳帮助我们得到事件顺序关系，但还有一种顺序关系不能用Lamport时间戳很好地表示出来，那就是同时发生关系(concurrent)[4]。
-Vector clock是在Lamport时间戳基础上演进的另一种逻辑时钟方法，它通过vector结构不但记录本节点的Lamport时间戳，同时也记录了其他节点的Lamport时间戳[5][6]。
-
-![image](https://images2015.cnblogs.com/blog/116770/201605/116770-20160502134654404-1109556515.png)
-
-如果 Tb[Q] > Ta[Q] 并且 Tb[P] < Ta[P]，则认为a、b同时发生，记作 a <-> b。例如图2中节点B上的第4个事件 (A:2，B:4，C:1) 与节点C上的第2个事件 (B:3，C:2) 没有因果关系、属于同时发生事件。
-
-因为B4 > B3并且 C1<C2，说明两者之间没有顺序关系，否则不会出现一大一小，因此他们是同时发生的。
-
-### Version vector
-
-基于Vector clock我们可以获得任意两个事件的顺序关系，结果或为先后顺序或为同时发生，识别事件顺序在工程实践中有很重要的引申应用，最常见的应用是发现数据冲突(detect conflict)。
-
- 
-
-分布式系统中数据一般存在多个副本(replication)，多个副本可能被同时更新，这会引起副本间数据不一致[7]，Version vector的实现与Vector clock非常类似[8]，目的用于发现数据冲突[9]。
-
-当两个写入数据事件同时发生则发生了冲突，于是通过某些方法解决数据冲突。
-
-Vector clock只用于发现数据冲突，不能解决数据冲突。如何解决数据冲突因场景而异，具体方法有以最后更新为准(last write win)，或将冲突的数据交给client由client端决定如何处理，或通过quorum决议事先避免数据冲突的情况发生[11]。
-
-### 选主，租约，多数派
-
-> 选举(election)是分布式系统实践中常见的问题，通过打破节点间的对等关系，选得的leader(或叫master、coordinator)有助于实现事务原子性、提升决议效率。
-> 
-> 多数派(quorum)的思路帮助我们在网络分化的情况下达成决议一致性，在leader选举的场景下帮助我们选出唯一leader。
-> 
-> 租约(lease)在一定期限内给予节点特定权利，也可以用于实现leader选举。
-
-选举(electioin)
-
-> 一致性问题(consistency)是独立的节点间如何达成决议的问题，选出大家都认可的leader本质上也是一致性问题，因而如何应对宕机恢复、网络分化等在leader选举中也需要考量。
-> 
->  在一致性算法Paxos、ZAB[2]、Raft[3]中，为提升决议效率均有节点充当leader的角色。
->  
->  ZAB、Raft中描述了具体的leader选举实现，与Bully算法类似ZAB中使用zxid标识节点，具有最大zxid的节点表示其所具备的事务(transaction)最新、被选为leader。
-
-多数派(quorum)
-
-> 在网络分化的场景下以上Bully算法会遇到一个问题，被分隔的节点都认为自己具有最大的序号、将产生多个leader，这时候就需要引入多数派(quorum)[4]。多数派的思路在分布式系统中很常见，其确保网络分化情况下决议唯一。
-
- 租约(lease)
-
-选举中很重要的一个问题，以上尚未提到：怎么判断leader不可用、什么时候应该发起重新选举？
->   
-> 最先可能想到会通过心跳(heart beat)判别leader状态是否正常，但在网络拥塞或瞬断的情况下，这容易导致出现双主。
-
- 
-
-租约(lease)是解决该问题的常用方法，其最初提出时用于解决分布式缓存一致性问题[6]，后面在分布式锁[7]等很多方面都有应用。
-    
-    (a). 节点0、1、2在Z上注册自己，Z根据一定的规则(例如先到先得)颁发租约给节点，该租约同时对应一个有效时长；这里假设节点0获得租约、成为leader
-    
-    (b). leader宕机时，只有租约到期(timeout)后才重新发起选举，这里节点1获得租约、成为leader
-
- 
-
-
-租约机制确保了一个时刻最多只有一个leader，避免只使用心跳机制产生双主的问题。在实践应用中，zookeeper、ectd可用于租约颁发。
-
-## 一致性，2pc和3pc
-
-一致性(consensus)
-
-何为一致性问题？简单而言，一致性问题就是相互独立的节点之间如何达成一项决议的问题。分布式系统中，进行数据库事务提交(commit transaction)、Leader选举、序列号生成等都会遇到一致性问题。
-
-为了保证执行的一致性，可以使用2pc两段式提交和3pc三段式提交。
-
-2PC
-> 
-> 2PC(tow phase commit)两阶段提交[5]顾名思义它分成两个阶段，先由一方进行提议(propose)并收集其他节点的反馈(vote)，再根据反馈决定提交(commit)或中止(abort)事务。我们将提议的节点称为协调者(coordinator)，其他参与决议节点称为参与者(participants, 或cohorts)：
-
-举个例子，首先用户想要执行一个事务，于是提交给leader，leader先让各个节点执行该事务。
-
-我们要知道，事务是通过日志来实现的。各个节点使用redo日志进行重做，使用undo日志进行回滚。
-
-于是各个节点执行事务，并把执行结果是否成功返回给leader，当leader收到全部确认消息后，发送消息让所有节点commit。如果有节点执行失败，则leader要求所有节点回滚。
-
-2pc可能出现的一些问题是：
-
-1 leader必须等待所有节点结果，如果有节点宕机或超时，则拒绝该事务，并向节点发送回滚的信息。
-
-2 如果leader宕机，则一般配置watcherdog自动切换成备用leader，然后进行下一次的请求提交。
-
-3这两种情况单独发生时都没有关系，有对应的措施可以进行回滚，但是如果当一个节点宕机时leader正在等待所有节点消息，其他节点也在等待leader最后的消息。
-
-此时leader也不幸宕机，切换之后leader并不知道一个节点宕机了，这样的话其他的节点也会被阻塞住导致无法回滚。
-> 
-3PC
-![image](https://images2015.cnblogs.com/blog/116770/201603/116770-20160314002734304-489496391.png)
-coordinator接收完participant的反馈(vote)之后，进入阶段2，给各个participant发送准备提交(prepare to commit)指令
-
-。participant接到准备提交指令后可以锁资源，但要求相关操作必须可回滚。coordinator接收完确认(ACK)后进入阶段3、进行commit/abort，3PC的阶段3与2PC的阶段2无异。协调者备份(coordinator watchdog)、状态记录(logging)同样应用在3PC。
-
-participant如果在不同阶段宕机，我们来看看3PC如何应对：
-
-> 阶段1: coordinator或watchdog未收到宕机participant的vote，直接中止事务；宕机的participant恢复后，读取logging发现未发出赞成vote，自行中止该次事务
-> 
-> 阶段2: coordinator未收到宕机participant的precommit ACK，但因为之前已经收到了宕机participant的赞成反馈(不然也不会进入到阶段2)，coordinator进行commit；watchdog可以通过问询其他participant获得这些信息，过程同理；宕机的participant恢复后发现收到precommit或已经发出赞成vote，则自行commit该次事务
-> 
-> 阶段3: 即便coordinator或watchdog未收到宕机participant的commit ACK，也结束该次事务；宕机的participant恢复后发现收到commit或者precommit，也将自行commit该次事务
-> 因为有了准备提交(prepare to
-commit)阶段，3PC的事务处理延时也增加了1个RTT，变为3个RTT(propose+precommit+commit)，但是它防止participant宕机后整个系统进入阻塞态，增强了系统的可用性，对一些现实业务场景是非常值得的。
-> 
-
-总结一下就是：阶段一leader要求节点准备，节点返回ack或者fail。
-
-如果节点都是ack，leader返回ack进入阶段二。
-（如果fail则回滚，因为节点没有接收到ack，所以最终都会回滚）
-
-阶段二时节点执行事务并且发送结果给leader，leader返回ack或者fail。由于阶段二的节点已经有了一个确定的状态ack，如果leader超时或宕机不返回，成功执行节点也会进行commit操作，这样即使有节点宕机也不会影响到其他节点。
-
-
-## 一致性算法paxos
-
-Basic Paxos
-
-何为一致性问题？简单而言，一致性问题是在节点宕机、消息无序等场景可能出现的情况下，相互独立的节点之间如何达成决议的问题，作为解决一致性问题的协议，Paxos的核心是节点间如何确定并只确定一个值(value)。
-
-和2PC类似，Paxos先把节点分成两类，发起提议(proposal)的一方为proposer，参与决议的一方为acceptor。假如只有一个proposer发起提议，并且节点不宕机、消息不丢包，那么acceptor做到以下这点就可以确定一个值。
-
-> proposer发出提议，acceptor根据提议的id和值来决定是否接收提议，接受提议则替换为自己的提议，并且返回之前id最大的提议，当超过一半节点提议该值时，则该值被确定，这样既保证了时序，也保证了多数派。
-
- Multi Paxos
-
-通过以上步骤分布式系统已经能确定一个值，“只确定一个值有什么用？这可解决不了我面临的问题。” 你心中可能有这样的疑问。
-
-其实不断地进行“确定一个值”的过程、再为每个过程编上序号，就能得到具有全序关系(total order)的系列值，进而能应用在数据库副本存储等很多场景。我们把单次“确定一个值”的过程称为实例(instance)，它由proposer/acceptor/learner组成。    
-
-Fast Paxos
-
-在Multi Paxos中，proposer -> leader -> acceptor -> learner，从提议到完成决议共经过3次通信，能不能减少通信步骤？
-
-对Multi Paxos phase2a，如果可以自由提议value，则可以让proposer直接发起提议、leader退出通信过程，变为proposer -> acceptor -> learner，这就是Fast Paxos[2]的由来。
-
-> 多次paxos的确定值使用可以让多个proposer，acceptor一起运作。多个proposer提出提议，acceptor保留最大提议比返回之前提议，proposer当提议数量满足多数派则取出最大值向acceptor提议，于是过半数的acceptor比较提议后可以接受该提议，于是最终leader将提议写入acceptor，而acceptor再写入对应的learner。
-
-## raft和zab
-
-Zab
-
-Zab[5][6]的全称是Zookeeper atomic broadcast protocol，是Zookeeper内部用到的一致性协议。相比Paxos，Zab最大的特点是保证强一致性(strong consistency，或叫线性一致性linearizable consistency)。
-
- 
-
-和Raft一样，Zab要求唯一Leader参与决议，Zab可以分解成discovery、sync、broadcast三个阶段：
-
-![image](https://images2015.cnblogs.com/blog/116770/201610/116770-20161025133734734-658183229.jpg)
-> 
-> discovery: 选举产生PL(prospective leader)，PL收集Follower epoch(cepoch)，根据Follower的反馈PL产生newepoch(每次选举产生新Leader的同时产生新epoch，类似Raft的term)
-
-> sync: PL补齐相比Follower多数派缺失的状态、之后各Follower再补齐相比PL缺失的状态，PL和Follower完成状态同步后PL变为正式Leader(established leader)
-
-> broadcast: Leader处理Client的写操作，并将状态变更广播至Follower，Follower多数派通过之后Leader发起将状态变更落地(deliver/commit)
-
-Raft：
-
-## 单个 Candidate 的竞选
-
-有三种节点：Follower、Candidate 和 Leader。Leader 会周期性的发送心跳包给 Follower。每个 Follower 都设置了一个随机的竞选超时时间，一般为 150ms~300ms，如果在这个时间内没有收到 Leader 的心跳包，就会变成 Candidate，进入竞选阶段。
-
-*   下图表示一个分布式系统的最初阶段，此时只有 Follower，没有 Leader。Follower A 等待一个随机的竞选超时时间之后，没收到 Leader 发来的心跳包，因此进入竞选阶段。
-
-[![](https://github.com/CyC2018/Interview-Notebook/raw/master/pics/111521118015898.gif)](https://github.com/CyC2018/Interview-Notebook/blob/master/pics/111521118015898.gif)
-
-*   此时 A 发送投票请求给其它所有节点。
-
-[![](https://github.com/CyC2018/Interview-Notebook/raw/master/pics/111521118445538.gif)](https://github.com/CyC2018/Interview-Notebook/blob/master/pics/111521118445538.gif)
-
-*   其它节点会对请求进行回复，如果超过一半的节点回复了，那么该 Candidate 就会变成 Leader。
-
-[![](https://github.com/CyC2018/Interview-Notebook/raw/master/pics/111521118483039.gif)](https://github.com/CyC2018/Interview-Notebook/blob/master/pics/111521118483039.gif)
-
-*   之后 Leader 会周期性地发送心跳包给 Follower，Follower 接收到心跳包，会重新开始计时。
-
-[![](https://github.com/CyC2018/Interview-Notebook/raw/master/pics/111521118640738.gif)](https://github.com/CyC2018/Interview-Notebook/blob/master/pics/111521118640738.gif)
-
-## [](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E4%B8%80%E8%87%B4%E6%80%A7.md#%E5%A4%9A%E4%B8%AA-candidate-%E7%AB%9E%E9%80%89)多个 Candidate 竞选
-
-*   如果有多个 Follower 成为 Candidate，并且所获得票数相同，那么就需要重新开始投票，例如下图中 Candidate B 和 Candidate D 都获得两票，因此需要重新开始投票。
-
-[![](https://github.com/CyC2018/Interview-Notebook/raw/master/pics/111521119203347.gif)](https://github.com/CyC2018/Interview-Notebook/blob/master/pics/111521119203347.gif)
-
-*   当重新开始投票时，由于每个节点设置的随机竞选超时时间不同，因此能下一次再次出现多个 Candidate 并获得同样票数的概率很低。
-
-[![](https://github.com/CyC2018/Interview-Notebook/raw/master/pics/111521119368714.gif)](https://github.com/CyC2018/Interview-Notebook/blob/master/pics/111521119368714.gif)
-
-## [](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E4%B8%80%E8%87%B4%E6%80%A7.md#%E6%97%A5%E5%BF%97%E5%A4%8D%E5%88%B6)日志复制
-
-*   来自客户端的修改都会被传入 Leader。注意该修改还未被提交，只是写入日志中。
-
-[![](https://github.com/CyC2018/Interview-Notebook/raw/master/pics/7.gif)](https://github.com/CyC2018/Interview-Notebook/blob/master/pics/7.gif)
-
-*   Leader 会把修改复制到所有 Follower。
-
-[![](https://github.com/CyC2018/Interview-Notebook/raw/master/pics/9.gif)](https://github.com/CyC2018/Interview-Notebook/blob/master/pics/9.gif)
-
-*   Leader 会等待大多数的 Follower 也进行了修改，然后才将修改提交。
-
-[![](https://github.com/CyC2018/Interview-Notebook/raw/master/pics/10.gif)](https://github.com/CyC2018/Interview-Notebook/blob/master/pics/10.gif)
-
-*   此时 Leader 会通知的所有 Follower 让它们也提交修改，此时所有节点的值达成一致。
-
-[![](https://github.com/CyC2018/Interview-Notebook/raw/master/pics/11.gif)](https://github.com/CyC2018/Interview-Notebook/blob/master/pics/11.gif)
-
-## zookeeper
-
-zookeeper在分布式系统中作为协调员的角色，可应用于Leader选举、分布式锁、配置管理等服务的实现。以下我们从zookeeper供的API、应用场景和监控三方面学习和了解zookeeper（以下简称ZK）。
-
-
-ZK API
-
-ZK以Unix文件系统树结构的形式管理存储的数据，图示如下：
-
-
-
-其中每个树节点被称为znode，每个znode类似一个文件，包含文件元信息(meta data)和数据。
-
- 
-
-以下我们用server表示ZK服务的提供方，client表示ZK服务的使用方，当client连接ZK时，相应创建session会话信息。
-
-有两种类型的znode：
-
-Regular: 该类型znode只能由client端显式创建或删除
-
-Ephemeral: client端可创建或删除该类型znode；当session终止时，ZK亦会删除该类型znode
-
-znode创建时还可以被打上sequential标志，被打上该标志的znode，将自行加上自增的数字后缀
-
- 
-
-    ZK提供了以下API，供client操作znode和znode中存储的数据：
-    
-    create(path, data, flags)：创建路径为path的znode，在其中存储data[]数据，flags可设置为Regular或Ephemeral，并可选打上sequential标志。
-    
-    delete(path, version)：删除相应path/version的znode
-    
-    exists(path,watch)：如果存在path对应znode，则返回true；否则返回false，watch标志可设置监听事件
-    
-    getData(path, watch)：返回对应znode的数据和元信息（如version等）
-    
-    setData(path, data, version)：将data[]数据写入对应path/version的znode
-    
-    getChildren(path, watch)：返回指定znode的子节点集合
-
-K应用场景
-
-基于以上ZK提供的znode和znode数据的操作，可轻松实现Leader选举、分布式锁、配置管理等服务。
-
- 
-
-Leader选举
-
-> 利用打上sequential标志的Ephemeral，我们可以实现Leader选举。假设需要从三个client中选取Leader，实现过程如下：
-> 
-> 1、各自创建Ephemeral类型的znode，并打上sequential标志：
-> 
-> [zk: localhost:2181(CONNECTED) 4] ls /master
-> [lock-0000000241, lock-0000000243, lock-0000000242]
-> 
-> 2、检查 /master 路径下的所有znode，如果自己创建的znode序号最小，则认为自己是Leader；否则记录序号比自己次小的znode
-> 
-> 3、非Leader在次小序号znode上设置监听事件，并重复执行以上步骤2
-
-配置管理
-
-znode可以存储数据，基于这一点，我们可以用ZK实现分布式系统的配置管理，假设有服务A，A扩容设备时需要将相应新增的ip/port同步到全网服务器的A.conf配置，实现过程如下：
-> 
-> 1、A扩容时，相应在ZK上新增znode，该znode数据形式如下：
-> 
-> [zk: localhost:2181(CONNECTED) 30] get /A/blk-0000340369
-> {"svr_info": [{"ip": "1.1.1.1.", "port": "11000"}]}
-> cZxid = 0x2ffdeda3be
-> ……
-> 
-> 2、全网机器监听 /A，当该znode下有新节点加入时，调用相应处理函数，将服务A的新增ip/port加入A.conf
-> 
-> 3、完成步骤2后，继续设置对 /A监听
-
-ZK监控
-
-ZK自身提供了一些“四字命令”，通过这些四字命令，我们可以获得ZK集群中，某台ZK的角色、znode数、健康状态等信息：
-
-
-小结
-
-zookeeper以目录树的形式管理数据，提供znode监听、数据设置等接口，基于这些接口，我们可以实现Leader选举、配置管理、命名服务等功能。结合四字命令，加上模拟zookeeper client 创建/删除znode，我们可以实现对zookeeper的有效监控。在各种分布式系统中，我们经常可以看到zookeeper的身影。
-
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/hxx/java/Java\345\220\216\347\253\257\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\344\271\246\345\215\225\357\274\210\344\273\216Java\345\237\272\347\241\200\345\210\260\345\210\206\345\270\203\345\274\217\357\274\211.md" "b/docs/hxx/java/Java\345\220\216\347\253\257\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\344\271\246\345\215\225\357\274\210\344\273\216Java\345\237\272\347\241\200\345\210\260\345\210\206\345\270\203\345\274\217\357\274\211.md"
index 7b4490d..65b42bb 100644
--- "a/docs/hxx/java/Java\345\220\216\347\253\257\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\344\271\246\345\215\225\357\274\210\344\273\216Java\345\237\272\347\241\200\345\210\260\345\210\206\345\270\203\345\274\217\357\274\211.md"
+++ "b/docs/hxx/java/Java\345\220\216\347\253\257\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\344\271\246\345\215\225\357\274\210\344\273\216Java\345\237\272\347\241\200\345\210\260\345\210\206\345\270\203\345\274\217\357\274\211.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
 * [网络](#网络)
   * [1 TCP/IP卷一](#1-tcpip卷一)
diff --git "a/docs/hxx/java/Java\345\267\245\347\250\213\345\270\210\344\277\256\347\202\274\344\271\213\350\267\257\357\274\210\346\240\241\346\213\233\346\200\273\347\273\223\357\274\211.md" "b/docs/hxx/java/Java\345\267\245\347\250\213\345\270\210\344\277\256\347\202\274\344\271\213\350\267\257\357\274\210\346\240\241\346\213\233\346\200\273\347\273\223\357\274\211.md"
index 1432c75..cd1bd87 100644
--- "a/docs/hxx/java/Java\345\267\245\347\250\213\345\270\210\344\277\256\347\202\274\344\271\213\350\267\257\357\274\210\346\240\241\346\213\233\346\200\273\347\273\223\357\274\211.md"
+++ "b/docs/hxx/java/Java\345\267\245\347\250\213\345\270\210\344\277\256\347\202\274\344\271\213\350\267\257\357\274\210\346\240\241\346\213\233\346\200\273\347\273\223\357\274\211.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
 * [前言](#前言)
 * [大学时期的迷茫与坚定](#大学时期的迷茫与坚定)
@@ -173,7 +173,7 @@
 
 具体的面经都比较长，这里大概介绍一下面试的情况，然后我会放上面经的链接供大家查阅。
 
-**1 阿里面经**  
+**1 阿里面经**
 
 [阿里中间件研发面经](http://mp.weixin.qq.com/s?__biz=MzUyMDc5MTYxNA==&mid=2247483852&idx=1&sn=9ec90620478b35d63a4a971a2222095d&chksm=f9e5b29dce923b8b2b080151e4b6b78373ee3f3e6f75b69252fc00b1a009d85c6f96944ed6e6&scene=21#wechat_redirect)
 
@@ -189,7 +189,7 @@
 
 阿里的面试体验还是比较好的，至少不要求手写算法，但是非常注重Java基础，中间件部门还会特别安排Java基础笔试。
 
-**2 腾讯面经**  
+**2 腾讯面经**
 
 [腾讯研发面经](http://mp.weixin.qq.com/s?__biz=MzUyMDc5MTYxNA==&mid=2247483849&idx=1&sn=f81fd42954589fb2deaf128026ddd856&chksm=f9e5b298ce923b8ef02ae36f7e9029fef0ddb7d5ae456dfa9d64c0073bebaacfb78fac4c8035&scene=21#wechat_redirect)
 
@@ -201,7 +201,7 @@ SNG的部门捞了我的简历，开始了面试，他们的技术栈主要是Ja
 
 腾讯的面试一如既往地注重考查网络和操作系统，并且喜欢问Linux底层的一些知识，在这方面我还是有很多不足的。
 
-**3 百度面经**  
+**3 百度面经**
 
 [百度研发面经](http://mp.weixin.qq.com/s?__biz=MzUyMDc5MTYxNA==&mid=2247483857&idx=1&sn=214b0f93db93407a7ac5a5149778cbad&chksm=f9e5b280ce923b96fcd535b2ef639fee2de78f12aa961d525b21760b11a3b95c0879113c2944&scene=21#wechat_redirect)
 
@@ -213,7 +213,7 @@ SNG的部门捞了我的简历，开始了面试，他们的技术栈主要是Ja
 
 百度的面试风格非常统一，每次面试基本都要到电脑上写算法，所以那段时间写算法写的头皮发麻。
 
-**4 网易面经**  
+**4 网易面经**
 
 [网易研发面经](http://mp.weixin.qq.com/s?__biz=MzUyMDc5MTYxNA==&mid=2247483875&idx=1&sn=fa9eaedd9cc3da172ad71d360c46a054&chksm=f9e5b2b2ce923ba443b91d56b24486d22b15bea16a4788e5ed3421906e84f8edd9ee10b2b306&scene=21#wechat_redirect)
 
@@ -225,7 +225,7 @@ SNG的部门捞了我的简历，开始了面试，他们的技术栈主要是Ja
 
 网易的面试比我想象中的要难，面试官会问的问题都比较深，并且会让你写一些结合实践的代码。
 
-**5 头条面经**  
+**5 头条面经**
 
 [今日头条研发面经](http://mp.weixin.qq.com/s?__biz=MzUyMDc5MTYxNA==&mid=2247483869&idx=1&sn=eedb7aebcb90cf3d4fe2450ef2d99947&chksm=f9e5b28cce923b9a9b0852a1c998ec014eb1aeb0442916c9028da276be8db0b2934c92292961&scene=21#wechat_redirect)
 
diff --git "a/docs/hxx/java/\344\270\272\344\273\200\344\271\210\346\210\221\344\274\232\351\200\211\346\213\251\350\265\260 Java \350\277\231\346\235\241\350\267\257\357\274\237.md" "b/docs/hxx/java/\344\270\272\344\273\200\344\271\210\346\210\221\344\274\232\351\200\211\346\213\251\350\265\260 Java \350\277\231\346\235\241\350\267\257\357\274\237.md"
index c72b4dd..ed2fe79 100644
--- "a/docs/hxx/java/\344\270\272\344\273\200\344\271\210\346\210\221\344\274\232\351\200\211\346\213\251\350\265\260 Java \350\277\231\346\235\241\350\267\257\357\274\237.md"	
+++ "b/docs/hxx/java/\344\270\272\344\273\200\344\271\210\346\210\221\344\274\232\351\200\211\346\213\251\350\265\260 Java \350\277\231\346\235\241\350\267\257\357\274\237.md"	
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [谈谈我的技术方向选择](#谈谈我的技术方向选择)
   * [谈谈各个技术方向的前景](#谈谈各个技术方向的前景)
diff --git "a/docs/hxx/java/\344\275\240\344\270\215\345\217\257\351\224\231\350\277\207\347\232\204Java\345\255\246\344\271\240\350\265\204\346\272\220\346\270\205\345\215\225.md" "b/docs/hxx/java/\344\275\240\344\270\215\345\217\257\351\224\231\350\277\207\347\232\204Java\345\255\246\344\271\240\350\265\204\346\272\220\346\270\205\345\215\225.md"
index b4a6a53..2885cab 100644
--- "a/docs/hxx/java/\344\275\240\344\270\215\345\217\257\351\224\231\350\277\207\347\232\204Java\345\255\246\344\271\240\350\265\204\346\272\220\346\270\205\345\215\225.md"
+++ "b/docs/hxx/java/\344\275\240\344\270\215\345\217\257\351\224\231\350\277\207\347\232\204Java\345\255\246\344\271\240\350\265\204\346\272\220\346\270\205\345\215\225.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [Java入门学习资源](#java入门学习资源)
   * [Java后端技术专栏](#java后端技术专栏)
@@ -38,25 +38,25 @@ https://blog.csdn.net/a724888
 
 总的来说算是比较全面了，做后端方向的同学可以参考一下。
 
-深入浅出Java核心技术  
+深入浅出Java核心技术
 
 https://blog.csdn.net/column/details/21930.html
 
 本专栏主要介绍Java基础，并且会结合实现原理以及具体实例来讲解。同时还介绍了Java集合类，设计模式以及Java8的相关知识。
 
-深入理解JVM虚拟机  
+深入理解JVM虚拟机
 
 https://blog.csdn.net/column/details/21960.html
 
 带你走进JVM的世界，整合高质量文章以阐述虚拟机的原理及相关技术，让开发者更好地了解Java的底层运行原理以及相应的调优方法。
 
-Java并发指南  
+Java并发指南
 
 https://blog.csdn.net/column/details/21961.html
 
 本专栏主要介绍Java并发编程相关的基本原理以及进阶知识。主要包括Java多线程基础，Java并发编程基本原理以及JUC并发包的使用和源码解析。
 
-Java网络编程与NIO  
+Java网络编程与NIO
 
 https://blog.csdn.net/column/details/21963.html
 
@@ -64,7 +64,7 @@ Java网络编程一直是很重要的一部分内容，其中涉及了socket的
 
 了解这部分知识对于理解网络编程有很多帮助。另外还补充了两个涉及NIO的重要技术：Tomcat和Netty。
 
-JavaWeb技术世界  
+JavaWeb技术世界
 
 https://blog.csdn.net/column/details/21850.html
 
@@ -72,7 +72,7 @@ https://blog.csdn.net/column/details/21850.html
 
 我们不仅要了解怎么使用它们，更要去了解它们为什么出现，其中一些技术的实现原理是什么。
 
-Spring与SpringMVC源码解析  
+Spring与SpringMVC源码解析
 
 https://blog.csdn.net/column/details/21851.html
 
@@ -108,7 +108,7 @@ https://blog.csdn.net/column/details/25481.html
 
 ## Java工程师书单
 
-我之前专门写了一篇文章介绍了Java工程师的书单，可以这里重点列举一些好书，推荐给大家。  
+我之前专门写了一篇文章介绍了Java工程师的书单，可以这里重点列举一些好书，推荐给大家。
 
 完整内容可以参考这篇文章：
 
@@ -126,15 +126,15 @@ Java工程师必备书单
 
 《Java核心技术卷一》 这本书还是比较适合入门的，当然，这种厚皮书要看完还是很有难度的，不过比起上面那本要简单一些
 
-《深入理解JVM虚拟机》 这本书是Java开发者必须看的书，很多jvm的文章都是提取这本书的内容。JVM是Java虚拟机，赋予了Java程序生命，所以好好看看把，我自己就已经看了三遍了。  
+《深入理解JVM虚拟机》 这本书是Java开发者必须看的书，很多jvm的文章都是提取这本书的内容。JVM是Java虚拟机，赋予了Java程序生命，所以好好看看把，我自己就已经看了三遍了。
 
 《Java并发编程艺术》 这本书是国内作者写的Java并发书籍，比上面那一本更简单易懂，适合作为并发编程的入门书籍，当然，学习并发原理之前，还是先把Java的多线程搞懂吧。
 
-《深入JavaWeb技术内幕》 这本书是Java Web的集大成之作，涵盖了大部分Java Web开发的知识点，不过一本书显然无法把所有细节都讲完，但是作为Java Web的入门或者进阶书籍来看的话还是很不错的。  
+《深入JavaWeb技术内幕》 这本书是Java Web的集大成之作，涵盖了大部分Java Web开发的知识点，不过一本书显然无法把所有细节都讲完，但是作为Java Web的入门或者进阶书籍来看的话还是很不错的。
 
 《Redis设计与实现》 该书全面而完整地讲解了 Redis 的内部运行机制,对 Redis 的大多数单机功能以及所有多机功能的实现原理进行了介绍。这本书把Redis的基本原理讲的一清二楚，包括数据结构，持久化，集群等内容，有空应该看看。
 
-《大型网站技术架构》 这本淘宝系技术指南还是非常值得推崇的，可以说是把大型网站的现代架构进行了一次简单的总结，内容涵盖了各方面，主要讲的是概念，很适合没接触过架构的同学入门。看完以后你会觉得后端技术原来这么博大精深。  
+《大型网站技术架构》 这本淘宝系技术指南还是非常值得推崇的，可以说是把大型网站的现代架构进行了一次简单的总结，内容涵盖了各方面，主要讲的是概念，很适合没接触过架构的同学入门。看完以后你会觉得后端技术原来这么博大精深。
 
 《分布式服务框架原理与实践》 上面那本书讲的是分布式架构的实践，而这本书更专注于分布式服务的原理讲解和对应实践，很好地讲述了分布式服务的基本概念，相关技术，以及解决方案等，对于想要学习分布式服务框架的同学来说是本好书。
 
@@ -176,9 +176,9 @@ https://www.zhihu.com/people/h2pl
 
 ## 技术大牛推荐
 
-1 江南白衣这位大大绝对是我的Java启蒙导师，他推荐的Java后端书架让我受益匪浅。  
+1 江南白衣这位大大绝对是我的Java启蒙导师，他推荐的Java后端书架让我受益匪浅。
 
-2 码农翻身刘欣，一位工作15年的IBM架构师，用最浅显易懂的文章讲解技术的那些事，力荐，他的文章帮我解决了很多困惑。  
+2 码农翻身刘欣，一位工作15年的IBM架构师，用最浅显易懂的文章讲解技术的那些事，力荐，他的文章帮我解决了很多困惑。
 
 3 CoolShell陈皓老师的博客相信大家都看过，干货很多，酷壳应该算是国内最有影响力的个人博客了。
 
diff --git "a/docs/hxx/java/\346\203\263\344\272\206\350\247\243Java\345\220\216\347\253\257\345\255\246\344\271\240\350\267\257\347\272\277\357\274\237\344\275\240\345\217\252\351\234\200\350\246\201\350\277\231\344\270\200\345\274\240\345\233\276\357\274\201.md" "b/docs/hxx/java/\346\203\263\344\272\206\350\247\243Java\345\220\216\347\253\257\345\255\246\344\271\240\350\267\257\347\272\277\357\274\237\344\275\240\345\217\252\351\234\200\350\246\201\350\277\231\344\270\200\345\274\240\345\233\276\357\274\201.md"
index 202769b..3da5c3d 100644
--- "a/docs/hxx/java/\346\203\263\344\272\206\350\247\243Java\345\220\216\347\253\257\345\255\246\344\271\240\350\267\257\347\272\277\357\274\237\344\275\240\345\217\252\351\234\200\350\246\201\350\277\231\344\270\200\345\274\240\345\233\276\357\274\201.md"
+++ "b/docs/hxx/java/\346\203\263\344\272\206\350\247\243Java\345\220\216\347\253\257\345\255\246\344\271\240\350\267\257\347\272\277\357\274\237\344\275\240\345\217\252\351\234\200\350\246\201\350\277\231\344\270\200\345\274\240\345\233\276\357\274\201.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
 * [![](https://mmbiz.qpic.cn/mmbiz_jpg/XHh0SksQZPNiac1cDGFicIqDTr2PoAq2jmvD3JnkUOiaBzxgZDjh9pcicS0rCKcGaWvGVnm7ZH2LvlODKAtzANlDZg/640?wx_fmt=jpeg&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)](#[]httpsmmbizqpiccnmmbiz_jpgxhh0sksqzpniac1cdgficiqdtr2poaq2jmvd3jnkuoiabzxgzdjh9pcics0rckcgawvgvnm7zh2lvlodkatzanldzg640wx_fmtjpegtpwebpwxfrom5wx_lazy1wx_co1)
 * [前言](#前言)
diff --git "a/docs/hxx/java/\346\210\221\347\232\204Java\347\247\213\346\213\233\351\235\242\347\273\217\345\244\247\345\220\210\351\233\206.md" "b/docs/hxx/java/\346\210\221\347\232\204Java\347\247\213\346\213\233\351\235\242\347\273\217\345\244\247\345\220\210\351\233\206.md"
index 3b54d0f..ca3dce9 100644
--- "a/docs/hxx/java/\346\210\221\347\232\204Java\347\247\213\346\213\233\351\235\242\347\273\217\345\244\247\345\220\210\351\233\206.md"
+++ "b/docs/hxx/java/\346\210\221\347\232\204Java\347\247\213\346\213\233\351\235\242\347\273\217\345\244\247\345\220\210\351\233\206.md"
@@ -1,11 +1,11 @@
-# Table of Contents
-
-* [阿里面经  ](#阿里面经  )
-* [腾讯面经  ](#腾讯面经  )
-* [百度面经  ](#百度面经  )
-* [网易面经  ](#网易面经  )
-* [头条面经  ](#头条面经  )
-* [快手&拼多多面经  ](#快手拼多多面经  )
+# 目录
+
+* [阿里面经](#阿里面经)
+* [腾讯面经](#腾讯面经)
+* [百度面经](#百度面经)
+* [网易面经](#网易面经)
+* [头条面经](#头条面经)
+* [快手&拼多多面经](#快手拼多多面经)
 * [京东&美团面经](#京东美团面经)
 * [斗鱼面经](#斗鱼面经)
 * [有赞面经](#有赞面经)
@@ -20,7 +20,7 @@
 ![](https://mmbiz.qpic.cn/mmbiz_jpg/XHh0SksQZPPAdahlOcBvxxLrx0ibYleGQvVONWia2JjwyBDoUibkYrcm3viapMOCBPehbX6eOxWSHNAa8TYTqj2ibYQ/640?wx_fmt=jpeg&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)
 
 
-# 阿里面经  
+# 阿里面经
 
 [阿里中间件研发面经](http://mp.weixin.qq.com/s?__biz=MzUyMDc5MTYxNA==&mid=2247483852&idx=1&sn=9ec90620478b35d63a4a971a2222095d&chksm=f9e5b29dce923b8b2b080151e4b6b78373ee3f3e6f75b69252fc00b1a009d85c6f96944ed6e6&scene=21#wechat_redirect)
 
@@ -36,7 +36,7 @@
 
 阿里的面试体验还是比较好的，至少不要求手写算法，但是非常注重Java基础，中间件部门还会特别安排Java基础笔试。
 
-# 腾讯面经  
+# 腾讯面经
 
 [腾讯研发面经](http://mp.weixin.qq.com/s?__biz=MzUyMDc5MTYxNA==&mid=2247483849&idx=1&sn=f81fd42954589fb2deaf128026ddd856&chksm=f9e5b298ce923b8ef02ae36f7e9029fef0ddb7d5ae456dfa9d64c0073bebaacfb78fac4c8035&scene=21#wechat_redirect)
 
@@ -48,7 +48,7 @@ SNG的部门捞了我的简历，开始了面试，他们的技术栈主要是Ja
 
 腾讯的面试一如既往地注重考查网络和操作系统，并且喜欢问Linux底层的一些知识，在这方面我还是有很多不足的。
 
-# 百度面经  
+# 百度面经
 
 [百度研发面经](http://mp.weixin.qq.com/s?__biz=MzUyMDc5MTYxNA==&mid=2247483857&idx=1&sn=214b0f93db93407a7ac5a5149778cbad&chksm=f9e5b280ce923b96fcd535b2ef639fee2de78f12aa961d525b21760b11a3b95c0879113c2944&scene=21#wechat_redirect)
 
@@ -60,7 +60,7 @@ SNG的部门捞了我的简历，开始了面试，他们的技术栈主要是Ja
 
 百度的面试风格非常统一，每次面试基本都要到电脑上写算法，所以那段时间写算法写的头皮发麻。
 
-# 网易面经  
+# 网易面经
 
 [网易研发面经](http://mp.weixin.qq.com/s?__biz=MzUyMDc5MTYxNA==&mid=2247483875&idx=1&sn=fa9eaedd9cc3da172ad71d360c46a054&chksm=f9e5b2b2ce923ba443b91d56b24486d22b15bea16a4788e5ed3421906e84f8edd9ee10b2b306&scene=21#wechat_redirect)
 
@@ -72,7 +72,7 @@ SNG的部门捞了我的简历，开始了面试，他们的技术栈主要是Ja
 
 网易的面试比我想象中的要难，面试官会问的问题都比较深，并且会让你写一些结合实践的代码。
 
-# 头条面经  
+# 头条面经
 
 [今日头条研发面经](http://mp.weixin.qq.com/s?__biz=MzUyMDc5MTYxNA==&mid=2247483869&idx=1&sn=eedb7aebcb90cf3d4fe2450ef2d99947&chksm=f9e5b28cce923b9a9b0852a1c998ec014eb1aeb0442916c9028da276be8db0b2934c92292961&scene=21#wechat_redirect)
 
@@ -82,7 +82,7 @@ SNG的部门捞了我的简历，开始了面试，他们的技术栈主要是Ja
 
 然后就开始了一下午的视频面试，一共三轮技术面试，每一轮都要写代码，问问题的风格有点像腾讯，也喜欢问一些底层知识，让我有点懵逼。
 
-# 快手&拼多多面经  
+# 快手&拼多多面经
 
 [拼多多&快手研发面经](http://mp.weixin.qq.com/s?__biz=MzUyMDc5MTYxNA==&mid=2247483878&idx=1&sn=aaafff4b1171361ccd1d94708d2beaa0&chksm=f9e5b2b7ce923ba10140dff71dd3a0f9a20593434a32cec66929116bba196dc7496abf502884&scene=21#wechat_redirect)
 
diff --git a/docs/hxx/think/copy.md b/docs/hxx/think/copy.md
index c62954a..813a411 100644
--- a/docs/hxx/think/copy.md
+++ b/docs/hxx/think/copy.md
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
 * [微信公众号](#微信公众号)
   * [个人公众号：黄小斜](#个人公众号：黄小斜)
diff --git "a/docs/\347\224\265\345\255\220\344\271\246.md" "b/docs/hxx/\347\224\265\345\255\220\344\271\246.md"
similarity index 87%
rename from "docs/\347\224\265\345\255\220\344\271\246.md"
rename to "docs/hxx/\347\224\265\345\255\220\344\271\246.md"
index 9f5fa61..5908230 100644
--- "a/docs/\347\224\265\345\255\220\344\271\246.md"
+++ "b/docs/hxx/\347\224\265\345\255\220\344\271\246.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
 * [《菜鸟程序员成长之路：从技术小白到阿里巴巴Java工程师》](#《菜鸟程序员成长之路：从技术小白到阿里巴巴java工程师》)
   * [Java学习](#java学习)
@@ -17,9 +17,7 @@
     * [一些思考](#一些思考)
     * [互联网行业思考](#互联网行业思考)
     * [职场心得：](#职场心得：)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
   * [知识星球](#知识星球)
 
 
@@ -47,7 +45,7 @@
 
 ### 新手上路
 
- [用大白话告诉你 ：Java 后端到底是在做什么？](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247485885&idx=1&sn=0b3e02d09559ad0fe371ce915a77d7e0&chksm=fa59ce7acd2e476c501ca68b311de5abaf8021c5baa96fa24e0ca621acaaf4b1c64e2e16f3cb&scene=21#wechat_redirect)
+[用大白话告诉你 ：Java 后端到底是在做什么？](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247485885&idx=1&sn=0b3e02d09559ad0fe371ce915a77d7e0&chksm=fa59ce7acd2e476c501ca68b311de5abaf8021c5baa96fa24e0ca621acaaf4b1c64e2e16f3cb&scene=21#wechat_redirect)
 
 [Java工程师学习指南（入门篇）](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247484573&idx=2&sn=7baf8dfe36357264ab25010429644792&chksm=fa59c35acd2e4a4c24c5b55003136b6b8c5e778273714093b2df7a016d3bb0ed0c774573a7a4&scene=21#wechat_redirect)
 
@@ -200,15 +198,15 @@
 [马云退隐前，在年会上说了最重要的三件事](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247486268&idx=1&sn=dd13517634cd4f72f824278f93edebef&chksm=fa59ccfbcd2e45ed522c377ab3fa4554632f36c836e9b2e1490fb4748f4c0cdee9a4a99c91a6&scene=21#wechat_redirect)
 
 
- [那些拼命加班的程序员们，后来都怎么样了？](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247485861&idx=1&sn=e90ac488593b4b7adb4ac46303e715be&chksm=fa59ce62cd2e477410c26233ed6518e34fdd772e27ea7538bddfac36a549a50cab29b27881f4&scene=21#wechat_redirect)
+[那些拼命加班的程序员们，后来都怎么样了？](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247485861&idx=1&sn=e90ac488593b4b7adb4ac46303e715be&chksm=fa59ce62cd2e477410c26233ed6518e34fdd772e27ea7538bddfac36a549a50cab29b27881f4&scene=21#wechat_redirect)
 
- [互联网浪潮之下，聊聊 90 后所面临的困境](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247485843&idx=1&sn=492c9d3f7c9e32de9da7d833013cb9b9&chksm=fa59ce54cd2e4742939a5eb42a470bf282dbc79cb6f38ac9ec0112af5282091a9f2cd3615104&scene=21#wechat_redirect)
+[互联网浪潮之下，聊聊 90 后所面临的困境](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247485843&idx=1&sn=492c9d3f7c9e32de9da7d833013cb9b9&chksm=fa59ce54cd2e4742939a5eb42a470bf282dbc79cb6f38ac9ec0112af5282091a9f2cd3615104&scene=21#wechat_redirect)
 
- [程序员的工资到底花到哪里去了？](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247485826&idx=1&sn=cc13da981115341666ae919dd2646cb4&chksm=fa59ce45cd2e475344776b1f7f52a6d281d96210e21229c5d2f300cfad585f712b636cf60427&scene=21#wechat_redirect)
+[程序员的工资到底花到哪里去了？](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247485826&idx=1&sn=cc13da981115341666ae919dd2646cb4&chksm=fa59ce45cd2e475344776b1f7f52a6d281d96210e21229c5d2f300cfad585f712b636cf60427&scene=21#wechat_redirect)
 
- [互联网公司里都有哪些潜规则？](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247485819&idx=1&sn=816e20fa37a2abd99fa714c1c13e0402&chksm=fa59cebccd2e47aa8572071dadbb301008cd425cf0de4d71978af82b44bd3554faacfa8ad462&scene=21#wechat_redirect)
+[互联网公司里都有哪些潜规则？](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247485819&idx=1&sn=816e20fa37a2abd99fa714c1c13e0402&chksm=fa59cebccd2e47aa8572071dadbb301008cd425cf0de4d71978af82b44bd3554faacfa8ad462&scene=21#wechat_redirect)
 
- [大厂程序员的一天是如何度过的？](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247485803&idx=1&sn=5814daaa71fb164d33d858311708f1c3&chksm=fa59ceaccd2e47baf573c73fcefbdc93e74becd8b9d4c533cf79404a3f90b2b6cdb46eee4e40&scene=21#wechat_redirect)
+[大厂程序员的一天是如何度过的？](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247485803&idx=1&sn=5814daaa71fb164d33d858311708f1c3&chksm=fa59ceaccd2e47baf573c73fcefbdc93e74becd8b9d4c533cf79404a3f90b2b6cdb46eee4e40&scene=21#wechat_redirect)
 
 
 ### 职场心得：
@@ -224,23 +222,7 @@
 
 [从三流小公司到一线大厂，聊聊程序员的成长之道](http://mp.weixin.qq.com/s?__biz=MzUyOTk5NDQwOA==&mid=2247485427&idx=1&sn=6004e6bed110c44f0d8ce77a2ffca1dc&chksm=fa59c034cd2e492253625d91492467b841c5f6de21d299cae01f05483ab363f856e8d97fe339&scene=21#wechat_redirect)
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
 
 
 
diff --git a/docs/index.html b/docs/index.html
deleted file mode 100644
index 3d8c75e..0000000
--- a/docs/index.html
+++ /dev/null
@@ -1,45 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title>JavaGuide</title>
-  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
-  <meta name="description" content="Description">
-  <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
-  <link rel="stylesheet" href="//unpkg.com/docsify/lib/themes/vue.css">
-  <link rel="stylesheet" href="//unpkg.com/docsify/lib/themes/prism.css">
-</head>
-<body>
-  <div id="app"></div>
-  <script>
-    window.$docsify = {
-      name: 'JavaGuide',
-      repo: 'https://github.com/Snailclimb/JavaGuide',
-	  maxLevel: 3,//最大支持渲染的标题层级
-	  homepage: 'HomePage.md',
-	  coverpage: true,//封面,_coverpage.md
-	  auto2top: true,//切换页面后是否自动跳转到页面顶部
-	  //ga: 'UA-138586553-1',
-	  //logo: 'https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3logo-透明.png' ,
-     search: {
-	    //maxAge: 86400000, // 过期时间，单位毫秒，默认一天
-        paths: 'auto',
-		placeholder: '搜索',
-		noData: '找不到结果',
-	    // 搜索标题的最大程级, 1 - 6
-        depth: 3,
-        },
-	  
-    }
-  </script>
-  <script src="//unpkg.com/docsify/lib/docsify.min.js"></script>
-  <!--Java代码高亮-->
-  <script src="//unpkg.com/prismjs/components/prism-java.js"></script>
-  <!--全文搜索,直接用官方提供的无法生效-->
-  <script src="https://cdn.bootcss.com/docsify/4.5.9/plugins/search.min.js"></script>
-  <!--谷歌统计
-  <script src="//unpkg.com/docsify" data-ga="UA-138586553-1"></script>
-  <script src="//unpkg.com/docsify/lib/plugins/ga.js"></script>
-  -->
-</body>
-</html>
diff --git a/docs/interview/BATJ-Experience/2019alipay-pinduoduo-toutiao.md b/docs/interview/BATJ-Experience/alipay-pinduoduo-toutiao.md
similarity index 99%
rename from docs/interview/BATJ-Experience/2019alipay-pinduoduo-toutiao.md
rename to docs/interview/BATJ-Experience/alipay-pinduoduo-toutiao.md
index 1db1539..27df6fa 100644
--- a/docs/interview/BATJ-Experience/2019alipay-pinduoduo-toutiao.md
+++ b/docs/interview/BATJ-Experience/alipay-pinduoduo-toutiao.md
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
 * [2019年蚂蚁金服、头条、拼多多的面试总结](#2019年蚂蚁金服、头条、拼多多的面试总结)
   * [准备过程](#准备过程)
diff --git "a/docs/interview/BATJ-Experience/\350\232\202\350\232\201\351\207\221\346\234\215\345\256\236\344\271\240\347\224\237\351\235\242\347\273\217\346\200\273\347\273\223(\345\267\262\346\213\277\345\217\243\345\244\264offer).md" "b/docs/interview/BATJ-Experience/\350\232\202\350\232\201\351\207\221\346\234\215\345\256\236\344\271\240\347\224\237\351\235\242\347\273\217\346\200\273\347\273\223(\345\267\262\346\213\277\345\217\243\345\244\264offer).md"
index 95f8403..61fb537 100644
--- "a/docs/interview/BATJ-Experience/\350\232\202\350\232\201\351\207\221\346\234\215\345\256\236\344\271\240\347\224\237\351\235\242\347\273\217\346\200\273\347\273\223(\345\267\262\346\213\277\345\217\243\345\244\264offer).md"
+++ "b/docs/interview/BATJ-Experience/\350\232\202\350\232\201\351\207\221\346\234\215\345\256\236\344\271\240\347\224\237\351\235\242\347\273\217\346\200\273\347\273\223(\345\267\262\346\213\277\345\217\243\345\244\264offer).md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
     * [一面 (37 分钟左右)](#一面-37-分钟左右)
     * [二面 (33 分钟左右)](#二面-33-分钟左右)
diff --git "a/docs/interview/BATJ-Experience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md" "b/docs/interview/BATJ-Experience/\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md"
similarity index 99%
rename from "docs/interview/BATJ-Experience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md"
rename to "docs/interview/BATJ-Experience/\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md"
index 5a6e7e3..b06c915 100644
--- "a/docs/interview/BATJ-Experience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md"
+++ "b/docs/interview/BATJ-Experience/\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
     * [前言](#前言)
     * [一面(技术面)](#一面技术面)
diff --git "a/docs/interview/InterviewQuestions/Java\346\240\270\345\277\203\346\212\200\346\234\257\346\200\273\347\273\223.md" "b/docs/interview/InterviewQuestions/Java\346\240\270\345\277\203\346\212\200\346\234\257\346\200\273\347\273\223.md"
index 917620c..bc89b6d 100644
--- "a/docs/interview/InterviewQuestions/Java\346\240\270\345\277\203\346\212\200\346\234\257\346\200\273\347\273\223.md"
+++ "b/docs/interview/InterviewQuestions/Java\346\240\270\345\277\203\346\212\200\346\234\257\346\200\273\347\273\223.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [Java基础学习总结](#java基础学习总结)
     * [面向对象三大特性](#面向对象三大特性)
@@ -20,9 +20,7 @@
     * [IO流](#io流)
     * [网络编程](#网络编程)
     * [Java8](#java8)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
+
 
 
 ---
@@ -303,20 +301,4 @@ https://blog.csdn.net/a724888
 
 
 
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
 
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git a/docs/interview/PreparingForInterview/JavaInterviewLibrary.md b/docs/interview/PreparingForInterview/JavaInterviewLibrary.md
index e3d4e1d..2325618 100644
--- a/docs/interview/PreparingForInterview/JavaInterviewLibrary.md
+++ b/docs/interview/PreparingForInterview/JavaInterviewLibrary.md
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [知识点相关](#知识点相关)
     * [1.JavaGuide](#1javaguide)
diff --git a/docs/interview/PreparingForInterview/JavaProgrammerNeedKnow.md b/docs/interview/PreparingForInterview/JavaProgrammerNeedKnow.md
index 417d1f9..3997584 100644
--- a/docs/interview/PreparingForInterview/JavaProgrammerNeedKnow.md
+++ b/docs/interview/PreparingForInterview/JavaProgrammerNeedKnow.md
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
     * [Question1:我是双非/三本/专科学校的，我有机会进入大厂吗？](#question1我是双非三本专科学校的，我有机会进入大厂吗？)
     * [Question2:非计算机专业的学生能学好Java后台吗？我能进大厂吗？](#question2非计算机专业的学生能学好java后台吗？我能进大厂吗？)
diff --git a/docs/interview/PreparingForInterview/interviewPrepare.md b/docs/interview/PreparingForInterview/interviewPrepare.md
index 89a3dc6..72201be 100644
--- a/docs/interview/PreparingForInterview/interviewPrepare.md
+++ b/docs/interview/PreparingForInterview/interviewPrepare.md
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
   * [1 如何获取大厂面试机会？](#1-如何获取大厂面试机会？)
   * [2  面试前的准备](#2--面试前的准备)
diff --git "a/docs/interview/PreparingForInterview/\345\246\202\346\236\234\351\235\242\350\257\225\345\256\230\351\227\256\344\275\240\342\200\234\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\351\227\256\346\210\221\345\220\227\357\274\237\342\200\235\346\227\266\357\274\214\344\275\240\350\257\245\345\246\202\344\275\225\345\233\236\347\255\224.md" "b/docs/interview/PreparingForInterview/\345\246\202\346\236\234\351\235\242\350\257\225\345\256\230\351\227\256\344\275\240\342\200\234\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\351\227\256\346\210\221\345\220\227\357\274\237\342\200\235\346\227\266\357\274\214\344\275\240\350\257\245\345\246\202\344\275\225\345\233\236\347\255\224.md"
index 0dc99b2..c1f742b 100644
--- "a/docs/interview/PreparingForInterview/\345\246\202\346\236\234\351\235\242\350\257\225\345\256\230\351\227\256\344\275\240\342\200\234\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\351\227\256\346\210\221\345\220\227\357\274\237\342\200\235\346\227\266\357\274\214\344\275\240\350\257\245\345\246\202\344\275\225\345\233\236\347\255\224.md"
+++ "b/docs/interview/PreparingForInterview/\345\246\202\346\236\234\351\235\242\350\257\225\345\256\230\351\227\256\344\275\240\342\200\234\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\351\227\256\346\210\221\345\220\227\357\274\237\342\200\235\346\227\266\357\274\214\344\275\240\350\257\245\345\246\202\344\275\225\345\233\236\347\255\224.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
     * [这个问题对最终面试结果的影响到底大不大?](#这个问题对最终面试结果的影响到底大不大)
     * [真诚一点,不要问太 Low 的问题](#真诚一点不要问太-low-的问题)
diff --git "a/docs/interview/PreparingForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" "b/docs/interview/PreparingForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md"
index 096ecaf..f391399 100644
--- "a/docs/interview/PreparingForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md"
+++ "b/docs/interview/PreparingForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
 * [程序员简历就该这样写](#程序员简历就该这样写)
   * [为什么说简历很重要？](#为什么说简历很重要？)
diff --git "a/docs/interview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" "b/docs/interview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md"
index 4e62535..8b51c2a 100644
--- "a/docs/interview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md"
+++ "b/docs/interview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md"
@@ -1,4 +1,4 @@
-# Table of Contents
+# 目录
 
 * [一 基础篇](#一-基础篇)
   * [1. `System.out.println(3|9)`输出什么?](#1-`systemoutprintln39`输出什么)
diff --git "a/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2201\357\274\232SpringMVC\346\246\202\350\277\260.md" "b/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2201\357\274\232SpringMVC\346\246\202\350\277\260.md"
deleted file mode 100644
index 167e1fe..0000000
--- "a/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2201\357\274\232SpringMVC\346\246\202\350\277\260.md"
+++ /dev/null
@@ -1,1240 +0,0 @@
-# Table of Contents
-
-  * [Web MVC简介](#web-mvc简介)
-    * [Web开发中的请求-响应模型：](#web开发中的请求-响应模型：)
-    * [标准MVC模型概述](#标准mvc模型概述)
-    * [Web MVC概述](#web-mvc概述)
-    * [Web端开发发展历程](#web端开发发展历程)
-  * [Spring Web MVC是什么](#spring-web-mvc是什么)
-  * [Spring Web MVC能帮我们做什么](#spring-web-mvc能帮我们做什么)
-  * [Spring Web MVC架构](#spring-web-mvc架构)
-    * [Spring Web MVC处理请求的流程](#spring-web-mvc处理请求的流程)
-    * [Spring Web MVC架构](#spring-web-mvc架构-1)
-  * [Spring Web MVC优势](#spring-web-mvc优势)
-  * [DispatcherServlet作用](#dispatcherservlet作用)
-
-
-转自：[跟开涛学SpringMVC](http://jinnianshilongnian.iteye.com/category/231099)
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-文章将同步到我的个人博客：
-> www.how2playlife.com
-
-本文是微信公众号【Java技术江湖】的《Spring和SpringMVC源码分析》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从spring基础入手，一步步地学习spring基础和springmvc的框架知识，并上手进行项目实战，spring框架是每一个Java工程师必须要学习和理解的知识点，进一步来说，你还需要掌握spring甚至是springmvc的源码以及实现原理，才能更完整地了解整个spring技术体系，形成自己的知识框架。
-
-后续还会有springboot和springcloud的技术专题，陆续为大家带来，敬请期待。
-
-为了更好地总结和检验你的学习成果，本系列文章也会提供部分知识点对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-
-
-
-
-
-
-## Web MVC简介
-
-
-
-
-
-### Web开发中的请求-响应模型：
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/2fc5edc55fa262fddccecc1816f5ff7b__1.JPG)
-
-
-
-
-
-在Web世界里，具体步骤如下：
-
-
-
-
-
-1、  Web浏览器（如IE）发起请求，如访问[http://sishuok.com](http://sishuok.com/)
-
-
-
-
-
-2、  Web服务器（如Tomcat）接收请求，处理请求（比如用户新增，则将把用户保存一下），最后产生响应（一般为html）。
-
-
-
-
-
-3、web服务器处理完成后，返回内容给web客户端（一般就是我们的浏览器），客户端对接收的内容进行处理（如web浏览器将会对接收到的html内容进行渲染以展示给客户）。
-
-
-
-
-
-**因此，在Web世界里：**
-
-
-
-
-
-都是Web客户端发起请求，Web服务器接收、处理并产生响应。
-
-
-
-
-
-一般Web服务器是不能主动通知Web客户端更新内容。虽然现在有些技术如服务器推（如Comet）、还有现在的HTML5 websocket可以实现Web服务器主动通知Web客户端。
-
-
-
-
-
-到此我们了解了在web开发时的请求/响应模型，接下来我们看一下标准的MVC模型是什么。
-
-
-
-
-
-### 标准MVC模型概述
-
-
-
-
-
-**MVC模型：**是一种架构型的模式，本身不引入新功能，只是帮助我们将开发的结构组织的更加合理，使展示与模型分离、流程控制逻辑、业务逻辑调用与展示逻辑分离。如图1-2
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/a633b31a42f0224c9bf66cd3cc886e04__2.JPG)
-
-
-
-
-
-图1-2
-
-
-
-
-
-**首先让我们了解下MVC（Model-View-Controller）三元组的概念：**
-
-
-
-
-
-**Model（模型）：**数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据） 和 服务层（行为）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。
-
-
-
-
-
-**View（视图）：**负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。
-
-
-
-
-
-**Controller（控制器）：**接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。 也就是说控制器做了个调度员的工作，。
-
-
-
-
-
-从图1-1我们还看到，在标准的MVC中模型能主动推数据给视图进行更新（观察者设计模式，在模型上注册视图，当模型更新时自动更新视图），但在Web开发中模型是无法主动推给视图（无法主动更新用户界面），因为在Web开发是请求-响应模型。
-
-
-
-
-
-那接下来我们看一下在Web里MVC是什么样子，我们称其为 Web MVC 来区别标准的MVC。
-
-
-
-
-
-### Web MVC概述
-
-
-
-
-
-模型-视图-控制器概念和标准MVC概念一样，请参考1.2，我们再看一下Web MVC标准架构，如图1-3：
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/baa1df353ed98b79231b535bc1f73dea__3.JPG)
-
-
-
-
-
-如图1-3
-
-
-
-
-
-在Web MVC模式下，模型无法主动推数据给视图，如果用户想要视图更新，需要再发送一次请求（即请求-响应模型）。
-
-
-
-
-
-概念差不多了，我们接下来了解下Web端开发的发展历程，和使用代码来演示一下Web MVC是如何实现的，还有为什么要使用MVC这个模式呢？
-
-
-
-
-
-### Web端开发发展历程
-
-
-
-
-
-此处我们只是简单的叙述比较核心的历程，如图1-4
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/41f193e4f961be27d511789df2ee7680__4.JPG)
-
-
-
-
-
-图1-4
-
-
-
-
-
-**1.4.1、CGI**：（Common Gateway Interface）公共网关接口，一种在web服务端使用的脚本技术，使用C或Perl语言编写，用于接收web用户请求并处理，最后动态产生响应给用户，但每次请求将产生一个进程，重量级。
-
-
-
-
-
-**1.4.2、Servlet**：一种JavaEE web组件技术，是一种在服务器端执行的web组件，用于接收web用户请求并处理，最后动态产生响应给用户。但每次请求只产生一个线程（而且有线程池），轻量级。而且能利用许多JavaEE技术（如JDBC等）。本质就是在java代码里面 输出 html流。但表现逻辑、控制逻辑、业务逻辑调用混杂。如图1-5
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/799db5c79c85cb59b68b915916f8dddc__5.JPG "点击查看原始大小图片")
-
-
-
-
-
-图1-5
-
-
-
-
-
-如图1-5，这种做法是绝对不可取的，控制逻辑、表现代码、业务逻辑对象调用混杂在一起，最大的问题是直接在Java代码里面输出Html，这样前端开发人员无法进行页面风格等的设计与修改，即使修改也是很麻烦，因此实际项目这种做法不可取。
-
-
-
-
-
-**1.4.3、JSP：**（Java Server Page）：一种在服务器端执行的web组件，是一种运行在标准的HTML页面中嵌入脚本语言（现在只支持Java）的模板页面技术。本质就是在html代码中嵌入java代码。JSP最终还是会被编译为Servlet，只不过比纯Servlet开发页面更简单、方便。但表现逻辑、控制逻辑、业务逻辑调用还是混杂。如图1-6
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/7486df5510b6068a360d8f0c6bbb706c__6.JPG "点击查看原始大小图片")
-
-
-
-
-
-图1-6
-
-
-
-
-
-如图1-6，这种做法也是绝对不可取的，控制逻辑、表现代码、业务逻辑对象调用混杂在一起，但比直接在servlet里输出html要好一点，前端开发人员可以进行简单的页面风格等的设计与修改（但如果嵌入的java脚本太多也是很难修改的），因此实际项目这种做法不可取。
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/c59e61daa2ed98f75aab1ae3397fb235__7.JPG)
-
-
-
-
-
-JSP本质还是Servlet，最终在运行时会生成一个Servlet（如tomcat，将在tomcat\work\Catalina\web应用名\org\apache\jsp下生成），但这种使得写html简单点，但仍是控制逻辑、表现代码、业务逻辑对象调用混杂在一起。
-
-
-
-
-
-**1.4.4、Model1：**可以认为是JSP的增强版，可以认为是jsp+javabean如图1-7
-
-
-
-
-
-特点：使用jsp:useBean标准动作，自动将请求参数封装为JavaBean组件；还必须使用java脚本执行控制逻辑。
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/c25b9ce9064a37ab93ffe02711b3ecc7__8.JPG "点击查看原始大小图片")
-
-
-
-
-
-图1-7
-
-
-
-
-
-此处我们可以看出，使用jsp:useBean标准动作可以简化javabean的获取/创建，及将请求参数封装到javabean，再看一下Model1架构，如图1-8。
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/d3b5b2ec88706fff7ef4b98d110837d1__9.JPG "点击查看原始大小图片")
-
-
-
-
-
-图1-8 Model1架构
-
-
-
-
-
-Model1架构中，JSP负责控制逻辑、表现逻辑、业务对象（javabean）的调用，只是比纯JSP简化了获取请求参数和封装请求参数。同样是不好的，在项目中应该严禁使用（或最多再demo里使用）。
-
-
-
-
-
-**1.4.5、Model2：**在JavaEE世界里，它可以认为就是**Web MVC**模型
-
-
-
-
-
-Model2架构其实可以认为就是我们所说的Web MVC模型，只是控制器采用Servlet、模型采用JavaBean、视图采用JSP，如图1-9
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/a6b7b2ca293e610a7a2b32e47a16d718__10.JPG "点击查看原始大小图片")
-
-
-
-
-
-图1-9 Model2架构
-
-
-
-
-
-具体代码事例如下：
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/254a61cd5c20f1e8f0e1012f02cdaa31__11.JPG "点击查看原始大小图片")
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/0ec4c098750790295eaad2f1b3a4dc82__12.JPG "点击查看原始大小图片")
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/1f330763be94e5abe7ecdd7928930dbb__13.JPG "点击查看原始大小图片")
-
-
-
-
-
-从Model2架构可以看出，视图和模型分离了，控制逻辑和展示逻辑分离了。
-
-
-
-
-
-但我们也看到严重的缺点：
-
-
-
-
-
-1．  1、控制器：
-
-
-
-
-
-1．1．1、控制逻辑可能比较复杂，其实我们可以按照规约，如请求参数submitFlag=toAdd，我们其实可以直接调用toAdd方法，来简化控制逻辑；而且每个模块基本需要一个控制器，造成控制逻辑可能很复杂；
-
-
-
-
-
-1．1．2、请求参数到模型的封装比较麻烦，如果能交给框架来做这件事情，我们可以从中得到解放；
-
-
-
-
-
-1．1．3、选择下一个视图，严重依赖Servlet API，这样很难或基本不可能更换视图；
-
-
-
-
-
-1．1．4、给视图传输要展示的模型数据，使用Servlet API，更换视图技术也要一起更换，很麻烦。
-
-
-
-
-
-1.2、模型：
-
-
-
-
-
-1．2．1、此处模型使用JavaBean，可能造成JavaBean组件类很庞大，一般现在项目都是采用三层架构，而不采用JavaBean。
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/1570f54f6a52301d8ea58fe8fa9efb29__14.JPG)
-
-
-
-
-
-1.3、视图
-
-
-
-
-
-1．3．1、现在被绑定在JSP，很难更换视图，比如Velocity、FreeMarker；比如我要支持Excel、PDF视图等等。
-
-
-
-
-
-**1.4.5、服务到工作者：Front Controller + Application Controller + Page Controller + Context**
-
-
-
-
-
-即，前端控制器+应用控制器+页面控制器（也有称其为动作）+上下文，也是Web MVC，只是责任更加明确，详情请参考《核心J2EE设计模式》和《企业应用架构模式》如图1-10：
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/e7fae17e52bb3664d0d3f4ea8db7ae55__15.JPG "点击查看原始大小图片")
-
-
-
-
-
-图1-10
-
-
-
-
-
-运行流程如下：
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/1/925c5ff2cc8613c898b05a4817db1f56__16.JPG "点击查看原始大小图片")
-
-
-
-
-
-职责：
-
-
-
-
-
-**Front Controller：**前端控制器，负责为表现层提供统一访问点，从而避免Model2中出现的重复的控制逻辑（由前端控制器统一回调相应的功能方法，如前边的根据submitFlag=login转调login方法）；并且可以为多个请求提供共用的逻辑（如准备上下文等等），将选择具体视图和具体的功能处理（如login里边封装请求参数到模型，并调用业务逻辑对象）分离。
-
-
-
-
-
-**Application Controller：**应用控制器，前端控制器分离选择具体视图和具体的功能处理之后，需要有人来管理，应用控制器就是用来选择具体视图技术（视图的管理）和具体的功能处理（页面控制器/命令对象/动作管理），一种策略设计模式的应用，可以很容易的切换视图/页面控制器，相互不产生影响。
-
-
-
-
-
-**Page Controller(Command)：**页面控制器/动作/处理器：功能处理代码，收集参数、封装参数到模型，转调业务对象处理模型，返回逻辑视图名交给前端控制器（和具体的视图技术解耦），由前端控制器委托给应用控制器选择具体的视图来展示，可以是命令设计模式的实现。页面控制器也被称为处理器或动作。
-
-
-
-
-
-**Context：**上下文，还记得Model2中为视图准备要展示的模型数据吗，我们直接放在request中（Servlet API相关），有了上下文之后，我们就可以将相关数据放置在上下文，从而与协议无关（如Servlet API）的访问/设置模型数据，一般通过ThreadLocal模式实现。
-
-
-
-
-
-到此，我们回顾了整个web开发架构的发展历程，可能不同的web层框架在细节处理方面不同，但的目的是一样的：
-
-
-
-
-
-干净的web表现层：
-
-
-
-
-
-模型和视图的分离；
-
-
-
-
-
-控制器中的控制逻辑与功能处理分离（收集并封装参数到模型对象、业务对象调用）；
-
-
-
-
-
-控制器中的视图选择与具体视图技术分离。
-
-
-
-
-
-轻薄的web表现层：
-
-
-
-
-
-做的事情越少越好，薄薄的，不应该包含无关代码；
-
-
-
-
-
-只负责收集并组织参数到模型对象，启动业务对象的调用；
-
-
-
-
-
-控制器只返回逻辑视图名并由相应的应用控制器来选择具体使用的视图策略；
-
-
-
-
-
-尽量少使用框架特定API，保证容易测试。
-
-
-
-
-
-到此我们了解Web MVC的发展历程，接下来让我们了解下Spring MVC到底是什么、架构及来个HelloWorld了解下具体怎么使用吧。
-
-
-
-
-
-本章具体代码请参考 springmvc-chapter1工程。
-
-
-
-
-
-## Spring Web MVC是什么
-
-
-
-
-
-Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常Web开发的。
-
-
-
-
-
-另外还有一种基于组件的、事件驱动的Web框架在此就不介绍了，如Tapestry、JSF等。
-
-
-
-
-
-Spring Web MVC也是服务到工作者模式的实现，但进行可优化。前端控制器是`DispatcherServlet；`应用控制器其实拆为处理器映射器(Handler Mapping)进行处理器管理和视图解析器(View Resolver)进行视图管理；页面控制器/动作/处理器为Controller接口（仅包含`ModelAndView handleRequest(request, response)` 方法）的实现（也可以是任何的POJO类）；支持本地化（Locale）解析、主题（Theme）解析及文件上传等；提供了非常灵活的数据验证、格式化和数据绑定机制；提供了强大的约定大于配置（惯例优先原则）的契约式编程支持。
-
-
-
-
-
-## Spring Web MVC能帮我们做什么
-
-
-
-
-
-√让我们能非常简单的设计出干净的Web层和薄薄的Web层；
-
-
-
-
-
-√进行更简洁的Web层的开发；
-
-
-
-
-
-√天生与Spring框架集成（如IoC容器、AOP等）；
-
-
-
-
-
-√提供强大的约定大于配置的契约式编程支持；
-
-
-
-
-
-√能简单的进行Web层的单元测试；
-
-
-
-
-
-√支持灵活的URL到页面控制器的映射；
-
-
-
-
-
-√非常容易与其他视图技术集成，如Velocity、FreeMarker等等，因为模型数据不放在特定的API里，而是放在一个Model里（`Map`数据结构实现，因此很容易被其他框架使用）；
-
-
-
-
-
-√非常灵活的数据验证、格式化和数据绑定机制，能使用任何对象进行数据绑定，不必实现特定框架的API；
-
-
-
-
-
-√提供一套强大的JSP标签库，简化JSP开发；
-
-
-
-
-
-√支持灵活的本地化、主题等解析；
-
-
-
-
-
-√更加简单的异常处理；
-
-
-
-
-
-√对静态资源的支持；
-
-
-
-
-
-√支持Restful风格。
-
-
-
-
-
-## Spring Web MVC架构
-
-
-
-
-
-Spring Web MVC框架也是一个基于请求驱动的Web框架，并且也使用了前端控制器模式来进行设计，再根据请求映射规则分发给相应的页面控制器（动作/处理器）进行处理。首先让我们整体看一下Spring Web MVC处理请求的流程：
-
-
-
-
-
-### Spring Web MVC处理请求的流程
-
-
-
-
-
-如图2-1
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/14/529024df9d2b0d1e62d8054a86d866c9__1.JPG "点击查看原始大小图片")
-
-
-
-
-
-图2-1
-
-
-
-
-
-具体执行步骤如下：
-
-
-
-
-
-1、  首先用户发送请求————>前端控制器，前端控制器根据请求信息（如URL）来决定选择哪一个页面控制器进行处理并把请求委托给它，即以前的控制器的控制逻辑部分；图2-1中的1、2步骤；
-
-
-
-
-
-2、  页面控制器接收到请求后，进行功能处理，首先需要收集和绑定请求参数到一个对象，这个对象在Spring Web MVC中叫命令对象，并进行验证，然后将命令对象委托给业务对象进行处理；处理完毕后返回一个ModelAndView（模型数据和逻辑视图名）；图2-1中的3、4、5步骤；
-
-
-
-
-
-3、  前端控制器收回控制权，然后根据返回的逻辑视图名，选择相应的视图进行渲染，并把模型数据传入以便视图渲染；图2-1中的步骤6、7；
-
-
-
-
-
-4、  前端控制器再次收回控制权，将响应返回给用户，图2-1中的步骤8；至此整个结束。
-
-
-
-
-
-问题：
-
-
-
-
-
-1、  请求如何给前端控制器？
-
-
-
-
-
-2、  前端控制器如何根据请求信息选择页面控制器进行功能处理？
-
-
-
-
-
-3、  如何支持多种页面控制器呢？
-
-
-
-
-
-4、  如何页面控制器如何使用业务对象？
-
-
-
-
-
-5、  页面控制器如何返回模型数据？
-
-
-
-
-
-6、  前端控制器如何根据页面控制器返回的逻辑视图名选择具体的视图进行渲染？
-
-
-
-
-
-7、  不同的视图技术如何使用相应的模型数据？
-
-
-
-
-
-首先我们知道有如上问题，那这些问题如何解决呢？请让我们先继续，在后边依次回答。
-
-
-
-
-
-### Spring Web MVC架构
-
-
-
-
-
-1、Spring Web MVC核心架构图，如图2-2
-
-
-
-
-
-![](http://sishuok.com/forum/upload/2012/7/14/57ea9e7edeebd5ee2ec0cf27313c5fb6__2.JPG "点击查看原始大小图片")
-
-
-
-
-
-图2-2
-
-
-
-
-
-架构图对应的DispatcherServlet核心代码如下：
-
-
-
-
-
-java代码：
-
-```
-//前端控制器分派方法  
-protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  
-        HttpServletRequest processedRequest = request;  
-        HandlerExecutionChain mappedHandler = null;  
-        int interceptorIndex = -1;  
-
-        try {  
-            ModelAndView mv;  
-            boolean errorView = false;  
-
-            try {  
-                   //检查是否是请求是否是multipart（如文件上传），如果是将通过MultipartResolver解析  
-                processedRequest = checkMultipart(request);  
-                   //步骤2、请求到处理器（页面控制器）的映射，通过HandlerMapping进行映射  
-                mappedHandler = getHandler(processedRequest, false);  
-                if (mappedHandler == null || mappedHandler.getHandler() == null) {  
-                    noHandlerFound(processedRequest, response);  
-                    return;  
-                }  
-                   //步骤3、处理器适配，即将我们的处理器包装成相应的适配器（从而支持多种类型的处理器）  
-                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  
-
-                  // 304 Not Modified缓存支持  
-                //此处省略具体代码  
-
-                // 执行处理器相关的拦截器的预处理（HandlerInterceptor.preHandle）  
-                //此处省略具体代码  
-
-                // 步骤4、由适配器执行处理器（调用处理器相应功能处理方法）  
-                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  
-
-                // Do we need view name translation?  
-                if (mv != null && !mv.hasView()) {  
-                    mv.setViewName(getDefaultViewName(request));  
-                }  
-
-                // 执行处理器相关的拦截器的后处理（HandlerInterceptor.postHandle）  
-                //此处省略具体代码  
-            }  
-            catch (ModelAndViewDefiningException ex) {  
-                logger.debug("ModelAndViewDefiningException encountered", ex);  
-                mv = ex.getModelAndView();  
-            }  
-            catch (Exception ex) {  
-                Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);  
-                mv = processHandlerException(processedRequest, response, handler, ex);  
-                errorView = (mv != null);  
-            }  
-
-            //步骤5 步骤6、解析视图并进行视图的渲染  
-//步骤5 由ViewResolver解析View（viewResolver.resolveViewName(viewName, locale)）  
-//步骤6 视图在渲染时会把Model传入（view.render(mv.getModelInternal(), request, response);）  
-            if (mv != null && !mv.wasCleared()) {  
-                render(mv, processedRequest, response);  
-                if (errorView) {  
-                    WebUtils.clearErrorRequestAttributes(request);  
-                }  
-            }  
-            else {  
-                if (logger.isDebugEnabled()) {  
-                    logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +  
-                            "': assuming HandlerAdapter completed request handling");  
-                }  
-            }  
-
-            // 执行处理器相关的拦截器的完成后处理（HandlerInterceptor.afterCompletion）  
-            //此处省略具体代码  
-
-        catch (Exception ex) {  
-            // Trigger after-completion for thrown exception.  
-            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  
-            throw ex;  
-        }  
-        catch (Error err) {  
-            ServletException ex = new NestedServletException("Handler processing failed", err);  
-            // Trigger after-completion for thrown exception.  
-            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  
-            throw ex;  
-        }  
-
-        finally {  
-            // Clean up any resources used by a multipart request.  
-            if (processedRequest != request) {  
-                cleanupMultipart(processedRequest);  
-            }  
-        }  
-    }  
-
-```
-
-
-
-
-
-核心架构的具体流程步骤如下：
-
-
-
-
-
-1、  首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；
-
-
-
-
-
-2、  DispatcherServlet——>HandlerMapping， HandlerMapping将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个HandlerInterceptor拦截器）对象，通过这种策略模式，很容易添加新的映射策略；
-
-
-
-
-
-3、  DispatcherServlet——>HandlerAdapter，HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；
-
-
-
-
-
-4、  HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；
-
-
-
-
-
-5、  ModelAndView的逻辑视图名——> ViewResolver， ViewResolver将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；
-
-
-
-
-
-6、  View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；
-
-
-
-
-
-7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。
-
-
-
-
-
-此处我们只是讲了核心流程，没有考虑拦截器、本地解析、文件上传解析等，后边再细述。
-
-
-
-
-
-到此，再来看我们前边提出的问题：
-
-
-
-
-
-1、  请求如何给前端控制器？这个应该在web.xml中进行部署描述，在HelloWorld中详细讲解。
-
-
-
-
-
-2、  前端控制器如何根据请求信息选择页面控制器进行功能处理？ 我们需要配置HandlerMapping进行映射
-
-
-
-
-
-3、  如何支持多种页面控制器呢？配置HandlerAdapter从而支持多种类型的页面控制器
-
-
-
-
-
-4、  如何页面控制器如何使用业务对象？可以预料到，肯定利用Spring IoC容器的依赖注入功能
-
-
-
-
-
-5、  页面控制器如何返回模型数据？使用ModelAndView返回
-
-
-
-
-
-6、  前端控制器如何根据页面控制器返回的逻辑视图名选择具体的视图进行渲染？ 使用ViewResolver进行解析
-
-
-
-
-
-7、  不同的视图技术如何使用相应的模型数据？ 因为Model是一个Map数据结构，很容易支持其他视图技术
-
-
-
-
-
-在此我们可以看出具体的核心开发步骤：
-
-
-
-
-
-1、  DispatcherServlet在web.xml中的部署描述，从而拦截请求到Spring Web MVC
-
-
-
-
-
-2、  HandlerMapping的配置，从而将请求映射到处理器
-
-
-
-
-
-3、  HandlerAdapter的配置，从而支持多种类型的处理器
-
-
-
-
-
-4、  ViewResolver的配置，从而将逻辑视图名解析为具体视图技术
-
-
-
-
-
-5、处理器（页面控制器）的配置，从而进行功能处理
-
-
-
-
-
-上边的开发步骤我们会在Hello World中详细验证。
-
-
-
-
-
-## Spring Web MVC优势
-
-
-
-
-
-1、清晰的角色划分：前端控制器（`DispatcherServlet`）、请求到处理器映射（HandlerMapping）、处理器适配器（HandlerAdapter）、视图解析器（ViewResolver）、处理器或页面控制器（Controller）、验证器（   Validator）、命令对象（Command  请求参数绑定到的对象就叫命令对象）、表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）。
-
-
-
-
-
-2、分工明确，而且扩展点相当灵活，可以很容易扩展，虽然几乎不需要；
-
-
-
-
-
-3、由于命令对象就是一个POJO，无需继承框架特定API，可以使用命令对象直接作为业务对象；
-
-
-
-
-
-4、和Spring 其他框架无缝集成，是其它Web框架所不具备的；
-
-
-
-
-
-5、可适配，通过HandlerAdapter可以支持任意的类作为处理器；
-
-
-
-
-
-6、可定制性，HandlerMapping、ViewResolver等能够非常简单的定制；
-
-
-
-
-
-7、功能强大的数据验证、格式化、绑定机制；
-
-
-
-
-
-8、利用Spring提供的Mock对象能够非常简单的进行Web层单元测试；
-
-
-
-
-
-9、本地化、主题的解析的支持，使我们更容易进行国际化和主题的切换。
-
-
-
-
-
-10、强大的JSP标签库，使JSP编写更容易。
-
-
-
-
-
-………………还有比如RESTful风格的支持、简单的文件上传、约定大于配置的契约式编程支持、基于注解的零配置支持等等。
-
-
-
-
-
-## DispatcherServlet作用
-
-
-
-
-
-DispatcherServlet是前端控制器设计模式的实现，提供Spring Web MVC的集中访问点，而且负责职责的分派，而且与Spring IoC容器无缝集成，从而可以获得Spring的所有好处。 具体请参考第二章的图2-1。
-
-
-
-
-
-DispatcherServlet主要用作职责调度工作，本身主要用于控制流程，主要职责如下：
-
-
-
-
-
-1、文件上传解析，如果请求类型是multipart将通过MultipartResolver进行文件上传解析；
-
-
-
-
-
-2、通过HandlerMapping，将请求映射到处理器（返回一个HandlerExecutionChain，它包括一个处理器、多个HandlerInterceptor拦截器）；
-
-
-
-
-
-3、通过HandlerAdapter支持多种类型的处理器(HandlerExecutionChain中的处理器)；
-
-
-
-
-
-4、通过ViewResolver解析逻辑视图名到具体视图实现；
-
-
-
-
-
-5、本地化解析；
-
-
-
-
-
-6、渲染具体的视图等；
-
-
-
-
-
-7、如果执行过程中遇到异常将交给HandlerExceptionResolver来解析。
-
-
-
-
-
-从以上我们可以看出DispatcherServlet主要负责流程的控制（而且在流程中的每个关键点都是很容易扩展的）。
-
-
-
-作者：黄小斜
-链接：http://www.imooc.com/article/291594?block_id=tuijian_wz
-来源：慕课网
diff --git "a/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2204\357\274\232DispatcherServlet\345\246\202\344\275\225\346\211\276\345\210\260\346\255\243\347\241\256\347\232\204Controller.md" "b/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2204\357\274\232DispatcherServlet\345\246\202\344\275\225\346\211\276\345\210\260\346\255\243\347\241\256\347\232\204Controller.md"
deleted file mode 100644
index e349d33..0000000
--- "a/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2204\357\274\232DispatcherServlet\345\246\202\344\275\225\346\211\276\345\210\260\346\255\243\347\241\256\347\232\204Controller.md"
+++ /dev/null
@@ -1,341 +0,0 @@
-# Table of Contents
-
-  * [前言](#前言)
-  * [源码分析](#源码分析)
-  * [实例](#实例)
-  * [资源文件映射](#资源文件映射)
-  * [总结](#总结)
-
-
-本文转载自互联网，侵删
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-文章将同步到我的个人博客：
-> www.how2playlife.com
-
-本文是微信公众号【Java技术江湖】的《Spring和SpringMVC源码分析》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从spring基础入手，一步步地学习spring基础和springmvc的框架知识，并上手进行项目实战，spring框架是每一个Java工程师必须要学习和理解的知识点，进一步来说，你还需要掌握spring甚至是springmvc的源码以及实现原理，才能更完整地了解整个spring技术体系，形成自己的知识框架。
-
-后续还会有springboot和springcloud的技术专题，陆续为大家带来，敬请期待。
-
-为了更好地总结和检验你的学习成果，本系列文章也会提供部分知识点对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-## 前言
-SpringMVC是目前主流的Web MVC框架之一。 
-
-我们使用浏览器通过地址 http://ip:port/contextPath/path 进行访问，SpringMVC是如何得知用户到底是访问哪个Controller中的方法，这期间到底发生了什么。
-
-本文将分析SpringMVC是如何处理请求与Controller之间的映射关系的，让读者知道这个过程中到底发生了什么事情。
-
-本文实际上是在上文基础上，深入分析
-
-<pre>HandlerMapping里的</pre>
-
-<pre>HandlerExecutionChain getHandler(HttpServletRequest var1) throws Exception;</pre>
-
-<pre>该方法的具体实现，包括它如何找到对应的方法，以及如何把结果保存在map里，以便让请求转发到对应的handler上，同时也分析了handleradaptor具体做了什么事情。</pre>
-
-## 源码分析
-
-在分析源码之前，我们先了解一下几个东西。
-
-1.这个过程中重要的接口和类。
-
-**HandlerMethod类：**
-
-　　Spring3.1版本之后引入的。 是一个封装了方法参数、方法注解，方法返回值等众多元素的类。
-
-　　![](https://images0.cnblogs.com/i/411512/201405/232033308878895.jpg)
-
-　　它的子类InvocableHandlerMethod有两个重要的属性WebDataBinderFactory和HandlerMethodArgumentResolverComposite， 很明显是对请求进行处理的。
-
-　　InvocableHandlerMethod的子类ServletInvocableHandlerMethod有个重要的属性HandlerMethodReturnValueHandlerComposite，很明显是对响应进行处理的。
-
-　　ServletInvocableHandlerMethod这个类在HandlerAdapter对每个请求处理过程中，都会实例化一个出来(上面提到的属性由HandlerAdapter进行设置)，分别对请求和返回进行处理。　　(RequestMappingHandlerAdapter源码，实例化ServletInvocableHandlerMethod的时候分别set了上面提到的重要属性)
-
-　　![](https://images0.cnblogs.com/i/411512/201405/240149411377243.png)
-
-**MethodParameter类：**
-
-　　HandlerMethod类中的parameters属性类型，是一个MethodParameter数组。MethodParameter是一个封装了方法参数具体信息的工具类，包括参数的的索引位置，类型，注解，参数名等信息。
-
-　　HandlerMethod在实例化的时候，构造函数中会初始化这个数组，这时只初始化了部分数据，在HandlerAdapter对请求处理过程中会完善其他属性，之后交予合适的HandlerMethodArgumentResolver接口处理。
-
-　　以类DeptController为例：
-
-```
-@Controller
-@RequestMapping(value = "/dept")
-public class DeptController {
-
-  @Autowired
-  private IDeptService deptService;
-
-  @RequestMapping("/update")
-  @ResponseBody
-  public String update(Dept dept) {
-    deptService.saveOrUpdate(dept);
-    return "success";
-  }
-
-}
-
-```
-
-　　(刚初始化时的数据)　　
-
-![](https://images0.cnblogs.com/i/411512/201405/241246397157212.png)
-
-　　(HandlerAdapter处理后的数据)
-
-![](https://images0.cnblogs.com/i/411512/201405/241246574657656.png)
-
-**RequestCondition接口：**
-
-　　**Spring3.1版本之后引入的。 是SpringMVC的映射基础中的请求条件，可以进行combine, compareTo，getMatchingCondition操作。这个接口是映射匹配的关键接口，其中getMatchingCondition方法关乎是否能找到合适的映射。**
-
-　　![](https://images0.cnblogs.com/i/411512/201405/241429158878034.png)
-
-**RequestMappingInfo类：**
-
-　　Spring3.1版本之后引入的。 是一个封装了各种请求映射条件并实现了RequestCondition接口的类。
-
-　　有各种RequestCondition实现类属性，patternsCondition，methodsCondition，paramsCondition，headersCondition，consumesCondition以及producesCondition，这个请求条件看属性名也了解，分别代表http请求的路径模式、方法、参数、头部等信息。
-
-　　![](https://images0.cnblogs.com/i/411512/201405/241556162777007.png)
-
-**RequestMappingHandlerMapping类：**
-
- 　　处理请求与HandlerMethod映射关系的一个类。
-
-2.Web服务器启动的时候，SpringMVC到底做了什么。
-
-先看AbstractHandlerMethodMapping的initHandlerMethods方法中。
-
-![](https://images0.cnblogs.com/i/411512/201405/241831201065104.png)
-
-![](https://images0.cnblogs.com/i/411512/201405/241922304028276.png)
-
-![](https://images0.cnblogs.com/i/411512/201405/241932113242502.png)
-
-我们进入createRequestMappingInfo方法看下是如何构造RequestMappingInfo对象的。
-
-![](https://images0.cnblogs.com/i/411512/201405/251242523404424.png)
-
-PatternsRequestCondition构造函数：
-
-![](https://images0.cnblogs.com/i/411512/201405/252348515124305.png)
-
-类对应的RequestMappingInfo存在的话，跟方法对应的RequestMappingInfo进行combine操作。
-
-![](https://images0.cnblogs.com/i/411512/201405/250107154024892.png)
-
-然后使用符合条件的method来注册各种HandlerMethod。
-
-![](https://images0.cnblogs.com/i/411512/201405/260023477461660.png)
-
-下面我们来看下各种RequestCondition接口的实现类的combine操作。
-
-PatternsRequestCondition：
-
-![](https://images0.cnblogs.com/i/411512/201405/251617000436911.png)
-
-![](https://images0.cnblogs.com/i/411512/201405/251917084021029.png)
-
-RequestMethodsRequestCondition：
-
-方法的请求条件，用个set直接add即可。
-
-![](https://images0.cnblogs.com/i/411512/201405/251919265597456.png)
-
-其他相关的RequestConditon实现类读者可自行查看源码。
-
-最终，RequestMappingHandlerMapping中两个比较重要的属性
-
-private final Map<T, HandlerMethod> handlerMethods = new LinkedHashMap<T, HandlerMethod>();
-
-private final MultiValueMap<String, T> urlMap = new LinkedMultiValueMap<String, T>();
-
-T为RequestMappingInfo。
-
-构造完成。
-
-我们知道，SpringMVC的分发器DispatcherServlet会根据浏览器的请求地址获得HandlerExecutionChain。
-
-这个过程我们看是如何实现的。
-
-首先看HandlerMethod的获得(直接看关键代码了)：
-
-![](https://images0.cnblogs.com/i/411512/201405/252206079491274.png)
-
-这里的比较器是使用RequestMappingInfo的compareTo方法(RequestCondition接口定义的)。
-
-![](https://images0.cnblogs.com/i/411512/201405/252219494658063.png)
-
-然后构造HandlerExecutionChain加上拦截器
-
-![](https://images0.cnblogs.com/i/411512/201405/252208290431970.png)
-
-## 实例
-
-写了这么多，来点例子让我们验证一下吧。
-
-```
-@Controller
-@RequestMapping(value = "/wildcard")
-public class TestWildcardController {
-
-  @RequestMapping("/test/**")
-  @ResponseBody
-  public String test1(ModelAndView view) {
-    view.setViewName("/test/test");
-    view.addObject("attr", "TestWildcardController -> /test/**");
-    return view;
-  }
-
-  @RequestMapping("/test/*")
-  @ResponseBody
-  public String test2(ModelAndView view) {
-    view.setViewName("/test/test");
-    view.addObject("attr", "TestWildcardController -> /test*");
-    return view;
-  }
-
-  @RequestMapping("test?")
-  @ResponseBody
-  public String test3(ModelAndView view) {
-    view.setViewName("/test/test");
-    view.addObject("attr", "TestWildcardController -> test?");
-    return view;
-  }
-
-  @RequestMapping("test/*")
-  @ResponseBody
-  public String test4(ModelAndView view) {
-    view.setViewName("/test/test");
-    view.addObject("attr", "TestWildcardController -> test/*");
-    return view;
-  }
-
-}
-
-```
-
-由于这里的每个pattern都带了*因此，都不会加入到urlMap中，但是handlerMethods还是有的。
-
-![](https://images0.cnblogs.com/i/411512/201405/260032509654870.png)
-
-当我们访问：http://localhost:8888/SpringMVCDemo/wildcard/test1的时候。
-
-会先根据 "/wildcard/test1" 找urlMap对应的RequestMappingInfo集合，找不到的话取handlerMethods集合中所有的key集合(也就是RequestMappingInfo集合)。
-
-然后进行匹配，匹配根据RequestCondition的getMatchingCondition方法。
-
-![](https://images0.cnblogs.com/i/411512/201405/260046407936253.png)
-
-最终匹配到2个RequestMappingInfo：
-
-![](https://images0.cnblogs.com/i/411512/201405/260049401063106.png)
-
-然后会使用比较器进行排序。
-
-之前也分析过，比较器是有优先级的。
-
-我们看到，RequestMappingInfo除了pattern，其他属性都是一样的。
-
-我们看下PatternsRequestCondition比较的逻辑：
-
-![](https://images0.cnblogs.com/i/411512/201405/260125371817100.png)
-
-![](https://images0.cnblogs.com/i/411512/201405/260125488223078.png)
-
-因此，/test*的通配符比/test?的多，因此，最终选择了/test?
-
-![](https://images0.cnblogs.com/i/411512/201405/260129091195087.png)
-
-直接比较优先于通配符。
-
-![](https://images0.cnblogs.com/i/411512/201405/260129342756267.png)
-
-```
-@Controller
-@RequestMapping(value = "/priority")
-public class TestPriorityController {
-
-  @RequestMapping(method = RequestMethod.GET)
-  @ResponseBody
-  public String test1(ModelAndView view) {
-    view.setViewName("/test/test");
-    view.addObject("attr", "其他condition相同，带有method属性的优先级高");
-    return view;
-  }
-
-  @RequestMapping()
-  @ResponseBody
-  public String test2(ModelAndView view) {
-    view.setViewName("/test/test");
-    view.addObject("attr", "其他condition相同，不带method属性的优先级高");
-    return view;
-  }
-
-}
-
-```
-
- 这里例子，其他requestCondition都一样，只有RequestMethodCondition不一样。
-
-![](https://images0.cnblogs.com/i/411512/201405/260151358222728.png)
-
-看出，方法多的优先级越多。
-
-![](https://images0.cnblogs.com/i/411512/201405/260152065252948.png)
-
-至于其他的RequestCondition，大家自行查看源码吧。
-
-## 资源文件映射
-
-以上分析均是基于Controller方法的映射(RequestMappingHandlerMapping)。
-
-SpringMVC中还有静态文件的映射，SimpleUrlHandlerMapping。
-
-DispatcherServlet找对应的HandlerExecutionChain的时候会遍历属性handlerMappings，这个一个实现了HandlerMapping接口的集合。
-
-由于我们在*-dispatcher.xml中加入了以下配置：
-
-```
-<mvc:resources location="/static/" mapping="/static/**"/>
-```
-
- Spring解析配置文件会使用ResourcesBeanDefinitionParser进行解析的时候，会实例化出SimpleUrlHandlerMapping。
-
-![](https://images0.cnblogs.com/i/411512/201405/261025451501584.jpg)
-
-![](https://images0.cnblogs.com/i/411512/201405/261026409781228.jpg)
-
-其中注册的HandlerMethod为ResourceHttpRequestHandler。
-
-访问地址：http://localhost:8888/SpringMVCDemo/static/js/jquery-1.11.0.js
-
-![](https://images0.cnblogs.com/i/411512/201405/261013551199069.jpg)
-
-![](https://images0.cnblogs.com/i/411512/201405/261028504315946.jpg)
-
-地址匹配到/static/**。
-
-最终SimpleUrlHandlerMapping找到对应的Handler -> ResourceHttpRequestHandler。
-
-ResourceHttpRequestHandler进行handleRequest的时候，直接输出资源文件的文本内容。
-
-## 总结
-
-大致上整理了一下SpringMVC对请求的处理，包括其中比较关键的类和接口，希望对读者有帮助。
-
-让自己对SpringMVC有了更深入的认识，也为之后分析数据绑定，拦截器、HandlerAdapter等打下基础。
diff --git "a/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2206\357\274\232SpringMVC\347\232\204\350\247\206\345\233\276\350\247\243\346\236\220\345\216\237\347\220\206.md" "b/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2206\357\274\232SpringMVC\347\232\204\350\247\206\345\233\276\350\247\243\346\236\220\345\216\237\347\220\206.md"
deleted file mode 100644
index e1fe779..0000000
--- "a/docs/java-web/SSM/SpringMVC\346\272\220\347\240\201\345\210\206\346\236\2206\357\274\232SpringMVC\347\232\204\350\247\206\345\233\276\350\247\243\346\236\220\345\216\237\347\220\206.md"
+++ /dev/null
@@ -1,397 +0,0 @@
-# Table of Contents
-
-  * [目录](#目录)
-  * [前言](#前言)
-  * [重要接口和类介绍](#重要接口和类介绍)
-  * [源码分析](#源码分析)
-  * [编码自定义的ViewResolver](#编码自定义的viewresolver)
-    * [This is jsp page](#this-is-jsp-page)
-    * [This is freemarker page](#this-is-freemarker-page)
-  * [总结](#总结)
-
-
-转自 [SpringMVC视图机制详解[附带源码分析]](https://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html)
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-文章将同步到我的个人博客：
-> www.how2playlife.com
-
-本文是微信公众号【Java技术江湖】的《Spring和SpringMVC源码分析》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从spring基础入手，一步步地学习spring基础和springmvc的框架知识，并上手进行项目实战，spring框架是每一个Java工程师必须要学习和理解的知识点，进一步来说，你还需要掌握spring甚至是springmvc的源码以及实现原理，才能更完整地了解整个spring技术体系，形成自己的知识框架。
-
-后续还会有springboot和springcloud的技术专题，陆续为大家带来，敬请期待。
-
-为了更好地总结和检验你的学习成果，本系列文章也会提供部分知识点对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-
-## 目录
-
-*   [前言](http://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html#preface)
-*   [重要接口和类介绍](http://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html#introduction)
-*   [源码分析](http://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html#analysis)
-*   [编码自定义的ViewResolver](http://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html#demo)
-*   [总结](http://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html#summary)
-*   [参考资料](http://www.cnblogs.com/fangjian0423/p/springMVC-view-viewResolver.html#reference)
-
-## 前言
-
-SpringMVC是目前主流的Web MVC框架之一。 
-
-如果有同学对它不熟悉，那么请参考它的入门blog：[http://www.cnblogs.com/fangjian0423/p/springMVC-introduction.html](http://www.cnblogs.com/fangjian0423/p/springMVC-introduction.html)
-
-本文将分析SpringMVC的视图这部分内容，让读者了解SpringMVC视图的设计原理。
-
-## 重要接口和类介绍
-
-**1. View接口**
-
-　　视图基础接口，它的各种实现类是无状态的，因此是线程安全的。 该接口定义了两个方法：　
-
-![](https://images0.cnblogs.com/i/411512/201406/092359485145662.png)
-
-**2. AbstractView抽象类**
-
-View接口的基础实现类。我们稍微介绍一下这个抽象类。
-
-　　首先看下这个类的属性：
-
-![](https://images0.cnblogs.com/i/411512/201406/100014083899865.png)
-
-　　再看下抽象类中接口方法的实现：
-
-　　getContentType方法直接返回contentType属性即可。
-
-![](https://images0.cnblogs.com/i/411512/201406/100110310773735.png)
-
- 　　render方法：
-
-![](https://images0.cnblogs.com/i/411512/201406/102247323892787.png)
-
-**3. AbstractUrlBasedView抽象类**
-
-　　继承自AbstractView抽象类，增加了1个类型为String的url参数。
-
-**4. InternalResourceView类**
-
-　　继承自AbstractUrlBasedView抽象类的类，表示JSP视图。
-
-　　我们看下这个类的renderMergedOutputModel方法(AbstractView抽象类定义的抽象方法，为View接口提供的render方法服务)。
-
-![](https://images0.cnblogs.com/i/411512/201406/102252020309641.png)
-
-**5. JstlView类**
-
-　　JSTL视图，继承自InternalResourceView，该类大致上与InternalResourceView类一致。
-
-**6. AbstractTemplateView抽象类**
-
-　　继承自AbstractUrlBasedView抽象类，重写了renderMergedOutputModel方法，在该方法中会调用renderMergedTemplateModel方法，renderMergedTemplateModel方法为新定义的抽象方法。
-
-　　该抽象类有几个boolean属性exposeSessionAttributes，exposeRequestAttributes。 设置为true的话会将request和session中的键值和值丢入到renderMergedTemplateModel方法中的model这个Map参数中。
-
-　　这个类是某些模板引擎视图类的父类。 比如FreemarkerView，VelocityView。
-
-**7. FreeMarkerView类**
-
-　　继承自AbstractTemplateView抽象类。
-
-　　直接看renderMergedTemplateModel方法，renderMergedTemplateModel内部会调用doRender方法：
-
-![](https://images0.cnblogs.com/i/411512/201406/102258387178319.png)
-
-**8\. RedirectView类**
-
-　　继承自AbstractUrlBasedView，并实现SmartView接口。SmartView接口定义了1个boolean isRedirectView();方法。
-
-　　该视图的renderMergedOutputModel方法主要就是通过response.sendRedirect进行重定向。
-
-　　有关RedirectView方面的知识楼主另外写了1篇博客。[http://www.cnblogs.com/fangjian0423/p/springMVC-redirectView-analysis.html](http://www.cnblogs.com/fangjian0423/p/springMVC-redirectView-analysis.html)
-
-**9. ViewResolver接口**
-
-　　视图解释器，用来解析视图View，与View接口配合使用。
-
-　　该接口只有1个方法，通过视图名称viewName和Locale对象得到View接口实现类：
-
-```
-  View resolveViewName(String viewName, Locale locale) throws Exception;
-```
-
-**10. AbstractCachingViewResolver抽象类**
-
-　　带有缓存功能的ViewResolver接口基础实现抽象类，该类有个属性名为viewAccessCache的以 "viewName_locale" 为key， View接口为value的Map。
-
-　　该抽象类实现的resolveViewName方法内部会调用createView方法，方法内部会调用loadView抽象方法。
-
-**11. UrlBasedViewResolver类**
-
-　　继承自AbstractCachingViewResolver抽象类、并实现Ordered接口的类，是ViewResolver接口简单的实现类。
-
-![](https://images0.cnblogs.com/i/411512/201406/102341126705605.png)
-
-　　该类复写了createView方法：
-
-![](https://images0.cnblogs.com/i/411512/201406/102349273585708.png)
-
-　　父类(AbstractCachingViewResolver)的createView方法内部会调用loadView抽象方法，UrlBasedViewResolver实现了这个抽象方法：
-
-![](https://images0.cnblogs.com/i/411512/201406/110037187498815.png)
-
-![](https://images0.cnblogs.com/i/411512/201406/110043510779523.png)
-
-　　下面对UrlBasedViewResolver做1个test，配置如下：
-
-```
-<bean class="org.springframework.web.servlet.view.UrlBasedViewResolver">
-  <property name="prefix" value="/WEB-INF/view/"/>
-  <property name="suffix" value=".jsp"/>
-  <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceView"/>
-  <property name="viewNames">
-
-      <value type="java.lang.String">*</value>  
-
-  </property>  
-  <property name="contentType" value="text/html;charset=utf-8"/>
-  <property name="attributesMap">
-    <map>
-      <entry key="mytest" value="mytestvalue"/>
-    </map>
-  </property>
-  <property name="attributes">
-    <props>
-      <prop key="test">testvalue</prop>
-    </props>
-  </property>
-</bean>
-
-```
-
-　　我们看到：以InternalResourceView这个JSP视图作为视图；viewNames我们设置了_，这里的_代表全部视图名(这个viewNames属性不设置也可以，代表全部视图名都处理)；http响应头部contentType信息：text/html;charset=utf-8；attributesMap和attributes传入的Map和Properties参数都会被丢入到staticAttributes属性中，这个staticAttributes会被设置成AbstractView的staticAttributes属性，也就是request域中的参数。
-
-![](https://images0.cnblogs.com/i/411512/201406/122254034056621.png)
-
-![](https://images0.cnblogs.com/i/411512/201406/122255053584961.png)
-
-![](https://images0.cnblogs.com/i/411512/201406/122253337649444.png)
-
-　　我们看到request域中没有设置mytest和testvalue值。但是页面中会显示，因为我们配置了attributesMap和attributes参数。
-
-　　如果我们把viewNames中的"*"改成"index1"。那么就报错了，因为处理视图名的时候index匹配不上index1。
-
-![](https://images0.cnblogs.com/i/411512/201406/122258119528822.png)
-
-**12. InternalResourceViewResolver类**
-
-　　继承自UrlBasedViewResolver，以InternalResourceView作为视图，若项目中存在“javax.servlet.jsp.jstl.core.Config”该类，那么会以JstlView作为视图。重写了buildView方法，主要就是为了给InternalResourceView视图设置属性。
-
-**13. AbstractTemplateViewResolver类**
-
-　　继承自UrlBasedViewResolver，重写了buildView方法，主要就是构造AbstractTemplateView以及为它设置相应的属性。
-
-**14. FreeMarkerViewResolver类**
-
-　　继承自AbstractTemplateViewResolver，将视图设置为FreeMarkerView。
-
-**15\. ModelAndView对象**
-
-　　顾名思义，带有视图和Model属性的一个模型和视图类。
-
-![](https://images0.cnblogs.com/i/411512/201406/122342141709643.png)
-
-　　值得注意的是，这个视图属性是一个Object类型的数据，可以直接是View接口的实现类或者视图名(字符串)。
-
-## 源码分析
-
-下面我们来分析SpringMVC处理视图的源码。
-
-SpringMVC在处理请求的时候，通过RequestMappingHandlerMapping得到HandlerExecutionChain，然后通过RequestMappingHandlerAdapter得到1个ModelAndView对象，之后通过processDispatchResult方法处理。
-
-processDispatchResult方法如下：
-
-![](https://images0.cnblogs.com/i/411512/201406/122331490924509.png)
-
-![](https://images0.cnblogs.com/i/411512/201406/122339489831665.png)
-
-如果配置的ViewResolver如下：
-
-```
-<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
-  <property name="prefix" value="/WEB-INF/view/"/>
-  <property name="suffix" value=".jsp"/>
-</bean>
-
-```
-
-那么就是使用InternalResourceViewResolver来解析视图。
-
-之前分析过，InternalResourceViewResolver重写了UrlBasedViewResolver的buildView方法。但是还是会调用UrlBasedViewResolver的buildView方法。
-
-![](https://images0.cnblogs.com/i/411512/201406/130106345772394.png)
-
-最终得到InternalResourceView或JstlView视图。这两个视图的render方法本文介绍重要接口及类的时候已分析。
-
-PS：DispathcerServlet中的viewResolvers属性是个集合，如果存在多个ViewResolver对象，必定会有优先级的问题，这部分的内容请参考楼主的另一篇博客：
-
-[http://www.cnblogs.com/fangjian0423/p/spring-Ordered-interface.html](http://www.cnblogs.com/fangjian0423/p/spring-Ordered-interface.html)
-
-## 编码自定义的ViewResolver
-
-下面，我们就来编写自定义的ViewResolver。
-
-自定义的ViewResolver处理视图名的时候，遇到 "jsp:" 开头的会找jsp页面，遇到 "freemarker:" 开头的找freemarker页面。
-
-```
-public class CustomViewResolver extends UrlBasedViewResolver {
-
-  public static final String JSP_URL_PREFIX = "jsp:";
-  public static final String FTL_URL_PREFIX = "freemarker:";
-
-  private static final boolean jstlPresent = ClassUtils.isPresent(
-            "javax.servlet.jsp.jstl.core.Config", CustomViewResolver.class.getClassLoader());
-
-  private Boolean exposePathVariables = false;
-
-  private boolean exposeRequestAttributes = false;
-
-  private boolean allowRequestOverride = false;
-
-  private boolean exposeSessionAttributes = false;
-
-  private boolean allowSessionOverride = false;
-
-  private boolean exposeSpringMacroHelpers = true;
-
-  public CustomViewResolver() {
-      this.setViewClass(FreeMarkerView.class);
-  }  
-
-  @Override
-  protected AbstractUrlBasedView buildView(String viewName) throws Exception { 
-    if(viewName.startsWith(FTL_URL_PREFIX)) {
-        return buildFreemarkerView(viewName.substring(FTL_URL_PREFIX.length()));
-    } else if(viewName.startsWith(JSP_URL_PREFIX)) {
-        Class viewCls = jstlPresent ? JstlView.class : InternalResourceView.class;
-        return buildView(viewCls, viewName.substring(JSP_URL_PREFIX.length()), getPrefix(), ".jsp");
-    } else {
-        //默认以freemarker处理
-        return buildFreemarkerView(viewName);
-    }
-  }
-
-  private AbstractUrlBasedView build(Class viewClass, String viewName, String prefix, String suffix) { 
-    AbstractUrlBasedView view = (AbstractUrlBasedView) BeanUtils.instantiateClass(viewClass);
-    view.setUrl(prefix + viewName + suffix);
-    String contentType = getContentType();
-    if (contentType != null) {
-        view.setContentType(contentType);
-    }
-    view.setRequestContextAttribute(getRequestContextAttribute());
-    view.setAttributesMap(getAttributesMap());
-    if (this.exposePathVariables != null) {
-        view.setExposePathVariables(exposePathVariables);
-    }
-    return view;    
-  }
-
-  private AbstractUrlBasedView buildFreemarkerView(String viewName) throws Exception { 
-    AbstractTemplateView view = (AbstractTemplateView) build(FreeMarkerView.class, viewName, "", getSuffix());
-    view.setExposeRequestAttributes(this.exposeRequestAttributes);
-    view.setAllowRequestOverride(this.allowRequestOverride);
-    view.setExposeSessionAttributes(this.exposeSessionAttributes);
-    view.setAllowSessionOverride(this.allowSessionOverride);
-    view.setExposeSpringMacroHelpers(this.exposeSpringMacroHelpers);
-    return view;      
-  }
-
-  //get set方法省略
-
-}
-
-```
-
-xml配置：
-
-```
-<bean class="org.format.demo.support.viewResolver.CustomViewResolver">
-  <property name="prefix" value="/WEB-INF/view/"/>
-  <property name="suffix" value=".ftl"/>
-  <property name="contentType" value="text/html;charset=utf-8"/>
-  <property name="exposeRequestAttributes" value="true"/>
-  <property name="exposeSessionAttributes" value="true"/>
-  <property name="exposeSpringMacroHelpers" value="true"/>
-  <property name="requestContextAttribute" value="request"/>
-</bean>
-
-```
-
-```
-<bean id="freemarkerConfig" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
-  <property name="templateLoaderPath" value="/WEB-INF/view/"/>
-  <property name="defaultEncoding" value="utf-8"/>
-  <property name="freemarkerSettings">
-    <props>
-      <prop key="template_update_delay">10</prop>
-      <prop key="locale">zh_CN</prop>
-      <prop key="datetime_format">yyyy-MM-dd</prop>
-      <prop key="date_format">yyyy-MM-dd</prop>
-      <prop key="number_format">#.##</prop>
-    </props>
-  </property>
-</bean>
-
-```
-
-简单解释一下：CustomViewResolver解析视图名的时候，判断 "jsp:" 和 "freemarker:" 开头的名字，如果是 "jsp:" 开头的，如果有JSTL依赖，构造JSTLView视图，否则构造InternalResourceView视图。如果是 "freemarker:" 构造FreemarkerView。在构造视图之前分别会设置一些属性。
-
-xml配置：配置prefix是为了给jsp视图用的，freemarker视图不需要prefix，因为FreemarkerView内部会使用配置的FreeMarkerConfigurer，并用FreeMarkerConfigurer内部的templateLoaderPath属性作为前缀，配置的suffix是为了让FreemarkerView使用，当后缀。
-
-最后附上Controller代码：
-
-```
-@Controller
-@RequestMapping(value = "/tvrc")
-public class TestViewResolverController {
-
-    @RequestMapping("jsp")
-    public ModelAndView jsp(ModelAndView view) {
-        view.setViewName("jsp:trvc/index");
-        return view;
-    }
-
-    @RequestMapping("/ftl")
-    public ModelAndView freemarker(ModelAndView view) {
-        view.setViewName("freemarker:trvc/index");
-        return view;
-    }
-
-}
-```
-
-视图 /WEB-INF/view/trvc/index.jsp 中的的内容是输出
-
-### This is jsp page
-
-视图 /WEB-INF/view/trvc/index.ftl 中的的内容是输出
-
-### This is freemarker page
-
-![](https://images0.cnblogs.com/i/411512/201406/140202040149946.png)
-
-![](https://images0.cnblogs.com/i/411512/201406/140202212495247.png)
-
-## 总结
-
-本文分析了SpringMVC中的视图机制，View和ViewResolver这两个接口是视图机制的核心，并分析了几个重要的View和ViewResolver接口实现类，最终写了一个区别jsp和freemarker视图的ViewResolver实现类，让读者更加理解视图机制。
-
-希望这篇文章能帮助读者了解SpringMVC视图机制。
-
-文中难免有错误，希望读者能够指明出来。
diff --git "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2201\357\274\232Spring\346\246\202\350\277\260.md" "b/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2201\357\274\232Spring\346\246\202\350\277\260.md"
deleted file mode 100644
index 0aa081b..0000000
--- "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2201\357\274\232Spring\346\246\202\350\277\260.md"
+++ /dev/null
@@ -1,127 +0,0 @@
-# Table of Contents
-
-  * [Spring是什么](#spring是什么)
-  * [Spring能帮我们做什么](#spring能帮我们做什么)
-  * [为何需要Spring](#为何需要spring)
-  * [为什么需要Spring及Spring的优点](#为什么需要spring及spring的优点)
-  * [如何学好Spring](#如何学好spring)
-
-
-原文出处： [张开涛](http://sishuok.com/forum/blogPost/list/0/2508.html)
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-文章将同步到我的个人博客：
-> www.how2playlife.com
-
-本文是微信公众号【Java技术江湖】的《Spring和SpringMVC源码分析》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从spring基础入手，一步步地学习spring基础和springmvc的框架知识，并上手进行项目实战，spring框架是每一个Java工程师必须要学习和理解的知识点，进一步来说，你还需要掌握spring甚至是springmvc的源码以及实现原理，才能更完整地了解整个spring技术体系，形成自己的知识框架。
-
-后续还会有springboot和springcloud的技术专题，陆续为大家带来，敬请期待。
-
-为了更好地总结和检验你的学习成果，本系列文章也会提供部分知识点对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-
-在讲源码之前，先让我们回顾一下一下Spring的基本概念，当然，在看源码之前你需要使用过spring或者spirngmvc。
-
-##  Spring是什么
-Spring是一个开源的轻量级Java SE（Java 标准版本）/Java EE（Java 企业版本）开发应用框架，其目的是用于简化企业级应用程序开发。应用程序是由一组相互协作的对象组成。而在传统应用程序开发中，一个完整的应用是由一组相互协作的对象组成。所以开发一个应用除了要开发业务逻辑之外，最多的是关注如何使这些对象协作来完成所需功能，而且要低耦合、高内聚。
-
-业务逻辑开发是不可避免的，那如果有个框架出来帮我们来创建对象及管理这些对象之间的依赖关系。可能有人说了，比如“抽象工厂、工厂方法设计模式”不也可以帮我们创建对象，“生成器模式”帮我们处理对象间的依赖关系，不也能完成这些功能吗？
-
-可是这些又需要我们创建另一些工厂类、生成器类，我们又要而外管理这些类，增加了我们的负担，如果能有种通过配置方式来创建对象，管理对象之间依赖关系，我们不需要通过工厂和生成器来创建及管理对象之间的依赖关系，这样我们是不是减少了许多工作，加速了开发，能节省出很多时间来干其他事。Spring框架刚出来时主要就是来完成这个功能。
-
-Spring框架除了帮我们管理对象及其依赖关系，还提供像通用日志记录、性能统计、安全控制、异常处理等面向切面的能力，还能帮我管理最头疼的数据库事务，本身提供了一套简单的JDBC访问实现，提供与第三方数据访问框架集成（如Hibernate、JPA），与各种Java EE技术整合（如Java Mail、任务调度等等），提供一套自己的web层框架Spring MVC、而且还能非常简单的与第三方web框架集成。
-
-从这里我们可以认为Spring是一个超级粘合平台，除了自己提供功能外，还提供粘合其他技术和框架的能力，从而使我们可以更自由的选择到底使用什么技术进行开发。而且不管是JAVA SE（C/S架构）应用程序还是JAVA EE（B/S架构）应用程序都可以使用这个平台进行开发。让我们来深入看一下Spring到底能帮我们做些什么？
-
-## Spring能帮我们做什么
-Spring除了不能帮我们写业务逻辑，其余的几乎什么都能帮助我们简化开发：
-
- 
-
-一、传统程序开发，创建对象及组装对象间依赖关系由我们在程序内部进行控制，这样会加大各个对象间的耦合，如果我们要修改对象间的依赖关系就必须修改源代码，重新编译、部署；而如果采用Spring，则由Spring根据配置文件来进行创建及组装对象间依赖关系，只需要改配置文件即可，无需重新编译。所以，Spring能帮我们根据配置文件创建及组装对象之间的依赖关系。
-
- 
-
-二、当我们要进行一些日志记录、权限控制、性能统计等时，在传统应用程序当中我们可能在需要的对象或方法中进行，而且比如权限控制、性能统计大部分是重复的，这样代码中就存在大量重复代码，即使有人说我把通用部分提取出来，那必然存在调用还是存在重复，像性能统计我们可能只是在必要时才进行，在诊断完毕后要删除这些代码；还有日志记录，比如记录一些方法访问日志、数据访问日志等等，这些都会渗透到各个要访问方法中；
-
-还有权限控制，必须在方法执行开始进行审核，想想这些是多么可怕而且是多么无聊的工作。如果采用Spring，这些日志记录、权限控制、性能统计从业务逻辑中分离出来，通过Spring支持的面向切面编程，在需要这些功能的地方动态添加这些功能，无需渗透到各个需要的方法或对象中；
-
-
-有人可能说了，我们可以使用“代理设计模式”或“包装器设计模式”，你可以使用这些，但还是需要通过编程方式来创建代理对象，还是要耦合这些代理对象，而采用Spring 面向切面编程能提供一种更好的方式来完成上述功能，一般通过配置方式，而且不需要在现有代码中添加任何额外代码，现有代码专注业务逻辑。
-
-所以，Spring 面向切面编程能帮助我们无耦合的实现日志记录，性能统计，安全控制。
-
- 
-
-三、在传统应用程序当中，我们如何来完成数据库事务管理？需要一系列“获取连接，执行SQL，提交或回滚事务，关闭连接”，而且还要保证在最后一定要关闭连接，多么可怕的事情，而且也很无聊；如果采用Spring，我们只需获取连接，执行SQL，其他的都交给Spring来管理了，简单吧。所以，Spring能非常简单的帮我们管理数据库事务。
-
- 
-
-四、Spring还提供了与第三方数据访问框架（如Hibernate、JPA）无缝集成，而且自己也提供了一套JDBC访问模板，来方便数据库访问。
-
- 
-
-五、Spring还提供与第三方Web（如Struts、JSF）框架无缝集成，而且自己也提供了一套Spring MVC框架，来方便web层搭建。
-
- 
-
-六、Spring能方便的与Java EE（如Java Mail、任务调度）整合，与更多技术整合（比如缓存框架）。
-
- 
-
-Spring能帮我们做这么多事情，提供这么多功能和与那么多主流技术整合，而且是帮我们做了开发中比较头疼和困难的事情，那可能有人会问，难道只有Spring这一个框架，没有其他选择？当然有，比如EJB需要依赖应用服务器、开发效率低、在开发中小型项目是宰鸡拿牛刀，虽然发展到现在EJB比较好用了，但还是比较笨重还需要依赖应用服务器等。那为何需要使用Spring，而不是其他框架呢？让我们接着往下看。
-
- 
-## 为何需要Spring
-一 首先阐述几个概念
-
-1、应用程序：是能完成我们所需要功能的成品，比如购物网站、OA系统。
-
-2、框架：是能完成一定功能的半成品，比如我们可以使用框架进行购物网站开发；框架做一部分功能，我们自己做一部分功能，这样应用程序就创建出来了。而且框架规定了你在开发应用程序时的整体架构，提供了一些基础功能，还规定了类和对象的如何创建、如何协作等，从而简化我们开发，让我们专注于业务逻辑开发。
-
-3、非侵入式设计：从框架角度可以这样理解，无需继承框架提供的类，这种设计就可以看作是非侵入式设计，如果继承了这些框架类，就是侵入设计，如果以后想更换框架之前写过的代码几乎无法重用，如果非侵入式设计则之前写过的代码仍然可以继续使用。
-
-4、轻量级及重量级：轻量级是相对于重量级而言的，轻量级一般就是非入侵性的、所依赖的东西非常少、资源占用非常少、部署简单等等，其实就是比较容易使用，而重量级正好相反。
-
-5、POJO：POJO（Plain Old Java Objects）简单的Java对象，它可以包含业务逻辑或持久化逻辑，但不担当任何特殊角色且不继承或不实现任何其它Java框架的类或接口。
-
-6、容器：在日常生活中容器就是一种盛放东西的器具，从程序设计角度看就是装对象的的对象，因为存在放入、拿出等操作，所以容器还要管理对象的生命周期。
-
-7、控制反转：即Inversion of Control，缩写为IoC，控制反转还有一个名字叫做依赖注入（Dependency Injection），就是由容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。
-
-8、Bean：一般指容器管理对象，在Spring中指Spring IoC容器管理对象。
-
- 
-
-## 为什么需要Spring及Spring的优点
-
-●非常轻量级的容器：以集中的、自动化的方式进行应用程序对象创建和装配，负责对象创建和装配，管理对象生命周期，能组合成复杂的应用程序。Spring容器是非侵入式的（不需要依赖任何Spring特定类），而且完全采用POJOs进行开发，使应用程序更容易测试、更容易管理。而且核心JAR包非常小，Spring3.0.5不到1M，而且不需要依赖任何应用服务器，可以部署在任何环境（Java SE或Java EE）。
-
-●AOP：AOP是Aspect Oriented Programming的缩写，意思是面向切面编程，提供从另一个角度来考虑程序结构以完善面向对象编程（相对于OOP），即可以通过在编译期间、装载期间或运行期间实现在不修改源代码的情况下给程序动态添加功能的一种技术。通俗点说就是把可重用的功能提取出来，然后将这些通用功能在合适的时候织入到应用程序中；比如安全，日记记录，这些都是通用的功能，我们可以把它们提取出来，然后在程序执行的合适地方织入这些代码并执行它们，从而完成需要的功能并复用了这些功能。
-
-● 简单的数据库事务管理：在使用数据库的应用程序当中，自己管理数据库事务是一项很让人头疼的事，而且很容易出现错误，Spring支持可插入的事务管理支持，而且无需JEE环境支持，通过Spring管理事务可以把我们从事务管理中解放出来来专注业务逻辑。
-
-●JDBC抽象及ORM框架支持：Spring使JDBC更加容易使用；提供DAO（数据访问对象）支持，非常方便集成第三方ORM框架，比如Hibernate等；并且完全支持Spring事务和使用Spring提供的一致的异常体系。
-
-●灵活的Web层支持：Spring本身提供一套非常强大的MVC框架，而且可以非常容易的与第三方MVC框架集成，比如Struts等。
-
-●简化各种技术集成：提供对Java Mail、任务调度、JMX、JMS、JNDI、EJB、动态语言、远程访问、Web Service等的集成。
-
-Spring能帮助我们简化应用程序开发，帮助我们创建和组装对象，为我们管理事务，简单的MVC框架，可以把Spring看作是一个超级粘合平台，能把很多技术整合在一起，形成一个整体，使系统结构更优良、性能更出众，从而加速我们程序开发，有如上优点，我们没有理由不考虑使用它。
-
-##  如何学好Spring
-要学好Spring，首先要明确Spring是个什么东西，能帮我们做些什么事情，知道了这些然后做个简单的例子，这样就基本知道怎么使用Spring了。
-
-Spring核心是IoC容器，所以一定要透彻理解什么是IoC容器，以及如何配置及使用容器，其他所有技术都是基于容器实现的；
-
-理解好IoC后，接下来是面向切面编程，首先还是明确概念，基本配置，最后是实现原理，接下来就是数据库事务管理，其实Spring管理事务是通过面向切面编程实现的，所以基础很重要，IoC容器和面向切面编程搞定后，其余都是基于这俩东西的实现，学起来就更加轻松了。要学好Spring不能急，一定要把基础打牢，基础牢固了，这就是磨刀不误砍柴工。
diff --git "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2203\357\274\232Spring IOC\345\256\271\345\231\250\347\232\204\345\212\240\350\275\275\350\277\207\347\250\213.md" "b/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2203\357\274\232Spring IOC\345\256\271\345\231\250\347\232\204\345\212\240\350\275\275\350\277\207\347\250\213.md"
deleted file mode 100644
index 50c5dc2..0000000
--- "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2203\357\274\232Spring IOC\345\256\271\345\231\250\347\232\204\345\212\240\350\275\275\350\277\207\347\250\213.md"	
+++ /dev/null
@@ -1,1300 +0,0 @@
-# Table of Contents
-
-  * [spring ioc 容器的加载流程](#spring-ioc-容器的加载流程)
-  * [Spring Ioc Demo](#spring-ioc-demo)
-  * [ApplicationContext 继承结构](#applicationcontext-继承结构)
-  * [Spring Ioc容器加载过程源码详解](#spring-ioc容器加载过程源码详解)
-* [refresh()方法](#refresh方法)
-  * [调试栈截图](#调试栈截图)
-  * [整体流程](#整体流程)
-  * [bean.xml的处理](#beanxml的处理)
-  * [loadBeanDefinitions](#loadbeandefinitions)
-    * [loadBeanDefinitions: 源码阅读](#loadbeandefinitions-源码阅读)
-* [loadBeanDefinitions](#loadbeandefinitions-1)
-
-
-本文转自五月的仓颉 https://www.cnblogs.com/xrq730
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-文章将同步到我的个人博客：
-> www.how2playlife.com
-
-本文是微信公众号【Java技术江湖】的《Spring和SpringMVC源码分析》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从spring基础入手，一步步地学习spring基础和springmvc的框架知识，并上手进行项目实战，spring框架是每一个Java工程师必须要学习和理解的知识点，进一步来说，你还需要掌握spring甚至是springmvc的源码以及实现原理，才能更完整地了解整个spring技术体系，形成自己的知识框架。
-
-后续还会有springboot和springcloud的技术专题，陆续为大家带来，敬请期待。
-
-为了更好地总结和检验你的学习成果，本系列文章也会提供部分知识点对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-
-## spring ioc 容器的加载流程
-
-**1.目标：**熟练使用spring，并分析其源码，了解其中的思想。这篇主要介绍spring ioc 容器的加载
-
-**2.前提条件：**会使用debug
-
-**3.源码分析方法：**Intellj idea debug 模式下源码追溯
-通过ClassPathXmlApplicationContext 进行xml 件的读取，从每个堆栈中读取程序的运行信息
-
-**4.注意：**由于Spring的类继承体系比较复杂,不能全部贴图，所以只将分析源码之后发现的最主要的类继承结构类图贴在下方。
-
-**5.关于Spring Ioc
-Demo：**我们从demo入手一步步进行代码追溯。
-
-## Spring Ioc Demo
-
-* * *
-
-> 1.定义数据访问接口IUserDao.java
-
-```
-public interface IUserDao {  
-    public void InsertUser(String username,String password);
-}
-
-```
-
-2.定义IUserDao.java实现类IUserDaoImpl.java
-
-```
-public class UserDaoImpl implements IUserDao {    
-    @Override    
-    public void InsertUser(String username, String password) { 
-        System.out.println("----UserDaoImpl --addUser----");    
-    }
-}
-
-```
-
-3.定义业务逻辑接口UserService.java
-
-```
-public interface UserService {    
-    public void addUser(String username,String password);
-}
-
-```
-
-4.定义UserService.java实现类UserServiceImpl.java
-
-```
-public class UserServiceImpl implements UserService {    
-    private     IUserDao  userDao;    //set方法  
-    public void  setUserDao(IUserDao  userDao) {        
-        this.userDao = userDao;   
-    }    
-    @Override    
-    public void addUser(String username,String password) { 
-        userDao.InsertUser(username,password);    
-    }
-}
-
-```
-
-bean.xml配置文件
-
-```
-<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-3.0.xsd         ">  
- <!--id名字自己取，class表示他代表的类，如果在包里的话需要加上包名-->    
- <bean id="userService"  class="UserServiceImpl" >      
-        <!--property代表是通过set方法注入,ref的值表示注入的内容-->
-        <property  name="userDao"  ref="userDao"/>  
- </bean>    
-  <bean id="userDao"  class="UserDaoImpl"/>
-</beans>
-
-```
-
-## ApplicationContext 继承结构
-
-* * *
-
-> 1.顶层接口：ApplicationContext
-> 2.ClassPathXmlApplicationContext实现类继承AbstractXmlApplication 抽象类
-> 3.AbstractXmlApplication 继承AbstractRefreshableConfigApplicationContext
-> 4.AbstractRefreshableConfigApplicationContext抽象类继承AbstractRefreshableApplicationContext
-> 5.AbstractRefreshableApplicationContext 继承 AbstractApplicationContext
-> 6.AbstractApplicationContext 实现ConfigurableApplicationContext 接口
-> 7.ConfigurableApplicationContext 接口继承
-> ApplicationContext接口
-> 总体来说继承实现结构较深，内部使用了大量适配器模式。
-> 以ClassPathXmlApplicationContext为例，继承类图如下图所示：
-> 
-> ![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825134835291-1628501369.png)
-
-## Spring Ioc容器加载过程源码详解
-
-* * *
-
-在开始之前，先介绍一个整体的概念。即spring ioc容器的加载，大体上经过以下几个过程：
-资源文件定位、解析、注册、实例化
-
-> **1.资源文件定位**
-> 其中资源文件定位，一般是在ApplicationContext的实现类里完成的，因为ApplicationContext接口继承ResourcePatternResolver 接口，ResourcePatternResolver接口继承ResourceLoader接口，ResourceLoader其中的getResource()方法，可以将外部的资源，读取为Resource类。
-
-* * *
-
-**2.解析**DefaultBeanDefinitionDocumentReader，
-解析主要是在BeanDefinitionReader中完成的，最常用的实现类是XmlBeanDefinitionReader，其中的loadBeanDefinitions()方法，负责读取Resource，并完成后续的步骤。ApplicationContext完成资源文件定位之后，是将解析工作委托给XmlBeanDefinitionReader来完成的
-解析这里涉及到很多步骤，最常见的情况，资源文件来自一个XML配置文件。首先是BeanDefinitionReader，将XML文件读取成w3c的Document文档。
-
-
-DefaultBeanDefinitionDocumentReader对Document进行进一步解析。然后DefaultBeanDefinitionDocumentReader又委托给BeanDefinitionParserDelegate进行解析。如果是标准的xml namespace元素，会在Delegate内部完成解析，如果是非标准的xml namespace元素，则会委托合适的NamespaceHandler进行解析最终解析的结果都封装为BeanDefinitionHolder，至此解析就算完成。
-**后续会进行细致讲解。**
-
-* * *
-
-**3.注册**
-然后bean的注册是在BeanFactory里完成的，BeanFactory接口最常见的一个实现类是DefaultListableBeanFactory，它实现了BeanDefinitionRegistry接口，所以其中的registerBeanDefinition()方法，可以对BeanDefinition进行注册这里附带一提，最常见的XmlWebApplicationContext不是自己持有BeanDefinition的，它继承自AbstractRefreshableApplicationContext，其持有一个DefaultListableBeanFactory的字段，就是用它来保存BeanDefinition
-所谓的注册，其实就是将BeanDefinition的name和实例，保存到一个Map中。
-
-
-刚才说到，最常用的实现DefaultListableBeanFactory，其中的字段就是beanDefinitionMap，是一个ConcurrentHashMap。
-代码如下：
-**>1.DefaultListableBeanFactory继承实现关系**
-
-```
-public class DefaultListableBeanFactory
-extends 
-AbstractAutowireCapableBeanFactory   
-implements
-ConfigurableListableBeanFactory, 
-BeanDefinitionRegistry,
-Serializable { 
-     // DefaultListableBeanFactory的实例中最终保存了所有注册的bean    beanDefinitionMap
-     /** Map of bean definition objects, keyed by bean name */
-     private final Map<String, BeanDefinition> beanDefinitionMap 
-     = new ConcurrentHashMap<String, BeanDefinition>(64); 
-     //实现BeanDefinitionRegistry中定义的registerBeanDefinition()抽象方法
-     public void registerBeanDefinition(String beanName, BeanDefinition    beanDefinition)      throws BeanDefinitionStoreException {
-     }
-
-```
-
-**>2.BeanDefinitionRegistry接口**
-
-```
-public interface BeanDefinitionRegistry extends AliasRegistry {   
-    //定义注册BeanDefinition实例的抽象方法
-    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)         throws BeanDefinitionStoreException;
-
-```
-
-**4.实例化**
-
-* * *
-
-注册也完成之后，在BeanFactory的getBean()方法之中，会完成初始化，也就是依赖注入的过程
-大体上的流程就是这样。
-
-# refresh()方法
-
-> **1.目标：**
-> 这篇记录debug 追溯源码的过程，大概分三个篇幅，这是第一篇，现整体了解一下运行流程，定位资源加载，资源解析，bean 注册发生的位置。
-> 2.**记录结构：**
-> 1.调试栈截图
-> 2.整体流程
-> 3.bean.xml的处理
-> **每段代码下面有相应的讲解**
-
-## 调试栈截图
-
-* * *
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825134839933-520783623.png)
-
-每个栈帧中方法的行号都有标明，按照行号追溯源码，然后配合教程能够快速学习。
-
-## 整体流程
-
-* * *
-
-ioc容器实例化代码
-
-```
-ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
-
-```
-
-进入代码中一步步追溯，发现重要方法：refresh();
-如下所示：
-
-```
-public void refresh() throws BeansException, IllegalStateException {
-
-        synchronized (this.startupShutdownMonitor) {
-            // Prepare this context for refreshing.
-            prepareRefresh();
-            //beanFactory实例化方法 单步调试入口
-            // 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) {
-                // Destroy already created singletons to avoid dangling resources.
-                destroyBeans();
-
-                // Reset 'active' flag.
-                cancelRefresh(ex);
-
-                // Propagate exception to caller.
-                throw ex;
-            }
-        }
-    }
-
-```
-
-首先这个方法是同步的，以避免重复刷新。然后刷新的每个步骤，都放在单独的方法里，比较清晰，可以按顺序一个个看
-
-首先是prepareRefresh()方法
-
-```
-protected void prepareRefresh() {
-        this.startupDate = System.currentTimeMillis();
-
-        synchronized (this.activeMonitor) {
-            this.active = true;
-        }
-
-        if (logger.isInfoEnabled()) {
-            logger.info("Refreshing " + this);
-        }
-
-        // Initialize any placeholder property sources in the context environment
-        initPropertySources();
-
-        // Validate that all properties marked as required are resolvable
-        // see ConfigurablePropertyResolver#setRequiredProperties
-        this.environment.validateRequiredProperties();
-    }
-
-```
-
-这个方法里做的事情不多，记录了开始时间，输出日志，另外initPropertySources()方法和validateRequiredProperties()方法一般都没有做什么事。
-
-然后是核心的obtainFreshBeanFactory()方法，这个方法是初始化BeanFactory，是整个refresh()方法的核心，其中完成了配置文件的加载、解析、注册，后面会专门详细说 。
-
-这里要说明一下，ApplicationContext实现了BeanFactory接口，并实现了ResourceLoader、MessageSource等接口，可以认为是增强的BeanFactory。但是ApplicationContext并不自己重复实现BeanFactory定义的方法，而是委托给DefaultListableBeanFactory来实现。这种设计思路也是值得学习的。
-后面的 prepareBeanFactory()、postProcessBeanFactory()、invokeBeanFactoryPostProcessors()、registerBeanPostProcessors()、initMessageSource()、initApplicationEventMulticaster()、onRefresh()、registerListeners()、finishBeanFactoryInitialization()、finishRefresh()等方法，是添加一些后处理器、广播、拦截器等，就不一个个细说了
-
-其中的关键方法是finishBeanFactoryInitialization()，在这个方法中，会对刚才注册的Bean（不延迟加载的），进行实例化，所以也是一个核心方法。
-
-## bean.xml的处理
-
-* * *
-
-从整体上介绍完了流程，接下来就重点看obtainFreshBeanFactory()方法，上文说到，在这个方法里，完成了配置文件的加载、解析、注册
-
-```
-protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
-        refreshBeanFactory();
-        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
-        if (logger.isDebugEnabled()) {
-            logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
-        }
-        return beanFactory;
-    }
-
-```
-
-这个方法做了2件事，首先通过refreshBeanFactory()方法，创建了DefaultListableBeanFactory的实例，并进行初始化。
-
-```
-protected final void refreshBeanFactory() throws BeansException {
-        if (hasBeanFactory()) {
-            destroyBeans();
-            closeBeanFactory();
-        }
-        try {
-            DefaultListableBeanFactory beanFactory = createBeanFactory();
-            beanFactory.setSerializationId(getId());
-            customizeBeanFactory(beanFactory);
-            loadBeanDefinitions(beanFactory);
-            synchronized (this.beanFactoryMonitor) {
-                this.beanFactory = beanFactory;
-            }
-        }
-        catch (IOException ex) {
-            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
-        }
-    }
-
-```
-
-首先如果已经有BeanFactory实例，就先清空。然后通过createBeanFactory()方法，创建一个DefaultListableBeanFactory的实例
-
-```
-protected DefaultListableBeanFactory createBeanFactory() {
-        return new DefaultListableBeanFactory(getInternalParentBeanFactory());
-    }
-
-```
-
-接下来设置ID唯一标识
-
-```
-beanFactory.setSerializationId(getId());
-
-```
-
-然后允许用户进行一些自定义的配置
-
-```
-protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
-        if (this.allowBeanDefinitionOverriding != null) {
-            beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
-        }
-        if (this.allowCircularReferences != null) {
-            beanFactory.setAllowCircularReferences(this.allowCircularReferences);
-        }
-        beanFactory.setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
-    }
-
-```
-
-最后，就是核心的loadBeanDefinitions()方法
-
-```
-protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
-        // Create a new XmlBeanDefinitionReader for the given BeanFactory.
-        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
-
-        // Configure the bean definition reader with this context's
-        // resource loading environment.
-        beanDefinitionReader.setEnvironment(this.getEnvironment());
-        beanDefinitionReader.setResourceLoader(this);
-        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
-
-        // Allow a subclass to provide custom initialization of the reader,
-        // then proceed with actually loading the bean definitions.
-        initBeanDefinitionReader(beanDefinitionReader);
-        loadBeanDefinitions(beanDefinitionReader);
-    }
-
-```
-
-这里首先会创建一个XmlBeanDefinitionReader的实例，然后进行初始化。这个XmlBeanDefinitionReader中其实传递的BeanDefinitionRegistry类型的实例，为什么可以传递一个beanFactory呢，因为DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，这里是多态的使用。
-
-```
-protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
-        // Create a new XmlBeanDefinitionReader for the given BeanFactory.
-        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
-
-        // Configure the bean definition reader with this context's
-        // resource loading environment.
-        beanDefinitionReader.setEnvironment(this.getEnvironment());
-        beanDefinitionReader.setResourceLoader(this);
-        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
-
-        // Allow a subclass to provide custom initialization of the reader,
-        // then proceed with actually loading the bean definitions.
-        initBeanDefinitionReader(beanDefinitionReader);
-}
-
-```
-
-这里要说明一下，ApplicationContext并不自己负责配置文件的加载、解析、注册，而是将这些工作委托给XmlBeanDefinitionReader来做。
-
-```
-loadBeanDefinitions(beanDefinitionReader);
-
-```
-
-这行代码，就是Bean定义读取实际发生的地方。这里的工作，主要是XmlBeanDefinitionReader来完成的，下一篇博客会详细介绍这个过程。
-
-## loadBeanDefinitions
-
-### loadBeanDefinitions: 源码阅读
-
-* * *
-
-入口是loadBeanDefinitions方法
-
-```
-protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) 
-throws IOException {
-        String[] configLocations = getConfigLocations();
-        if (configLocations != null) {
-            for (String configLocation : configLocations) {
-                reader.loadBeanDefinitions(configLocation);
-            }
-        }
-}
-
-```
-
-这是解析过程最外围的代码，首先要获取到配置文件的路径，这在之前已经完成了。
-然后将每个配置文件的路径，作为参数传给BeanDefinitionReader的loadBeanDefinitions方法里
-
-```
-public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
-        return loadBeanDefinitions(location, null);
-}
-
-```
-
-这个方法又调用了重载方法
-
-```
-public int loadBeanDefinitions(String location, Set<Resource> actualResources) 
-throws BeanDefinitionStoreException {
-        ResourceLoader resourceLoader = getResourceLoader();
-        if (resourceLoader == null) {
-            throw new BeanDefinitionStoreException(
-                    "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
-        }
-
-        if (resourceLoader instanceof ResourcePatternResolver) {
-            // Resource pattern matching available.
-            try {
-                Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
-                int loadCount = loadBeanDefinitions(resources);
-                if (actualResources != null) {
-                    for (Resource resource : resources) {
-                        actualResources.add(resource);
-                    }
-                }
-                if (logger.isDebugEnabled()) {
-                    logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
-                }
-                return loadCount;
-            }
-            catch (IOException ex) {
-                throw new BeanDefinitionStoreException(
-                        "Could not resolve bean definition resource pattern [" + location + "]", ex);
-            }
-        }
-        else {
-            // Can only load single resources by absolute URL.
-            Resource resource = resourceLoader.getResource(location);
-            int loadCount = loadBeanDefinitions(resource);
-            if (actualResources != null) {
-                actualResources.add(resource);
-            }
-            if (logger.isDebugEnabled()) {
-                logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
-            }
-            return loadCount;
-        }
-    }
-
-```
-
-首先getResourceLoader()的实现的前提条件是因为XmlBeanDefinitionReader在实例化的时候已经确定了创建了实例ResourceLoader实例, 代码位于 AbstractBeanDefinitionReader
-
-```
-protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {   
-     Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); 
-     this.registry = registry;   
-     // Determine ResourceLoader to use.  
-     if (this.registry instanceof ResourceLoader) {     
-         this.resourceLoader = (ResourceLoader) this.registry;   
-      }  else {      
-         this.resourceLoader = new PathMatchingResourcePatternResolver();  
-      }   
-     // Inherit Environment if possible   
-     if (this.registry instanceof EnvironmentCapable) {      
-          this.environment = ((EnvironmentCapable)this.registry).getEnvironment();  
-      }  else {      
-          this.environment = new StandardEnvironment(); 
-      }
-}
-
-```
-
-这个方法比较长，BeanDefinitionReader不能直接加载配置文件，需要把配置文件封装成Resource，然后才能调用重载方法loadBeanDefinitions()。所以这个方法其实就是2段，第一部分是委托ResourceLoader将配置文件封装成Resource，第二部分是调用loadBeanDefinitions()，对Resource进行解析
-
-而这里的ResourceLoader，就是前面的XmlWebApplicationContext，因为ApplicationContext接口，是继承自ResourceLoader接口的
-
-Resource也是一个接口体系，在web环境下，这里就是ServletContextResource
-
-接下来进入重载方法loadBeanDefinitions()
-
-```
-public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
-        Assert.notNull(resources, "Resource array must not be null");
-        int counter = 0;
-        for (Resource resource : resources) {
-            counter += loadBeanDefinitions(resource);
-        }
-        return counter;
-    }
-
-```
-
-这里就不用说了，就是把每一个Resource作为参数，继续调用重载方法。读spring源码，会发现重载方法特别多。
-
-```
-public int loadBeanDefinitions(Resource resource)  throws
- BeanDefinitionStoreException {
-        return loadBeanDefinitions(new EncodedResource(resource));
-}
-
-```
-
-还是重载方法，不过这里对传进来的Resource又进行了一次封装，变成了编码后的Resource。
-
-```
-public int loadBeanDefinitions(EncodedResource encodedResource) 
-throws BeanDefinitionStoreException {
-        Assert.notNull(encodedResource, "EncodedResource must not be null");
-        if (logger.isInfoEnabled()) {
-            logger.info("Loading XML bean definitions from " + encodedResource.getResource());
-        }
-
-        Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
-        if (currentResources == null) {
-            currentResources = new HashSet<EncodedResource>(4);
-            this.resourcesCurrentlyBeingLoaded.set(currentResources);
-        }
-        if (!currentResources.add(encodedResource)) {
-            throw new BeanDefinitionStoreException(
-                    "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
-        }
-        try {
-            InputStream inputStream = encodedResource.getResource().getInputStream();
-            try {
-                InputSource inputSource = new InputSource(inputStream);
-                if (encodedResource.getEncoding() != null) {
-                    inputSource.setEncoding(encodedResource.getEncoding());
-                }
-                return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
-            }
-            finally {
-                inputStream.close();
-            }
-        }
-        catch (IOException ex) {
-            throw new BeanDefinitionStoreException(
-                    "IOException parsing XML document from " + encodedResource.getResource(), ex);
-        }
-        finally {
-            currentResources.remove(encodedResource);
-            if (currentResources.isEmpty()) {
-                this.resourcesCurrentlyBeingLoaded.remove();
-            }
-        }
-    }
-
-```
-
-这个就是loadBeanDefinitions()的最后一个重载方法，比较长，可以拆看来看。
-
-```
-Assert.notNull(encodedResource, "EncodedResource must not be null");
-        if (logger.isInfoEnabled()) {
-            logger.info("Loading XML bean definitions from " + encodedResource.getResource());
-        }
-
-        Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
-        if (currentResources == null) {
-            currentResources = new HashSet<EncodedResource>(4);
-            this.resourcesCurrentlyBeingLoaded.set(currentResources);
-        }
-        if (!currentResources.add(encodedResource)) {
-            throw new BeanDefinitionStoreException(
-                    "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
-        }
-
-```
-
-这第一部分，是处理线程相关的工作，把当前正在解析的Resource，设置为当前Resource。
-
-```
-try {
-            InputStream inputStream = encodedResource.getResource().getInputStream();
-            try {
-                InputSource inputSource = new InputSource(inputStream);
-                if (encodedResource.getEncoding() != null) {
-                    inputSource.setEncoding(encodedResource.getEncoding());
-                }
-                return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
-            }
-            finally {
-                inputStream.close();
-            }
-        }
-
-```
-
-这里是第二部分，是核心，首先把Resource还原为InputStream，然后调用实际解析的方法doLoadBeanDefinitions()。**可以看到，这种命名方式是很值得学习的，一种业务方法，比如parse()，可能需要做一些外围的工作，然后实际解析的方法，可以命名为doParse()。这种doXXX()的命名方法，在很多开源框架中都有应用，比如logback等。**
-接下来就看一下这个doLoadBeanDefinitions()方法
-
-```
-protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
-            throws BeanDefinitionStoreException {
-        try {
-            Document doc = doLoadDocument(inputSource, resource);return registerBeanDefinitions(doc, resource);
-            return registerBeanDefinitions(doc, resource);
-        }
-        catch (BeanDefinitionStoreException ex) {
-            throw ex;
-        }
-        catch (SAXParseException ex) {
-            throw new XmlBeanDefinitionStoreException(resource.getDescription(),
-                    "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
-        }
-        catch (SAXException ex) {
-            throw new XmlBeanDefinitionStoreException(resource.getDescription(),
-                    "XML document from " + resource + " is invalid", ex);
-        }
-        catch (ParserConfigurationException ex) {
-            throw new BeanDefinitionStoreException(resource.getDescription(),
-                    "Parser configuration exception parsing XML from " + resource, ex);
-        }
-        catch (IOException ex) {
-            throw new BeanDefinitionStoreException(resource.getDescription(),
-                    "IOException parsing XML document from " + resource, ex);
-        }
-        catch (Throwable ex) {
-            throw new BeanDefinitionStoreException(resource.getDescription(),
-                    "Unexpected exception parsing XML document from " + resource, ex);
-        }
-    }
-
-```
-
-抛开异常处理：核心代码如下：
-
-```
- Document doc = doLoadDocument(inputSource, resource);
- return  registerBeanDefinitions(doc, resource);
-
-```
-
-doLoadDocument方法将InputStream读取成标准的Document对象，然后调用registerBeanDefinitions()，进行解析工作。
-
-```
-protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {   
-    return this.documentLoader.loadDocument(inputSource,  
-                                            getEntityResolver(), this.errorHandler,  
-                                            getValidationModeForResource(resource),  
-                                            isNamespaceAware());
-}
-
-```
-
-接下来就看一下这个核心方法registerBeanDefinitions
-
-```
-public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
-        //创建的其实是DefaultBeanDefinitionDocumentReader 的实例，利用反射创建的。
-        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
-        documentReader.setEnvironment(this.getEnvironment());
-        int countBefore = getRegistry().getBeanDefinitionCount();
-        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
-        return getRegistry().getBeanDefinitionCount() - countBefore;
-}
-
-```
-
-**这里注意两点 :**
-
-> **1.Document对象**
-> 首先这个Document对象，是W3C定义的标准XML对象，跟spring无关。其次这个registerBeanDefinitions方法，我觉得命名有点误导性。因为这个时候实际上解析还没有开始，怎么直接就注册了呢。比较好的命名，我觉得可以是parseAndRegisterBeanDefinitions()。
-> **2.documentReader的创建时使用反射创建的，代码如下**
-
-```
-protected BeanDefinitionDocumentReader    
- createBeanDefinitionDocumentReader() {   
-          return BeanDefinitionDocumentReader.class.cast(BeanUtils.
-            instantiateClass(this.documentReaderClass));
-}
-
-```
-
-instantiateClass方法中传入了一个Class类型的参数。追溯发现下述代码：
-
-```
-private Class<?> documentReaderClass = 
-DefaultBeanDefinitionDocumentReader.class;
-
-```
-
-所以创建的documentReaderClass是DefaultBeanDefinitionDocumentReader类的实例。
-接下来就进入BeanDefinitionDocumentReader 中定义的registerBeanDefinitions()方法看看
-
-```
-public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
-        this.readerContext = readerContext;
-        logger.debug("Loading bean definitions");
-        Element root = doc.getDocumentElement();
-        doRegisterBeanDefinitions(root);
-    }
-
-```
-
-处理完外围事务之后，进入doRegisterBeanDefinitions()方法，这种命名规范，上文已经介绍过了
-
-```
-protected void doRegisterBeanDefinitions(Element root) {
-        String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
-        if (StringUtils.hasText(profileSpec)) {
-            Assert.state(this.environment != null, "environment property must not be null");
-            String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
-            if (!this.environment.acceptsProfiles(specifiedProfiles)) {
-                return;
-            }
-        }
-        // any nested <beans> elements will cause recursion in this method. In
-        // order to propagate and preserve <beans> default-* attributes correctly,
-        // keep track of the current (parent) delegate, which may be null. Create
-        // the new (child) delegate with a reference to the parent for fallback purposes,
-        // then ultimately reset this.delegate back to its original (parent) reference.
-        // this behavior emulates a stack of delegates without actually necessitating one.
-        BeanDefinitionParserDelegate parent = this.delegate;
-        this.delegate = createHelper(readerContext, root, parent);
-        preProcessXml(root);
-        parseBeanDefinitions(root, this.delegate);
-        postProcessXml(root);
-        this.delegate = parent;
-}
-
-```
-
-这个方法也比较长，拆开来看
-
-```
-String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
-        if (StringUtils.hasText(profileSpec)) {
-            Assert.state(this.environment != null, "environment property must not be null");
-            String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
-            if (!this.environment.acceptsProfiles(specifiedProfiles)) {
-                return;
-            }
-}
-
-```
-
-如果配置文件中元素，配有profile属性，就会进入这一段，不过一般都是不会的
-
-```
-        BeanDefinitionParserDelegate parent = this.delegate;
-        this.delegate = createHelper(readerContext, root, parent);
-        preProcessXml(root);
-        parseBeanDefinitions(root, this.delegate);
-        postProcessXml(root);
-        this.delegate = parent;
-
-```
-
-然后这里创建了BeanDefinitionParserDelegate对象，preProcessXml()和postProcessXml()都是空方法，核心就是parseBeanDefinitions()方法。这里又把BeanDefinition解析和注册的工作，委托给了BeanDefinitionParserDelegate对象，在parseBeanDefinitions()方法中完成
-总的来说，解析工作的委托链是这样的：ClassPathXmlApplicationContext，XmlBeanDefinitionReader，DefaultBeanDefinitionDocumentReader，BeanDefinitionParserDelegate
-ClassPathXmlApplicationContext作为最外围的组件，发起解析的请求
-XmlBeanDefinitionReader将配置文件路径封装为Resource，读取出w3c定义的Document对象，然后委托给DefaultBeanDefinitionDocumentReader
-DefaultBeanDefinitionDocumentReader就开始做实际的解析工作了，但是涉及到bean的具体解析，它还是会继续委托给BeanDefinitionParserDelegate来做。
-接下来在parseBeanDefinitions()方法中发生了什么，以及BeanDefinitionParserDelegate类完成的工作，在下一篇博客中继续介绍。
-
-# loadBeanDefinitions
-
-> BeanDefinition的解析,已经走到了DefaultBeanDefinitionDocumentR
-> eader里，这时候配置文件已经被加载，并解析成w3c的Document对象。这篇博客就接着介绍，DefaultBeanDefinitionDocumentReader和BeanDefinitionParserDelegate类，是怎么协同完成bean的解析和注册的。
-
-```
-        BeanDefinitionParserDelegate parent = this.delegate;
-        this.delegate = createHelper(readerContext, root, parent);
-        preProcessXml(root);
-        parseBeanDefinitions(root, this.delegate);
-        postProcessXml(root);
-        this.delegate = parent;
-
-```
-
-这段代码，创建了一个BeanDefinitionParserDelegate组件，然后就是preProcessXml()、parseBeanDefinitions()、postProcessXml()方法
-其中preProcessXml()和postProcessXml()默认是空方法，接下来就看下parseBeanDefinitions()方法
-
-```
-protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
-        if (delegate.isDefaultNamespace(root)) {
-            NodeList nl = root.getChildNodes();
-            for (int i = 0; i < nl.getLength(); i++) {
-                Node node = nl.item(i);
-                if (node instanceof Element) {
-                    Element ele = (Element) node;
-                    if (delegate.isDefaultNamespace(ele)) {
-                        parseDefaultElement(ele, delegate);
-                    }
-                    else {
-                        delegate.parseCustomElement(ele);
-                    }
-                }
-            }
-        }
-        else {
-            delegate.parseCustomElement(root);
-        }
-    }
-
-```
-
-从这个方法开始，BeanDefinitionParserDelegate就开始发挥作用了，判断当前解析元素是否属于默认的命名空间，如果是的话，就调用parseDefaultElement()方法，否则调用delegate上parseCustomElement()方法
-
-```
-public boolean isDefaultNamespace(String namespaceUri) {
-        return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri));
-    }
-    public boolean isDefaultNamespace(Node node) {
-        return isDefaultNamespace(getNamespaceURI(node));
-    }
-
-```
-
-只有**[http://www.springframework.org/schema/beans](https://link.jianshu.com/?t=http://www.springframework.org/schema/beans)**，会被认为是默认的命名空间。也就是说，beans、bean这些元素，会认为属于默认的命名空间，而像task:scheduled这些，就认为不属于默认命名空间。
-根节点beans的一个子节点bean，是属于默认命名空间的，所以会进入parseDefaultElement()方法
-
-```
-private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
-        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
-            importBeanDefinitionResource(ele);
-        }
-        else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
-            processAliasRegistration(ele);
-        }
-        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
-            processBeanDefinition(ele, delegate);
-        }
-        else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
-            // recurse
-            doRegisterBeanDefinitions(ele);
-        }
-    }
-
-```
-
-这里可能会有4种情况，import、alias、bean、beans，分别有一个方法与之对应，这里解析的是bean元素，所以会进入processBeanDefinition()方法
-
-```
-protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
-        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
-        if (bdHolder != null) {
-            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
-            try {
-                // Register the final decorated instance.
-                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
-            }
-            catch (BeanDefinitionStoreException ex) {
-                getReaderContext().error("Failed to register bean definition with name '" +
-                        bdHolder.getBeanName() + "'", ele, ex);
-            }
-            // Send registration event.
-            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
-        }
-    }
-
-```
-
-这里主要有3个步骤，先是委托delegate对bean进行解析，然后委托delegate对bean进行装饰，最后由一个工具类来完成BeanDefinition的注册
-可以看出来，DefaultBeanDefinitionDocumentReader不负责任何具体的bean解析，它面向的是xml Document对象，根据其元素的命名空间和名称，起一个类似路由的作用（不过，命名空间的判断，也是委托给delegate来做的）。所以这个类的命名，是比较贴切的，突出了其面向Document的特性。具体的工作，是由BeanDefinitionParserDelegate来完成的
-下面就看下parseBeanDefinitionElement()方法
-
-```
-public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
-        String id = ele.getAttribute(ID_ATTRIBUTE);
-        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
-        List<String> aliases = new ArrayList<String>();
-        if (StringUtils.hasLength(nameAttr)) {
-            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
-            aliases.addAll(Arrays.asList(nameArr));
-        }
-        String beanName = id;
-        if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
-            beanName = aliases.remove(0);
-            if (logger.isDebugEnabled()) {
-                logger.debug("No XML 'id' specified - using '" + beanName +
-                        "' as bean name and " + aliases + " as aliases");
-            }
-        }
-        if (containingBean == null) {
-            checkNameUniqueness(beanName, aliases, ele);
-        }
-        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
-        if (beanDefinition != null) {
-            if (!StringUtils.hasText(beanName)) {
-                try {
-                    if (containingBean != null) {
-                        beanName = BeanDefinitionReaderUtils.generateBeanName(
-                                beanDefinition, this.readerContext.getRegistry(), true);
-                    }
-                    else {
-                        beanName = this.readerContext.generateBeanName(beanDefinition);
-                        // Register an alias for the plain bean class name, if still possible,
-                        // if the generator returned the class name plus a suffix.
-                        // This is expected for Spring 1.2/2.0 backwards compatibility.
-                        String beanClassName = beanDefinition.getBeanClassName();
-                        if (beanClassName != null &&
-                                beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&                      !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
-                            aliases.add(beanClassName);
-                        }
-                    }
-                    if (logger.isDebugEnabled()) {
-                        logger.debug("Neither XML 'id' nor 'name' specified - " +
-                                "using generated bean name [" + beanName + "]");
-                    }
-                }
-                catch (Exception ex) {
-                    error(ex.getMessage(), ele);
-                    return null;
-                }
-            }
-            String[] aliasesArray = StringUtils.toStringArray(aliases);
-            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
-        }
-        return null;
-    }
-
-```
-
-这个方法很长，可以分成三段来看
-
-```
-String id = ele.getAttribute(ID_ATTRIBUTE);
-        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
-        List<String> aliases = new ArrayList<String>();
-        if (StringUtils.hasLength(nameAttr)) {
-            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
-            aliases.addAll(Arrays.asList(nameArr));
-        }
-        String beanName = id;
-        if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
-            beanName = aliases.remove(0);
-            if (logger.isDebugEnabled()) {
-                logger.debug("No XML 'id' specified - using '" + beanName +
-                        "' as bean name and " + aliases + " as aliases");
-            }
-        }
-        if (containingBean == null) {
-            checkNameUniqueness(beanName, aliases, ele);
-        }
-
-```
-
-这一段，主要是处理一些跟alias，id等标识相关的东西
-
-```
-AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
-
-```
-
-这一行是核心，进行实际的解析
-
-```
-if (beanDefinition != null) {
-            if (!StringUtils.hasText(beanName)) {
-                try {
-                    if (containingBean != null) {
-                        beanName = BeanDefinitionReaderUtils.generateBeanName(
-                                beanDefinition, this.readerContext.getRegistry(), true);
-                    }
-                    else {
-                        beanName = this.readerContext.generateBeanName(beanDefinition);
-                        // Register an alias for the plain bean class name, if still possible,
-                        // if the generator returned the class name plus a suffix.
-                        // This is expected for Spring 1.2/2.0 backwards compatibility.
-                        String beanClassName = beanDefinition.getBeanClassName();
-                        if (beanClassName != null &&
-                                beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
-                                !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
-                            aliases.add(beanClassName);
-                        }
-                    }
-                    if (logger.isDebugEnabled()) {
-                        logger.debug("Neither XML 'id' nor 'name' specified - " +
-                                "using generated bean name [" + beanName + "]");
-                    }
-                }
-                catch (Exception ex) {
-                    error(ex.getMessage(), ele);
-                    return null;
-                }
-            }
-            String[] aliasesArray = StringUtils.toStringArray(aliases);
-            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
-        }
-
-```
-
-这段是后置处理，对beanName进行处理
-前置处理和后置处理，不是核心，就不细看了，重点看下核心的那一行调用
-
-```
-public AbstractBeanDefinition parseBeanDefinitionElement(
-            Element ele, String beanName, BeanDefinition containingBean) {
-        this.parseState.push(new BeanEntry(beanName));
-        String className = null;
-        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
-            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
-        }
-        try {
-            String parent = null;
-            if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
-                parent = ele.getAttribute(PARENT_ATTRIBUTE);
-            }
-            AbstractBeanDefinition bd = createBeanDefinition(className, parent);
-            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
-            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
-            parseMetaElements(ele, bd);
-            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
-            parseReplacedMethodSubElements(ele,   bd.getMethodOverrides());
-            parseConstructorArgElements(ele, bd);
-            parsePropertyElements(ele, bd);
-            parseQualifierElements(ele, bd);
-            bd.setResource(this.readerContext.getResource());
-            bd.setSource(extractSource(ele));
-            return bd;
-        }
-        catch (ClassNotFoundException ex) {
-            error("Bean class [" + className + "] not found", ele, ex);
-        }
-        catch (NoClassDefFoundError err) {
-            error("Class that bean class [" + className + "] depends on not found", ele, err);
-        }
-        catch (Throwable ex) {
-            error("Unexpected failure during bean definition parsing", ele, ex);
-        }
-        finally {
-            this.parseState.pop();
-        }
-        return null;
-    }
-
-```
-
-这个方法也挺长的，拆开看看
-
-```
-this.parseState.push(new BeanEntry(beanName));
-        String className = null;
-        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
-            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
-        }
-
-```
-
-这段是从配置中抽取出类名。接下来的长长一段，把异常处理先抛开，看看实际的业务
-
-```
-            String parent = null;
-            if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
-                parent = ele.getAttribute(PARENT_ATTRIBUTE);
-            }
-            AbstractBeanDefinition bd = createBeanDefinition(className, parent);
-            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);                  
-            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
-            parseMetaElements(ele, bd);
-            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
-            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
-            parseConstructorArgElements(ele, bd);
-            parsePropertyElements(ele, bd);
-            parseQualifierElements(ele, bd);
-            bd.setResource(this.readerContext.getResource());
-            bd.setSource(extractSource(ele));
-            return bd;
-
-```
-
-这里每个方法的命名，就说明了是要干什么，可以一个个跟进去看，本文就不细说了。总之，经过这里的解析，就得到了一个完整的BeanDefinitionHolder。只是说明一下，如果在配置文件里，没有对一些属性进行设置，比如autowire-candidate等，那么这个解析生成的BeanDefinition，都会得到一个默认值
-**然后，对这个Bean做一些必要的装饰**
-
-```
-public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
-            Element ele, BeanDefinitionHolder definitionHolder, BeanDefinition containingBd) {
-        BeanDefinitionHolder finalDefinition = definitionHolder;
-        // Decorate based on custom attributes first.
-        NamedNodeMap attributes = ele.getAttributes();
-        for (int i = 0; i < attributes.getLength(); i++) {
-            Node node = attributes.item(i);
-            finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
-        }
-        // Decorate based on custom nested elements.
-        NodeList children = ele.getChildNodes();
-        for (int i = 0; i < children.getLength(); i++) {
-            Node node = children.item(i);
-            if (node.getNodeType() == Node.ELEMENT_NODE) {
-                finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
-            }
-        }
-        return finalDefinition;
-    }
-
-```
-
-持续单步调试，代码继续运行到DefaultBeanDefinitionDocumentReader中的processBeanDefinition中的registerBeanDefinition()
-
-```
-BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, 
-getReaderContext().getRegistry());
-
-```
-
-单步进入代码发现BeanDefinitionReaderUtils静态方法registerBeanDefinition()
-
-```
-public static void registerBeanDefinition(
-            BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
-            throws BeanDefinitionStoreException {
-        // Register bean definition under primary name.
-        String beanName = definitionHolder.getBeanName();
-        // 其实调用的是DefaultListableBeanFactory中的registerBeanDefinition方法
-        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
-        // Register aliases for bean name, if any.
-        String[] aliases = definitionHolder.getAliases();
-        if (aliases != null) {
-            for (String aliase : aliases) {
-                registry.registerAlias(beanName, aliase);
-            }
-        }
-    }
-
-```
-
-解释一下**其实调用的是DefaultListableBeanFactory中的registerBeanDefinition方法**这句话，因为DefaultListableBeanFactory实现BeanDefinitionRegistry接口，BeanDefinitionRegistry接口中定义了registerBeanDefinition()方法
-看下DefaultListableBeanFactory中registerBeanDefinition()实例方法的具体实现：
-
-```
-public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
-            throws BeanDefinitionStoreException {
-        Assert.hasText(beanName, "Bean name must not be empty");
-        Assert.notNull(beanDefinition, "BeanDefinition must not be null");
-        if (beanDefinition instanceof AbstractBeanDefinition) {
-            try {
-                ((AbstractBeanDefinition) beanDefinition).validate();
-            }
-            catch (BeanDefinitionValidationException ex) {
-                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
-                        "Validation of bean definition failed", ex);
-            }
-        }
-        synchronized (this.beanDefinitionMap) {
-            Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);
-            if (oldBeanDefinition != null) {
-                if (!this.allowBeanDefinitionOverriding) {
-                    throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
-                            "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
-                            "': There is already [" + oldBeanDefinition + "] bound.");
-                }
-                else {
-                    if (this.logger.isInfoEnabled()) {
-                        this.logger.info("Overriding bean definition for bean '" + beanName +
-                                "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
-                    }
-                }
-            }
-            else {
-                this.beanDefinitionNames.add(beanName);
-                this.frozenBeanDefinitionNames = null;
-            }
-            this.beanDefinitionMap.put(beanName, beanDefinition);
-            resetBeanDefinition(beanName);
-        }
-    }
-
-```
-
-代码追溯之后发现这个方法里，最关键的是以下2行：
-
-```
-this.beanDefinitionNames.add(beanName);
-this.beanDefinitionMap.put(beanName, beanDefinition);
-
-```
-
-前者是把beanName放到队列里，后者是把BeanDefinition放到map中，到此注册就完成了。在后面实例化的时候，就是把beanDefinitionMap中的BeanDefinition取出来，逐一实例化
-BeanFactory准备完毕之后，代码又回到了ClassPathXmlApplicationContext里
-
-```
-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) {
-                // Destroy already created singletons to avoid dangling resources.
-                destroyBeans();
-                // Reset 'active' flag.
-                cancelRefresh(ex);
-                // Propagate exception to caller.
-                throw ex;
-            }
-        }
-    }
-
-```
-
-也就是obtainFreshBeanFactory()方法执行之后，再进行下面的步骤。
-总结来说，ApplicationContext将解析配置文件的工作委托给BeanDefinitionReader，然后BeanDefinitionReader将配置文件读取为xml的Document文档之后，又委托给BeanDefinitionDocumentReader
-BeanDefinitionDocumentReader这个组件是根据xml元素的命名空间和元素名，起到一个路由的作用，实际的解析工作，是委托给BeanDefinitionParserDelegate来完成的。
-
-
-BeanDefinitionParserDelegate的解析工作完成以后，会返回BeanDefinitionHolder给BeanDefinitionDocumentReader，在这里，会委托给DefaultListableBeanFactory完成bean的注册
-XmlBeanDefinitionReader（计数、解析XML文档），BeanDefinitionDocumentReader（依赖xml文档，进行解析和注册），BeanDefinitionParserDelegate（实际的解析工作）。
-
-
-可以看出，在解析bean的过程中，这3个组件的分工是比较清晰的，各司其职，这种设计思想值得学习
-到此为止，bean的解析、注册、spring ioc 容器的实例化过程就基本分析结束了。
diff --git "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2204\357\274\232\346\207\222\345\212\240\350\275\275\347\232\204\345\215\225\344\276\213Bean\350\216\267\345\217\226\350\277\207\347\250\213\345\210\206\346\236\220.md" "b/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2204\357\274\232\346\207\222\345\212\240\350\275\275\347\232\204\345\215\225\344\276\213Bean\350\216\267\345\217\226\350\277\207\347\250\213\345\210\206\346\236\220.md"
deleted file mode 100644
index 3d41877..0000000
--- "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2204\357\274\232\346\207\222\345\212\240\350\275\275\347\232\204\345\215\225\344\276\213Bean\350\216\267\345\217\226\350\277\207\347\250\213\345\210\206\346\236\220.md"
+++ /dev/null
@@ -1,154 +0,0 @@
-# Table of Contents
-
-  * [前言](#前言)
-  * [step1:](#step1)
-  * [step2:](#step2)
-  * [step3 : 我们已经step by step 的看到了如何将xml文件转换成Document的，现在就要分析是如何提取和注册bean的。](#step3--我们已经step-by-step-的看到了如何将xml文件转换成document的，现在就要分析是如何提取和注册bean的。)
-
-
-本文转自五月的仓颉 https://www.cnblogs.com/xrq730
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-文章将同步到我的个人博客：
-> www.how2playlife.com
-
-本文是微信公众号【Java技术江湖】的《Spring和SpringMVC源码分析》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从spring基础入手，一步步地学习spring基础和springmvc的框架知识，并上手进行项目实战，spring框架是每一个Java工程师必须要学习和理解的知识点，进一步来说，你还需要掌握spring甚至是springmvc的源码以及实现原理，才能更完整地了解整个spring技术体系，形成自己的知识框架。
-
-后续还会有springboot和springcloud的技术专题，陆续为大家带来，敬请期待。
-
-为了更好地总结和检验你的学习成果，本系列文章也会提供部分知识点对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-## 前言
-
-xml的读取应该是Spring的重要功能，因为Spring的大部分功能都是以配置做为切入点的。
-
-       我们在静态代码块中读取配置文件可以这样做：
-
-```
-   //这样来加载配置文件    
-   XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml")); 
-```
-
-       （1）XmlBeanFactory 继承 AbstractBeanDefinitionReader ，使用ResourceLoader 将资源文件路径转换为对应的Resource文件。
-
-       （2）通过DocumentLoader 对 Resource 文件进行转换，将 Resource 文件转换为 Document 文件。
-
-       （3）通过实现接口 BeanDefinitionDocumentReader 的 DefaultBeanDefinitionDocumentReader 类对Document 进行解析，并且使用 BeanDefinitionParserDelegate对Element进行解析。
-
-## step1:
-
-![bb0bf7543226c4ada238d93363f864d39da8e3e8](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/bb0bf7543226c4ada238d93363f864d39da8e3e8.png)
-
-     在平常开发中，我们也可以使用Resource 获取 资源文件：
-
-```
-  Resource resource = new ClassPathResource("application.xml");
-  InputStream in = resource.getInputStream();
-```
-
-## step2:
-
-![13bd511377c0957e4ef8daebdf457585a9acabea](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/13bd511377c0957e4ef8daebdf457585a9acabea.png)
-
-      在资源实现加载之前，调用了 super(parentBeanFactory) --  /**Ignore the given dependency interface for autowiring.(忽略接口的自动装配功能)*/
-
-      调用XmlBeanDefinitionReader 的 loadBeanDefinitions（）方法进行加载资源：
-
-      （1） 对Resource资源进行编码
-
-      （2） 通过SAX读取XML文件来创建InputSource对象
-
-      （3） 核心处理
-
-![7613f54877fef111ccbe68f2c3a96a9588029fb3](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/7613f54877fef111ccbe68f2c3a96a9588029fb3.png)
-
-       可以很直观的看出来是这个function是在解析xml文件从而获得对应的Document对象。
-
-![4b3425c37260bbb7e68ace81867259089871a0db](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/4b3425c37260bbb7e68ace81867259089871a0db.png)
-
-      在doLoadDocument方法里面还存一个方法getValidationModeForResource（）用来读取xml的验证模式。（和我关心的没什么关系，暂时不看了~）
-
-      转换成document也是最常用的方法：
-
-     ![869effccb2e4f7b69e0b53d17fe0a2b50044d61b](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/869effccb2e4f7b69e0b53d17fe0a2b50044d61b.png)
-
-## step3 : 我们已经step by step 的看到了如何将xml文件转换成Document的，现在就要分析是如何提取和注册bean的。
-
-            /**Register the bean definitions contained in the given DOM document*/
-
-![2daf08bfd105a15d3c5eaf411fdb0083b3969f81](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/2daf08bfd105a15d3c5eaf411fdb0083b3969f81.png)
-
-参数doc是doLoadBeanDefinitions（）方法传进来的  loadDocument 加载过来的。这边就很好的体现出了面向对象的单一全责原则，将逻辑处理委托給单一的类去处理。
-
-在这边单一逻辑处理类是：  BeanDefinitionDocumentReader
-
-核心方法：  <font color="#FF0000">documentReader.registerBeanDefinitions(doc, createReaderContext(resource));</font>
-
-<font color="#FF0000">![46ca5d8a7167fb010024f79e1f334820d7d2080a](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/46ca5d8a7167fb010024f79e1f334820d7d2080a.png)</font>
-
-<font color="#FF0000">开始解析：</font>
-
-<font color="#FF0000">![43eb5d219f00c7b5c99c0eed0828b9ff2550af41](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/43eb5d219f00c7b5c99c0eed0828b9ff2550af41.png)</font> 
-
--------------
-
-在Spring的xml配置中有两种方式来声明bean:
-
-     一种是默认的：  <bean id = " " class = " " />
-
-     还有一种是自定义的：  < tx : annotation-driven / >
-
-![fecfb37a9f121df42d5754f6fdf99367539936c6](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/fecfb37a9f121df42d5754f6fdf99367539936c6.png)
-
-通过xml配置文件的默认配置空间来判断：http://www.springframework.org/schema/beans
-
-对于默认标签的解析：
-
-![2b3bba761875a27d4ca52d72e76de934a90e51a1](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/2b3bba761875a27d4ca52d72e76de934a90e51a1.png)
-
-对Bean 配置的解析：
-
-![8dac08836a4c27f90d15355991774186886ef141](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/8dac08836a4c27f90d15355991774186886ef141.png)
-
-**BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);  返回BeanDefinitionHolder**
-
-**![f163a5df0d4ea8e105526fa7ef39547a1c188047](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/f163a5df0d4ea8e105526fa7ef39547a1c188047.png)**
-
-**![b93c6e1209359777b877f17e203e6226a269f4e0](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/b93c6e1209359777b877f17e203e6226a269f4e0.png)**
-
-这边代码大致看下来：
-
-1.  提取元素中的id和name属性
-2.  进一步解析将其他属性封装到 BeanDefinition 的实现类中
-3.  如果没有指定beanName 变使用默认规则生成beanName
-4.  封装类BeanDefinitionHolder
-
-可以先了解一下  BeanDefinition  这个类的作用。
-
-      BeanDefinition是一个接口，对应着配置文件中<bean>里面的所有配置，在Spring中存在着三个实现类：
-
-![917b789f984dee75d3b2748d885dcdd6541df8fe](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/917b789f984dee75d3b2748d885dcdd6541df8fe.png)
-
-      在配置文件中，可以定义父<bean>和子<bean>，父<bean>是用RootDefinition来表示，子<bean>是用ChildBeanDefinition来表示。
-
-      Spring 通过BeanDefiniton将配置文件中的<bean>配置信息转换为容器内部表示，并且将这些BeanDefinition注册到BeanDefinitonRegistry中。
-
-Spring容器的BeanDefinitonRegistry就像是Spring配置信息的内存数据库，主要是以map的形式保存的。
-
-     因此解析属性首先要创建用于承载属性的实例：
-
-![83cf6bccba49fb369d0221e7970187041da349f0](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/83cf6bccba49fb369d0221e7970187041da349f0.png)
-
-然后就是各种对属性的解析的具体方法：
-
-![89c0d5422e0495347f18fa03110bfb2afa255493](https://oss-cn-hangzhou.aliyuncs.com/yqfiles/89c0d5422e0495347f18fa03110bfb2afa255493.png)
diff --git "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2205\357\274\232JDK\345\222\214cglib\345\212\250\346\200\201\344\273\243\347\220\206\345\216\237\347\220\206\350\257\246\350\247\243.md" "b/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2205\357\274\232JDK\345\222\214cglib\345\212\250\346\200\201\344\273\243\347\220\206\345\216\237\347\220\206\350\257\246\350\247\243.md"
deleted file mode 100644
index 5bd2ca0..0000000
--- "a/docs/java-web/Spring/Spring\346\272\220\347\240\201\345\211\226\346\236\2205\357\274\232JDK\345\222\214cglib\345\212\250\346\200\201\344\273\243\347\220\206\345\216\237\347\220\206\350\257\246\350\247\243.md"
+++ /dev/null
@@ -1,877 +0,0 @@
-# Table of Contents
-
-  * [前言](#前言)
-  * [Java代理介绍](#java代理介绍)
-  * [静态代理](#静态代理)
-  * [JDK动态代理](#jdk动态代理)
-    * [JDK动态代理实现原理](#jdk动态代理实现原理)
-    * [Proxy类中的newProxyInstance](#proxy类中的newproxyinstance)
-    * [字节码生成](#字节码生成)
-  * [代理类的方法调用](#代理类的方法调用)
-  * [深入理解CGLIB动态代理机制](#深入理解cglib动态代理机制)
-    * [CGLIB动态代理示例](#cglib动态代理示例)
-    * [生成代理类对象](#生成代理类对象)
-    * [对委托类进行代理](#对委托类进行代理)
-
-
-转自 https://www.jianshu.com/u/668d0795a95b
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-文章将同步到我的个人博客：
-> www.how2playlife.com
-
-本文是微信公众号【Java技术江湖】的《Spring和SpringMVC源码分析》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从spring基础入手，一步步地学习spring基础和springmvc的框架知识，并上手进行项目实战，spring框架是每一个Java工程师必须要学习和理解的知识点，进一步来说，你还需要掌握spring甚至是springmvc的源码以及实现原理，才能更完整地了解整个spring技术体系，形成自己的知识框架。
-
-后续还会有springboot和springcloud的技术专题，陆续为大家带来，敬请期待。
-
-为了更好地总结和检验你的学习成果，本系列文章也会提供部分知识点对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-## 前言
-AOP的基础是Java动态代理，了解和使用两种动态代理能让我们更好地理解 AOP，在讲解AOP之前，让我们先来看看Java动态代理的使用方式以及底层实现原理。
-
-本文是基于jdk1.8来对动态代理的底层机制进行探究的
-
-## Java代理介绍
-
-Java中代理的实现一般分为三种：JDK静态代理、JDK动态代理以及CGLIB动态代理。在Spring的AOP实现中，主要应用了JDK动态代理以及CGLIB动态代理。但是本文着重介绍JDK动态代理机制，CGLIB动态代理后面会接着探究。
-
-代理一般实现的模式为JDK静态代理：创建一个接口，然后创建被代理的类实现该接口并且实现该接口中的抽象方法。之后再创建一个代理类，同时使其也实现这个接口。在代理类中持有一个被代理对象的引用，而后在代理类方法中调用该对象的方法。
-
-其实就是代理类为被代理类预处理消息、过滤消息并在此之后将消息转发给被代理类，之后还能进行消息的后置处理。代理类和被代理类通常会存在关联关系(即上面提到的持有的被带离对象的引用)，代理类本身不实现服务，而是通过调用被代理类中的方法来提供服务。
-
-## 静态代理
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140729721-1002455386.png)
-
-接口
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140729978-492174823.png)
-
-被代理类
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140730312-501564524.png)
-
-代理类
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140730518-1275832673.png)
-
-测试类以及输出结果
-
-我们可以看出，使用JDK静态代理很容易就完成了对一个类的代理操作。但是JDK静态代理的缺点也暴露了出来：由于代理只能为一个类服务，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐。
-
-下面我们使用JDK动态代理来做同样的事情
-
-## JDK动态代理
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140729721-1002455386.png)
-
-接口
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140729978-492174823.png)
-
-被代理类
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140731035-1119549632.png)
-
-代理类
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140731317-1929161422.png)
-
-测试类以及输出结果
-
-### JDK动态代理实现原理
-
-JDK动态代理其实也是基本接口实现的。因为通过接口指向实现类实例的多态方式，可以有效地将具体实现与调用解耦，便于后期的修改和维护。
-
-通过上面的介绍，我们可以发现JDK静态代理与JDK动态代理之间有些许相似，比如说都要创建代理类，以及代理类都要实现接口等。但是不同之处也非常明显----在静态代理中我们需要对哪个接口和哪个被代理类创建代理类，所以我们在编译前就需要代理类实现与被代理类相同的接口，并且直接在实现的方法中调用被代理类相应的方法；但是动态代理则不同，我们不知道要针对哪个接口、哪个被代理类创建代理类，因为它是在运行时被创建的。
-
-让我们用一句话来总结一下JDK静态代理和JDK动态代理的区别，然后开始探究JDK动态代理的底层实现机制：
-JDK静态代理是通过直接编码创建的，而JDK动态代理是利用反射机制在运行时创建代理类的。
-其实在动态代理中，核心是InvocationHandler。每一个代理的实例都会有一个关联的调用处理程序(InvocationHandler)。对待代理实例进行调用时，将对方法的调用进行编码并指派到它的调用处理器(InvocationHandler)的invoke方法。所以对代理对象实例方法的调用都是通过InvocationHandler中的invoke方法来完成的，而invoke方法会根据传入的代理对象、方法名称以及参数决定调用代理的哪个方法。
-
-我们从JDK动态代理的测试类中可以发现代理类生成是通过Proxy类中的newProxyInstance来完成的，下面我们进入这个函数看一看：
-
-### Proxy类中的newProxyInstance
-
-```
- public static Object newProxyInstance(ClassLoader loader,
-                                          Class<?>[] interfaces,
-                                          InvocationHandler h)
-        throws IllegalArgumentException
-    {
-        //如果h为空将抛出异常
-        Objects.requireNonNull(h);
-
-        final Class<?>[] intfs = interfaces.clone();//拷贝被代理类实现的一些接口，用于后面权限方面的一些检查
-        final SecurityManager sm = System.getSecurityManager();
-        if (sm != null) {
-            //在这里对某些安全权限进行检查，确保我们有权限对预期的被代理类进行代理
-            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
-        }
-
-        /*
-         * 下面这个方法将产生代理类
-         */
-        Class<?> cl = getProxyClass0(loader, intfs);
-
-        /*
-         * 使用指定的调用处理程序获取代理类的构造函数对象
-         */
-        try {
-            if (sm != null) {
-                checkNewProxyPermission(Reflection.getCallerClass(), cl);
-            }
-
-            final Constructor<?> cons = cl.getConstructor(constructorParams);
-            final InvocationHandler ih = h;
-            //假如代理类的构造函数是private的，就使用反射来set accessible
-            if (!Modifier.isPublic(cl.getModifiers())) {
-                AccessController.doPrivileged(new PrivilegedAction<Void>() {
-                    public Void run() {
-                        cons.setAccessible(true);
-                        return null;
-                    }
-                });
-            }
-            //根据代理类的构造函数来生成代理类的对象并返回
-            return cons.newInstance(new Object[]{h});
-        } catch (IllegalAccessException|InstantiationException e) {
-            throw new InternalError(e.toString(), e);
-        } catch (InvocationTargetException e) {
-            Throwable t = e.getCause();
-            if (t instanceof RuntimeException) {
-                throw (RuntimeException) t;
-            } else {
-                throw new InternalError(t.toString(), t);
-            }
-        } catch (NoSuchMethodException e) {
-            throw new InternalError(e.toString(), e);
-        }
-    }
-
-```
-
-所以代理类其实是通过getProxyClass方法来生成的：
-
-```
- /**
-     * 生成一个代理类，但是在调用本方法之前必须进行权限检查
-     */
-    private static Class<?> getProxyClass0(ClassLoader loader,
-                                           Class<?>... interfaces) {
-        //如果接口数量大于65535，抛出非法参数错误
-        if (interfaces.length > 65535) {
-            throw new IllegalArgumentException("interface limit exceeded");
-        }
-
-        // 如果在缓存中有对应的代理类，那么直接返回
-        // 否则代理类将有 ProxyClassFactory 来创建
-        return proxyClassCache.get(loader, interfaces);
-    }
-
-```
-
-那么ProxyClassFactory是什么呢？
-
-```
-   /**
-     *  里面有一个根据给定ClassLoader和Interface来创建代理类的工厂函数  
-     *
-     */
-    private static final class ProxyClassFactory
-        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
-    {
-        // 代理类的名字的前缀统一为“$Proxy”
-        private static final String proxyClassNamePrefix = "$Proxy";
-
-        // 每个代理类前缀后面都会跟着一个唯一的编号，如$Proxy0、$Proxy1、$Proxy2
-        private static final AtomicLong nextUniqueNumber = new AtomicLong();
-
-        @Override
-        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
-
-            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
-            for (Class<?> intf : interfaces) {
-                /*
-                 * 验证类加载器加载接口得到对象是否与由apply函数参数传入的对象相同
-                 */
-                Class<?> interfaceClass = null;
-                try {
-                    interfaceClass = Class.forName(intf.getName(), false, loader);
-                } catch (ClassNotFoundException e) {
-                }
-                if (interfaceClass != intf) {
-                    throw new IllegalArgumentException(
-                        intf + " is not visible from class loader");
-                }
-                /*
-                 * 验证这个Class对象是不是接口
-                 */
-                if (!interfaceClass.isInterface()) {
-                    throw new IllegalArgumentException(
-                        interfaceClass.getName() + " is not an interface");
-                }
-                /*
-                 * 验证这个接口是否重复
-                 */
-                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
-                    throw new IllegalArgumentException(
-                        "repeated interface: " + interfaceClass.getName());
-                }
-            }
-
-            String proxyPkg = null;     // 声明代理类所在的package
-            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
-
-            /*
-             * 记录一个非公共代理接口的包，以便在同一个包中定义代理类。同时验证所有非公共
-             * 代理接口都在同一个包中
-             */
-            for (Class<?> intf : interfaces) {
-                int flags = intf.getModifiers();
-                if (!Modifier.isPublic(flags)) {
-                    accessFlags = Modifier.FINAL;
-                    String name = intf.getName();
-                    int n = name.lastIndexOf('.');
-                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
-                    if (proxyPkg == null) {
-                        proxyPkg = pkg;
-                    } else if (!pkg.equals(proxyPkg)) {
-                        throw new IllegalArgumentException(
-                            "non-public interfaces from different packages");
-                    }
-                }
-            }
-
-            if (proxyPkg == null) {
-                // 如果全是公共代理接口，那么生成的代理类就在com.sun.proxy package下
-                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
-            }
-
-            /*
-             * 为代理类生成一个name  package name + 前缀+唯一编号
-             * 如 com.sun.proxy.$Proxy0.class
-             */
-            long num = nextUniqueNumber.getAndIncrement();
-            String proxyName = proxyPkg + proxyClassNamePrefix + num;
-
-            /*
-             * 生成指定代理类的字节码文件
-             */
-            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
-                proxyName, interfaces, accessFlags);
-            try {
-                return defineClass0(loader, proxyName,
-                                    proxyClassFile, 0, proxyClassFile.length);
-            } catch (ClassFormatError e) {
-                /*
-                 * A ClassFormatError here means that (barring bugs in the
-                 * proxy class generation code) there was some other
-                 * invalid aspect of the arguments supplied to the proxy
-                 * class creation (such as virtual machine limitations
-                 * exceeded).
-                 */
-                throw new IllegalArgumentException(e.toString());
-            }
-        }
-    }
-
-```
-
-### 字节码生成
-
-由上方代码byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);可以看到，其实生成代理类字节码文件的工作是通过 ProxyGenerate类中的generateProxyClass方法来完成的。
-
-```
- public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
-        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
-       // 真正用来生成代理类字节码文件的方法在这里
-        final byte[] var4 = var3.generateClassFile();
-       // 保存代理类的字节码文件
-        if(saveGeneratedFiles) {
-            AccessController.doPrivileged(new PrivilegedAction() {
-                public Void run() {
-                    try {
-                        int var1 = var0.lastIndexOf(46);
-                        Path var2;
-                        if(var1 > 0) {
-                            Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar), 
-                                                                                   new String[0]);
-                            Files.createDirectories(var3, new FileAttribute[0]);
-                            var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
-                        } else {
-                            var2 = Paths.get(var0 + ".class", new String[0]);
-                        }
-
-                        Files.write(var2, var4, new OpenOption[0]);
-                        return null;
-                    } catch (IOException var4x) {
-                        throw new InternalError("I/O exception saving generated file: " + var4x);
-                    }
-                }
-            });
-        }
-
-        return var4;
-    }
-
-```
-
-下面来看看真正用于生成代理类字节码文件的generateClassFile方法：
-
-```
-private byte[] generateClassFile() {
-        //下面一系列的addProxyMethod方法是将接口中的方法和Object中的方法添加到代理方法中(proxyMethod)
-        this.addProxyMethod(hashCodeMethod, Object.class);
-        this.addProxyMethod(equalsMethod, Object.class);
-        this.addProxyMethod(toStringMethod, Object.class);
-        Class[] var1 = this.interfaces;
-        int var2 = var1.length;
-
-        int var3;
-        Class var4;
-       //获得接口中所有方法并添加到代理方法中
-        for(var3 = 0; var3 < var2; ++var3) {
-            var4 = var1[var3];
-            Method[] var5 = var4.getMethods();
-            int var6 = var5.length;
-
-            for(int var7 = 0; var7 < var6; ++var7) {
-                Method var8 = var5[var7];
-                this.addProxyMethod(var8, var4);
-            }
-        }
-
-        Iterator var11 = this.proxyMethods.values().iterator();
-        //验证具有相同方法签名的方法的返回类型是否一致
-        List var12;
-        while(var11.hasNext()) {
-            var12 = (List)var11.next();
-            checkReturnTypes(var12);
-        }
-
-        //后面一系列的步骤用于写代理类Class文件
-        Iterator var15;
-        try {
-             //生成代理类的构造函数
-            this.methods.add(this.generateConstructor());
-            var11 = this.proxyMethods.values().iterator();
-
-            while(var11.hasNext()) {
-                var12 = (List)var11.next();
-                var15 = var12.iterator();
-
-                while(var15.hasNext()) {
-                    ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
-                    //将代理类字段声明为Method，并且字段修饰符为 private static.
-                   //因为 10 是 ACC_PRIVATE和ACC_STATIC的与运算 故代理类的字段都是 private static Method ***
-                    this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, 
-                                   "Ljava/lang/reflect/Method;", 10));
-                   //生成代理类的方法
-                    this.methods.add(var16.generateMethod());
-                }
-            }
-           //为代理类生成静态代码块对某些字段进行初始化
-            this.methods.add(this.generateStaticInitializer());
-        } catch (IOException var10) {
-            throw new InternalError("unexpected I/O Exception", var10);
-        }
-
-        if(this.methods.size() > '\uffff') { //代理类中的方法数量超过65535就抛异常
-            throw new IllegalArgumentException("method limit exceeded");
-        } else if(this.fields.size() > '\uffff') {// 代理类中字段数量超过65535也抛异常
-            throw new IllegalArgumentException("field limit exceeded");
-        } else {
-            // 后面是对文件进行处理的过程
-            this.cp.getClass(dotToSlash(this.className));
-            this.cp.getClass("java/lang/reflect/Proxy");
-            var1 = this.interfaces;
-            var2 = var1.length;
-
-            for(var3 = 0; var3 < var2; ++var3) {
-                var4 = var1[var3];
-                this.cp.getClass(dotToSlash(var4.getName()));
-            }
-
-            this.cp.setReadOnly();
-            ByteArrayOutputStream var13 = new ByteArrayOutputStream();
-            DataOutputStream var14 = new DataOutputStream(var13);
-
-            try {
-                var14.writeInt(-889275714);
-                var14.writeShort(0);
-                var14.writeShort(49);
-                this.cp.write(var14);
-                var14.writeShort(this.accessFlags);
-                var14.writeShort(this.cp.getClass(dotToSlash(this.className)));
-                var14.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
-                var14.writeShort(this.interfaces.length);
-                Class[] var17 = this.interfaces;
-                int var18 = var17.length;
-
-                for(int var19 = 0; var19 < var18; ++var19) {
-                    Class var22 = var17[var19];
-                    var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));
-                }
-
-                var14.writeShort(this.fields.size());
-                var15 = this.fields.iterator();
-
-                while(var15.hasNext()) {
-                    ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
-                    var20.write(var14);
-                }
-
-                var14.writeShort(this.methods.size());
-                var15 = this.methods.iterator();
-
-                while(var15.hasNext()) {
-                    ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
-                    var21.write(var14);
-                }
-
-                var14.writeShort(0);
-                return var13.toByteArray();
-            } catch (IOException var9) {
-                throw new InternalError("unexpected I/O Exception", var9);
-            }
-        }
-    }
-
-```
-
-## 代理类的方法调用
-
-下面是将接口与Object中一些方法添加到代理类中的addProxyMethod方法：
-
-```
-private void addProxyMethod(Method var1, Class<?> var2) {
-        String var3 = var1.getName();//获得方法名称
-        Class[] var4 = var1.getParameterTypes();//获得方法参数类型
-        Class var5 = var1.getReturnType();//获得方法返回类型
-        Class[] var6 = var1.getExceptionTypes();//异常类型
-        String var7 = var3 + getParameterDescriptors(var4);//获得方法签名
-        Object var8 = (List)this.proxyMethods.get(var7);//根据方法前面获得proxyMethod的value
-        if(var8 != null) {//处理多个代理接口中方法重复的情况
-            Iterator var9 = ((List)var8).iterator();
-
-            while(var9.hasNext()) {
-                ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next();
-                if(var5 == var10.returnType) {
-                    ArrayList var11 = new ArrayList();
-                    collectCompatibleTypes(var6, var10.exceptionTypes, var11);
-                    collectCompatibleTypes(var10.exceptionTypes, var6, var11);
-                    var10.exceptionTypes = new Class[var11.size()];
-                    var10.exceptionTypes = (Class[])var11.toArray(var10.exceptionTypes);
-                    return;
-                }
-            }
-        } else {
-            var8 = new ArrayList(3);
-            this.proxyMethods.put(var7, var8);
-        }
-
-        ((List)var8).add(new ProxyGenerator.ProxyMethod(var3, var4, var5, var6, var2, null));
-    }
-```
-
-这就是最终真正的代理类，它继承自Proxy并实现了我们定义的Subject接口。我们通过
-
-```
-HelloInterface helloInterface = (HelloInterface ) Proxy.newProxyInstance(loader, interfaces, handler);
-```
-
-*   1
-
-得到的最终代理类对象就是上面这个类的实例。那么我们执行如下语句：
-
-```
-helloInterface.hello("Tom");
-```
-
-*   1
-
-实际上就是执行上面类的相应方法，也就是：
-
-```
- public final void hello(String paramString)
-  {
-    try
-    {
-      this.h.invoke(this, m3, new Object[] { paramString });
-      //就是调用我们自定义的InvocationHandlerImpl的 invoke方法：
-      return;
-    }
-    catch (Error|RuntimeException localError)
-    {
-      throw localError;
-    }
-    catch (Throwable localThrowable)
-    {
-      throw new UndeclaredThrowableException(localThrowable);
-    }
-  }
-```
-
-注意这里的`this.h.invoke`中的h，它是类Proxy中的一个属性
-
-```
- protected InvocationHandler h;
-```
-
-因为这个代理类继承了Proxy，所以也就继承了这个属性，而这个属性值就是我们定义的
-
-```
-InvocationHandler handler = new InvocationHandlerImpl(hello);
-```
-
-*   1
-
-同时我们还发现，invoke方法的第一参数在底层调用的时候传入的是`this`，也就是最终生成的代理对象ProxySubject，这是JVM自己动态生成的，而不是我们自己定义的代理对象。
-
-## 深入理解CGLIB动态代理机制
-
-Cglib是什么
-
-Cglib是一个强大的、高性能的代码生成包，它广泛被许多AOP框架使用，为他们提供方法的拦截。下图是我网上找到的一张Cglib与一些框架和语言的关系：
-
-![](https://images2015.cnblogs.com/blog/801753/201704/801753-20170403122105941-1116862243.gif)
-
-对此图总结一下：
-
-*   最底层的是字节码Bytecode，字节码是Java为了保证“一次编译、到处运行”而产生的一种虚拟指令格式，例如iload_0、iconst_1、if_icmpne、dup等
-*   位于字节码之上的是ASM，这是一种直接操作字节码的框架，应用ASM需要对Java字节码、Class结构比较熟悉
-*   位于ASM之上的是CGLIB、Groovy、BeanShell，后两种并不是Java体系中的内容而是脚本语言，它们通过ASM框架生成字节码变相执行Java代码，这说明在JVM中执行程序并不一定非要写Java代码----只要你能生成Java字节码，JVM并不关心字节码的来源，当然通过Java代码生成的JVM字节码是通过编译器直接生成的，算是最“正统”的JVM字节码
-*   位于CGLIB、Groovy、BeanShell之上的就是Hibernate、Spring AOP这些框架了，这一层大家都比较熟悉
-*   最上层的是Applications，即具体应用，一般都是一个Web项目或者本地跑一个程序
-
-本文是基于CGLIB 3.1进行探究的
-
-cglib is a powerful, high performance and quality Code Generation Library, It is used to extend JAVA classes and implements interfaces at runtime.
-
-在Spring AOP中，通常会用它来生成AopProxy对象。不仅如此，在Hibernate中PO(Persistant Object 持久化对象)字节码的生成工作也要靠它来完成。
-
-本文将深入探究CGLIB动态代理的实现机制，配合下面这篇文章一起食用口味更佳：
-[深入理解JDK动态代理机制](https://www.jianshu.com/p/471c80a7e831)
-
-### CGLIB动态代理示例
-
-下面由一个简单的示例开始我们对CGLIB动态代理的介绍：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140731697-1665999459.png)
-
-为了后续编码的顺利进行，我们需要使用Maven引入CGLIB的包
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140732067-1529903146.png)
-
-图1.1 被代理类
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140732309-293903217.png)
-
-图1.2 实现MethodInterceptor接口生成方法拦截器
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140732746-1527907182.png)
-
-图1.3 生成代理类对象并打印在代理类对象调用方法之后的执行结果
-
-JDK代理要求被代理的类必须实现接口，有很强的局限性。而CGLIB动态代理则没有此类强制性要求。简单的说，CGLIB会让生成的代理类继承被代理类，并在代理类中对代理方法进行强化处理(前置处理、后置处理等)。在CGLIB底层，其实是借助了ASM这个非常强大的Java字节码生成框架。
-
-### 生成代理类对象
-
-从图1.3中我们看到，代理类对象是由Enhancer类创建的。Enhancer是CGLIB的字节码增强器，可以很方便的对类进行拓展，如图1.3中的为类设置Superclass。
-
-创建代理对象的几个步骤:
-
-*   生成代理类的二进制字节码文件；
-*   加载二进制字节码，生成Class对象( 例如使用Class.forName()方法 )；
-*   通过反射机制获得实例构造，并创建代理类对象
-
-我们来看看将代理类Class文件反编译之后的Java代码
-
-```
-package proxy;
-
-import java.lang.reflect.Method;
-import net.sf.cglib.core.ReflectUtils;
-import net.sf.cglib.core.Signature;
-import net.sf.cglib.proxy.Callback;
-import net.sf.cglib.proxy.Factory;
-import net.sf.cglib.proxy.MethodInterceptor;
-import net.sf.cglib.proxy.MethodProxy;
-
-public class HelloServiceImpl$EnhancerByCGLIB$82ef2d06
-  extends HelloServiceImpl
-  implements Factory
-{
-  private boolean CGLIB$BOUND;
-  private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
-  private static final Callback[] CGLIB$STATIC_CALLBACKS;
-  private MethodInterceptor CGLIB$CALLBACK_0;
-  private static final Method CGLIB$sayHello$0$Method;
-  private static final MethodProxy CGLIB$sayHello$0$Proxy;
-  private static final Object[] CGLIB$emptyArgs;
-  private static final Method CGLIB$finalize$1$Method;
-  private static final MethodProxy CGLIB$finalize$1$Proxy;
-  private static final Method CGLIB$equals$2$Method;
-  private static final MethodProxy CGLIB$equals$2$Proxy;
-  private static final Method CGLIB$toString$3$Method;
-  private static final MethodProxy CGLIB$toString$3$Proxy;
-  private static final Method CGLIB$hashCode$4$Method;
-  private static final MethodProxy CGLIB$hashCode$4$Proxy;
-  private static final Method CGLIB$clone$5$Method;
-  private static final MethodProxy CGLIB$clone$5$Proxy;
-
-  static void CGLIB$STATICHOOK1()
-  {
-    CGLIB$THREAD_CALLBACKS = new ThreadLocal();
-    CGLIB$emptyArgs = new Object[0];
-    Class localClass1 = Class.forName("proxy.HelloServiceImpl$EnhancerByCGLIB$82ef2d06");
-    Class localClass2;
-    Method[] tmp95_92 = ReflectUtils.findMethods(new String[] { "finalize", "()V", "equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;" }, (localClass2 = Class.forName("java.lang.Object")).getDeclaredMethods());
-    CGLIB$finalize$1$Method = tmp95_92[0];
-    CGLIB$finalize$1$Proxy = MethodProxy.create(localClass2, localClass1, "()V", "finalize", "CGLIB$finalize$1");
-    Method[] tmp115_95 = tmp95_92;
-    CGLIB$equals$2$Method = tmp115_95[1];
-    CGLIB$equals$2$Proxy = MethodProxy.create(localClass2, localClass1, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
-    Method[] tmp135_115 = tmp115_95;
-    CGLIB$toString$3$Method = tmp135_115[2];
-    CGLIB$toString$3$Proxy = MethodProxy.create(localClass2, localClass1, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
-    Method[] tmp155_135 = tmp135_115;
-    CGLIB$hashCode$4$Method = tmp155_135[3];
-    CGLIB$hashCode$4$Proxy = MethodProxy.create(localClass2, localClass1, "()I", "hashCode", "CGLIB$hashCode$4");
-    Method[] tmp175_155 = tmp155_135;
-    CGLIB$clone$5$Method = tmp175_155[4];
-    CGLIB$clone$5$Proxy = MethodProxy.create(localClass2, localClass1, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
-    tmp175_155;
-    Method[] tmp223_220 = ReflectUtils.findMethods(new String[] { "sayHello", "()V" }, (localClass2 = Class.forName("proxy.HelloServiceImpl")).getDeclaredMethods());
-    CGLIB$sayHello$0$Method = tmp223_220[0];
-    CGLIB$sayHello$0$Proxy = MethodProxy.create(localClass2, localClass1, "()V", "sayHello", "CGLIB$sayHello$0");
-    tmp223_220;
-    return;
-  }
-
-  final void CGLIB$sayHello$0()
-  {
-    super.sayHello();
-  }
-
-  public final void sayHello()
-  {
-    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
-    if (tmp4_1 == null)
-    {
-      tmp4_1;
-      CGLIB$BIND_CALLBACKS(this);
-    }
-    if (this.CGLIB$CALLBACK_0 != null) {
-      return;
-    }
-    super.sayHello();
-  }
-
-  final void CGLIB$finalize$1()
-    throws Throwable
-  {
-    super.finalize();
-  }
-
-  protected final void finalize()
-    throws Throwable
-  {
-    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
-    if (tmp4_1 == null)
-    {
-      tmp4_1;
-      CGLIB$BIND_CALLBACKS(this);
-    }
-    if (this.CGLIB$CALLBACK_0 != null) {
-      return;
-    }
-    super.finalize();
-  }
-
-  final boolean CGLIB$equals$2(Object paramObject)
-  {
-    return super.equals(paramObject);
-  }
-
-  public final boolean equals(Object paramObject)
-  {
-    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
-    if (tmp4_1 == null)
-    {
-      tmp4_1;
-      CGLIB$BIND_CALLBACKS(this);
-    }
-    MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
-    if (tmp17_14 != null)
-    {
-      Object tmp41_36 = tmp17_14.intercept(this, CGLIB$equals$2$Method, new Object[] { paramObject }, CGLIB$equals$2$Proxy);
-      tmp41_36;
-      return tmp41_36 == null ? false : ((Boolean)tmp41_36).booleanValue();
-    }
-    return super.equals(paramObject);
-  }
-
-  final String CGLIB$toString$3()
-  {
-    return super.toString();
-  }
-
-  public final String toString()
-  {
-    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
-    if (tmp4_1 == null)
-    {
-      tmp4_1;
-      CGLIB$BIND_CALLBACKS(this);
-    }
-    MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
-    if (tmp17_14 != null) {
-      return (String)tmp17_14.intercept(this, CGLIB$toString$3$Method, CGLIB$emptyArgs, CGLIB$toString$3$Proxy);
-    }
-    return super.toString();
-  }
-
-  final int CGLIB$hashCode$4()
-  {
-    return super.hashCode();
-  }
-
-  public final int hashCode()
-  {
-    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
-    if (tmp4_1 == null)
-    {
-      tmp4_1;
-      CGLIB$BIND_CALLBACKS(this);
-    }
-    MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
-    if (tmp17_14 != null)
-    {
-      Object tmp36_31 = tmp17_14.intercept(this, CGLIB$hashCode$4$Method, CGLIB$emptyArgs, CGLIB$hashCode$4$Proxy);
-      tmp36_31;
-      return tmp36_31 == null ? 0 : ((Number)tmp36_31).intValue();
-    }
-    return super.hashCode();
-  }
-
-  final Object CGLIB$clone$5()
-    throws CloneNotSupportedException
-  {
-    return super.clone();
-  }
-
-  protected final Object clone()
-    throws CloneNotSupportedException
-  {
-    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
-    if (tmp4_1 == null)
-    {
-      tmp4_1;
-      CGLIB$BIND_CALLBACKS(this);
-    }
-    MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
-    if (tmp17_14 != null) {
-      return tmp17_14.intercept(this, CGLIB$clone$5$Method, CGLIB$emptyArgs, CGLIB$clone$5$Proxy);
-    }
-    return super.clone();
-  }
-
-  public static MethodProxy CGLIB$findMethodProxy(Signature paramSignature)
-  {
-    String tmp4_1 = paramSignature.toString();
-    switch (tmp4_1.hashCode())
-    {
-    case -1574182249: 
-      if (tmp4_1.equals("finalize()V")) {
-        return CGLIB$finalize$1$Proxy;
-      }
-      break;
-    }
-  }
-
-  public HelloServiceImpl$EnhancerByCGLIB$82ef2d06()
-  {
-    CGLIB$BIND_CALLBACKS(this);
-  }
-
-  public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] paramArrayOfCallback)
-  {
-    CGLIB$THREAD_CALLBACKS.set(paramArrayOfCallback);
-  }
-
-  public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] paramArrayOfCallback)
-  {
-    CGLIB$STATIC_CALLBACKS = paramArrayOfCallback;
-  }
-
-  private static final void CGLIB$BIND_CALLBACKS(Object paramObject)
-  {
-    82ef2d06 local82ef2d06 = (82ef2d06)paramObject;
-    if (!local82ef2d06.CGLIB$BOUND)
-    {
-      local82ef2d06.CGLIB$BOUND = true;
-      Object tmp23_20 = CGLIB$THREAD_CALLBACKS.get();
-      if (tmp23_20 == null)
-      {
-        tmp23_20;
-        CGLIB$STATIC_CALLBACKS;
-      }
-      local82ef2d06.CGLIB$CALLBACK_0 = (// INTERNAL ERROR //
-
-```
-
-### 对委托类进行代理
-
-我们上面贴出了生成的代理类源码。以我们上面的例子为参考，下面我们总结一下CGLIB在进行代理的时候都进行了哪些工作呢
-
-*   生成的代理类HelloServiceImpl$EnhancerByCGLIB$82ef2d06继承被代理类HelloServiceImpl。在这里我们需要注意一点：如果委托类被final修饰，那么它不可被继承，即不可被代理；同样，如果委托类中存在final修饰的方法，那么该方法也不可被代理；
-*   代理类会为委托方法生成两个方法，一个是重写的sayHello方法，另一个是CGLIB$sayHello$0方法，我们可以看到它是直接调用父类的sayHello方法；
-*   当执行代理对象的sayHello方法时，会首先判断一下是否存在实现了MethodInterceptor接口的CGLIB$CALLBACK_0;，如果存在，则将调用MethodInterceptor中的intercept方法，如图2.1。
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140733103-2101709172.png)
-
-图2.1 intercept方法
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140733381-1955520660.png)
-
-图2.2 代理类为每个委托方法都会生成两个方法
-
-在intercept方法中，我们除了会调用委托方法，还会进行一些增强操作。在Spring AOP中，典型的应用场景就是在某些敏感方法执行前后进行操作日志记录。
-
-我们从图2.1中看到，调用委托方法是通过代理方法的MethodProxy对象调用invokeSuper方法来执行的，下面我们看看invokeSuper方法中的玄机：
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140733825-816756585.png)
-
-图2.3 invokeSuper方法
-
-在这里好像不能直接看出代理方法的调用。没关系，我会慢慢介绍。
-我们知道，在JDK动态代理中方法的调用是通过反射来完成的。如果有对此不太了解的同学，可以看下我之前的博客----[深入理解JDK动态代理机制](https://www.jianshu.com/p/471c80a7e831)。但是在CGLIB中，方法的调用并不是通过反射来完成的，而是直接对方法进行调用：FastClass对Class对象进行特别的处理，比如将会用数组保存method的引用，每次调用方法的时候都是通过一个index下标来保持对方法的引用。比如下面的getIndex方法就是通过方法签名来获得方法在存储了Class信息的数组中的下标。
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140734172-226519980.png)
-
-图2.4 getIndex方法
-
-![](https://img2018.cnblogs.com/blog/1092007/201908/1092007-20190825140734361-1715137603.png)
-
-图2.5 FastClassInfo类中持有两个FastClass对象的引用.png
-
-以我们上面的sayHello方法为例，f1指向委托类对象，f2指向代理类对象，i1和i2分别代表着sayHello方法以及CGLIB$sayHello$0方法在对象信息数组中的下标。
-
-到此为止CGLIB动态代理机制就介绍完了，下面给出三种代理方式之间对比。
-
-| 代理方式 | 实现 | 优点 | 缺点 | 特点 |
-| --- | --- | --- | --- | --- |
-| JDK静态代理 | 代理类与委托类实现同一接口，并且在代理类中需要硬编码接口 | 实现简单，容易理解 | 代理类需要硬编码接口，在实际应用中可能会导致重复编码，浪费存储空间并且效率很低 | 好像没啥特点 |
-| JDK动态代理 | 代理类与委托类实现同一接口，主要是通过代理类实现InvocationHandler并重写invoke方法来进行动态代理的，在invoke方法中将对方法进行增强处理 | 不需要硬编码接口，代码复用率高 | 只能够代理实现了接口的委托类 | 底层使用反射机制进行方法的调用 |
-| CGLIB动态代理 | 代理类将委托类作为自己的父类并为其中的非final委托方法创建两个方法，一个是与委托方法签名相同的方法，它在方法中会通过super调用委托方法；另一个是代理类独有的方法。在代理方法中，它会判断是否存在实现了MethodInterceptor接口的对象，若存在则将调用intercept方法对委托方法进行代理 | 可以在运行时对类或者是接口进行增强操作，且委托类无需实现接口 | 不能对final类以及final方法进行代理 | 底层将方法全部存入一个数组中，通过数组索引直接进行方法调用 |
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21413\357\274\232Hibernate\345\205\245\351\227\250\347\273\217\345\205\270\344\270\216\346\263\250\350\247\243\345\274\217\345\274\200\345\217\221.md" "b/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21413\357\274\232Hibernate\345\205\245\351\227\250\347\273\217\345\205\270\344\270\216\346\263\250\350\247\243\345\274\217\345\274\200\345\217\221.md"
deleted file mode 100644
index 738b37f..0000000
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\21413\357\274\232Hibernate\345\205\245\351\227\250\347\273\217\345\205\270\344\270\216\346\263\250\350\247\243\345\274\217\345\274\200\345\217\221.md"
+++ /dev/null
@@ -1,1083 +0,0 @@
-# Table of Contents
-
-  * [前言](#前言)
-  * [ORM概述](#orm概述)
-  * [测试](#测试)
-  * [相关类](#相关类)
-  * [扩展](#扩展)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [个人公众号：程序员黄小斜](#个人公众号：程序员黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
-
-
-本文转载自互联网，侵删
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-本系列文章将同步到我的个人博客：
-> www.how2playlife.com
-
-更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
-
-本文是《走进JavaWeb技术世界》系列博文的其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从入门到进阶，从servlet到框架，从ssm再到SpringBoot，一步步地学习JavaWeb基础知识，并上手进行实战，接着了解JavaWeb项目中经常要使用的技术和组件，包括日志组件、Maven、Junit，等等内容，以便让你更完整地了解整个JavaWeb技术体系，形成自己的知识框架。为了更好地总结和检验你的学习成果，本系列文章也会提供每个知识点对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-**文末赠送8000G的Java架构师学习资料，需要的朋友可以到文末了解领取方式，资料包括Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源）**
-<!-- more -->
-
-## 前言
-
-本博文主要讲解介绍Hibernate框架，ORM的概念和Hibernate入门，相信你们看了就会使用Hibernate了!
-
-什么是Hibernate框架？
-Hibernate是一种ORM框架，全称为 Object_Relative DateBase-Mapping，在Java对象与关系数据库之间建立某种映射，以实现直接存取Java对象！
-
-为什么要使用Hibernate？
-既然Hibernate是关于Java对象和关系数据库之间的联系的话，也就是我们MVC中的数据持久层->在编写程序中的DAO层...
-
-首先，我们来回顾一下我们在DAO层写程序的历程吧：
-
-在DAO层操作XML，将数据封装到XML文件上，读写XML文件数据实现CRUD
-在DAO层使用原生JDBC连接数据库，实现CRUD
-嫌弃JDBC的ConnectionStatementResultSet等对象太繁琐，使用对原生JDBC的封装组件-->DbUtils组件
-我们来看看使用DbUtils之后，程序的代码是怎么样的：
-
-
-    public class CategoryDAOImpl implements zhongfucheng.dao.CategoryDao {
-    
-        @Override
-        public void addCategory(Category category) {
-    
-            QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
-    
-            String sql = "INSERT INTO category (id, name, description) VALUES(?,?,?)";
-            try {
-                queryRunner.update(sql, new Object[]{category.getId(), category.getName(), category.getDescription()});
-    
-            } catch (SQLException e) {
-                throw new RuntimeException(e);
-            }
-        }
-    
-        @Override
-        public Category findCategory(String id) {
-            QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
-            String sql = "SELECT * FROM category WHERE id=?";
-    
-            try {
-                Category category = (Category) queryRunner.query(sql, id, new BeanHandler(Category.class));
-    
-                return category;
-    
-            } catch (SQLException e) {
-                throw new RuntimeException(e);
-            }
-    
-        }
-    
-        @Override
-        public List<Category> getAllCategory() {
-            QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
-            String sql = "SELECT * FROM category";
-    
-            try {
-                List<Category> categories = (List<Category>) queryRunner.query(sql, new BeanListHandler(Category.class));
-    
-                return categories;
-            } catch (SQLException e) {
-                throw  new RuntimeException(e);
-            }
-    
-        }
-    }
-    
-其实使用DbUtils时，DAO层中的代码编写是很有规律的。
-
-当插入数据的时候，就将JavaBean对象拆分，拼装成SQL语句
-当查询数据的时候，用SQL把数据库表中的列组合，拼装成JavaBean对象
-也就是说：javaBean对象和数据表中的列存在映射关系!如果程序能够自动生成SQL语句就好了....那么Hibernate就实现了这个功能！
-
-简单来说：我们使用Hibernate框架就不用我们写很多繁琐的SQL语句，从而简化我们的开发！
-
-
-## ORM概述
-在介绍Hibernate的时候，说了Hibernate是一种ORM的框架。那什么是ORM呢？ORM是一种思想
-
-O代表的是Objcet
-R代表的是Relative
-M代表的是Mapping
-ORM->对象关系映射....ORM关注是对象与数据库中的列的关系
-
-
-
-Hibernate快速入门
-学习一个框架无非就是三个步骤：
-
-引入jar开发包
-配置相关的XML文件
-熟悉API
-引入相关jar包
-我们使用的是Hibernate3.6的版本
-
-hibernate3.jar核心 + required 必须引入的(6个) + jpa 目录 + 数据库驱动包
-
-
-编写对象和对象映射
-编写一个User对象->User.java
-
-
-    public class User {
-    
-        private int id;
-        private String username;
-        private String password;
-        private String cellphone;
-    
-        //各种setter和getter
-    }
-编写对象映射->User.hbm.xml。一般它和JavaBean对象放在同一目录下
-
-我们是不知道该XML是怎么写的，可以搜索一下Hibernate文件夹中后缀为.hbm.xml。看看它们是怎么写的。然后复制一份过来
-
-    
-    <?xml version="1.0"?>
-    <!DOCTYPE hibernate-mapping PUBLIC 
-        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
-        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
-    
-    <!-- 
-    
-      This mapping demonstrates content-based discrimination for the
-      table-per-hierarchy mapping strategy, using a formula
-      discriminator.
-    
-    -->
-    
-    <hibernate-mapping 
-        package="org.hibernate.test.array">
-    
-        <class name="A" lazy="true" table="aaa">
-    
-            <id name="id">
-                <generator class="native"/>
-            </id>
-    
-            
-                <key column="a_id"/>
-                <list-index column="idx"/>
-                <one-to-many class="B"/>
-            
-    
-        </class>
-    
-        <class name="B" lazy="true" table="bbb">
-            <id name="id">
-                <generator class="native"/>
-            </id>
-        </class>
-    
-    </hibernate-mapping>
-    
-在上面的模板上修改～下面会具体讲解这个配置文件!
-
-    <!--在domain包下-->
-        <hibernate-mapping package="zhongfucheng.domain">
-        
-            <!--类名为User，表名也为User-->
-            <class name="User"  table="user">
-        
-                <!--主键映射，属性名为id，列名也为id-->
-                <id name="id" column="id">
-                    <!--根据底层数据库主键自动增长-->
-                    <generator class="native"/>
-        
-                </id>
-        
-                <!--非主键映射，属性和列名一一对应-->
-                <property name="username" column="username"/>
-                <property name="cellphone" column="cellphone"/>
-                <property name="password" column="password"/>
-            </class>
-        </hibernate-mapping>
-
-如果使用Intellij Idea生成的Hibernate可以指定生成出主配置文件hibernate.cfg.xml，它是要放在src目录下的
-
-如果不是自动生成的，我们可以在Hibernate的hibernate-distribution-3.6.0.Final\project\etc这个目录下可以找到
-
-它长得这个样子：
-
-    
-    <?xml version='1.0' encoding='utf-8'?>
-    <!DOCTYPE hibernate-configuration PUBLIC
-            "-//Hibernate/Hibernate Configuration DTD//EN"
-            "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
-    <hibernate-configuration>
-        <session-factory>
-            <property name="connection.url."/>
-            <property name="connection.driver_class"/>
-            <property name="connection.username"/>
-            <property name="connection.password"/>
-            <!-- DB schema will be updated if needed -->
-            <!-- <property name="hbm2ddl.auto">update</property> -->
-        </session-factory>
-    </hibernate-configuration>
-    
-通过上面的模板进行修改，后面会有对该配置文件进行讲解！
-
-
-    <hibernate-configuration>
-        <!-- 通常，一个session-factory节点代表一个数据库 -->
-        <session-factory>
-    
-            <!-- 1\. 数据库连接配置 -->
-            <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
-            <property name="hibernate.connection.url">jdbc:mysql:///zhongfucheng</property>
-            <property name="hibernate.connection.username">root</property>
-            <property name="hibernate.connection.password">root</property>
-            <!--
-                数据库方法配置， hibernate在运行的时候，会根据不同的方言生成符合当前数据库语法的sql
-             -->
-            <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
-    
-            <!-- 2\. 其他相关配置 -->
-            <!-- 2.1 显示hibernate在运行时候执行的sql语句 -->
-            <property name="hibernate.show_sql">true</property>
-            <!-- 2.2 格式化sql -->
-            <property name="hibernate.format_sql">true</property>
-            <!-- 2.3 自动建表  -->
-            <property name="hibernate.hbm2ddl.auto">create</property>
-    
-            <!--3\. 加载所有映射-->
-            <mapping resource="zhongfucheng/domain/User.hbm.xml"/>
-    
-        </session-factory>
-    </hibernate-configuration>
-
-## 测试
-
-    package zhongfucheng.domain;
-    
-    import org.hibernate.SessionFactory;
-    import org.hibernate.Transaction;
-    import org.hibernate.cfg.Configuration;
-    import org.hibernate.classic.Session;
-
-    /**
-     * Created by ozc on 2017/5/6.
-     */
-    public class App {
-        public static void main(String[] args) {
-    
-            //创建对象
-            User user = new User();
-            user.setPassword("123");
-            user.setCellphone("122222");
-            user.setUsername("nihao");
-    
-            //获取加载配置管理类
-            Configuration configuration = new Configuration();
-    
-            //不给参数就默认加载hibernate.cfg.xml文件，
-            configuration.configure();
-    
-            //创建Session工厂对象
-            SessionFactory factory = configuration.buildSessionFactory();
-    
-            //得到Session对象
-            Session session = factory.openSession();
-    
-            //使用Hibernate操作数据库，都要开启事务,得到事务对象
-            Transaction transaction = session.getTransaction();
-    
-            //开启事务
-            transaction.begin();
-    
-            //把对象添加到数据库中
-            session.save(user);
-    
-            //提交事务
-            transaction.commit();
-    
-            //关闭Session
-            session.close();
-        }
-    }
-
-值得注意的是：JavaBean的主键类型只能是int类型，因为在映射关系中配置是自动增长的，String类型是不能自动增长的。如果是你设置了String类型，又使用了自动增长，那么就会报出下面的错误！
-
-
-    Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Table 'zhongfucheng.user' does
-    
-执行完程序后，Hibernate就为我们创建对应的表，并把数据存进了数据库了
-
-我们看看快速入门案例的代码用到了什么对象吧，然后一个一个讲解
-
-
-    public static void main(String[] args) {
-
-        //创建对象
-        User user = new User();
-        user.setPassword("123");
-        user.setCellphone("122222");
-        user.setUsername("nihao");
-
-        //获取加载配置管理类
-        Configuration configuration = new Configuration();
-
-        //不给参数就默认加载hibernate.cfg.xml文件，
-        configuration.configure();
-
-        //创建Session工厂对象
-        SessionFactory factory = configuration.buildSessionFactory();
-
-        //得到Session对象
-        Session session = factory.openSession();
-
-        //使用Hibernate操作数据库，都要开启事务,得到事务对象
-        Transaction transaction = session.getTransaction();
-
-        //开启事务
-        transaction.begin();
-
-        //把对象添加到数据库中
-        session.save(user);
-
-        //提交事务
-        transaction.commit();
-
-        //关闭Session
-        session.close();
-    }
-## 相关类    
-Configuration
-配置管理类：主要管理配置文件的一个类
-
-它拥有一个子类AnnotationConfiguration，也就是说：我们可以使用注解来代替XML配置文件来配置相对应的信息
-
-
-configure方法
-configure()方法用于加载配置文件
-
-加载主配置文件的方法
-
-如果指定参数，那么加载参数的路径配置文件
-如果不指定参数，默认加载src/目录下的hibernate.cfg.xml
-
-buildSessionFactory方法
-buildSessionFactory()用于创建Session工厂
-
-
-SessionFactory
-SessionFactory-->Session的工厂，也可以说代表了hibernate.cfg.xml这个文件...hibernate.cfg.xml的就有<session-factory>这么一个节点
-
-openSession方法
-创建一个Session对象
-
-getCurrentSession方法
-创建Session对象或取出Session对象
-
-Session
-Session是Hibernate最重要的对象，Session维护了一个连接（Connection），只要使用Hibernate操作数据库，都需要用到Session对象
-
-通常我们在DAO层中都会有以下的方法，Session也为我们提供了对应的方法来实现！
-
-
-    public interface IEmployeeDao {
-    
-        void save(Employee emp);
-        void update(Employee emp);
-        Employee findById(Serializable id);
-        List<Employee> getAll();
-        List<Employee> getAll(String employeeName);
-        List<Employee> getAll(int index, int count);
-        void delete(Serializable id);
-    
-    }
-
-更新操作
-
-我们在快速入门中使用到了save(Objcet o)方法，调用了这个方法就把对象保存在数据库之中了。Session对象还提供着其他的方法来进行对数据库的更新
-
-session.save(obj); 【保存一个对象】
-session.update(obj); 【更新一个对象】
-session.saveOrUpdate(obj); 【保存或者更新的方法】
-
-没有设置主键，执行保存；
-有设置主键，执行更新操作;
-如果设置主键不存在报错！
-我们来使用一下update()方法吧....既然是更新操作了，那么肯定需要设置主键的，不设置主键，数据库怎么知道你要更新什么。将id为1的记录修改成如下：
-
-        user.setId(1);
-        user.setPassword("qwer");
-        user.setCellphone("1111");
-        user.setUsername("zhongfucheng");
-
-主键查询
-
-通过主键来查询数据库的记录，从而返回一个JavaBean对象
-
-session.get(javaBean.class, int id); 【传入对应的class和id就可以查询】
-session.load(javaBean.class, int id); 【支持懒加载】
-User重写toString()来看一下效果：
-
-
-       User user1 = (User) session.get(User.class, 1);
-        System.out.println(user1);
-
-HQL查询
-
-HQL:hibernate query language 即hibernate提供的面向对象的查询语言
-
-查询的是对象以及对象的属性【它查询的是对象以及属性，因此是区分大小写的！】。
-
-    SQL：Struct query language 结构化查询语言
-
-查询的是表以及列【不区分大小写】
-HQL是面向对象的查询语言，可以用来查询全部的数据！
-
-
-        Query query = session.createQuery("FROM User");
-
-        List list = query.list();
-        System.out.println(list);
-
-当然啦，它也可以传递参数进去查询
-
-
-        Query query = session.createQuery("FROM User WHERE id=?");
-
-        //这里的？号是从0开始的，并不像JDBC从1开始的！
-        query.setParameter(0, user.getId());
-
-        List list = query.list();
-        System.out.println(list);
-
-
-
-QBC查询
-
-QBC查询: query by criteria 完全面向对象的查询
-
-从上面的HQL查询，我们就可以发现：HQL查询是需要SQL的基础的，因为还是要写少部分的SQL代码....QBC查询就是完全的面向对象查询...但是呢，我们用得比较少
-
-我们来看一下怎么使用吧：
-
-
-        //创建关于user对象的criteria对象
-        Criteria criteria = session.createCriteria(User.class);
-
-        //添加条件
-        criteria.add(Restrictions.eq("id", 1));
-
-        //查询全部数据
-        List list = criteria.list();
-        System.out.println(list);
-
-
-本地SQL查询
-
-有的时候，如果SQL是非常复杂的，我们不能靠HQL查询来实现功能的话，我们就需要使用原生的SQL来进行复杂查询了！
-
-但是呢，它有一个缺陷：它是不能跨平台的...因此我们在主配置文件中已经配置了数据库的“方言“了。
-
-我们来简单使用一下把：
-
-
-        //将所有的记录封装成User对象存进List集合中
-        SQLQuery sqlQuery = session.createSQLQuery("SELECT * FROM user").addEntity(User.class);
-
-        List list = sqlQuery.list();
-
-        System.out.println(list);
-
-beginTransaction方法
-
-开启事务，返回的是一个事务对象....Hibernate规定所有的数据库操作都必须在事务环境下进行，否则报错！
-
-
-
-Hibernate注解开发
-
-在Hibernate中我们一般都会使用注解，这样可以帮助我们大大简化hbm映射文件的配置。下面我就来为大家详细介绍。
-
-PO类注解配置
-
-首先肯定是搭建好Hibernate的开发环境啦，我在此也不过多赘述，读者自行实践。接着在src目录下创建一个cn.itheima.domain包，并在该包下创建一个Book实体类，由于Book实体类中写有注解配置，所以就不用编写那个映射配置文件啦！
-
-    @Entity // 定义了一个实体
-    @Table(name="t_book",catalog="hibernateTest")
-    public class Book {
-
-    @Id // 这表示一个主键
-    // @GeneratedValue 相当于native主键生成策略
-    @GeneratedValue(strategy=GenerationType.IDENTITY) // 相当于identity主键生成策略
-    private Integer id; // 主键
-
-    @Column(name="c_name", length=30, nullable=true)
-    private String name;
-
-    @Temporal(TemporalType.TIMESTAMP) // 是用来定义日期类型
-    private Date publicationDate; // 出版日期
-
-    @Type(type="double") // 允许你去指定Hibernate里面的一些类型
-    private Double price; // 价格，如果没有添加注解，也会自动的生成在表中
-
-    public Integer getId() {
-        return id;
-    }
-    public void setId(Integer id) {
-        this.id = id;
-    }
-    public String getName() {
-        return name;
-    }
-    public void setName(String name) {
-        this.name = name;
-    }
-    public Date getPublicationDate() {
-        return publicationDate;
-    }
-    public void setPublicationDate(Date publicationDate) {
-        this.publicationDate = publicationDate;
-    }
-    public Double getPrice() {
-        return price;
-    }
-    public void setPrice(Double price) {
-        this.price = price;
-    }
-
-}
-
-下面我就来详细说一下Book实体类中的注解。
-
-    @Entity：声明一个实体。
-    @Table：来描述类与表之间的对应关系。
-
-    @Entity // 定义了一个实体
-    @Table(name="t_book",catalog="hibernateTest")
-    public class Book {
-        ......
-    }
-
-    @id：声明一个主键。
-    @GeneratedValue：用它来声明一个主键生成策略。默认情况是native主键生成策略。可以选择的主键生成策略有：AUTO、IDENTITY、SEQUENCE
-
-    @Id // 这表示一个主键
-    // @GeneratedValue 相当于native主键生成策略
-    @GeneratedValue(strategy=GenerationType.IDENTITY) // 相当于identity主键生成策略
-    private Integer id; // 主键
-    
-    @Column：定义列。
-    
-    @Column(name="c_name", length=30, nullable=true)
-    private String name;
-
-**注意：对于PO类中所有属性，如果你不写注解，默认情况下也会在表中生成对应的列，列的名称就是属性的名称，列的类型也即属性的类型**。
-    @Temporal：声明日期类型。
-    
-    @Temporal(TemporalType.TIMESTAMP) // 是用来定义日期类型
-    private Date publicationDate; // 出版日期
-
-日期类型可以选择的有：
-
-    *   TemporalType.DATA：只有年月日。
-    *   TemporalType.TIME：只有小时分钟秒。
-    *   TemporalType.TIMESTAMP：有年月日小时分钟秒。
-    @Type：可允许你去指定Hibernate里面的一些类型。
-    
-    @Type(type="double") // 允许你去指定Hibernate里面的一些类型
-    private Double price; // 价格，如果没有添加注解，也会自动的生成在表中
-
-最后我们在src目录下创建一个cn.itheima.test包，在该包下编写一个HibernateAnnotationTest单元测试类，并在该类中编写一个用于测试PO类的注解开发的方法：
-
-    public class HibernateAnnotationTest {
-    
-        // 测试PO的注解开发
-        @Test
-        public void test1() {
-            Session session = HibernateUtils.openSession();
-            session.beginTransaction();
-    
-            Book b = new Book();
-            b.setName("情书");
-            b.setPrice(56.78);
-            b.setPublicationDate(new Date());
-    
-            session.save(b);
-    
-            session.getTransaction().commit();
-            session.close();
-        }
-    
-    }
-
-现在来思考两个问题：
-
-如果主键生成策略我们想使用UUID类型呢？
-如何设定类的属性不在表中映射？
-这两个问题我们一起解决。废话不多说，直接上例子。在cn.itheima.domain包下再编写一个Person实体类，同样使用注解配置。
-
-    @Entity
-    @Table(name="t_person", catalog="hibernateTest")
-    public class Person {
-    
-        // 生成UUID的主键生成策略
-        @Id
-        @GenericGenerator(name="myuuid", strategy="uuid") // 声明一种主键生成策略(uuid)
-        @GeneratedValue(generator="myuuid") // 引用uuid主键生成策略
-        private String id;
-    
-        @Type(type="string") // 允许你去指定Hibernate里面的一些类型
-        private String name;
-    
-        @Transient
-        private String msg; // 现在这个属性不想生成在表中
-    
-        public String getId() {
-            return id;
-        }
-    
-        public void setId(String id) {
-            this.id = id;
-        }
-    
-        public String getName() {
-            return name;
-        }
-    
-        public void setName(String name) {
-            this.name = name;
-        }
-    
-        public String getMsg() {
-            return msg;
-        }
-    
-        public void setMsg(String msg) {
-            this.msg = msg;
-        }
-    
-    }
-
-
-
-最后在HibernateAnnotationTest单元测试类中编写如下一个方法：
-
-    public class HibernateAnnotationTest {
-    
-        // 测试uuid的主键生成策略及不生成表中映射
-        @Test
-        public void test2() {
-            Session session = HibernateUtils.openSession();
-            session.beginTransaction();
-    
-            Person p = new Person();
-            p.setName("李四");
-            p.setMsg("这是一个好人");
-    
-            session.save(p);
-    
-            session.getTransaction().commit();
-            session.close();
-        }
-    
-    }
-
-至此，两个问题就解决了。 
-注意：对于我们以上讲解的关于属性配置的注解，我们也可以在其对应的getXxx方法去使用。
-
-Hibernate关联映射——一对多（多对一）
-仍以客户(Customer)和订单(Order)为例来开始我的表演。 
-在src目录下创建一个cn.itheima.oneToMany包，并在该包编写这两个实体类：
-
-客户(Customer)类
-    
-        // 客户 ---- 一的一方
-        @Entity
-        @Table(name="t_customer")
-        public class Customer {
-    
-        @Id
-        @GeneratedValue(strategy=GenerationType.IDENTITY)
-        private Integer id; // 主键
-        private String name; // 姓名
-    
-        // 描述客户可以有多个订单
-        /*
-         * targetEntity="..."：相当于<one-to-many >
-         */
-        @OneToMany(targetEntity=Order.class,mappedBy="c")
-        private Set<Order> orders = new HashSet<Order>();
-    
-        public Set<Order> getOrders() {
-            return orders;
-        }
-        public void setOrders(Set<Order> orders) {
-            this.orders = orders;
-        }
-        public Integer getId() {
-            return id;
-        }
-        public void setId(Integer id) {
-            this.id = id;
-        }
-        public String getName() {
-            return name;
-        }
-        public void setName(String name) {
-            this.name = name;
-        }
-    
-        }
-    
-    
-        订单(Order)类
-        
-        // 订单 ---- 多的一方
-        @Entity
-        @Table(name="t_order")
-        public class Order {
-    
-        @Id
-        @GeneratedValue(strategy=GenerationType.IDENTITY)
-        private Integer id;
-        private Double money;
-        private String receiverInfo; // 收货地址
-    
-        // 订单与客户关联
-        @ManyToOne(targetEntity=Customer.class)
-        @JoinColumn(name="c_customer_id") // 指定外键列
-        private Customer c; // 描述订单属于某一个客户
-    
-        public Customer getC() {
-            return c;
-        }
-        public void setC(Customer c) {
-            this.c = c;
-        }
-        public Integer getId() {
-            return id;
-        }
-        public void setId(Integer id) {
-            this.id = id;
-        }
-        public Double getMoney() {
-            return money;
-        }
-        public void setMoney(Double money) {
-            this.money = money;
-        }
-        public String getReceiverInfo() {
-            return receiverInfo;
-        }
-        public void setReceiverInfo(String receiverInfo) {
-            this.receiverInfo = receiverInfo;
-        }
-    
-    }
-
-
-这儿用到了`@OneToMany`和`@ManyToOne`这两个注解。
-以上两个实体类编写好之后，可以很明显的看出我们不需要写它们对应的映射配置文件了，是不是很爽呢！接下来，我就要编写测试程序测试一下了。现在我的需求是保存客户时，顺便保存订单，对于这种情况我们需要在Customer类中配置cascade操作，即配置cascade="save-update"，配置的方式有两种，下面我细细说来：
-
-第一种方式，可以使用JPA提供的注解。 
-那么@OneToMany注解就应修改为：
-
-    @OneToMany(targetEntity=Order.class,mappedBy="c",cascade=CascadeType.ALL)
-    private Set<Order> orders = new HashSet<Order>();
-
-第二种方式，可以使用Hibernate提供的注解。 
-那么@OneToMany注解就应修改为：
-
-    @OneToMany(targetEntity=Order.class,mappedBy="c")
-    @Cascade(CascadeType.SAVE_UPDATE)
-    private Set<Order> orders = new HashSet<Order>();
-
-两种方式都可以，口味任君选择，不过我倾向于第二种方式。 
-接下来在HibernateAnnotationTest单元测试类中编写如下方法进行测试：
-
-    public class HibernateAnnotationTest {
-    
-        // 测试one-to-many注解操作(保存客户时级联保存订单)
-        @Test
-        public void test3() {
-            Session session = HibernateUtils.openSession();
-            session.beginTransaction();
-    
-            // 1.创建一个客户
-            Customer c = new Customer();
-            c.setName("叶子");
-    
-            // 2.创建两个订单
-            Order o1 = new Order();
-            o1.setMoney(1000d);
-            o1.setReceiverInfo("武汉");
-            Order o2 = new Order();
-            o2.setMoney(2000d);
-            o2.setReceiverInfo("天门");
-    
-            // 3.建立关系
-            c.getOrders().add(o1);
-            c.getOrders().add(o2);
-    
-            // 4.保存客户，并级联保存订单
-            session.save(c);
-    
-            session.getTransaction().commit();
-            session.close();
-        }
-    
-    }
-
-这时运行以上方法，会发现虽然客户表的那条记录插进去了，但是订单表就变成这个鬼样了： 
-
-订单表中没有关联客户的id，这是为什么呢？原因是我们在Customer类中配置了mappedBy=”c”，它代表的是外键的维护由Order方来维护，而Customer不维护，这时你在保存客户时，级联保存订单，是可以的，但是不能维护外键，所以，我们必须在代码中添加订单与客户之间的关系。所以须将test3方法修改为：
-
-    public class HibernateAnnotationTest {
-    
-        // 测试one-to-many注解操作(保存客户时级联保存订单)
-        @Test
-        public void test3() {
-            Session session = HibernateUtils.openSession();
-            session.beginTransaction();
-    
-            // 1.创建一个客户
-            Customer c = new Customer();
-            c.setName("叶子");
-    
-            // 2.创建两个订单
-            Order o1 = new Order();
-            o1.setMoney(1000d);
-            o1.setReceiverInfo("武汉");
-            Order o2 = new Order();
-            o2.setMoney(2000d);
-            o2.setReceiverInfo("天门");
-    
-            // 3.建立关系
-            // 原因：是为了维护外键，不然的话，外键就不能正确的生成！！！
-            o1.setC(c);
-            o2.setC(c);
-    
-            // 原因：是为了进行级联操作
-            c.getOrders().add(o1);
-            c.getOrders().add(o2);
-    
-            // 4.保存客户，并级联保存订单
-            session.save(c);
-    
-            session.getTransaction().commit();
-            session.close();
-        }
-    
-    }
-
-这时再测试，就没有任何问题啦！
-
-## 扩展
-Hibernate注解@Cascade中的DELETE_ORPHAN已经过时了，如下： 
-
-可使用下面方案来替换过时方案： 
-
-Hibernate关联映射——多对多
-以学生与老师为例开始我的表演，我是使用注解完成这种多对多的配置。使用@ManyToMany注解来配置多对多，只需要在一端配置中间表，另一端使用mappedBy表示放置外键的维护权。 
-在src目录下创建一个cn.itheima.manyToMany包，并在该包编写这两个实体类：
-
-学生类
-
-    @Entity
-    @Table(name="t_student")
-    public class Student {
-    
-        @Id
-        @GeneratedValue(strategy=GenerationType.IDENTITY)
-        private Integer id;
-    
-        private String name;
-    
-        @ManyToMany(targetEntity=Teacher.class)
-        // @JoinTable：使用@JoinTable来描述中间表，并描述中间表中外键与Student、Teacher的映射关系
-        // joinColumns：它是用来描述Student与中间表的映射关系
-        // inverseJoinColumns：它是用来描述Teacher与中间表的映射关系
-        @JoinTable(name="s_t", joinColumns={@JoinColumn(name="c_student_id",referencedColumnName="id")}, inverseJoinColumns={@JoinColumn(name="c_teacher_id")}) 
-        private Set<Teacher> teachers = new HashSet<Teacher>();
-    
-        public Integer getId() {
-            return id;
-        }
-        public void setId(Integer id) {
-            this.id = id;
-        }
-        public String getName() {
-            return name;
-        }
-        public void setName(String name) {
-            this.name = name;
-        }
-        public Set<Teacher> getTeachers() {
-            return teachers;
-        }
-        public void setTeachers(Set<Teacher> teachers) {
-            this.teachers = teachers;
-        }
-    
-    }
-
-老师类
-
-    @Entity
-    @Table(name="t_teacher")
-    public class Teacher {
-    
-        @Id
-        @GeneratedValue(strategy=GenerationType.IDENTITY)
-        private Integer id;
-    
-        private String name;
-    
-        @ManyToMany(targetEntity=Student.class, mappedBy="teachers") // 代表由对方来维护外键
-        private Set<Student> students = new HashSet<Student>();
-    
-        public Integer getId() {
-            return id;
-        }
-        public void setId(Integer id) {
-            this.id = id;
-        }
-        public String getName() {
-            return name;
-        }
-        public void setName(String name) {
-            this.name = name;
-        }
-        public Set<Student> getStudents() {
-            return students;
-        }
-        public void setStudents(Set<Student> students) {
-            this.students = students;
-        }
-    
-    }
-
-接下来，我就要编写测试程序测试一下了。 从上面可看出我们将外键的维护权利交由Student类来维护，现在我们演示保存学生时，将老师也级联保存，对于这种情况我们需要在Student类中配置cascade操作，即配置cascade=”save-update”，如下：
-
-    @JoinTable(name="s_t", joinColumns={@JoinColumn(name="c_student_id",referencedColumnName="id")}, inverseJoinColumns={@JoinColumn(name="c_teacher_id")}) 
-    @Cascade(CascadeType.SAVE_UPDATE)
-    private Set<Teacher> teachers = new HashSet<Teacher>();
-
-接下来在HibernateAnnotationTest单元测试类中编写如下方法进行测试：
-
-    public class HibernateAnnotationTest {
-    
-        // 测试多对多级联保存(保存学生时同时保存老师)
-        @Test
-        public void test4() {
-            Session session = HibernateUtils.openSession();
-            session.beginTransaction();
-    
-            // 1.创建两个老师
-            Teacher t1 = new Teacher();
-            t1.setName("Tom");
-    
-            Teacher t2 = new Teacher();
-            t2.setName("Fox");
-    
-            // 2.创建两个学生
-            Student s1 = new Student();
-            s1.setName("张丹");
-    
-            Student s2 = new Student();
-            s2.setName("叶紫");
-    
-            // 3.学生关联老师
-            s1.getTeachers().add(t1);
-            s1.getTeachers().add(t2);
-    
-            s2.getTeachers().add(t1);
-            s2.getTeachers().add(t2);
-    
-            // 保存学生同时保存老师
-            session.save(s1);
-            session.save(s2);
-    
-            session.getTransaction().commit();
-            session.close();
-        }
-    
-    }
-
-运行以上方法，一切正常。 
-接着我们测试级联删除操作。见下图： 
-这里写图片描述
-
-可在HibernateAnnotationTest单元测试类中编写如下方法进行测试：
-
-    public class HibernateAnnotationTest {
-    
-        // 测试多对多级联删除(前提是建立了双向的级联)
-        @Test
-        public void test5() {
-            Session session = HibernateUtils.openSession();
-            session.beginTransaction();
-    
-            Student s = session.get(Student.class, 1);
-            session.delete(s);
-    
-            session.getTransaction().commit();
-            session.close();
-        }
-    
-    }
-
-## 参考文章
-
-<https://segmentfault.com/a/1190000009707894>
-
-<https://www.cnblogs.com/hysum/p/7100874.html>
-
-<http://c.biancheng.net/view/939.html>
-
-<https://www.runoob.com/>
-
-https://blog.csdn.net/android_hl/article/details/53228348
-
-## 微信公众号
-
-### 个人公众号：程序员黄小斜
-
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注微信公众号【程序员黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
-
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的微信公众号【Java技术江湖】
-
-这是一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-
-**Java工程师必备学习资源:** 
-关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
-
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-​                     
diff --git "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2146\357\274\232Tomcat5\346\200\273\344\275\223\346\236\266\346\236\204\345\211\226\346\236\220.md" "b/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2146\357\274\232Tomcat5\346\200\273\344\275\223\346\236\266\346\236\204\345\211\226\346\236\220.md"
deleted file mode 100644
index 2434a07..0000000
--- "a/docs/java-web/\350\265\260\350\277\233JavaWeb\346\212\200\346\234\257\344\270\226\347\225\2146\357\274\232Tomcat5\346\200\273\344\275\223\346\236\266\346\236\204\345\211\226\346\236\220.md"
+++ /dev/null
@@ -1,1202 +0,0 @@
-# Table of Contents
-
-  * [Tomcat 总体结构](#tomcat-总体结构)
-    * [以 Service 作为“婚姻”](#以-service-作为婚姻)
-        * [图 2\. Service 接口](#图-2-service-接口)
-        * [图 3\. StandardService 的类结构图](#图-3-standardservice-的类结构图)
-        * [清单 1\. StandardService. SetContainer](#清单-1-standardservice-setcontainer)
-        * [清单 2\. StandardService. addConnector](#清单-2-standardservice-addconnector)
-    * [以 Server 为“居”](#以-server-为居)
-        * [图 4\. Server 的类结构图](#图-4-server-的类结构图)
-        * [清单 3\. StandardServer.addService](#清单-3-standardserveraddservice)
-    * [组件的生命线“Lifecycle”](#组件的生命线lifecycle)
-        * [图 5\. Lifecycle 类结构图](#图-5-lifecycle-类结构图)
-        * [清单 4\. StandardServer.Start](#清单-4-standardserverstart)
-        * [清单 5\. StandardServer.Stop](#清单-5-standardserverstop)
-  * [Connector 组件](#connector-组件)
-        * [图 6\. Connector 处理一次请求顺序图](#图-6-connector-处理一次请求顺序图)
-        * [图 7\. Connector 的主要类图](#图-7-connector-的主要类图)
-        * [清单 6\. HttpConnector.Start](#清单-6-httpconnectorstart)
-        * [清单 7\. HttpProcessor.assign](#清单-7-httpprocessorassign)
-        * [清单 8\. HttpProcessor.Run](#清单-8-httpprocessorrun)
-        * [清单 9\. HttpProcessor.process](#清单-9-httpprocessorprocess)
-  * [Servlet 容器“Container”](#servlet-容器container)
-        * [清单 10\. Server.xml](#清单-10-serverxml)
-    * [容器的总体设计](#容器的总体设计)
-        * [图 8\. 四个容器的关系图](#图-8-四个容器的关系图)
-        * [图 9\. Engine 和 Host 处理请求的时序图](#图-9-engine-和-host-处理请求的时序图)
-        * [清单 11\. Server.xml](#清单-11-serverxml)
-        * [图 10\. Context 和 wrapper 的处理请求时序图](#图-10-context-和-wrapper-的处理请求时序图)
-    * [Engine 容器](#engine-容器)
-        * [图 11\. Engine 接口的类结构](#图-11-engine-接口的类结构)
-        * [清单 12\. StandardEngine. addChild](#清单-12-standardengine-addchild)
-    * [Host 容器](#host-容器)
-        * [图 12\. Host 相关的类图](#图-12-host-相关的类图)
-    * [Context 容器](#context-容器)
-        * [清单 13\. StandardContext.start](#清单-13-standardcontextstart)
-        * [清单 14\. Server.xml](#清单-14-serverxml)
-        * [清单 15\. StandardContext. backgroundProcess](#清单-15-standardcontext-backgroundprocess)
-    * [Wrapper 容器](#wrapper-容器)
-        * [清单 16\. StandardWrapper.loadServlet](#清单-16-standardwrapperloadservlet)
-        * [图 13\. ServletConfig 与 StandardWrapperFacade、StandardWrapper 的关系](#图-13-servletconfig-与-standardwrapperfacade、standardwrapper-的关系)
-  * [Tomcat 中其它组件](#tomcat-中其它组件)
-  * [微信公众号](#微信公众号)
-    * [个人公众号：程序员黄小斜](#个人公众号：程序员黄小斜)
-    * [技术公众号：Java技术江湖](#技术公众号：java技术江湖)
-
-
-
-本文转载自互联网，侵删
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-本系列文章将同步到我的个人博客：
-> www.how2playlife.com
-
-更多Java技术文章将陆续在微信公众号【Java技术江湖】更新，敬请关注。
-
-本文是《走进JavaWeb技术世界》系列博文的其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从入门到进阶，从servlet到框架，从ssm再到SpringBoot，一步步地学习JavaWeb基础知识，并上手进行实战，接着了解JavaWeb项目中经常要使用的技术和组件，包括日志组件、Maven、Junit，等等内容，以便让你更完整地了解整个JavaWeb技术体系，形成自己的知识框架。为了更好地总结和检验你的学习成果，本系列文章也会提供每个知识点对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-**文末赠送8000G的Java架构师学习资料，需要的朋友可以到文末了解领取方式，资料包括Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源）**
-<!-- more -->
-## Tomcat 总体结构
-
-Tomcat 的结构很复杂，但是 Tomcat 也非常的模块化，找到了 Tomcat 最核心的模块，您就抓住了 Tomcat 的“七寸”。下面是 Tomcat 的总体结构图：
-
-![](https://img-blog.csdn.net/20180603163955992?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppbmdsZTE4ODIwMTA=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
-
-从上图中可以看出 Tomcat 的心脏是两个组件：Connector 和 Container，关于这两个组件将在后面详细介绍。Connector 组件是可以被替换，这样可以提供给服务器设计者更多的选择，因为这个组件是如此重要，不仅跟服务器的设计的本身，而且和不同的应用场景也十分相关，所以一个 Container 可以选择对应多个 Connector。多个 Connector 和一个 Container 就形成了一个 Service，Service 的概念大家都很熟悉了，有了 Service 就可以对外提供服务了，但是 Service 还要一个生存的环境，必须要有人能够给她生命、掌握其生死大权，那就非 Server 莫属了。所以整个 Tomcat 的生命周期由 Server 控制。
-
-### 以 Service 作为“婚姻”
-
-我们将 Tomcat 中 Connector、Container 作为一个整体比作一对情侣的话，Connector 主要负责对外交流，可以比作为 Boy，Container 主要处理 Connector 接受的请求，主要是处理内部事务，可以比作为 Girl。那么这个 Service 就是连接这对男女的结婚证了。是 Service 将它们连接在一起，共同组成一个家庭。当然要组成一个家庭还要很多其它的元素。
-
-说白了，Service 只是在 Connector 和 Container 外面多包一层，把它们组装在一起，向外面提供服务，一个 Service 可以设置多个 Connector，但是只能有一个 Container 容器。这个 Service 接口的方法列表如下：
-
-##### 图 2\. Service 接口
-
-![图 2\. Service 接口](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/image002.png)
-
-从 Service 接口中定义的方法中可以看出，它主要是为了关联 Connector 和 Container，同时会初始化它下面的其它组件，注意接口中它并没有规定一定要控制它下面的组件的生命周期。所有组件的生命周期在一个 Lifecycle 的接口中控制，这里用到了一个重要的设计模式，关于这个接口将在后面介绍。
-
-Tomcat 中 Service 接口的标准实现类是 StandardService 它不仅实现了 Service 借口同时还实现了 Lifecycle 接口，这样它就可以控制它下面的组件的生命周期了。StandardService 类结构图如下：
-
-##### 图 3\. StandardService 的类结构图
-
-![图 3\. StandardService 的类结构图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/image003.png)
-
-从上图中可以看出除了 Service 接口的方法的实现以及控制组件生命周期的 Lifecycle 接口的实现，还有几个方法是用于在事件监听的方法的实现，不仅是这个 Service 组件，Tomcat 中其它组件也同样有这几个方法，这也是一个典型的设计模式，将在后面介绍。
-
-下面看一下 StandardService 中主要的几个方法实现的代码，下面是 setContainer 和 addConnector 方法的源码：
-
-##### 清单 1\. StandardService. SetContainer
-
-
-
-    public void setContainer(Container container) {
-    
-        Container oldContainer = this.container;
-    
-        if ((oldContainer != null) && (oldContainer instanceof Engine))
-    
-            ((Engine) oldContainer).setService(null);
-    
-        this.container = container;
-    
-        if ((this.container != null) && (this.container instanceof Engine))
-    
-            ((Engine) this.container).setService(this);
-    
-        if (started && (this.container != null) && (this.container instanceof Lifecycle)) {
-    
-            try {
-    
-                ((Lifecycle) this.container).start();
-    
-            } catch (LifecycleException e) {
-    
-                ;
-    
-            }
-    
-        }
-    
-        synchronized (connectors) {
-    
-            for (int i = 0; i < connectors.length; i++)
-    
-                connectors[i].setContainer(this.container);
-    
-        }
-    
-        if (started && (oldContainer != null) && (oldContainer instanceof Lifecycle)) {
-    
-            try {
-    
-                ((Lifecycle) oldContainer).stop();
-    
-            } catch (LifecycleException e) {
-    
-                ;
-    
-            }
-    
-        }
-    
-        support.firePropertyChange("container", oldContainer, this.container);
-    
-    }
-
-
-
-
-这段代码很简单，其实就是先判断当前的这个 Service 有没有已经关联了 Container，如果已经关联了，那么去掉这个关联关系—— oldContainer.setService(null)。如果这个 oldContainer 已经被启动了，结束它的生命周期。然后再替换新的关联、再初始化并开始这个新的 Container
-
-的生命周期。最后将这个过程通知感兴趣的事件监听程序。这里值得注意的地方就是，修改 Container 时要将新的 Container 关联到每个 Connector，还好 Container 和 Connector 没有双向关联，不然这个关联关系将会很难维护。
-
-##### 清单 2\. StandardService. addConnector
-
-    public void addConnector(Connector connector) {
-    
-        synchronized (connectors) {
-    
-            connector.setContainer(this.container);
-    
-            connector.setService(this);
-    
-            Connector results[] = new Connector[connectors.length + 1];
-    
-            System.arraycopy(connectors, 0, results, 0, connectors.length);
-    
-            results[connectors.length] = connector;
-    
-            connectors = results;
-    
-            if (initialized) {
-    
-                try {
-    
-                    connector.initialize();
-    
-                } catch (LifecycleException e) {
-    
-                    e.printStackTrace(System.err);
-    
-                }
-    
-            }
-    
-            if (started && (connector instanceof Lifecycle)) {
-    
-                try {
-    
-                    ((Lifecycle) connector).start();
-    
-                } catch (LifecycleException e) {
-    
-                    ;
-    
-                }
-    
-            }
-    
-            support.firePropertyChange("connector", null, connector);
-    
-        }
-    
-    }
-
-
-
-
-
-
-
-上面是 addConnector 方法，这个方法也很简单，首先是设置关联关系，然后是初始化工作，开始新的生命周期。这里值得一提的是，注意 Connector 用的是数组而不是 List 集合，这个从性能角度考虑可以理解，有趣的是这里用了数组但是并没有向我们平常那样，一开始就分配一个固定大小的数组，它这里的实现机制是：重新创建一个当前大小的数组对象，然后将原来的数组对象 copy 到新的数组中，这种方式实现了类似的动态数组的功能，这种实现方式，值得我们以后拿来借鉴。
-
-最新的 Tomcat6 中 StandardService 也基本没有变化，但是从 Tomcat5 开始 Service、Server 和容器类都继承了 MBeanRegistration 接口，Mbeans 的管理更加合理。
-
-### 以 Server 为“居”
-
-前面说一对情侣因为 Service 而成为一对夫妻，有了能够组成一个家庭的基本条件，但是它们还要有个实体的家，这是它们在社会上生存之本，有了家它们就可以安心的为人民服务了，一起为社会创造财富。
-
-Server 要完成的任务很简单，就是要能够提供一个接口让其它程序能够访问到这个 Service 集合、同时要维护它所包含的所有 Service 的生命周期，包括如何初始化、如何结束服务、如何找到别人要访问的 Service。还有其它的一些次要的任务，如您住在这个地方要向当地政府去登记啊、可能还有要配合当地公安机关日常的安全检查什么的。
-
-Server 的类结构图如下：
-
-##### 图 4\. Server 的类结构图
-
-![图 4\. Server 的类结构图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/image004.png)
-
-它的标准实现类 StandardServer 实现了上面这些方法，同时也实现了 Lifecycle、MbeanRegistration 两个接口的所有方法，下面主要看一下 StandardServer 重要的一个方法 addService 的实现：
-
-##### 清单 3\. StandardServer.addService
-
-
-
-    public void addService(Service service) {
-    
-        service.setServer(this);
-    
-        synchronized (services) {
-    
-            Service results[] = new Service[services.length + 1];
-    
-            System.arraycopy(services, 0, results, 0, services.length);
-    
-            results[services.length] = service;
-    
-            services = results;
-    
-            if (initialized) {
-    
-                try {
-    
-                    service.initialize();
-    
-                } catch (LifecycleException e) {
-    
-                    e.printStackTrace(System.err);
-    
-                }
-    
-            }
-    
-            if (started && (service instanceof Lifecycle)) {
-    
-                try {
-    
-                    ((Lifecycle) service).start();
-    
-                } catch (LifecycleException e) {
-    
-                    ;
-    
-                }
-    
-            }
-    
-            support.firePropertyChange("service", null, service);
-    
-        }
-    
-    }
-
-
-
-
-
-从上面第一句就知道了 Service 和 Server 是相互关联的，Server 也是和 Service 管理 Connector 一样管理它，也是将 Service 放在一个数组中，后面部分的代码也是管理这个新加进来的 Service 的生命周期。Tomcat6 中也是没有什么变化的。
-
-### 组件的生命线“Lifecycle”
-
-前面一直在说 Service 和 Server 管理它下面组件的生命周期，那它们是如何管理的呢？
-
-Tomcat 中组件的生命周期是通过 Lifecycle 接口来控制的，组件只要继承这个接口并实现其中的方法就可以统一被拥有它的组件控制了，这样一层一层的直到一个最高级的组件就可以控制 Tomcat 中所有组件的生命周期，这个最高的组件就是 Server，而控制 Server 的是 Startup，也就是您启动和关闭 Tomcat。
-
-下面是 Lifecycle 接口的类结构图：
-
-##### 图 5\. Lifecycle 类结构图
-
-![图 5\. Lifecycle 类结构图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/image005.png)
-
-除了控制生命周期的 Start 和 Stop 方法外还有一个监听机制，在生命周期开始和结束的时候做一些额外的操作。这个机制在其它的框架中也被使用，如在 Spring 中。关于这个设计模式会在后面介绍。
-
-Lifecycle 接口的方法的实现都在其它组件中，就像前面中说的，组件的生命周期由包含它的父组件控制，所以它的 Start 方法自然就是调用它下面的组件的 Start 方法，Stop 方法也是一样。如在 Server 中 Start 方法就会调用 Service 组件的 Start 方法，Server 的 Start 方法代码如下：
-
-##### 清单 4\. StandardServer.Start
-
-
-    public void start() throws LifecycleException {
-    
-        if (started) {
-    
-            log.debug(sm.getString("standardServer.start.started"));
-    
-            return;
-    
-        }
-    
-        lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
-    
-        lifecycle.fireLifecycleEvent(START_EVENT, null);
-    
-        started = true;
-    
-        synchronized (services) {
-    
-            for (int i = 0; i < services.length; i++) {
-    
-                if (services[i] instanceof Lifecycle)
-    
-                    ((Lifecycle) services[i]).start();
-    
-            }
-    
-        }
-    
-        lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
-    
-    }
-
-
-
-
-监听的代码会包围 Service 组件的启动过程，就是简单的循环启动所有 Service 组件的 Start 方法，但是所有 Service 必须要实现 Lifecycle 接口，这样做会更加灵活。
-
-Server 的 Stop 方法代码如下：
-
-##### 清单 5\. StandardServer.Stop
-
-
-    public void stop() throws LifecycleException {
-    
-        if (!started)
-    
-            return;
-    
-        lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);
-    
-        lifecycle.fireLifecycleEvent(STOP_EVENT, null);
-    
-        started = false;
-    
-        for (int i = 0; i < services.length; i++) {
-    
-            if (services[i] instanceof Lifecycle)
-    
-                ((Lifecycle) services[i]).stop();
-    
-        }
-    
-        lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
-    
-    }
-
-
-
-它所要做的事情也和 Start 方法差不多。
-
-## Connector 组件
-
-Connector 组件是 Tomcat 中两个核心组件之一，它的主要任务是负责接收浏览器的发过来的 tcp 连接请求，创建一个 Request 和 Response 对象分别用于和请求端交换数据，然后会产生一个线程来处理这个请求并把产生的 Request 和 Response 对象传给处理这个请求的线程，处理这个请求的线程就是 Container 组件要做的事了。
-
-由于这个过程比较复杂，大体的流程可以用下面的顺序图来解释：
-
-##### 图 6\. Connector 处理一次请求顺序图
-
-![图 6\. Connector 处理一次请求顺序图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/image006.png)
-
-（[查看清晰大图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/origin_image006.png)）
-
-Tomcat5 中默认的 Connector 是 Coyote，这个 Connector 是可以选择替换的。Connector 最重要的功能就是接收连接请求然后分配线程让 Container 来处理这个请求，所以这必然是多线程的，多线程的处理是 Connector 设计的核心。Tomcat5 将这个过程更加细化，它将 Connector 划分成 Connector、Processor、Protocol, 另外 Coyote 也定义自己的 Request 和 Response 对象。
-
-下面主要看一下 Tomcat 中如何处理多线程的连接请求，先看一下 Connector 的主要类图：
-
-##### 图 7\. Connector 的主要类图
-
-![图 7\. Connector 的主要类图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/image007.png)
-
-（[查看清晰大图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/origin_image007.png)）
-
-看一下 HttpConnector 的 Start 方法：
-
-##### 清单 6\. HttpConnector.Start
-
-
-
-
-
-    public void start() throws LifecycleException {
-    
-        if (started)
-    
-            throw new LifecycleException
-    
-                (sm.getString("httpConnector.alreadyStarted"));
-    
-        threadName = "HttpConnector[" + port + "]";
-    
-        lifecycle.fireLifecycleEvent(START_EVENT, null);
-    
-        started = true;
-    
-        threadStart();
-    
-        while (curProcessors < minProcessors) {
-    
-            if ((maxProcessors > 0) && (curProcessors >= maxProcessors))
-    
-                break;
-    
-            HttpProcessor processor = newProcessor();
-    
-            recycle(processor);
-    
-        }
-    
-    }
-
-
-
-
-
-
-threadStart() 执行就会进入等待请求的状态，直到一个新的请求到来才会激活它继续执行，这个激活是在 HttpProcessor 的 assign 方法中，这个方法是代码如下 `：`
-
-##### 清单 7\. HttpProcessor.assign
-
-    synchronized void assign(Socket socket) {
-    
-        while (available) {
-    
-            try {
-    
-                wait();
-    
-            } catch (InterruptedException e) {
-    
-            }
-    
-        }
-    
-        this.socket = socket;
-    
-        available = true;
-    
-        notifyAll();
-    
-        if ((debug >= 1) && (socket != null))
-    
-            log(" An incoming request is being assigned");
-    
-    }
-
-
-
-
-创建 HttpProcessor 对象是会把 available 设为 false，所以当请求到来时不会进入 while 循环，将请求的 socket 赋给当期处理的 socket，并将 available 设为 true，当 available 设为 true 是 HttpProcessor 的 run 方法将被激活，接下去将会处理这次请求。
-
-Run 方法代码如下：
-
-##### 清单 8\. HttpProcessor.Run
-
-
-    public void run() {
-    
-        while (!stopped) {
-    
-            Socket socket = await();
-    
-            if (socket == null)
-    
-                continue;
-    
-            try {
-    
-                process(socket);
-    
-            } catch (Throwable t) {
-    
-                log("process.invoke", t);
-    
-            }
-    
-            connector.recycle(this);
-    
-        }
-    
-        synchronized (threadSync) {
-    
-            threadSync.notifyAll();
-    
-        }
-    
-    }
-
-
-解析 socket 的过程在 process 方法中，process 方法的代码片段如下：
-
-##### 清单 9\. HttpProcessor.process
-
-
-
-
-    private void process(Socket socket) {
-    
-        boolean ok = true;
-    
-        boolean finishResponse = true;
-    
-        SocketInputStream input = null;
-    
-        OutputStream output = null;
-    
-        try {
-    
-            input = new SocketInputStream(socket.getInputStream(),connector.getBufferSize());
-    
-        } catch (Exception e) {
-    
-            log("process.create", e);
-    
-            ok = false;
-    
-        }
-    
-        keepAlive = true;
-    
-        while (!stopped && ok && keepAlive) {
-    
-            finishResponse = true;
-    
-            try {
-    
-                request.setStream(input);
-    
-                request.setResponse(response);
-    
-                output = socket.getOutputStream();
-    
-                response.setStream(output);
-    
-                response.setRequest(request);
-    
-                ((HttpServletResponse) response.getResponse())
-    
-                    .setHeader("Server", SERVER_INFO);
-    
-            } catch (Exception e) {
-    
-                log("process.create", e);
-    
-                ok = false;
-    
-            }
-    
-            try {
-    
-                if (ok) {
-    
-                    parseConnection(socket);
-    
-                    parseRequest(input, output);
-    
-                    if (!request.getRequest().getProtocol().startsWith("HTTP/0"))
-    
-                        parseHeaders(input);
-    
-                    if (http11) {
-    
-                        ackRequest(output);
-    
-                        if (connector.isChunkingAllowed())
-    
-                            response.setAllowChunking(true);
-    
-                    }
-    
-                }
-    
-            。。。。。。
-    
-            try {
-    
-                ((HttpServletResponse) response).setHeader
-    
-                    ("Date", FastHttpDateFormat.getCurrentDate());
-    
-                if (ok) {
-    
-                    connector.getContainer().invoke(request, response);
-    
-                }
-    
-                。。。。。。
-    
-            }
-    
-            try {
-    
-                shutdownInput(input);
-    
-                socket.close();
-    
-            } catch (IOException e) {
-    
-                ;
-    
-            } catch (Throwable e) {
-    
-                log("process.invoke", e);
-    
-            }
-    
-        socket = null;
-    
-    }
-
-
-
-
-
-
-当 Connector 将 socket 连接封装成 request 和 response 对象后接下来的事情就交给 Container 来处理了。
-
-## Servlet 容器“Container”
-
-Container 是容器的父接口，所有子容器都必须实现这个接口，Container 容器的设计用的是典型的责任链的设计模式，它有四个子容器组件构成，分别是：Engine、Host、Context、Wrapper，这四个组件不是平行的，而是父子关系，Engine 包含 Host,Host 包含 Context，Context 包含 Wrapper。通常一个 Servlet class 对应一个 Wrapper，如果有多个 Servlet 就可以定义多个 Wrapper，如果有多个 Wrapper 就要定义一个更高的 Container 了，如 Context，Context 通常就是对应下面这个配置：
-
-##### 清单 10\. Server.xml
-
-
-
-
-
-    <Context
-    
-        path="/library"
-    
-        docBase="D:\projects\library\deploy\target\library.war"
-    
-        reloadable="true"
-    
-    />
-
-
-
-
-
-
-
-### 容器的总体设计
-
-Context 还可以定义在父容器 Host 中，Host 不是必须的，但是要运行 war 程序，就必须要 Host，因为 war 中必有 web.xml 文件，这个文件的解析就需要 Host 了，如果要有多个 Host 就要定义一个 top 容器 Engine 了。而 Engine 没有父容器了，一个 Engine 代表一个完整的 Servlet 引擎。
-
-那么这些容器是如何协同工作的呢？先看一下它们之间的关系图：
-
-##### 图 8\. 四个容器的关系图
-
-![图 8\. 四个容器的关系图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/image008.png)
-
-（[查看清晰大图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/origin_image008.png)）
-
-当 Connector 接受到一个连接请求时，将请求交给 Container，Container 是如何处理这个请求的？这四个组件是怎么分工的，怎么把请求传给特定的子容器的呢？又是如何将最终的请求交给 Servlet 处理。下面是这个过程的时序图：
-
-##### 图 9\. Engine 和 Host 处理请求的时序图
-
-![图 9\. Engine 和 Host 处理请求的时序图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/image009.png)
-
-（[查看清晰大图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/origin_image009.png)）
-
-这里看到了 Valve 是不是很熟悉，没错 Valve 的设计在其他框架中也有用的，同样 Pipeline 的原理也基本是相似的，它是一个管道，Engine 和 Host 都会执行这个 Pipeline，您可以在这个管道上增加任意的 Valve，Tomcat 会挨个执行这些 Valve，而且四个组件都会有自己的一套 Valve 集合。您怎么才能定义自己的 Valve 呢？在 server.xml 文件中可以添加，如给 Engine 和 Host 增加一个 Valve 如下：
-
-##### 清单 11\. Server.xml
-
-
-
-
-
-
-
-
-
-    <Engine defaultHost="localhost" name="Catalina">
-    
-     
-    
-        <Valve className="org.apache.catalina.valves.RequestDumperValve"/>
-    
-        ………
-    
-        <Host appBase="webapps" autoDeploy="true" name="localhost" unpackWARs="true"
-    
-            xmlNamespaceAware="false" xmlValidation="false">
-    
-     
-    
-            <Valve className="org.apache.catalina.valves.FastCommonAccessLogValve"
-    
-                directory="logs"  prefix="localhost_access_log." suffix=".txt"
-    
-                pattern="common" resolveHosts="false"/>    
-    
-        …………
-    
-        </Host>
-    
-    </Engine>
-
-
-
-
-
-
-
-StandardEngineValve 和 StandardHostValve 是 Engine 和 Host 的默认的 Valve，它们是最后一个 Valve 负责将请求传给它们的子容器，以继续往下执行。
-
-前面是 Engine 和 Host 容器的请求过程，下面看 Context 和 Wrapper 容器时如何处理请求的。下面是处理请求的时序图：
-
-##### 图 10\. Context 和 wrapper 的处理请求时序图
-
-![图 10\. Context 和 wrapper 的处理请求时序图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/image010.png)
-
-（[查看清晰大图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/origin_image010.png)）
-
-从 Tomcat5 开始，子容器的路由放在了 request 中，request 中保存了当前请求正在处理的 Host、Context 和 wrapper。
-
-### Engine 容器
-
-Engine 容器比较简单，它只定义了一些基本的关联关系，接口类图如下：
-
-##### 图 11\. Engine 接口的类结构
-
-![图 11\. Engine 接口的类结构](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/image011.png)
-
-它的标准实现类是 StandardEngine，这个类注意一点就是 Engine 没有父容器了，如果调用 setParent 方法时将会报错。添加子容器也只能是 Host 类型的，代码如下：
-
-##### 清单 12\. StandardEngine. addChild
-
-
-
-
-
-
-
-
-    public void addChild(Container child) {
-    
-        if (!(child instanceof Host))
-    
-            throw new IllegalArgumentException
-    
-                (sm.getString("standardEngine.notHost"));
-    
-        super.addChild(child);
-    
-    }
-    
-     
-    
-    public void setParent(Container container) {
-    
-        throw new IllegalArgumentException
-    
-            (sm.getString("standardEngine.notParent"));
-    
-    }
-    
-
-
-
-
-
-它的初始化方法也就是初始化和它相关联的组件，以及一些事件的监听。
-
-### Host 容器
-
-Host 是 Engine 的字容器，一个 Host 在 Engine 中代表一个虚拟主机，这个虚拟主机的作用就是运行多个应用，它负责安装和展开这些应用，并且标识这个应用以便能够区分它们。它的子容器通常是 Context，它除了关联子容器外，还有就是保存一个主机应该有的信息。
-
-下面是和 Host 相关的类关联图：
-
-##### 图 12\. Host 相关的类图
-
-![图 12\. Host 相关的类图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/image012.png)
-
-（[查看清晰大图](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/origin_image012.png)）
-
-从上图中可以看出除了所有容器都继承的 ContainerBase 外，StandardHost 还实现了 Deployer 接口，上图清楚的列出了这个接口的主要方法，这些方法都是安装、展开、启动和结束每个 web application。
-
-Deployer 接口的实现是 StandardHostDeployer，这个类实现了的最要的几个方法，Host 可以调用这些方法完成应用的部署等。
-
-### Context 容器
-
-Context 代表 Servlet 的 Context，它具备了 Servlet 运行的基本环境，理论上只要有 Context 就能运行 Servlet 了。简单的 Tomcat 可以没有 Engine 和 Host。
-
-Context 最重要的功能就是管理它里面的 Servlet 实例，Servlet 实例在 Context 中是以 Wrapper 出现的，还有一点就是 Context 如何才能找到正确的 Servlet 来执行它呢？ Tomcat5 以前是通过一个 Mapper 类来管理的，Tomcat5 以后这个功能被移到了 request 中，在前面的时序图中就可以发现获取子容器都是通过 request 来分配的。
-
-Context 准备 Servlet 的运行环境是在 Start 方法开始的，这个方法的代码片段如下：
-
-##### 清单 13\. StandardContext.start
-
-
-
-
-    synchronized void start() throws LifecycleException {
-    
-        ………
-    
-        if( !initialized ) {
-    
-            try {
-    
-                init();
-    
-            } catch( Exception ex ) {
-    
-                throw new LifecycleException("Error initializaing ", ex);
-    
-            }
-    
-        }
-    
-         
-    
-        ………
-    
-        lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
-    
-        setAvailable(false);
-    
-        setConfigured(false);
-    
-        boolean ok = true;
-    
-        File configBase = getConfigBase();
-    
-        if (configBase != null) {
-    
-            if (getConfigFile() == null) {
-    
-                File file = new File(configBase, getDefaultConfigFile());
-    
-                setConfigFile(file.getPath());
-    
-                try {
-    
-                    File appBaseFile = new File(getAppBase());
-    
-                    if (!appBaseFile.isAbsolute()) {
-    
-                        appBaseFile = new File(engineBase(), getAppBase());
-    
-                    }
-    
-                    String appBase = appBaseFile.getCanonicalPath();
-    
-                    String basePath =
-    
-                        (new File(getBasePath())).getCanonicalPath();
-    
-                    if (!basePath.startsWith(appBase)) {
-    
-                        Server server = ServerFactory.getServer();
-    
-                        ((StandardServer) server).storeContext(this);
-    
-                    }
-    
-                } catch (Exception e) {
-    
-                    log.warn("Error storing config file", e);
-    
-                }
-    
-            } else {
-    
-                try {
-    
-                    String canConfigFile =  (new File(getConfigFile())).getCanonicalPath();
-    
-                    if (!canConfigFile.startsWith (configBase.getCanonicalPath())) {
-    
-                        File file = new File(configBase, getDefaultConfigFile());
-    
-                        if (copy(new File(canConfigFile), file)) {
-    
-                            setConfigFile(file.getPath());
-    
-                        }
-    
-                    }
-    
-                } catch (Exception e) {
-    
-                    log.warn("Error setting config file", e);
-    
-                }
-    
-            }
-    
-        }
-    
-     
-    
-        ………
-    
-        Container children[] = findChildren();
-    
-        for (int i = 0; i < children.length; i++) {
-    
-            if (children[i] instanceof Lifecycle)
-    
-                ((Lifecycle) children[i]).start();
-    
-        }
-    
-         
-    
-        if (pipeline instanceof Lifecycle)
-    
-            ((Lifecycle) pipeline).start();
-    
-        ………
-    
-     
-    
-    }
-
-
-
-
-它主要是设置各种资源属性和管理组件，还有非常重要的就是启动子容器和 Pipeline。
-
-我们知道 Context 的配置文件中有个 reloadable 属性，如下面配置：
-
-##### 清单 14\. Server.xml
-
-
-
-    
-    
-    
-    <Context
-    
-        path="/library"
-    
-        docBase="D:\projects\library\deploy\target\library.war"
-    
-        reloadable="true"
-    
-    />
-    
-
-
-
-
-当这个 reloadable 设为 true 时，war 被修改后 Tomcat 会自动的重新加载这个应用。如何做到这点的呢 ? 这个功能是在 StandardContext 的 backgroundProcess 方法中实现的，这个方法的代码如下：
-
-##### 清单 15\. StandardContext. backgroundProcess
-
-
-    public void backgroundProcess() {
-    
-        if (!started) return;
-    
-        count = (count + 1) % managerChecksFrequency;
-    
-        if ((getManager() != null) && (count == 0)) {
-    
-            try {
-    
-                getManager().backgroundProcess();
-    
-            } catch ( Exception x ) {
-    
-                log.warn("Unable to perform background process on manager",x);
-    
-            }
-    
-        }
-    
-        if (getLoader() != null) {
-    
-            if (reloadable && (getLoader().modified())) {
-    
-                try {
-    
-                    Thread.currentThread().setContextClassLoader
-    
-                        (StandardContext.class.getClassLoader());
-    
-                    reload();
-    
-                } finally {
-    
-                    if (getLoader() != null) {
-    
-                        Thread.currentThread().setContextClassLoader
-    
-                            (getLoader().getClassLoader());
-    
-                    }
-    
-                }
-    
-            }
-    
-            if (getLoader() instanceof WebappLoader) {
-    
-                ((WebappLoader) getLoader()).closeJARs(false);
-    
-            }
-    
-        }
-    
-    }
-
-
-
-
-
-
-
-它会调用 reload 方法，而 reload 方法会先调用 stop 方法然后再调用 Start 方法，完成 Context 的一次重新加载。可以看出执行 reload 方法的条件是 reloadable 为 true 和应用被修改，那么这个 backgroundProcess 方法是怎么被调用的呢？
-
-这个方法是在 ContainerBase 类中定义的内部类 ContainerBackgroundProcessor 被周期调用的，这个类是运行在一个后台线程中，它会周期的执行 run 方法，它的 run 方法会周期调用所有容器的 backgroundProcess 方法，因为所有容器都会继承 ContainerBase 类，所以所有容器都能够在 backgroundProcess 方法中定义周期执行的事件。
-
-### Wrapper 容器
-
-Wrapper 代表一个 Servlet，它负责管理一个 Servlet，包括的 Servlet 的装载、初始化、执行以及资源回收。Wrapper 是最底层的容器，它没有子容器了，所以调用它的 addChild 将会报错。
-
-Wrapper 的实现类是 StandardWrapper，StandardWrapper 还实现了拥有一个 Servlet 初始化信息的 ServletConfig，由此看出 StandardWrapper 将直接和 Servlet 的各种信息打交道。
-
-下面看一下非常重要的一个方法 loadServlet，代码片段如下：
-
-##### 清单 16\. StandardWrapper.loadServlet
-
-
-
-    public synchronized Servlet loadServlet() throws ServletException {
-    
-        ………
-    
-        Servlet servlet;
-    
-        try {
-    
-            ………
-    
-            ClassLoader classLoader = loader.getClassLoader();
-    
-            ………
-    
-            Class classClass = null;
-    
-            ………
-    
-            servlet = (Servlet) classClass.newInstance();
-    
-            if ((servlet instanceof ContainerServlet) &&
-    
-                (isContainerProvidedServlet(actualClass) ||
-    
-                ((Context)getParent()).getPrivileged() )) {
-    
-                    ((ContainerServlet) servlet).setWrapper(this);
-    
-            }
-    
-            classLoadTime=(int) (System.currentTimeMillis() -t1);
-    
-            try {
-    
-                instanceSupport.fireInstanceEvent(InstanceEvent.BEFORE_INIT_EVENT,servlet);
-    
-                if( System.getSecurityManager() != null) {
-    
-                    Class[] classType = new Class[]{ServletConfig.class};
-    
-                    Object[] args = new Object[]{((ServletConfig)facade)};
-    
-                    SecurityUtil.doAsPrivilege("init",servlet,classType,args);
-    
-                } else {
-    
-                    servlet.init(facade);
-    
-                }
-    
-                if ((loadOnStartup >= 0) && (jspFile != null)) {
-    
-                    ………
-    
-                    if( System.getSecurityManager() != null) {
-    
-                        Class[] classType = new Class[]{ServletRequest.class,
-    
-                            ServletResponse.class};
-    
-                        Object[] args = new Object[]{req, res};
-    
-                        SecurityUtil.doAsPrivilege("service",servlet,classType,args);
-    
-                    } else {
-    
-                        servlet.service(req, res);
-    
-                    }
-    
-                }
-    
-                instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,servlet);
-    
-                ………
-    
-             
-    
-        return servlet;
-    
-    }
-
-
-
-
-
-它基本上描述了对 Servlet 的操作，当装载了 Servlet 后就会调用 Servlet 的 init 方法，同时会传一个 StandardWrapperFacade 对象给 Servlet，这个对象包装了 StandardWrapper，ServletConfig 与它们的关系图如下：
-
-##### 图 13\. ServletConfig 与 StandardWrapperFacade、StandardWrapper 的关系
-
-![图 13\. ServletConfig 与 StandardWrapperFacade、StandardWrapper 的关系](https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/image013.png)
-
-Servlet 可以获得的信息都在 StandardWrapperFacade 封装，这些信息又是在 StandardWrapper 对象中拿到的。所以 Servlet 可以通过 ServletConfig 拿到有限的容器的信息。
-
-当 Servlet 被初始化完成后，就等着 StandardWrapperValve 去调用它的 service 方法了，调用 service 方法之前要调用 Servlet 所有的 filter。
-
-## Tomcat 中其它组件
-
-Tomcat 还有其它重要的组件，如安全组件 security、logger 日志组件、session、mbeans、naming 等其它组件。这些组件共同为 Connector 和 Container 提供必要的服务。
-
-
-
-
-## 微信公众号
-
-### 个人公众号：程序员黄小斜
-
-​
-黄小斜是 985 硕士，阿里巴巴Java工程师，在自学编程、技术求职、Java学习等方面有丰富经验和独到见解，希望帮助到更多想要从事互联网行业的程序员们。
-​
-作者专注于 JAVA 后端技术栈，热衷于分享程序员干货、学习经验、求职心得，以及自学编程和Java技术栈的相关干货。
-​
-黄小斜是一个斜杠青年，坚持学习和写作，相信终身学习的力量，希望和更多的程序员交朋友，一起进步和成长！
-
-**原创电子书:**
-关注微信公众号【程序员黄小斜】后回复【原创电子书】即可领取我原创的电子书《菜鸟程序员修炼手册：从技术小白到阿里巴巴Java工程师》这份电子书总结了我2年的Java学习之路，包括学习方法、技术总结、求职经验和面试技巧等内容，已经帮助很多的程序员拿到了心仪的offer！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取，包括Java、python、C++、大数据、机器学习、前端、移动端等方向的技术资料。
-
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-### 技术公众号：Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的微信公众号【Java技术江湖】
-
-这是一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-
-**Java工程师必备学习资源:** 
-关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源
-
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-​                     
diff --git "a/docs/java/basic/23\343\200\201\347\273\247\346\211\277\343\200\201\345\260\201\350\243\205\343\200\201\345\244\232\346\200\201\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md" "b/docs/java/basic/23\343\200\201\347\273\247\346\211\277\343\200\201\345\260\201\350\243\205\343\200\201\345\244\232\346\200\201\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
deleted file mode 100644
index 9e30b88..0000000
--- "a/docs/java/basic/23\343\200\201\347\273\247\346\211\277\343\200\201\345\260\201\350\243\205\343\200\201\345\244\232\346\200\201\347\232\204\345\256\236\347\216\260\345\216\237\347\220\206.md"
+++ /dev/null
@@ -1,544 +0,0 @@
-# 目录
-  * [从JVM结构开始谈多态](#从jvm结构开始谈多态)
-    * [JVM 的结构](#jvm-的结构)
-    * [Java 的方法调用方式](#java-的方法调用方式)
-    * [常量池（constant pool）](#常量池（constant-pool）)
-        * [图 2\. 常量池各表的关系](#图-2-常量池各表的关系)
-    * [方法表与方法调用](#方法表与方法调用)
-        * [清单 1](#清单-1)
-    * [接口调用](#接口调用)
-        * [图 5.Dancer 的方法表（[查看大图](https://www.ibm.com/developerworks/cn/java/j-lo-polymorph/image011.jpg)）](#图-5dancer-的方法表（[查看大图]httpswwwibmcomdeveloperworkscnjavaj-lo-polymorphimage011jpg）)
-  * [继承的实现原理](#继承的实现原理)
-  * [重载和重写的实现原理](#重载和重写的实现原理)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
----
-title: 夯实Java基础系列23：深入理解Java继承、封装、多态的底层实现原理
-date: 2019-9-23 15:56:26 # 文章生成时间，一般不改
-categories:
-    - Java技术江湖
-    - Java基础
-tags:
-    - 继承
-    - 封装
-    - 多态
----
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-文章首发于我的个人博客：
-> www.how2playlife.com
-
-本文是微信公众号【Java技术江湖】的《夯实Java基础系列博文》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-该系列博文会告诉你如何从入门到进阶，一步步地学习Java基础知识，并上手进行实战，接着了解每个Java知识点背后的实现原理，更完整地了解整个Java技术体系，形成自己的知识框架。为了更好地总结和检验你的学习成果，本系列文章也会提供每个知识点对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-## 从JVM结构开始谈多态
-
-Java 对于方法调用动态绑定的实现主要依赖于方法表，但通过类引用调用和接口引用调用的实现则有所不同。总体而言，当某个方法被调用时，JVM 首先要查找相应的常量池，得到方法的符号引用，并查找调用类的方法表以确定该方法的直接引用，最后才真正调用该方法。以下分别对该过程中涉及到的相关部分做详细介绍。
-
-### JVM 的结构
-
-典型的 Java 虚拟机的运行时结构如下图所示
-
- 图 1.JVM 运行时结构
-
-![图 1.JVM 运行时结构](https://www.ibm.com/developerworks/cn/java/j-lo-polymorph/image003.jpg)
-
-此结构中，我们只探讨和本文密切相关的方法区 (method area)。当程序运行需要某个类的定义时，载入子系统 (class loader subsystem) 装入所需的 class 文件，并在内部建立该类的类型信息，这个类型信息就存贮在方法区。类型信息一般包括该类的方法代码、类变量、成员变量的定义等等。可以说，类型信息就是类的 Java 文件在运行时的内部结构，包含了改类的所有在 Java 文件中定义的信息。
-
-注意到，该类型信息和 class 对象是不同的。class 对象是 JVM 在载入某个类后于堆 (heap) 中创建的代表该类的对象，可以通过该 class 对象访问到该类型信息。比如最典型的应用，在 Java 反射中应用 class 对象访问到该类支持的所有方法，定义的成员变量等等。可以想象，JVM 在类型信息和 class 对象中维护着它们彼此的引用以便互相访问。两者的关系可以类比于进程对象与真正的进程之间的关系。
-
-### Java 的方法调用方式
-
-Java 的方法调用有两类，动态方法调用与静态方法调用。静态方法调用是指对于类的静态方法的调用方式，是静态绑定的；而动态方法调用需要有方法调用所作用的对象，是动态绑定的。类调用 (invokestatic) 是在编译时刻就已经确定好具体调用方法的情况，而实例调用 (invokevirtual) 则是在调用的时候才确定具体的调用方法，这就是动态绑定，也是多态要解决的核心问题。
-
-JVM 的方法调用指令有四个，分别是 invokestatic，invokespecial，invokesvirtual 和 invokeinterface。前两个是静态绑定，后两个是动态绑定的。本文也可以说是对于 JVM 后两种调用实现的考察。
-
-### 常量池（constant pool）
-
-常量池中保存的是一个 Java 类引用的一些常量信息，包含一些字符串常量及对于类的符号引用信息等。Java 代码编译生成的类文件中的常量池是静态常量池，当类被载入到虚拟机内部的时候，在内存中产生类的常量池叫运行时常量池。
-
-常量池在逻辑上可以分成多个表，每个表包含一类的常量信息，本文只探讨对于 Java 调用相关的常量池表。
-
-CONSTANT_Utf8_info
-
-字符串常量表，该表包含该类所使用的所有字符串常量，比如代码中的字符串引用、引用的类名、方法的名字、其他引用的类与方法的字符串描述等等。其余常量池表中所涉及到的任何常量字符串都被索引至该表。
-
-CONSTANT_Class_info
-
-类信息表，包含任何被引用的类或接口的符号引用，每一个条目主要包含一个索引，指向 CONSTANT_Utf8_info 表，表示该类或接口的全限定名。
-
-CONSTANT_NameAndType_info
-
-名字类型表，包含引用的任意方法或字段的名称和描述符信息在字符串常量表中的索引。
-
-CONSTANT_InterfaceMethodref_info
-
-接口方法引用表，包含引用的任何接口方法的描述信息，主要包括类信息索引和名字类型索引。
-
-CONSTANT_Methodref_info
-
-类方法引用表，包含引用的任何类型方法的描述信息，主要包括类信息索引和名字类型索引。
-
-##### 图 2\. 常量池各表的关系
-
-![图 2\. 常量池各表的关系](https://www.ibm.com/developerworks/cn/java/j-lo-polymorph/image005.jpg)
-
-可以看到，给定任意一个方法的索引，在常量池中找到对应的条目后，可以得到该方法的类索引（class_index）和名字类型索引 (name_and_type_index), 进而得到该方法所属的类型信息和名称及描述符信息（参数，返回值等）。注意到所有的常量字符串都是存储在 CONSTANT_Utf8_info 中供其他表索引的。
-
-### 方法表与方法调用
-
-方法表是动态调用的核心，也是 Java 实现动态调用的主要方式。它被存储于方法区中的类型信息，包含有该类型所定义的所有方法及指向这些方法代码的指针，注意这些具体的方法代码可能是被覆写的方法，也可能是继承自基类的方法。
-
-如有类定义 Person, Girl, Boy,
-
-##### 清单 1
-
-
-
-<pre name="code"> class Person { 
- public String toString(){ 
-    return "I'm a person."; 
-     } 
- public void eat(){} 
- public void speak(){} 
-
- } 
-
- class Boy extends Person{ 
- public String toString(){ 
-    return "I'm a boy"; 
-     } 
- public void speak(){} 
- public void fight(){} 
- } 
-
- class Girl extends Person{ 
- public String toString(){ 
-    return "I'm a girl"; 
-     } 
- public void speak(){} 
- public void sing(){} 
- }</pre>
-
-
-
-当这三个类被载入到 Java 虚拟机之后，方法区中就包含了各自的类的信息。Girl 和 Boy 在方法区中的方法表可表示如下：
-
-图 3.Boy 和 Girl 的方法表
-
-![图 3.Boy 和 Girl 的方法表](https://www.ibm.com/developerworks/cn/java/j-lo-polymorph/image007.jpg)
-
-可以看到，Girl 和 Boy 的方法表包含继承自 Object 的方法，继承自直接父类 Person 的方法及各自新定义的方法。注意方法表条目指向的具体的方法地址，如 Girl 的继承自 Object 的方法中，只有 toString() 指向自己的实现（Girl 的方法代码），其余皆指向 Object 的方法代码；其继承自于 Person 的方法 eat() 和 speak() 分别指向 Person 的方法实现和本身的实现。
-
-Person 或 Object 的任意一个方法，在它们的方法表和其子类 Girl 和 Boy 的方法表中的位置 (index) 是一样的。这样 JVM 在调用实例方法其实只需要指定调用方法表中的第几个方法即可。
-
-如调用如下：
-
- 清单 2
-
-
-
-<pre name="code"> class Party{ 
-…
- void happyHour(){ 
- Person girl = new Girl(); 
- girl.speak(); 
-…
-     } 
- }</pre>
-
-
-
-当编译 Party 类的时候，生成 `girl.speak()`的方法调用假设为：
-
-Invokevirtual #12
-
-设该调用代码对应着 girl.speak(); #12 是 Party 类的常量池的索引。JVM 执行该调用指令的过程如下所示：
-
-图 4\. 解析调用过程
-
-![图 4\. 解析调用过程](https://www.ibm.com/developerworks/cn/java/j-lo-polymorph/image009.jpg)
-
-JVM 首先查看 Party 的常量池索引为 12 的条目（应为 CONSTANT_Methodref_info 类型，可视为方法调用的符号引用），进一步查看常量池（CONSTANT_Class_info，CONSTANT_NameAndType_info ，CONSTANT_Utf8_info）可得出要调用的方法是 Person 的 speak 方法（注意引用 girl 是其基类 Person 类型），查看 Person 的方法表，得出 speak 方法在该方法表中的偏移量 15（offset），这就是该方法调用的直接引用。
-
-当解析出方法调用的直接引用后（方法表偏移量 15），JVM 执行真正的方法调用：根据实例方法调用的参数 this 得到具体的对象（即 girl 所指向的位于堆中的对象），据此得到该对象对应的方法表 (Girl 的方法表 )，进而调用方法表中的某个偏移量所指向的方法（Girl 的 speak() 方法的实现）。
-
-### 接口调用
-
-因为 Java 类是可以同时实现多个接口的，而当用接口引用调用某个方法的时候，情况就有所不同了。Java 允许一个类实现多个接口，从某种意义上来说相当于多继承，这样同样的方法在基类和派生类的方法表的位置就可能不一样了。
-
-清单 3
-
-
-
-<pre name="code">interface IDance{ 
-   void dance(); 
- } 
-
- class Person { 
- public String toString(){ 
-   return "I'm a person."; 
-     } 
- public void eat(){} 
- public void speak(){} 
-
- } 
-
- class Dancer extends Person 
- implements IDance { 
- public String toString(){ 
-   return "I'm a dancer."; 
-     } 
- public void dance(){} 
- } 
-
- class Snake implements IDance{ 
- public String toString(){ 
-   return "A snake."; 
-     } 
- public void dance(){ 
- //snake dance 
-     } 
- }</pre>
-
-
-
-##### 图 5.Dancer 的方法表（[查看大图](https://www.ibm.com/developerworks/cn/java/j-lo-polymorph/image011.jpg)）
-
-![图 5.Dancer 的方法表](https://www.ibm.com/developerworks/cn/java/j-lo-polymorph/image011_small.JPG)
-
-可以看到，由于接口的介入，继承自于接口 IDance 的方法 dance（）在类 Dancer 和 Snake 的方法表中的位置已经不一样了，显然我们无法通过给出方法表的偏移量来正确调用 Dancer 和 Snake 的这个方法。这也是 Java 中调用接口方法有其专有的调用指令（invokeinterface）的原因。
-
-Java 对于接口方法的调用是采用搜索方法表的方式，对如下的方法调用
-
-invokeinterface #13
-
-JVM 首先查看常量池，确定方法调用的符号引用（名称、返回值等等），然后利用 this 指向的实例得到该实例的方法表，进而搜索方法表来找到合适的方法地址。
-
-因为每次接口调用都要搜索方法表，所以从效率上来说，接口方法的调用总是慢于类方法的调用的。
-
-执行结果如下：
-![这里写图片描述](https://img-blog.csdn.net/20160330162239971)
-可以看到`System.out.println(dancer);` 调用的是Person的toString方法。
-
-## 继承的实现原理
-
-Java 的继承机制是一种复用类的技术，从原理上来说，是更好的使用了组合技术，因此要理解继承，首先需要了解类的组合技术是如何实现类的复用的。
-
-使用组合技术复用类
-假设现在的需求是要创建一个具有基本类型，String 类型以及一个其他非基本类型的对象。该如何处理呢？
-
-对于基本类型的变量，在新类中成员变量处直接定义即可，但对于非基本类型变量，不仅需要在类中声明其引用，并且还需要手动初始化这个对象。
-
-这里需要注意的是，编译器并不会默认将所有的引用都创建对象，因为这样的话在很多情况下会增加不必要的负担，因此，在合适的时机初始化合适的对象，可以通过以下几个位置做初始化操作：
-
-在定义对象的地方，先于构造方法执行。
-在构造方法中。
-在正要使用之前，这个被称为惰性初始化。
-使用实例初始化。
-
-    class Soap {
-        private String s;
-        Soap() {
-            System.out.println("Soap()");
-            s = "Constructed";
-        }
-        public String tiString(){
-            return s;
-        }
-    }
-    
-    public class Bath {
-        // s1 初始化先于构造函数
-        private String s1 = "Happy", s2 = "Happy", s3, s4;
-        private Soap soap;
-        private int i;
-        private float f;
-        
-        public Both() {
-            System.out.println("inSide Both");
-            s3 = "Joy";
-            f = 3.14f;
-            soap = new Soap();
-        }
-        
-        {
-            i = 88;
-        }
-        
-        public String toString() {
-            if(s4 == null){
-                s4 = "Joy"
-            }
-            return "s1 = " + s1 +"\n" +
-                   "s2 = " + s2 +"\n" +
-                   "s3 = " + s3 +"\n" +
-                   "s4 = " + s4 +"\n" +
-                   "i = " + i +"\n" +
-                   "f = " + f +"\n" +
-                   "soap = " + soap;
-        }
-    }
-
-继承
-Java 中的继承由 extend 关键字实现，组合的语法比较平实，而继承是一种特殊的语法。当一个类继承自另一个类时，那么这个类就可以拥有另一个类的域和方法。
-
-    class Cleanser{
-        private String s = "Cleanser";
-        
-        public void append(String a){
-            s += a;
-        }
-        public void apply(){
-            append("apply");
-        }
-        public void scrub(){
-            append("scrub");
-        }
-        public String toString(){
-            return s;
-        }
-        public static void main(String args){
-            Cleanser c = new Cleanser();
-            
-            c.apply();
-            System.out.println(c);
-        }
-    }
-    
-    public class Deter extends Cleanser{
-        public void apply(){
-            append("Deter.apply");
-            super.scrub();
-        }
-        public void foam(){
-            append("foam");
-        }
-        public static void main(String args){
-            Deter d = new Deter();
-            
-            d.apply();
-            d.scrub();
-            d.foam();
-            System.out.println(d);
-            Cleanser.main(args);
-        }
-    }
-
-
-上面的代码中，展示了继承语法中的一些特性：
-
-子类可以直接使用父类中公共的方法和成员变量（通常为了保护数据域，成员变量均为私有）
-子类中可以覆盖父类中的方法，也就是子类重写了父类的方法，此时若还需要调用被覆盖的父类的方法，则需要用到 super 来指定是调用父类中的方法。
-子类中可以自定义父类中没有的方法。
-可以发现上面两个类中均有 main 方法，命令行中调用的哪个类就执行哪个类的 main 方法，例如：java Deter。
-继承语法的原理
-接下来我们将通过创建子类对象来分析继承语法在我们看不到的地方做了什么样的操作。
-
-可以先思考一下，如何理解使用子类创建的对象呢，首先这个对象中包含子类的所有信息，但是也包含父类的所有公共的信息。
-
-下面来看一段代码，观察一下子类在创建对象初始化的时候，会不会用到父类相关的方法。
-
-    class Art{
-        Art() {
-            System.out.println("Art Construct");
-        }
-    }
-    
-    class Drawing extends Art {
-        Drawing() {
-            System.out.println("Drawing Construct");
-        }
-    }
-    
-    public class Cartoon extends Drawing {
-        public Cartoon() {
-            System.out.println("Cartoon construct");
-        }
-        public void static main(String args) {
-            Cartoon c = new Cartoon();
-        }
-    }
-    /*output:
-    Art Construct
-    Drawing Construct
-    Cartoon construct
-    */
-
-通过观察代码可以发现，在实例化Cartoon时，事实上是从最顶层的父类开始向下逐个实例化，也就是最终实例化了三个对象。编译器会默认在子类的构造方法中增加调用父类默认构造方法的代码。
-
-因此，继承可以理解为编译器帮我们完成了类的特殊组合技术，即在子类中存在一个父类的对象，使得我们可以用子类对象调用父类的方法。而在开发者看来只不过是使用了一个关键字。
-
-注意：虽然继承很接近组合技术，但是继承拥有其他更多的区别于组合的特性，例如父类的对象我们是不可见的，对于父类中的方法也做了相应的权限校验等。
-
-那么，如果类中的构造方法是带参的，该如何操作呢？（使用super关键字显示调用）
-
-见代码：
-
-    class Game {
-        Game(int i){
-            System.out.println("Game Construct");
-        }
-    }
-    
-    class BoardGame extends Game {
-        BoardGame(int j){
-            super(j);
-            System.out.println("BoardGame Construct");
-        }
-    }
-    public class Chess extends BoardGame{
-        Chess(){
-            super(99);
-            System.out.println("Chess construct");
-        }
-        public static void main(String args) {
-            Chess c = new Chess();
-        }
-    }
-    /*output:
-    Game Construct
-    BoardGame Construct
-    Chess construc
-    */
-
-## 重载和重写的实现原理
-
-    刚开始学习Java的时候，就了解了Java这个比较有意思的特性：重写 和 重载。开始的有时候从名字上还总是容易弄混。我相信熟悉Java这门语言的同学都应该了解这两个特性，可能只是从语言层面上了解这种写法，但是jvm是如何实现他们的呢 ?
-
-重载官方给出的介绍：
-
-> 一.  overload:
-> The Java programming language supports overloading methods, and Java can distinguish between methods with different method signatures. This means that methods within a class can have the same name if they have different parameter lists .
-> 
-> Overloaded methods are differentiated by the number and the type of the arguments passed into the method.
-> 
-> You cannot declare more than one method with the same name and the same number and type of arguments, because the compiler cannot tell them apart.
-> 
-> The compiler does not consider return type when differentiating methods, so you cannot declare two methods with the same signature even if they have a different return type.
-> 
-首先看一段代码，来看看代码的执行结果：
-
-    public class OverrideTest {
-     
-        class Father{}
-     
-        class Sun extends Father {}
-     
-        public void doSomething(Father father){
-            System.out.println("Father do something");
-        }
-     
-        public void doSomething(Sun father){
-            System.out.println("Sun do something");
-        }
-     
-        public static void main(String [] args){
-            OverrideTest overrideTest = new OverrideTest();
-            Father sun = overrideTest.new Sun();
-            Father father = overrideTest.new Father();
-            overrideTest.doSomething(father);
-            overrideTest.doSomething(sun);
-        }
-    }
-
-看下这段代码的执行结果，最后会打印：
-
-Father do something
-Father do something
-
-为什么会打印出这样的结果呢？ 首先要介绍两个概念：静态分派和动态分派
-
-静态分派：依赖静态类型来定位方法执行版本的分派动作称为静态分派
-
-动态分派：运行期根据实际类型确定方法执行版本的分派过程。
-
-他们的区别是：
-
-1.  静态分派发生在编译期，动态分派发生在运行期；
-
-2.  private,static,final 方法发生在编译期，并且不能被重写，一旦发生了重写，将会在运行期处理。
-
-3.  重载是静态分派，重写是动态分派
-
-回到上面的问题，因为重载是发生在编译期，所以在编译期已经确定两次 doSomething 方法的参数都是Father类型，在class文件中已经指向了Father类的符号引用，所以最后会打印两次Father do something。
-
-> 二. override:
-> An instance method in a subclass with the same signature (name, plus the number and the type of its parameters) and return type as an instance method in the superclass overrides the superclass's method.
-> 
-> The ability of a subclass to override a method allows a class to inherit from a superclass whose behavior is "close enough" and then to modify behavior as needed. The overriding method has the same name, number and type of parameters, and return type as the method that it overrides. An overriding method can also return a subtype of the type returned by the overridden method. This subtype is called a covariant return type.
-
-还是上面那个代码，稍微改动下
-
-    public class OverrideTest {
-     
-        class Father{}
-     
-        class Sun extends Father {}
-     
-        public void doSomething(){
-            System.out.println("Father do something");
-        }
-     
-        public void doSomething(){
-            System.out.println("Sun do something");
-        }
-     
-        public static void main(String [] args){
-            OverrideTest overrideTest = new OverrideTest();
-            Father sun = overrideTest.new Sun();
-            Father father = overrideTest.new Father();
-            overrideTest.doSomething();
-            overrideTest.doSomething();
-        }
-    }
- 
-​
-最后会打印：
-
-Father do something
-
-Sun do something
-
- 
-
-相信大家都会知道这个结果，那么这个结果jvm是怎么实现的呢？
-
-在编译期，只会识别到是调用Father类的doSomething方法，到运行期才会真正找到对象的实际类型。
-
-首先该方法的执行，jvm会调用invokevirtual指令，该指令会找栈顶第一个元素所指向的对象的实际类型，如果该类型存在调用的方法，则会走验证流程，否则继续找其父类。这也是为什么子类可以直接调用父类具有访问权限的方法的原因。简而言之，就是在运行期才会去确定对象的实际类型，根据这个实际类型确定方法执行版本，这个过程称为动态分派。override 的实现依赖jvm的动态分派。
-
-## 参考文章
-https://blog.csdn.net/dj_dengjian/article/details/80811348
-https://blog.csdn.net/chenssy/article/details/12757911
-https://blog.csdn.net/fan2012huan/article/details/51007517
-https://blog.csdn.net/fan2012huan/article/details/50999777
-https://www.cnblogs.com/serendipity-fly/p/9469289.html
-https://blog.csdn.net/m0_37264516/article/details/86709537
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。 
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2434\357\274\232HashMap\345\222\214HashTable.md" "b/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2434\357\274\232HashMap\345\222\214HashTable.md"
deleted file mode 100644
index d5a7072..0000000
--- "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2434\357\274\232HashMap\345\222\214HashTable.md"
+++ /dev/null
@@ -1,628 +0,0 @@
-# Table of Contents
-
-  * [HashMap](#hashmap)
-    * [定义](#定义)
-    * [构造函数](#构造函数)
-    * [数据结构](#数据结构)
-    * [存储实现：put(key,vlaue)](#存储实现：putkeyvlaue)
-    * [JDK1.8的hashmap：put方法](#jdk18的hashmap：put方法)
-    * [扩容](#扩容)
-    * [读取实现：get(key)](#读取实现：getkey)
-  * [HashTable](#hashtable)
-    * [定义](#定义-1)
-    * [构造方法](#构造方法)
-    * [主要方法](#主要方法)
-  * [HashTable与HashMap的异同点](#hashtable与hashmap的异同点)
-  * [面试题：HashMap和HashTable的区别](#面试题：hashmap和hashtable的区别)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-    
-本文参考http://cmsblogs.com/?p=176
-
-
-《Java集合详解系列》是我在完成夯实Java基础篇的系列博客后准备开始整理的新系列文章。
-为了更好地诠释知识点，形成体系文章，本系列文章整理了很多优质的博客内容，如有侵权请联系我，一定删除。
-
-这些文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star、fork哈
-
-本系列文章将整理于我的个人博客：
-
-> www.how2playlife.com
-
-
-## HashMap
-
- HashMap也是我们使用非常多的Collection，它是基于哈希表的 Map 接口的实现，以key-value的形式存在。在HashMap中，key-value总是会当做一个整体来处理，系统会根据hash算法来来计算key-value的存储位置，我们总是可以通过key快速地存、取value。下面就来分析HashMap的存取。
-
-
-
-### 定义
-
-  HashMap实现了Map接口，继承AbstractMap。其中Map接口定义了键映射到值的规则，而AbstractMap类提供 Map 接口的骨干实现，以最大限度地减少实现此接口所需的工作，其实AbstractMap类已经实现了Map，这里标注Map LZ觉得应该是更加清晰吧！
-
-    public class HashMap<K,V>
-        extends AbstractMap<K,V>
-        implements Map<K,V>, Cloneable, Serializable
-
-### 构造函数
-
-      HashMap提供了三个构造函数：
-    
-      HashMap()：构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
-    
-      HashMap(int initialCapacity)：构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。
-    
-      HashMap(int initialCapacity, float loadFactor)：构造一个带指定初始容量和加载因子的空 HashMap。
-
-  在这里提到了两个参数：初始容量，加载因子。
-
->   这两个参数是影响HashMap性能的重要参数，其中容量表示哈希表中桶的数量，初始容量是创建哈希表时的容量，加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。
->
->   对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。系统默认负载因子为0.75，一般情况下我们是无需修改的。
-
-  HashMap是一种支持快速存取的数据结构，要了解它的性能必须要了解它的数据结构。
-
-### 数据结构
-
->   我们知道在Java中最常用的两种结构是数组和模拟指针(引用)，几乎所有的数据结构都可以利用这两种来组合实现，HashMap也是如此。实际上HashMap是一个“链表散列”，如下是它的数据结构：
-
-HashMap数据结构图
-
-下图的table数组的每个格子都是一个桶。负载因子就是map中的元素占用的容量百分比。比如负载因子是0.75，初始容量（桶数量）为16时，那么允许装填的元素最大个数就是16*0.75 = 12，这个最大个数也被成为阈值，就是map中定义的threshold。超过这个阈值时，map就会自动扩容。
-
-
-### 存储实现：put(key,vlaue)
-
-      首先我们先看源码
-    
-    public V put(K key, V value) {
-            //当key为null，调用putForNullKey方法，保存null与table第一个位置中，这是HashMap允许为null的原因
-            if (key == null)
-                return putForNullKey(value);
-            //计算key的hash值，此处对原来元素的hashcode进行了再次hash
-            int hash = hash(key.hashCode());                  ------(1)
-            //计算key hash 值在 table 数组中的位置
-            int i = indexFor(hash, table.length);             ------(2)
-            //从i出开始迭代 e,找到 key 保存的位置
-            for (Entry<K, V> e = table[i]; e != null; e = e.next) {
-                Object k;
-                //判断该条链上是否有hash值相同的(key相同)
-                //若存在相同，则直接覆盖value，返回旧value
-                if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
-                    V oldValue = e.value;    //旧值 = 新值
-                    e.value = value;
-                    e.recordAccess(this);
-                    return oldValue;     //返回旧值
-                }
-            }
-            //修改次数增加1
-            modCount++;
-            //将key、value添加至i位置处
-            addEntry(hash, key, value, i);
-            return null;
-        }
-
-  通过源码我们可以清晰看到HashMap保存数据的过程为：首先判断key是否为null，若为null，则直接调用putForNullKey方法。
-
-  若不为空则先计算key的hash值，然后根据hash值搜索在table数组中的索引位置，如果table数组在该位置处有元素，则通过比较是否存在相同的key，若存在则覆盖原来key的value，==否则将该元素保存在链头（最先保存的元素放在链尾）==。
-
-  若table在该处没有元素，则直接保存。这个过程看似比较简单，其实深有内幕。有如下几点：
-
->   1、 先看迭代处。此处迭代原因就是为了防止存在相同的key值，若发现两个hash值（key）相同时，HashMap的处理方式是用新value替换旧value，这里并没有处理key，这就解释了HashMap中没有两个相同的key。
->
->   2、 在看（1）、（2）处。这里是HashMap的精华所在。首先是hash方法，该方法为一个纯粹的数学计算，就是计算h的hash值。
-
-    static int hash(int h) {
-            h ^= (h >>> 20) ^ (h >>> 12);
-            return h ^ (h >>> 7) ^ (h >>> 4);
-        }
-
-  我们知道对于HashMap的table而言，数据分布需要均匀（最好每项都只有一个元素，这样就可以直接找到），不能太紧也不能太松，太紧会导致查询速度慢，太松则浪费空间。计算hash值后，怎么才能保证table元素分布均与呢？我们会想到取模，但是由于取模的消耗较大，HashMap是这样处理的：调用indexFor方法。
-
-    static int indexFor(int h, int length) {
-            return h & (length-1);
-        }
-
-  HashMap的底层数组长度总是2的n次方，在构造函数中存在：capacity <<= 1;这样做总是能够保证HashMap的底层数组长度为2的n次方。当length为2的n次方时，h&(length - 1)就相当于对length取模，而且速度比直接取模快得多，这是HashMap在速度上的一个优化。至于为什么是2的n次方下面解释。
-
- ==对length取模来得到hash是常用的hash索引方法，这里采用位运算的话效率更高。==
-
-  我们回到indexFor方法，该方法仅有一条语句：h&(length - 1)，这句话除了上面的取模运算外还有一个非常重要的责任：均匀分布table数据和充分利用空间。
-
-  这里我们假设length为16(2^n)和15，h为5、6、7。
-
-  当n=15时，6和7的结果一样，这样表示他们在table存储的位置是相同的，也就是产生了碰撞，6、7就会在一个位置形成链表，这样就会导致查询速度降低。诚然这里只分析三个数字不是很多，那么我们就看0-15。
-
->   而当length = 16时，length – 1 = 15 即1111，那么进行低位&运算时，值总是与原来hash值相同，而进行高位运算时，其值等于其低位值。所以说当length = 2^n时，不同的hash值发生碰撞的概率比较小，这样就会使得数据在table数组中分布较均匀，查询速度也较快。
->
->   这里我们再来复习put的流程：当我们想一个HashMap中添加一对key-value时，系统首先会计算key的hash值，然后根据hash值确认在table中存储的位置。若该位置没有元素，则直接插入。否则迭代该处元素链表并依此比较其key的hash值。
->
->   如果两个hash值相等且key值相等(e.hash == hash && ((k = e.key) == key || key.equals(k))),则用新的Entry的value覆盖原来节点的value。如果两个hash值相等但key值不等 ，则将该节点插入该链表的链头。具体的实现过程见addEntry方法，如下：
-
-    void addEntry(int hash, K key, V value, int bucketIndex) {
-            //获取bucketIndex处的Entry
-            Entry<K, V> e = table[bucketIndex];
-            //将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry 
-            table[bucketIndex] = new Entry<K, V>(hash, key, value, e);
-            //若HashMap中元素的个数超过极限了，则容量扩大两倍
-            if (size++ >= threshold)
-                resize(2 * table.length);
-        }
-
-这个方法中有两点需要注意：
-
-    后面添加的entry反而会接到前面。
-
-  一、是链的产生。
-
-  这是一个非常优雅的设计。系统总是将新的Entry对象添加到bucketIndex处。如果bucketIndex处已经有了对象，那么新添加的Entry对象将指向原有的Entry对象，形成一条Entry链，但是若bucketIndex处没有Entry对象，也就是e==null,那么新添加的Entry对象指向null，也就不会产生Entry链了。
-
-  二、扩容问题。
-
-  随着HashMap中元素的数量越来越多，发生碰撞的概率就越来越大，所产生的链表长度就会越来越长，这样势必会影响HashMap的速度，为了保证HashMap的效率，系统必须要在某个临界点进行扩容处理。
-
-  该临界点在当HashMap中元素的数量等于table数组长度*加载因子。但是扩容是一个非常耗时的过程，因为它需要重新计算这些数据在新table数组中的位置并进行复制处理。所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。
-
-### JDK1.8的hashmap：put方法
-
-    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
-                       boolean evict) {
-            Node<K,V>[] tab; Node<K,V> p; int n, i;
-            if ((tab = table) == null || (n = tab.length) == 0)
-                n = (tab = resize()).length;
-            if ((p = tab[i = (n - 1) & hash]) == null)
-                tab[i] = newNode(hash, key, value, null);
-            else {
-                Node<K,V> e; K k;
-                if (p.hash == hash &&
-                    ((k = p.key) == key || (key != null && key.equals(k))))
-                    e = p;
-                    //如果p是红黑树节点，则用另外的处理方法
-                else if (p instanceof TreeNode)
-                    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
-                else {
-                    for (int binCount = 0; ; ++binCount) {
-                        if ((e = p.next) == null) {
-                            p.next = newNode(hash, key, value, null);
-                            if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
-                            //当链表节点数超过8个，则直接进行红黑树化。
-                                treeifyBin(tab, hash);
-                            break;
-                        }
-                        if (e.hash == hash &&
-                            ((k = e.key) == key || (key != null && key.equals(k))))
-                            break;
-                        p = e;
-                    }
-                }
-                if (e != null) { // existing mapping for key
-                    V oldValue = e.value;
-                    if (!onlyIfAbsent || oldValue == null)
-                        e.value = value;
-                    afterNodeAccess(e);
-                    return oldValue;
-                }
-            }
-            ++modCount;
-            if (++size > threshold)
-                resize();
-            afterNodeInsertion(evict);
-            return null;
-        }
-
-JDK1.8在链表长度超过8时会转换为红黑树。
-转换方法如下：
-
-    final void treeifyBin(Node<K,V>[] tab, int hash) {
-            int n, index; Node<K,V> e;
-            if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
-            //如果节点数变小小于红黑树的节点数阈值时，调整空间
-                resize();
-            else if ((e = tab[index = (n - 1) & hash]) != null) {
-                TreeNode<K,V> hd = null, tl = null;
-                do {
-                //该方法直接返回一个红黑树结点。
-                    TreeNode<K,V> p = replacementTreeNode(e, null);
-                    if (tl == null)
-                        hd = p;
-                    else {
-                    //从链表头开始依次插入红黑树
-                        p.prev = tl;
-                        tl.next = p;
-                    }
-                    tl = p;
-                } while ((e = e.next) != null);
-                if ((tab[index] = hd) != null)
-                    hd.treeify(tab);
-            }
-        }
-        
-            // For treeifyBin
-    TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
-        return new TreeNode<>(p.hash, p.key, p.value, next);
-    }
-
-### 扩容
-
-    final Node<K,V>[] resize() {
-            Node<K,V>[] oldTab = table;
-            int oldCap = (oldTab == null) ? 0 : oldTab.length;
-            int oldThr = threshold;
-            int newCap, newThr = 0;
-            if (oldCap > 0) {
-                //如果原容量大于最大空间，则让阈值为最大值。因为不能再扩容了，最大容量就是整数最大值。
-                if (oldCap >= MAXIMUM_CAPACITY) {
-                    threshold = Integer.MAX_VALUE;
-                    return oldTab;
-                }
-                //两倍扩容，阈值也跟着变为两倍
-                else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
-                         oldCap >= DEFAULT_INITIAL_CAPACITY)
-                    newThr = oldThr << 1; // double threshold
-            }
-            else if (oldThr > 0) // initial capacity was placed in threshold
-                newCap = oldThr;
-            else {               // zero initial threshold signifies using defaults
-                newCap = DEFAULT_INITIAL_CAPACITY;
-                newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
-            }
-            if (newThr == 0) {
-                float ft = (float)newCap * loadFactor;
-                newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
-                          (int)ft : Integer.MAX_VALUE);
-            }
-            threshold = newThr;
-            @SuppressWarnings({"rawtypes","unchecked"})
-                Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
-            table = newTab;
-            if (oldTab != null) {
-                for (int j = 0; j < oldCap; ++j) {
-                    Node<K,V> e;
-                    if ((e = oldTab[j]) != null) {
-                        oldTab[j] = null;
-                        if (e.next == null)
-                            //当后面没有节点时，直接插入即可 //每个元素重新计算索引位置，此处的hash值并没有变，只是改变索引值
-                            newTab[e.hash & (newCap - 1)] = e;
-                        else if (e instanceof TreeNode)
-                            ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
-                        else { // preserve order
-                        //否则，就从头到尾依次将节点进行索引然后插入新数组，这样插入后的链表顺序会和原来的顺序相反。
-                            Node<K,V> loHead = null, loTail = null;
-                            Node<K,V> hiHead = null, hiTail = null;
-                            Node<K,V> next;
-                            do {
-                                next = e.next;
-                                if ((e.hash & oldCap) == 0) {
-                                    if (loTail == null)
-                                        loHead = e;
-                                    else
-                                        loTail.next = e;
-                                    loTail = e;
-                                }
-                                else {
-                                    if (hiTail == null)
-                                        hiHead = e;
-                                    else
-                                        hiTail.next = e;
-                                    hiTail = e;
-                                }
-                            } while ((e = next) != null);
-                            if (loTail != null) {
-                                loTail.next = null;
-                                newTab[j] = loHead;
-                            }
-                            if (hiTail != null) {
-                                hiTail.next = null;
-                                newTab[j + oldCap] = hiHead;
-                            }
-                        }
-                    }
-                }
-            }
-            return newTab;
-        }
-
-### 读取实现：get(key)
-
-            相对于HashMap的存而言，取就显得比较简单了。通过key的hash值找到在table数组中的索引处的Entry，然后返回该key对应的value即可。
-    
-    public V get(Object key) {
-            // 若为null，调用getForNullKey方法返回相对应的value
-            if (key == null)
-                return getForNullKey();
-            // 根据该 key 的 hashCode 值计算它的 hash 码  
-            int hash = hash(key.hashCode());
-            // 取出 table 数组中指定索引处的值
-            for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
-                Object k;
-                //若搜索的key与查找的key相同，则返回相对应的value
-                if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
-                    return e.value;
-            }
-            return null;
-        }
-
-> 在这里能够根据key快速的取到value除了和HashMap的数据结构密不可分外，还和Entry有莫大的关系，在前面就提到过，HashMap在存储过程中并没有将key，value分开来存储，而是当做一个整体key-value来处理的，这个整体就是Entry对象。
->
-> 同时value也只相当于key的附属而已。在存储的过程中，系统根据key的hashcode来决定Entry在table数组中的存储位置，在取的过程中同样根据key的hashcode取出相对应的Entry对象。
->
-> 在java中与有两个类都提供了一个多种用途的hashTable机制，他们都可以将可以key和value结合起来构成键值对通过put(key,value)方法保存起来，然后通过get(key)方法获取相对应的value值。
-
-## HashTable
-
-一个是前面提到的HashMap，还有一个就是马上要讲解的HashTable。对于HashTable而言，它在很大程度上和HashMap的实现差不多，如果我们对HashMap比较了解的话，对HashTable的认知会提高很大的帮助。他们两者之间只存在几点的不同，这个后面会阐述。
-
-### 定义
-
-      HashTable在Java中的定义如下：
-    
-    public class Hashtable<K,V>
-        extends Dictionary<K,V>
-        implements Map<K,V>, Cloneable, java.io.Serializable
-          从中可以看出HashTable继承Dictionary类，实现Map接口。其中Dictionary类是任何可将键映射到相应值的类（如 Hashtable）的抽象父类。每个键和每个值都是一个对象。在任何一个 Dictionary 对象中，每个键至多与一个值相关联。Map是"key-value键值对"接口。
-
-
-
-      HashTable采用"拉链法"实现哈希表，它定义了几个重要的参数：table、count、threshold、loadFactor、modCount。
-
-
-
-      table：为一个Entry[]数组类型，Entry代表了“拉链”的节点，每一个Entry代表了一个键值对，哈希表的"key-value键值对"都是存储在Entry数组中的。
-
-
-
-      count：HashTable的大小，注意这个大小并不是HashTable的容器大小，而是他所包含Entry键值对的数量。
-
-
-
-      threshold：Hashtable的阈值，用于判断是否需要调整Hashtable的容量。threshold的值="容量*加载因子"。
-
-
-
-      loadFactor：加载因子。
-
-
-
-      modCount：用来实现“fail-fast”机制的（也就是快速失败）。所谓快速失败就是在并发集合中，其进行迭代操作时，若有其他线程对其进行结构性的修改，这时迭代器会立马感知到，并且立即抛出ConcurrentModificationException异常，而不是等到迭代完成之后才告诉你（你已经出错了）。
-
-### 构造方法
-
-      在HashTabel中存在5个构造函数。通过这5个构造函数我们构建出一个我想要的HashTable。
-    
-    public Hashtable() {
-            this(11, 0.75f);
-        }
-          默认构造函数，容量为11，加载因子为0.75。
-    
-    public Hashtable(int initialCapacity) {
-            this(initialCapacity, 0.75f);
-        }
-          用指定初始容量和默认的加载因子 (0.75) 构造一个新的空哈希表。
-    
-    public Hashtable(int initialCapacity, float loadFactor) {
-            //验证初始容量
-            if (initialCapacity < 0)
-                throw new IllegalArgumentException("Illegal Capacity: "+
-                                                   initialCapacity);
-            //验证加载因子
-            if (loadFactor <= 0 || Float.isNaN(loadFactor))
-                throw new IllegalArgumentException("Illegal Load: "+loadFactor);
-    
-            if (initialCapacity==0)
-                initialCapacity = 1;
-    
-            this.loadFactor = loadFactor;
-    
-            //初始化table，获得大小为initialCapacity的table数组
-            table = new Entry[initialCapacity];
-            //计算阀值
-            threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
-            //初始化HashSeed值
-            initHashSeedAsNeeded(initialCapacity);
-        }
-
-
-​        
->  用指定初始容量和指定加载因子构造一个新的空哈希表。其中initHashSeedAsNeeded方法用于初始化hashSeed参数，其中hashSeed用于计算key的hash值，它与key的hashCode进行按位异或运算。这个hashSeed是一个与实例相关的随机值，主要用于解决hash冲突。
-
-    private int hash(Object k) {
-            return hashSeed ^ k.hashCode();
-        }
-
-  构造一个与给定的 Map 具有相同映射关系的新哈希表。
-
-    public Hashtable(Map<? extends K, ? extends V> t) {
-            //设置table容器大小，其值==t.size * 2 + 1
-            this(Math.max(2*t.size(), 11), 0.75f);
-            putAll(t);
-        }
-
-### 主要方法
-
-HashTable的API对外提供了许多方法，这些方法能够很好帮助我们操作HashTable，但是这里我只介绍两个最根本的方法：put、get。
-
-      首先我们先看put方法：将指定 key 映射到此哈希表中的指定 value。注意这里键key和值value都不可为空。
-    
-    public synchronized V put(K key, V value) {
-            // 确保value不为null
-            if (value == null) {
-                throw new NullPointerException();
-            }
-    
-            /*
-             * 确保key在table[]是不重复的
-             * 处理过程：
-             * 1、计算key的hash值，确认在table[]中的索引位置
-             * 2、迭代index索引位置，如果该位置处的链表中存在一个一样的key，则替换其value，返回旧值
-             */
-            Entry tab[] = table;
-            int hash = hash(key);    //计算key的hash值
-            int index = (hash & 0x7FFFFFFF) % tab.length;     //确认该key的索引位置
-            //迭代，寻找该key，替换
-            for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
-                if ((e.hash == hash) && e.key.equals(key)) {
-                    V old = e.value;
-                    e.value = value;
-                    return old;
-                }
-            }
-    
-            modCount++;
-            if (count >= threshold) {  //如果容器中的元素数量已经达到阀值，则进行扩容操作
-                rehash();
-                tab = table;
-                hash = hash(key);
-                index = (hash & 0x7FFFFFFF) % tab.length;
-            }
-    
-            // 在索引位置处插入一个新的节点
-            Entry<K,V> e = tab[index];
-            tab[index] = new Entry<>(hash, key, value, e);
-            //容器中元素+1
-            count++;
-            return null;
-        }
-
->   put方法的整个处理流程是：计算key的hash值，根据hash值获得key在table数组中的索引位置，然后迭代该key处的Entry链表（我们暂且理解为链表），若该链表中存在一个这个的key对象，那么就直接替换其value值即可，否则在将改key-value节点插入该index索引位置处
-
- 在HashTabled的put方法中有两个地方需要注意：
-
-1、HashTable的扩容操作，在put方法中，如果需要向table[]中添加Entry元素，会首先进行容量校验，如果容量已经达到了阀值，HashTable就会进行扩容处理rehash()，如下:
-
-    protected void rehash() {
-            int oldCapacity = table.length;
-            //元素
-            Entry<K,V>[] oldMap = table;
-    
-            //新容量=旧容量 * 2 + 1
-            int newCapacity = (oldCapacity << 1) + 1;
-            if (newCapacity - MAX_ARRAY_SIZE > 0) {
-                if (oldCapacity == MAX_ARRAY_SIZE)
-                    return;
-                newCapacity = MAX_ARRAY_SIZE;
-            }
-    
-            //新建一个size = newCapacity 的HashTable
-            Entry<K,V>[] newMap = new Entry[];
-    
-            modCount++;
-            //重新计算阀值
-            threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
-            //重新计算hashSeed
-            boolean rehash = initHashSeedAsNeeded(newCapacity);
-    
-            table = newMap;
-            //将原来的元素拷贝到新的HashTable中
-            for (int i = oldCapacity ; i-- > 0 ;) {
-                for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
-                    Entry<K,V> e = old;
-                    old = old.next;
-    
-                    if (rehash) {
-                        e.hash = hash(e.key);
-                    }
-                    int index = (e.hash & 0x7FFFFFFF) % newCapacity;
-                    e.next = newMap[index];
-                    newMap[index] = e;
-                }
-            }
-        }
-
- 在这个rehash()方法中我们可以看到容量扩大两倍+1，同时需要将原来HashTable中的元素一一复制到新的HashTable中，这个过程是比较消耗时间的，同时还需要重新计算hashSeed的，毕竟容量已经变了。
-
- 这里对阀值啰嗦一下：比如初始值11、加载因子默认0.75，那么这个时候阀值threshold=8，当容器中的元素达到8时，HashTable进行一次扩容操作，容量 = 8 * 2 + 1 =17，而阀值threshold=17*0.75 = 13，当容器元素再一次达到阀值时，HashTable还会进行扩容操作，依次类推。
-
-下面是计算key的hash值，这里hashSeed发挥了作用。
-
-    private int hash(Object k) {
-            return hashSeed ^ k.hashCode();
-        }
-
- 相对于put方法，get方法就会比较简单，处理过程就是计算key的hash值，判断在table数组中的索引位置，然后迭代链表，匹配直到找到相对应key的value,若没有找到返回null。
-    
-    public synchronized V get(Object key) {
-            Entry tab[] = table;
-            int hash = hash(key);
-            int index = (hash & 0x7FFFFFFF) % tab.length;
-            for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
-                if ((e.hash == hash) && e.key.equals(key)) {
-                    return e.value;
-                }
-            }
-            return null;
-        }
-
-## HashTable与HashMap的异同点
-
-  HashTable和HashMap存在很多的相同点，但是他们还是有几个比较重要的不同点。
-
-
->
-> 第一：我们从他们的定义就可以看出他们的不同，HashTable基于Dictionary类，而HashMap是基于AbstractMap。Dictionary是什么？它是任何可将键映射到相应值的类的抽象父类，而AbstractMap是基于Map接口的骨干实现，它以最大限度地减少实现此接口所需的工作。
->
-> 
->
-> 第二：HashMap可以允许存在一个为null的key和任意个为null的value，但是HashTable中的key和value都不允许为null。如下：
->
-> 
->
-> 当HashMap遇到为null的key时，它会调用putForNullKey方法来进行处理。对于value没有进行任何处理，只要是对象都可以。
->
->     if (key == null)
->                 return putForNullKey(value);
->           而当HashTable遇到null时，他会直接抛出NullPointerException异常信息。
-
-    if (value == null) {
-        throw new NullPointerException();
-    }
-
->   第三：Hashtable的方法是同步的，而HashMap的方法不是。所以有人一般都建议如果是涉及到多线程同步时采用HashTable，没有涉及就采用HashMap，但是在Collections类中存在一个静态方法：synchronizedMap()，该方法创建了一个线程安全的Map对象，并把它作为一个封装的对象来返回，所以通过Collections类的synchronizedMap方法是可以我们你同步访问潜在的HashMap。这样君该如何选择呢？？？
->
-
-## 面试题：HashMap和HashTable的区别
-
-HashMap线程不安全，HashTable是线程安全的。HashMap内部实现没有任何线程同步相关的代码，所以相对而言性能要好一点。如果在多线程中使用HashMap需要自己管理线程同步。HashTable大部分对外接口都使用synchronized包裹，所以是线程安全的，但是性能会相对差一些。
-
-二者的基类不一样。HashMap派生于AbstractMap，HashTable派生于Dictionary。它们都实现Map, Cloneable, Serializable这些接口。AbstractMap中提供的基础方法更多，并且实现了多个通用的方法，而在Dictionary中只有少量的接口，并且都是abstract类型。
-
-key和value的取值范围不同。HashMap的key和value都可以为null，但是HashTablekey和value都不能为null。对于HashMap如果get返回null，并不能表明HashMap不存在这个key，如果需要判断HashMap中是否包含某个key，就需要使用containsKey这个方法来判断。
-
-算法不一样。HashMap的initialCapacity为16，而HashTable的initialCapacity为11。HashMap中初始容量必须是2的幂,如果初始化传入的initialCapacity不是2的幂，将会自动调整为大于出入的initialCapacity最小的2的幂。HashMap使用自己的计算hash的方法(会依赖key的hashCode方法)，HashTable则使用key的hashCode方法得到。
-
-## 参考文章
-http://cmsblogs.com/?p=176
-
-http://mini.eastday.com/mobile/180310183019559.html#
-
-https://blog.csdn.net/lihua5419/article/details/87691965
-
-https://www.cnblogs.com/aeolian/p/8468632.html
-
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-
-​                     
diff --git "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2437\357\274\232HashSet\357\274\214TreeSet\344\270\216LinkedHashSet.md" "b/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2437\357\274\232HashSet\357\274\214TreeSet\344\270\216LinkedHashSet.md"
deleted file mode 100644
index 64108f8..0000000
--- "a/docs/java/collection/Java\351\233\206\345\220\210\350\257\246\350\247\2437\357\274\232HashSet\357\274\214TreeSet\344\270\216LinkedHashSet.md"
+++ /dev/null
@@ -1,655 +0,0 @@
-# Table of Contents
-
-  * [HashSet](#hashset)
-    * [定义](#定义)
-    * [方法](#方法)
-  * [TreeSet](#treeset)
-    * [TreeSet定义](#treeset定义)
-    * [TreeSet主要方法](#treeset主要方法)
-  * [最后](#最后)
-  * [LinkedHashSet](#linkedhashset)
-    * [LinkedHashSet内部是如何工作的](#linkedhashset内部是如何工作的)
-    * [LinkedHashSet是如何维护插入顺序的](#linkedhashset是如何维护插入顺序的)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-本文参考 http://cmsblogs.com/?p=599
-
-《Java集合详解系列》是我在完成夯实Java基础篇的系列博客后准备开始整理的新系列文章。
-为了更好地诠释知识点，形成体系文章，本系列文章整理了很多优质的博客内容，如有侵权请联系我，一定删除。
-
-这些文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star、fork哈
-
-本系列文章将整理于我的个人博客：
-
-> www.how2playlife.com
-
-今天我们来探索一下HashSet，TreeSet与LinkedHashSet的基本原理与源码实现，由于这三个set都是基于之前文章的三个map进行实现的，所以推荐大家先看一下前面有关map的文章，结合使用味道更佳。
-
-
-
-## HashSet
-
-### 定义
-
-    public class HashSet<E>
-        extends AbstractSet<E>
-        implements Set<E>, Cloneable, java.io.Serializable
-
-HashSet继承AbstractSet类，实现Set、Cloneable、Serializable接口。其中AbstractSet提供 Set 接口的骨干实现，从而最大限度地减少了实现此接口所需的工作。
-==Set接口是一种不包括重复元素的Collection，它维持它自己的内部排序，所以随机访问没有任何意义。==
-
-本文基于1.8jdk进行源码分析。
-
- 基本属性
-
-基于HashMap实现，底层使用HashMap保存所有元素
-
-    private transient HashMap<E,Object> map;
-    
-    //定义一个Object对象作为HashMap的value
-    private static final Object PRESENT = new Object();
-
- 构造函数
-
-    /**
-         * 默认构造函数
-         * 初始化一个空的HashMap，并使用默认初始容量为16和加载因子0.75。
-         */
-        public HashSet() {
-            map = new HashMap<>();
-        }
-    
-        /**
-         * 构造一个包含指定 collection 中的元素的新 set。
-         */
-        public HashSet(Collection<? extends E> c) {
-            map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
-            addAll(c);
-        }
-    
-        /**
-         * 构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子
-         */
-        public HashSet(int initialCapacity, float loadFactor) {
-            map = new HashMap<>(initialCapacity, loadFactor);
-        }
-    
-        /**
-         * 构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。
-         */
-        public HashSet(int initialCapacity) {
-           map = new HashMap<>(initialCapacity);
-        }
-    
-        /**
-         * 在API中我没有看到这个构造函数，今天看源码才发现（原来访问权限为包权限，不对外公开的）
-         * 以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。
-         * dummy 为标识 该构造函数主要作用是对LinkedHashSet起到一个支持作用
-         */
-        HashSet(int initialCapacity, float loadFactor, boolean dummy) {
-           map = new LinkedHashMap<>(initialCapacity, loadFactor);
-        }
-     从构造函数中可以看出HashSet所有的构造都是构造出一个新的HashMap，其中最后一个构造函数，为包访问权限是不对外公开，仅仅只在使用LinkedHashSet时才会发生作用。
-
-### 方法
-
- 既然HashSet是基于HashMap，那么对于HashSet而言，其方法的实现过程是非常简单的。
-
-    public Iterator<E> iterator() {
-            return map.keySet().iterator();
-        }
-
-> iterator()方法返回对此 set 中元素进行迭代的迭代器。返回元素的顺序并不是特定的。
->
-> 底层调用HashMap的keySet返回所有的key，这点反应了HashSet中的所有元素都是保存在HashMap的key中，value则是使用的PRESENT对象，该对象为static final。
->
->     public int size() {
->             return map.size();
->         }
->        size()返回此 set 中的元素的数量（set 的容量）。底层调用HashMap的size方法，返回HashMap容器的大小。
-
-    public boolean isEmpty() {
-            return map.isEmpty();
-        }
-        isEmpty()，判断HashSet()集合是否为空，为空返回 true，否则返回false。
-    
-    public boolean contains(Object o) {
-            return map.containsKey(o);
-    }
-    
-    public boolean containsKey(Object key) {
-        return getNode(hash(key), key) != null;
-    }
-    
-    //最终调用该方法进行节点查找
-    final Node<K,V> getNode(int hash, Object key) {
-        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
-        //先检查桶的头结点是否存在
-        if ((tab = table) != null && (n = tab.length) > 0 &&
-            (first = tab[(n - 1) & hash]) != null) {
-            if (first.hash == hash && // always check first node
-                ((k = first.key) == key || (key != null && key.equals(k))))
-                return first;
-                //不是头结点，则遍历链表，如果是树节点则使用树节点的方法遍历，直到找到，或者为null
-            if ((e = first.next) != null) {
-                if (first instanceof TreeNode)
-                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
-                do {
-                    if (e.hash == hash &&
-                        ((k = e.key) == key || (key != null && key.equals(k))))
-                        return e;
-                } while ((e = e.next) != null);
-            }
-        }
-        return null;
-    }
-
-contains()，判断某个元素是否存在于HashSet()中，存在返回true，否则返回false。更加确切的讲应该是要满足这种关系才能返回true：(o==null ? e==null : o.equals(e))。底层调用containsKey判断HashMap的key值是否为空。
-    
-    public boolean add(E e) {
-            return map.put(e, PRESENT)==null;
-    }
-    
-    public V put(K key, V value) {
-        return putVal(hash(key), key, value, false, true);
-    }
-    
-    map的put方法：
-    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
-                   boolean evict) {
-        Node<K,V>[] tab; Node<K,V> p; int n, i;
-        
-        //确认初始化
-        if ((tab = table) == null || (n = tab.length) == 0)
-            n = (tab = resize()).length;
-            
-        //如果桶为空，直接插入新元素，也就是entry
-        if ((p = tab[i = (n - 1) & hash]) == null)
-            tab[i] = newNode(hash, key, value, null);
-        else {
-            Node<K,V> e; K k;
-            //如果冲突，分为三种情况
-            //key相等时让旧entry等于新entry即可
-            if (p.hash == hash &&
-                ((k = p.key) == key || (key != null && key.equals(k))))
-                e = p;
-            //红黑树情况
-            else if (p instanceof TreeNode)
-                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
-            else {
-                //如果key不相等，则连成链表
-                for (int binCount = 0; ; ++binCount) {
-                    if ((e = p.next) == null) {
-                        p.next = newNode(hash, key, value, null);
-                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
-                            treeifyBin(tab, hash);
-                        break;
-                    }
-                    if (e.hash == hash &&
-                        ((k = e.key) == key || (key != null && key.equals(k))))
-                        break;
-                    p = e;
-                }
-            }
-            if (e != null) { // existing mapping for key
-                V oldValue = e.value;
-                if (!onlyIfAbsent || oldValue == null)
-                    e.value = value;
-                afterNodeAccess(e);
-                return oldValue;
-            }
-        }
-        ++modCount;
-        if (++size > threshold)
-            resize();
-        afterNodeInsertion(evict);
-        return null;
-    }
-
-> 这里注意一点，hashset只是不允许重复的元素加入，而不是不允许元素连成链表，因为只要key的equals方法判断为true时它们是相等的，此时会发生value的替换，因为所有entry的value一样，所以和没有插入时一样的。
->
-> 而当两个hashcode相同但key不相等的entry插入时，仍然会连成一个链表，长度超过8时依然会和hashmap一样扩展成红黑树，看完源码之后笔者才明白自己之前理解错了。所以看源码还是蛮有好处的。hashset基本上就是使用hashmap的方法再次实现了一遍而已，只不过value全都是同一个object，让你以为相同元素没有插入，事实上只是value替换成和原来相同的值而已。
-
-当add方法发生冲突时，如果key相同，则替换value，如果key不同，则连成链表。       
-
-add()如果此 set 中尚未包含指定元素，则添加指定元素。如果此Set没有包含满足(e==null ? e2==null : e.equals(e2)) 的e2时，则将e2添加到Set中，否则不添加且返回false。
-
-由于底层使用HashMap的put方法将key = e，value=PRESENT构建成key-value键值对，当此e存在于HashMap的key中，则value将会覆盖原有value，但是key保持不变，所以如果将一个已经存在的e元素添加中HashSet中，新添加的元素是不会保存到HashMap中，所以这就满足了HashSet中元素不会重复的特性。
-
-    public boolean remove(Object o) {
-        return map.remove(o)==PRESENT;
-    }
-remove如果指定元素存在于此 set 中，则将其移除。底层使用HashMap的remove方法删除指定的Entry。
-
-    public void clear() {
-        map.clear();
-    }
-
-clear从此 set 中移除所有元素。底层调用HashMap的clear方法清除所有的Entry。
-
-    public Object clone() {
-            try {
-                HashSet<E> newSet = (HashSet<E>) super.clone();
-                newSet.map = (HashMap<E, Object>) map.clone();
-                return newSet;
-            } catch (CloneNotSupportedException e) {
-                throw new InternalError();
-            }
-        }
-
-clone返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。
-
-后记：
-
-> 由于HashSet底层使用了HashMap实现，使其的实现过程变得非常简单，如果你对HashMap比较了解，那么HashSet简直是小菜一碟。有两个方法对HashMap和HashSet而言是非常重要的，下篇将详细讲解hashcode和equals。
-
-
-## TreeSet
-
-与HashSet是基于HashMap实现一样，TreeSet同样是基于TreeMap实现的。在《Java提高篇（二七）-----TreeMap》中LZ详细讲解了TreeMap实现机制，如果客官详情看了这篇博文或者多TreeMap有比较详细的了解，那么TreeSet的实现对您是喝口水那么简单。
-
-### TreeSet定义
-
-我们知道TreeMap是一个有序的二叉树，那么同理TreeSet同样也是一个有序的，它的作用是提供有序的Set集合。通过源码我们知道TreeSet基础AbstractSet，实现NavigableSet、Cloneable、Serializable接口。
-
-其中AbstractSet提供 Set 接口的骨干实现，从而最大限度地减少了实现此接口所需的工作。
-
-NavigableSet是扩展的 SortedSet，具有了为给定搜索目标报告最接近匹配项的导航方法，这就意味着它支持一系列的导航方法。比如查找与指定目标最匹配项。Cloneable支持克隆，Serializable支持序列化。
-
-    public class TreeSet<E> extends AbstractSet<E>
-        implements NavigableSet<E>, Cloneable, java.io.Serializable
-同时在TreeSet中定义了如下几个变量。
-
-    private transient NavigableMap<E,Object> m;
-        
-    //PRESENT会被当做Map的value与key构建成键值对
-     private static final Object PRESENT = new Object();
-其构造方法：
-
-    //默认构造方法，根据其元素的自然顺序进行排序
-    
-    public TreeSet() {
-        this(new TreeMap<E,Object>());
-    }
-    
-    //构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
-    public TreeSet(Comparator<? super E> comparator) {
-            this(new TreeMap<>(comparator));
-    }
-    
-    //构造一个新的空 TreeSet，它根据指定比较器进行排序。
-    public TreeSet(Collection<? extends E> c) {
-        this();
-        addAll(c);
-    }
-    
-    //构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。
-    public TreeSet(SortedSet<E> s) {
-        this(s.comparator());
-        addAll(s);
-    }
-    
-    TreeSet(NavigableMap<E,Object> m) {
-        this.m = m;
-    }
-
-
-### TreeSet主要方法
-
-1、add：将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。
-    
-    public boolean add(E e) {
-            return m.put(e, PRESENT)==null;
-        }
-     
-    public V put(K key, V value) {
-        Entry<K,V> t = root;
-        if (t == null) {
-        //空树时，判断节点是否为空
-            compare(key, key); // type (and possibly null) check
-    
-            root = new Entry<>(key, value, null);
-            size = 1;
-            modCount++;
-            return null;
-        }
-        int cmp;
-        Entry<K,V> parent;
-        // split comparator and comparable paths
-        Comparator<? super K> cpr = comparator;
-        //非空树，根据传入比较器进行节点的插入位置查找
-        if (cpr != null) {
-            do {
-                parent = t;
-                //节点比根节点小，则找左子树，否则找右子树
-                cmp = cpr.compare(key, t.key);
-                if (cmp < 0)
-                    t = t.left;
-                else if (cmp > 0)
-                    t = t.right;
-                    //如果key的比较返回值相等，直接更新值（一般compareto相等时equals方法也相等）
-                else
-                    return t.setValue(value);
-            } while (t != null);
-        }
-        else {
-        //如果没有传入比较器，则按照自然排序
-            if (key == null)
-                throw new NullPointerException();
-            @SuppressWarnings("unchecked")
-                Comparable<? super K> k = (Comparable<? super K>) key;
-            do {
-                parent = t;
-                cmp = k.compareTo(t.key);
-                if (cmp < 0)
-                    t = t.left;
-                else if (cmp > 0)
-                    t = t.right;
-                else
-                    return t.setValue(value);
-            } while (t != null);
-        }
-        //查找的节点为空，直接插入，默认为红节点
-        Entry<K,V> e = new Entry<>(key, value, parent);
-        if (cmp < 0)
-            parent.left = e;
-        else
-            parent.right = e;
-            //插入后进行红黑树调整
-        fixAfterInsertion(e);
-        size++;
-        modCount++;
-        return null;
-    }    
-
-2、get：获取元素
-
-    public V get(Object key) {
-        Entry<K,V> p = getEntry(key);
-        return (p==null ? null : p.value);
-    }
-
-该方法与put的流程类似，只不过是把插入换成了查找
-    
-3、ceiling：返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
-
-    public E ceiling(E e) {
-            return m.ceilingKey(e);
-        }
-4、clear：移除此 set 中的所有元素。
-
-    public void clear() {
-            m.clear();
-        }
-5、clone：返回 TreeSet 实例的浅表副本。属于浅拷贝。
-
-    public Object clone() {
-            TreeSet<E> clone = null;
-            try {
-                clone = (TreeSet<E>) super.clone();
-            } catch (CloneNotSupportedException e) {
-                throw new InternalError();
-            }
-    
-            clone.m = new TreeMap<>(m);
-            return clone;
-        }
-
-6、comparator：返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。
-
-    public Comparator<? super E> comparator() {
-            return m.comparator();
-        }
-7、contains：如果此 set 包含指定的元素，则返回 true。
-
-    public boolean contains(Object o) {
-            return m.containsKey(o);
-        }
-8、descendingIterator：返回在此 set 元素上按降序进行迭代的迭代器。
-
-    public Iterator<E> descendingIterator() {
-            return m.descendingKeySet().iterator();
-        }
-9、descendingSet：返回此 set 中所包含元素的逆序视图。
-
-    public NavigableSet<E> descendingSet() {
-            return new TreeSet<>(m.descendingMap());
-        }
-10、first：返回此 set 中当前第一个（最低）元素。
-
-    public E first() {
-            return m.firstKey();
-        }
-11、floor：返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
-    
-    public E floor(E e) {
-            return m.floorKey(e);
-        }
-12、headSet：返回此 set 的部分视图，其元素严格小于 toElement。
-
-    public SortedSet<E> headSet(E toElement) {
-            return headSet(toElement, false);
-        }
-13、higher：返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
-
-    public E higher(E e) {
-            return m.higherKey(e);
-        }
-14、isEmpty：如果此 set 不包含任何元素，则返回 true。
-
-    public boolean isEmpty() {
-            return m.isEmpty();
-        }
-15、iterator：返回在此 set 中的元素上按升序进行迭代的迭代器。
-
-    public Iterator<E> iterator() {
-            return m.navigableKeySet().iterator();
-        }
-16、last：返回此 set 中当前最后一个（最高）元素。
-
-    public E last() {
-            return m.lastKey();
-        }
-17、lower：返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
-    
-    public E lower(E e) {
-            return m.lowerKey(e);
-        }
-18、pollFirst：获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
-
-    public E pollFirst() {
-            Map.Entry<E,?> e = m.pollFirstEntry();
-            return (e == null) ? null : e.getKey();
-        }
-19、pollLast：获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
-
-    public E pollLast() {
-            Map.Entry<E,?> e = m.pollLastEntry();
-            return (e == null) ? null : e.getKey();
-        }
-20、remove：将指定的元素从 set 中移除（如果该元素存在于此 set 中）。
-
-    public boolean remove(Object o) {
-            return m.remove(o)==PRESENT;
-        }
-
-该方法与put类似，只不过把插入换成了删除，并且要进行删除后调整
-
-21、size：返回 set 中的元素数（set 的容量）。
-
-    public int size() {
-            return m.size();
-        }
-22、subSet：返回此 set 的部分视图
-
-    /**
-         * 返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。
-         */
-         public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
-                 E toElement,   boolean toInclusive) {
-                 return new TreeSet<>(m.subMap(fromElement, fromInclusive,
-                      toElement,   toInclusive));
-         }
-         
-         /**
-          * 返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。
-          */
-         public SortedSet<E> subSet(E fromElement, E toElement) {
-             return subSet(fromElement, true, toElement, false);
-         }
-23、tailSet：返回此 set 的部分视图
-
-    /**
-         * 返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。
-         */
-        public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
-            return new TreeSet<>(m.tailMap(fromElement, inclusive));
-        }
-        
-        /**
-         * 返回此 set 的部分视图，其元素大于等于 fromElement。
-         */
-        public SortedSet<E> tailSet(E fromElement) {
-            return tailSet(fromElement, true);
-        }
-
-
-## 最后
-
-由于TreeSet是基于TreeMap实现的，所以如果我们对treeMap有了一定的了解，对TreeSet那是小菜一碟，我们从TreeSet中的源码可以看出，其实现过程非常简单，几乎所有的方法实现全部都是基于TreeMap的。
-
-## LinkedHashSet
-
-### LinkedHashSet内部是如何工作的
-
-LinkedHashSet是HashSet的一个“扩展版本”，HashSet并不管什么顺序，不同的是LinkedHashSet会维护“插入顺序”。HashSet内部使用HashMap对象来存储它的元素，而LinkedHashSet内部使用LinkedHashMap对象来存储和处理它的元素。这篇文章，我们将会看到LinkedHashSet内部是如何运作的及如何维护插入顺序的。
-
-我们首先着眼LinkedHashSet的构造函数。在LinkedHashSet类中一共有4个构造函数。这些构造函数都只是简单地调用父类构造函数（如HashSet类的构造函数）。
-下面看看LinkedHashSet的构造函数是如何定义的。
-
-    //Constructor - 1
-     
-    public LinkedHashSet(int initialCapacity, float loadFactor)
-    {
-          super(initialCapacity, loadFactor, true);              //Calling super class constructor
-    }
-     
-    //Constructor - 2
-     
-    public LinkedHashSet(int initialCapacity)
-    {
-            super(initialCapacity, .75f, true);             //Calling super class constructor
-    }
-     
-    //Constructor - 3
-     
-    public LinkedHashSet()
-    {
-            super(16, .75f, true);                //Calling super class constructor
-    }
-     
-    //Constructor - 4
-     
-    public LinkedHashSet(Collection<? extends E> c)
-    {
-            super(Math.max(2*c.size(), 11), .75f, true);          //Calling super class constructor
-            addAll(c);
-    }
-    
-在上面的代码片段中，你可能注意到4个构造函数调用的是同一个父类的构造函数。这个构造函数（父类的，译者注）是一个包内私有构造函数（见下面的代码，HashSet的构造函数没有使用public公开，译者注），它只能被LinkedHashSet使用。
-
-这个构造函数需要初始容量，负载因子和一个boolean类型的哑值（没有什么用处的参数，作为标记，译者注）等参数。这个哑参数只是用来区别这个构造函数与HashSet的其他拥有初始容量和负载因子参数的构造函数，下面是这个构造函数的定义，
-
-    HashSet(int initialCapacity, float loadFactor, boolean dummy)
-    {
-            map = new LinkedHashMap<>(initialCapacity, loadFactor);
-    }
-显然，这个构造函数内部初始化了一个LinkedHashMap对象，这个对象恰好被LinkedHashSet用来存储它的元素。
-
-LinkedHashSet并没有自己的方法，所有的方法都继承自它的父类HashSet，因此，对LinkedHashSet的所有操作方式就好像对HashSet操作一样。
-
-唯一的不同是内部使用不同的对象去存储元素。在HashSet中，插入的元素是被当做HashMap的键来保存的，而在LinkedHashSet中被看作是LinkedHashMap的键。
-
-这些键对应的值都是常量PRESENT（PRESENT是HashSet的静态成员变量，译者注）。
-
-### LinkedHashSet是如何维护插入顺序的
-> LinkedHashSet使用LinkedHashMap对象来存储它的元素，插入到LinkedHashSet中的元素实际上是被当作LinkedHashMap的键保存起来的。
->
-> LinkedHashMap的每一个键值对都是通过内部的静态类Entry<K, V>实例化的。这个 Entry<K, V>类继承了HashMap.Entry类。
->
-> 这个静态类增加了两个成员变量，before和after来维护LinkedHasMap元素的插入顺序。这两个成员变量分别指向前一个和后一个元素，这让LinkedHashMap也有类似双向链表的表现。
-
-    private static class Entry<K,V> extends HashMap.Entry<K,V>
-    {
-            // These fields comprise the doubly linked list used for iteration.
-            Entry<K,V> before, after;
-     
-            Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
-                super(hash, key, value, next);
-            }
-    }
-从上面代码看到的LinkedHashMap内部类的前面两个成员变量——before和after负责维护LinkedHashSet的插入顺序。LinkedHashMap定义的成员变量header保存的是
-这个双向链表的头节点。header的定义就像下面这样，
-
-接下来看一个例子就知道LinkedHashSet内部是如何工作的了。
-
-    public class LinkedHashSetExample
-    {
-        public static void main(String[] args)
-        {
-            //Creating LinkedHashSet
-     
-            LinkedHashSet<String> set = new LinkedHashSet<String>();
-     
-            //Adding elements to LinkedHashSet
-     
-            set.add("BLUE");
-     
-            set.add("RED");
-     
-            set.add("GREEN");    
-     
-            set.add("BLACK");
-        }
-    }
-
-
-如果你知道LinkedHashMap内部是如何工作的，就非常容易明白LinkedHashSet内部是如何工作的。看一遍LinkedHashSet和LinkedHashMap的源码，
-你就能够准确地理解在Java中LinkedHashSet内部是如何工作的。
-
-
-## 参考文章
-http://cmsblogs.com/?p=599
-
-https://www.cnblogs.com/one-apple-pie/p/11036309.html
-
-https://blog.csdn.net/learningcoding/article/details/79983248
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
-
-
-
-​                     
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2272\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243Java\345\206\205\345\255\230\346\250\241\345\236\213JMM.md" "b/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2272\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243Java\345\206\205\345\255\230\346\250\241\345\236\213JMM.md"
deleted file mode 100644
index a84e568..0000000
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2272\357\274\232\346\267\261\345\205\245\347\220\206\350\247\243Java\345\206\205\345\255\230\346\250\241\345\236\213JMM.md"
+++ /dev/null
@@ -1,410 +0,0 @@
-# Table of Contents
-
-  * [一：JMM基础与happens-before](#一：jmm基础与happens-before)
-    * [并发编程模型的分类](#并发编程模型的分类)
-    * [重排序](#重排序)
-    * [处理器重排序与内存屏障指令](#处理器重排序与内存屏障指令)
-    * [happens-before](#happens-before)
-  * [二：重排序与JMM的as-if-serial](#二：重排序与jmm的as-if-serial)
-    * [数据依赖性](#数据依赖性)
-    * [as-if-serial语义](#as-if-serial语义)
-    * [程序顺序规则](#程序顺序规则)
-    * [重排序对多线程的影响](#重排序对多线程的影响)
-  * [三：顺序一致性内存模型与JMM](#三：顺序一致性内存模型与jmm)
-    * [数据竞争与顺序一致性保证](#数据竞争与顺序一致性保证)
-    * [顺序一致性内存模型](#顺序一致性内存模型)
-    * [同步程序的顺序一致性效果](#同步程序的顺序一致性效果)
-    * [未同步程序的执行特性](#未同步程序的执行特性)
-
-
-**本文转载自并发编程网，侵删**
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-文章同步发于我的个人博客：
-> www.how2playlife.com
-
-本文是微信公众号【Java技术江湖】的《Java并发指南》其中一篇，本文大部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何全面深入地学习Java并发技术，从Java多线程基础，再到并发编程的基础知识，从Java并发包的入门和实战，再到JUC的源码剖析，一步步地学习Java并发编程，并上手进行实战，以便让你更完整地了解整个Java并发编程知识体系，形成自己的知识框架。
-
-为了更好地总结和检验你的学习成果，本系列文章也会提供一些对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-<!--more -->
-
-## 一：JMM基础与happens-before
-
-### 并发编程模型的分类
-
-在并发编程中，我们需要处理两个关键问题：线程之间如何通信及线程之间如何同步（这里的线程是指并发执行的活动实体）。通信是指线程之间以何种机制来交换信息。在命令式编程中，线程之间的通信机制有两种：共享内存和消息传递。
-
-在共享内存的并发模型里，线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐式进行通信。在消息传递的并发模型里，线程之间没有公共状态，线程之间必须通过明确的发送消息来显式进行通信。
-
-同步是指程序用于控制不同线程之间操作发生相对顺序的机制。在共享内存并发模型里，同步是显式进行的。程序员必须显式指定某个方法或某段代码需要在线程之间互斥执行。在消息传递的并发模型里，由于消息的发送必须在消息的接收之前，因此同步是隐式进行的。
-
-Java内存模型的抽象
-
-Java的并发采用的是共享内存模型，Java线程之间的通信总是隐式进行，整个通信过程对程序员完全透明。如果编写多线程程序的Java程序员不理解隐式进行的线程之间通信的工作机制，很可能会遇到各种奇怪的内存可见性问题。
-
-在java中，所有实例域、静态域和数组元素存储在堆内存中，堆内存在线程之间共享（本文使用“共享变量”这个术语代指实例域，静态域和数组元素）。局部变量（Local variables），方法定义参数（java语言规范称之为formal method parameters）和异常处理器参数（exception handler parameters）不会在线程之间共享，它们不会有内存可见性问题，也不受内存模型的影响。
-
-Java线程之间的通信由Java内存模型（本文简称为JMM）控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。Java内存模型的抽象示意图如下：
-
-![](https://res.infoq.com/articles/java-memory-model-1/zh/resources/11.png)
-
-从上图来看，线程A与线程B之间如要通信的话，必须要经历下面2个步骤：
-
-1.  首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。
-2.  然后，线程B到主内存中去读取线程A之前已更新过的共享变量。
-
-下面通过示意图来说明这两个步骤：
-
-![](https://res.infoq.com/articles/java-memory-model-1/zh/resources/22.png)
-
-如上图所示，本地内存A和B有主内存中共享变量x的副本。假设初始时，这三个内存中的x值都为0。线程A在执行时，把更新后的x值（假设值为1）临时存放在自己的本地内存A中。当线程A和线程B需要通信时，线程A首先会把自己本地内存中修改后的x值刷新到主内存中，此时主内存中的x值变为了1。随后，线程B到主内存中去读取线程A更新后的x值，此时线程B的本地内存的x值也变为了1。
-
-从整体来看，这两个步骤实质上是线程A在向线程B发送消息，而且这个通信过程必须要经过主内存。JMM通过控制主内存与每个线程的本地内存之间的交互，来为java程序员提供内存可见性保证。
-
-### 重排序
-
-在执行程序时为了提高性能，编译器和处理器常常会对指令做重排序。重排序分三种类型：
-
-1.  编译器优化的重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
-2.  指令级并行的重排序。现代处理器采用了指令级并行技术（Instruction-Level Parallelism， ILP）来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
-3.  内存系统的重排序。由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。
-
-从java源代码到最终实际执行的指令序列，会分别经历下面三种重排序：
-
-![](https://res.infoq.com/articles/java-memory-model-1/zh/resources/33.png)
-
-上述的1属于编译器重排序，2和3属于处理器重排序。这些重排序都可能会导致多线程程序出现内存可见性问题。对于编译器，JMM的编译器重排序规则会禁止特定类型的编译器重排序（不是所有的编译器重排序都要禁止）。对于处理器重排序，JMM的处理器重排序规则会要求java编译器在生成指令序列时，插入特定类型的内存屏障（memory barriers，intel称之为memory fence）指令，通过内存屏障指令来禁止特定类型的处理器重排序（不是所有的处理器重排序都要禁止）。
-
-JMM属于语言级的内存模型，它确保在不同的编译器和不同的处理器平台之上，通过禁止特定类型的编译器重排序和处理器重排序，为程序员提供一致的内存可见性保证。
-
-### 处理器重排序与内存屏障指令
-
-现代的处理器使用写缓冲区来临时保存向内存写入的数据。写缓冲区可以保证指令流水线持续运行，它可以避免由于处理器停顿下来等待向内存写入数据而产生的延迟。同时，通过以批处理的方式刷新写缓冲区，以及合并写缓冲区中对同一内存地址的多次写，可以减少对内存总线的占用。虽然写缓冲区有这么多好处，但每个处理器上的写缓冲区，仅仅对它所在的处理器可见。这个特性会对内存操作的执行顺序产生重要的影响：处理器对内存的读/写操作的执行顺序，不一定与内存实际发生的读/写操作顺序一致！为了具体说明，请看下面示例：
-
-
-
-| Processor A | Processor B |
-| --- | --- |
-| a = 1; //A1x = b; //A2 | b = 2; //B1y = a; //B2 |
-| 初始状态：a = b = 0处理器允许执行后得到结果：x = y = 0 |
-
-
-
-假设处理器A和处理器B按程序的顺序并行执行内存访问，最终却可能得到x = y = 0的结果。具体的原因如下图所示：
-
-![](https://res.infoq.com/articles/java-memory-model-1/zh/resources/44.png)
-
-这里处理器A和处理器B可以同时把共享变量写入自己的写缓冲区（A1，B1），然后从内存中读取另一个共享变量（A2，B2），最后才把自己写缓存区中保存的脏数据刷新到内存中（A3，B3）。当以这种时序执行时，程序就可以得到x = y = 0的结果。
-
-从内存操作实际发生的顺序来看，直到处理器A执行A3来刷新自己的写缓存区，写操作A1才算真正执行了。虽然处理器A执行内存操作的顺序为：A1->A2，但内存操作实际发生的顺序却是：A2->A1。此时，处理器A的内存操作顺序被重排序了（处理器B的情况和处理器A一样，这里就不赘述了）。
-
-这里的关键是，由于写缓冲区仅对自己的处理器可见，它会导致处理器执行内存操作的顺序可能会与内存实际的操作执行顺序不一致。由于现代的处理器都会使用写缓冲区，因此现代的处理器都会允许对写-读操做重排序。
-
-下面是常见处理器允许的重排序类型的列表：
-
-
-
-|   | Load-Load | Load-Store | Store-Store | Store-Load | 数据依赖 |
-| --- | --- | --- | --- | --- | --- |
-| sparc-TSO | N | N | N | Y | N |
-| x86 | N | N | N | Y | N |
-| ia64 | Y | Y | Y | Y | N |
-| PowerPC | Y | Y | Y | Y | N |
-
-
-
-上表单元格中的“N”表示处理器不允许两个操作重排序，“Y”表示允许重排序。
-
-从上表我们可以看出：常见的处理器都允许Store-Load重排序；常见的处理器都不允许对存在数据依赖的操作做重排序。sparc-TSO和x86拥有相对较强的处理器内存模型，它们仅允许对写-读操作做重排序（因为它们都使用了写缓冲区）。
-
-※注1：sparc-TSO是指以TSO(Total Store Order)内存模型运行时，sparc处理器的特性。
-
-※注2：上表中的x86包括x64及AMD64。
-
-※注3：由于ARM处理器的内存模型与PowerPC处理器的内存模型非常类似，本文将忽略它。
-
-※注4：数据依赖性后文会专门说明。
-
-为了保证内存可见性，java编译器在生成指令序列的适当位置会插入内存屏障指令来禁止特定类型的处理器重排序。JMM把内存屏障指令分为下列四类：
-
-
-
-| 屏障类型 | 指令示例 | 说明 |
-| --- | --- | --- |
-| LoadLoad Barriers | Load1; LoadLoad; Load2 | 确保Load1数据的装载，之前于Load2及所有后续装载指令的装载。 |
-| StoreStore Barriers | Store1; StoreStore; Store2 | 确保Store1数据对其他处理器可见（刷新到内存），之前于Store2及所有后续存储指令的存储。 |
-| LoadStore Barriers | Load1; LoadStore; Store2 | 确保Load1数据装载，之前于Store2及所有后续的存储指令刷新到内存。 |
-| StoreLoad Barriers | Store1; StoreLoad; Load2 | 确保Store1数据对其他处理器变得可见（指刷新到内存），之前于Load2及所有后续装载指令的装载。StoreLoad Barriers会使该屏障之前的所有内存访问指令（存储和装载指令）完成之后，才执行该屏障之后的内存访问指令。 |
-
-
-
-StoreLoad Barriers是一个“全能型”的屏障，它同时具有其他三个屏障的效果。现代的多处理器大都支持该屏障（其他类型的屏障不一定被所有处理器支持）。执行该屏障开销会很昂贵，因为当前处理器通常要把写缓冲区中的数据全部刷新到内存中（buffer fully flush）。
-
-### happens-before
-
-从JDK5开始，java使用新的JSR -133内存模型（本文除非特别说明，针对的都是JSR- 133内存模型）。JSR-133提出了happens-before的概念，通过这个概念来阐述操作之间的内存可见性。如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须存在happens-before关系。这里提到的两个操作既可以是在一个线程之内，也可以是在不同线程之间。 与程序员密切相关的happens-before规则如下：
-
-*   程序顺序规则：一个线程中的每个操作，happens- before 于该线程中的任意后续操作。
-*   监视器锁规则：对一个监视器锁的解锁，happens- before 于随后对这个监视器锁的加锁。
-*   volatile变量规则：对一个volatile域的写，happens- before 于任意后续对这个volatile域的读。
-*   传递性：如果A happens- before B，且B happens- before C，那么A happens- before C。
-
-注意，两个操作之间具有happens-before关系，并不意味着前一个操作必须要在后一个操作之前执行！happens-before仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一个操作按顺序排在第二个操作之前（the first is visible to and ordered before the second）。happens- before的定义很微妙，后文会具体说明happens-before为什么要这么定义。
-
-happens-before与JMM的关系如下图所示：
-
-![](https://res.infoq.com/articles/java-memory-model-1/zh/resources/55.png)
-
-如上图所示，一个happens-before规则通常对应于多个编译器重排序规则和处理器重排序规则。对于java程序员来说，happens-before规则简单易懂，它避免程序员为了理解JMM提供的内存可见性保证而去学习复杂的重排序规则以及这些规则的具体实现。
-
-## 二：重排序与JMM的as-if-serial
-
-
-
-### 数据依赖性
-
-如果两个操作访问同一个变量，且这两个操作中有一个为写操作，此时这两个操作之间就存在数据依赖性。数据依赖分下列三种类型：
-
-
-
-| 名称 | 代码示例 | 说明 |
-| --- | --- | --- |
-| 写后读 | a = 1;b = a; | 写一个变量之后，再读这个位置。 |
-| 写后写 | a = 1;a = 2; | 写一个变量之后，再写这个变量。 |
-| 读后写 | a = b;b = 1; | 读一个变量之后，再写这个变量。 |
-
-
-
-上面三种情况，只要重排序两个操作的执行顺序，程序的执行结果将会被改变。
-
-注意，这里所说的数据依赖性仅针对单个处理器中执行的指令序列和单个线程中执行的操作，不同处理器之间和不同线程之间的数据依赖性不被编译器和处理器考虑。前面提到过，编译器和处理器可能会对操作做重排序。编译器和处理器在重排序时，会遵守数据依赖性，编译器和处理器不会改变存在数据依赖关系的两个操作的执行顺序。
-
-### as-if-serial语义
-
-as-if-serial语义的意思指：不管怎么重排序（编译器和处理器为了提高并行度），（单线程）程序的执行结果不能被改变。编译器，runtime 和处理器都必须遵守as-if-serial语义。
-
-为了遵守as-if-serial语义，编译器和处理器不会对存在数据依赖关系的操作做重排序，因为这种重排序会改变执行结果。但是，如果操作之间不存在数据依赖关系，这些操作可能被编译器和处理器重排序。为了具体说明，请看下面计算圆面积的代码示例：
-
- 
-    double pi = 3.14; //A
-     
-    double r = 1.0; //B
-     
-    double area = pi * r * r; //C
-
-    
-
-上面三个操作的数据依赖关系如下图所示：
-
-![](https://res.infoq.com/articles/java-memory-model-2/zh/resources/11.png)
-
-如上图所示，A和C之间存在数据依赖关系，同时B和C之间也存在数据依赖关系。因此在最终执行的指令序列中，C不能被重排序到A和B的前面（C排到A和B的前面，程序的结果将会被改变）。但A和B之间没有数据依赖关系，编译器和处理器可以重排序A和B之间的执行顺序。下图是该程序的两种执行顺序：
-
-![](https://res.infoq.com/articles/java-memory-model-2/zh/resources/22.png)
-
-as-if-serial语义把单线程程序保护了起来，遵守as-if-serial语义的编译器，runtime 和处理器共同为编写单线程程序的程序员创建了一个幻觉：单线程程序是按程序的顺序来执行的。as-if-serial语义使单线程程序员无需担心重排序会干扰他们，也无需担心内存可见性问题。
-
-### 程序顺序规则
-
-根据happens- before的程序顺序规则，上面计算圆的面积的示例代码存在三个happens- before关系：
-
-1.  A happens- before B；
-2.  B happens- before C；
-3.  A happens- before C；
-
-这里的第3个happens- before关系，是根据happens- before的传递性推导出来的。
-
-这里A happens- before B，但实际执行时B却可以排在A之前执行（看上面的重排序后的执行顺序）。在第一章提到过，如果A happens- before B，JMM并不要求A一定要在B之前执行。JMM仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一个操作按顺序排在第二个操作之前。这里操作A的执行结果不需要对操作B可见；而且重排序操作A和操作B后的执行结果，与操作A和操作B按happens- before顺序执行的结果一致。在这种情况下，JMM会认为这种重排序并不非法（not illegal），JMM允许这种重排序。
-
-在计算机中，软件技术和硬件技术有一个共同的目标：在不改变程序执行结果的前提下，尽可能的开发并行度。编译器和处理器遵从这一目标，从happens- before的定义我们可以看出，JMM同样遵从这一目标。
-
-### 重排序对多线程的影响
-
-现在让我们来看看，重排序是否会改变多线程程序的执行结果。请看下面的示例代码：
-
-
-    class ReorderExample {
-     
-    int a = 0;
-     
-    boolean flag = false;
-     
-     
-     
-    public void writer() {
-     
-    a = 1; //1
-     
-    flag = true; //2
-     
-    }
-     
-     
-     
-    Public void reader() {
-     
-    if (flag) { //3
-     
-    int i = a * a; //4
-     
-    ……
-     
-    }
-     
-    }
-     
-    }
-
-    
-
-flag变量是个标记，用来标识变量a是否已被写入。这里假设有两个线程A和B，A首先执行writer()方法，随后B线程接着执行reader()方法。线程B在执行操作4时，能否看到线程A在操作1对共享变量a的写入？
-
-答案是：不一定能看到。
-
-由于操作1和操作2没有数据依赖关系，编译器和处理器可以对这两个操作重排序；同样，操作3和操作4没有数据依赖关系，编译器和处理器也可以对这两个操作重排序。让我们先来看看，当操作1和操作2重排序时，可能会产生什么效果？请看下面的程序执行时序图：
-
-![](https://res.infoq.com/articles/java-memory-model-2/zh/resources/33.png)
-
-如上图所示，操作1和操作2做了重排序。程序执行时，线程A首先写标记变量flag，随后线程B读这个变量。由于条件判断为真，线程B将读取变量a。此时，变量a还根本没有被线程A写入，在这里多线程程序的语义被重排序破坏了！
-
-※注：本文统一用红色的虚箭线表示错误的读操作，用绿色的虚箭线表示正确的读操作。
-
-下面再让我们看看，当操作3和操作4重排序时会产生什么效果（借助这个重排序，可以顺便说明控制依赖性）。下面是操作3和操作4重排序后，程序的执行时序图：
-
-![](https://res.infoq.com/articles/java-memory-model-2/zh/resources/44.png)
-
-在程序中，操作3和操作4存在控制依赖关系。当代码中存在控制依赖性时，会影响指令序列执行的并行度。为此，编译器和处理器会采用猜测（Speculation）执行来克服控制相关性对并行度的影响。以处理器的猜测执行为例，执行线程B的处理器可以提前读取并计算a*a，然后把计算结果临时保存到一个名为重排序缓冲（reorder buffer ROB）的硬件缓存中。当接下来操作3的条件判断为真时，就把该计算结果写入变量i中。
-
-从图中我们可以看出，猜测执行实质上对操作3和4做了重排序。重排序在这里破坏了多线程程序的语义！
-
-在单线程程序中，对存在控制依赖的操作重排序，不会改变执行结果（这也是as-if-serial语义允许对存在控制依赖的操作做重排序的原因）；但在多线程程序中，对存在控制依赖的操作重排序，可能会改变程序的执行结果。
-
-## 三：顺序一致性内存模型与JMM
-
-### 数据竞争与顺序一致性保证
-
-当程序未正确同步时，就会存在数据竞争。java内存模型规范对数据竞争的定义如下：
-
-*   在一个线程中写一个变量，
-*   在另一个线程读同一个变量，
-*   而且写和读没有通过同步来排序。
-
-当代码中包含数据竞争时，程序的执行往往产生违反直觉的结果（前一章的示例正是如此）。如果一个多线程程序能正确同步，这个程序将是一个没有数据竞争的程序。
-
-JMM对正确同步的多线程程序的内存一致性做了如下保证：
-
-*   如果程序是正确同步的，程序的执行将具有顺序一致性（sequentially consistent）--即程序的执行结果与该程序在顺序一致性内存模型中的执行结果相同（马上我们将会看到，这对于程序员来说是一个极强的保证）。这里的同步是指广义上的同步，包括对常用同步原语（lock，volatile和final）的正确使用。
-
-### 顺序一致性内存模型
-
-顺序一致性内存模型是一个被计算机科学家理想化了的理论参考模型，它为程序员提供了极强的内存可见性保证。顺序一致性内存模型有两大特性：
-
-*   一个线程中的所有操作必须按照程序的顺序来执行。
-*   （不管程序是否同步）所有线程都只能看到一个单一的操作执行顺序。在顺序一致性内存模型中，每个操作都必须原子执行且立刻对所有线程可见。
-
-顺序一致性内存模型为程序员提供的视图如下：
-
-![](https://res.infoq.com/articles/java-memory-model-3/zh/resources/1.png)
-
-在概念上，顺序一致性模型有一个单一的全局内存，这个内存通过一个左右摆动的开关可以连接到任意一个线程。同时，每一个线程必须按程序的顺序来执行内存读/写操作。从上图我们可以看出，在任意时间点最多只能有一个线程可以连接到内存。当多个线程并发执行时，图中的开关装置能把所有线程的所有内存读/写操作串行化。
-
-为了更好的理解，下面我们通过两个示意图来对顺序一致性模型的特性做进一步的说明。
-
-假设有两个线程A和B并发执行。其中A线程有三个操作，它们在程序中的顺序是：A1->A2->A3。B线程也有三个操作，它们在程序中的顺序是：B1->B2->B3。
-
-假设这两个线程使用监视器来正确同步：A线程的三个操作执行后释放监视器，随后B线程获取同一个监视器。那么程序在顺序一致性模型中的执行效果将如下图所示：
-
-![](https://res.infoq.com/articles/java-memory-model-3/zh/resources/2.png)
-
-现在我们再假设这两个线程没有做同步，下面是这个未同步程序在顺序一致性模型中的执行示意图：
-
-![](https://res.infoq.com/articles/java-memory-model-3/zh/resources/3.png)
-
-未同步程序在顺序一致性模型中虽然整体执行顺序是无序的，但所有线程都只能看到一个一致的整体执行顺序。以上图为例，线程A和B看到的执行顺序都是：B1->A1->A2->B2->A3->B3。之所以能得到这个保证是因为顺序一致性内存模型中的每个操作必须立即对任意线程可见。
-
-但是，在JMM中就没有这个保证。未同步程序在JMM中不但整体的执行顺序是无序的，而且所有线程看到的操作执行顺序也可能不一致。比如，在当前线程把写过的数据缓存在本地内存中，且还没有刷新到主内存之前，这个写操作仅对当前线程可见；从其他线程的角度来观察，会认为这个写操作根本还没有被当前线程执行。只有当前线程把本地内存中写过的数据刷新到主内存之后，这个写操作才能对其他线程可见。在这种情况下，当前线程和其它线程看到的操作执行顺序将不一致。
-
-### 同步程序的顺序一致性效果
-
-下面我们对前面的示例程序ReorderExample用监视器来同步，看看正确同步的程序如何具有顺序一致性。
-
-请看下面的示例代码：
-    
-    
-    class SynchronizedExample {
-     
-    int a = 0;
-     
-    boolean flag = false;
-     
-     
-     
-    public synchronized void writer() {
-     
-    a = 1;
-     
-    flag = true;
-     
-    }
-     
-     
-     
-    public synchronized void reader() {
-     
-    if (flag) {
-     
-    int i = a;
-     
-    ……
-     
-    }
-     
-    }
-     
-    }
-
-上面示例代码中，假设A线程执行writer()方法后，B线程执行reader()方法。这是一个正确同步的多线程程序。根据JMM规范，该程序的执行结果将与该程序在顺序一致性模型中的执行结果相同。下面是该程序在两个内存模型中的执行时序对比图：
-
-![](https://res.infoq.com/articles/java-memory-model-3/zh/resources/4.png)
-
-在顺序一致性模型中，所有操作完全按程序的顺序串行执行。而在JMM中，临界区内的代码可以重排序（但JMM不允许临界区内的代码“逸出”到临界区之外，那样会破坏监视器的语义）。JMM会在退出监视器和进入监视器这两个关键时间点做一些特别处理，使得线程在这两个时间点具有与顺序一致性模型相同的内存视图（具体细节后文会说明）。虽然线程A在临界区内做了重排序，但由于监视器的互斥执行的特性，这里的线程B根本无法“观察”到线程A在临界区内的重排序。这种重排序既提高了执行效率，又没有改变程序的执行结果。
-
-从这里我们可以看到JMM在具体实现上的基本方针：在不改变（正确同步的）程序执行结果的前提下，尽可能的为编译器和处理器的优化打开方便之门。
-
-### 未同步程序的执行特性
-
-对于未同步或未正确同步的多线程程序，JMM只提供最小安全性：线程执行时读取到的值，要么是之前某个线程写入的值，要么是默认值（0，null，false），JMM保证线程读操作读取到的值不会无中生有（out of thin air）的冒出来。为了实现最小安全性，JVM在堆上分配对象时，首先会清零内存空间，然后才会在上面分配对象（JVM内部会同步这两个操作）。因此，在以清零的内存空间（pre-zeroed memory）分配对象时，域的默认初始化已经完成了。
-
-JMM不保证未同步程序的执行结果与该程序在顺序一致性模型中的执行结果一致。因为未同步程序在顺序一致性模型中执行时，整体上是无序的，其执行结果无法预知。保证未同步程序在两个模型中的执行结果一致毫无意义。
-
-和顺序一致性模型一样，未同步程序在JMM中的执行时，整体上也是无序的，其执行结果也无法预知。同时，未同步程序在这两个模型中的执行特性有下面几个差异：
-
-1.  顺序一致性模型保证单线程内的操作会按程序的顺序执行，而JMM不保证单线程内的操作会按程序的顺序执行（比如上面正确同步的多线程程序在临界区内的重排序）。这一点前面已经讲过了，这里就不再赘述。
-2.  顺序一致性模型保证所有线程只能看到一致的操作执行顺序，而JMM不保证所有线程能看到一致的操作执行顺序。这一点前面也已经讲过，这里就不再赘述。
-3.  JMM不保证对64位的long型和double型变量的读/写操作具有原子性，而顺序一致性模型保证对所有的内存读/写操作都具有原子性。
-
-第3个差异与处理器总线的工作机制密切相关。在计算机中，数据通过总线在处理器和内存之间传递。每次处理器和内存之间的数据传递都是通过一系列步骤来完成的，这一系列步骤称之为总线事务（bus transaction）。总线事务包括读事务（read transaction）和写事务（write transaction）。读事务从内存传送数据到处理器，写事务从处理器传送数据到内存，每个事务会读/写内存中一个或多个物理上连续的字。这里的关键是，总线会同步试图并发使用总线的事务。在一个处理器执行总线事务期间，总线会禁止其它所有的处理器和I/O设备执行内存的读/写。下面让我们通过一个示意图来说明总线的工作机制：
-
-![](https://res.infoq.com/articles/java-memory-model-3/zh/resources/5.png)
-
-如上图所示，假设处理器A，B和C同时向总线发起总线事务，这时总线仲裁（bus arbitration）会对竞争作出裁决，这里我们假设总线在仲裁后判定处理器A在竞争中获胜（总线仲裁会确保所有处理器都能公平的访问内存）。此时处理器A继续它的总线事务，而其它两个处理器则要等待处理器A的总线事务完成后才能开始再次执行内存访问。假设在处理器A执行总线事务期间（不管这个总线事务是读事务还是写事务），处理器D向总线发起了总线事务，此时处理器D的这个请求会被总线禁止。
-
-总线的这些工作机制可以把所有处理器对内存的访问以串行化的方式来执行；在任意时间点，最多只能有一个处理器能访问内存。这个特性确保了单个总线事务之中的内存读/写操作具有原子性。
-
-在一些32位的处理器上，如果要求对64位数据的读/写操作具有原子性，会有比较大的开销。为了照顾这种处理器，java语言规范鼓励但不强求JVM对64位的long型变量和double型变量的读/写具有原子性。当JVM在这种处理器上运行时，会把一个64位long/ double型变量的读/写操作拆分为两个32位的读/写操作来执行。这两个32位的读/写操作可能会被分配到不同的总线事务中执行，此时对这个64位变量的读/写将不具有原子性。
-
-当单个内存操作不具有原子性，将可能会产生意想不到后果。请看下面示意图：
-
-![](https://res.infoq.com/articles/java-memory-model-3/zh/resources/6.png)
-
-如上图所示，假设处理器A写一个long型变量，同时处理器B要读这个long型变量。处理器A中64位的写操作被拆分为两个32位的写操作，且
-
-这两个32位的写操作被分配到不同的写事务中执行。同时处理器B中64位的读操作被拆分为两个32位的读操作，且这两个32位的读操作被分配到同一个的读事务中执行。当处理器A和B按上图的时序来执行时，处理器B将看到仅仅被处理器A“写了一半“的无效值。
diff --git "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2275\357\274\232JMM\344\270\255\347\232\204final\345\205\263\351\224\256\345\255\227\350\247\243\346\236\220.md" "b/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2275\357\274\232JMM\344\270\255\347\232\204final\345\205\263\351\224\256\345\255\227\350\247\243\346\236\220.md"
deleted file mode 100644
index 6d56e6e..0000000
--- "a/docs/java/currency/Java\345\271\266\345\217\221\346\214\207\345\215\2275\357\274\232JMM\344\270\255\347\232\204final\345\205\263\351\224\256\345\255\227\350\247\243\346\236\220.md"
+++ /dev/null
@@ -1,217 +0,0 @@
-# Table of Contents
-
-  * [前言](#前言)
-  * [写final域的重排序规则](#写final域的重排序规则)
-  * [读final域的重排序规则](#读final域的重排序规则)
-  * [如果final域是引用类型](#如果final域是引用类型)
-  * [为什么final引用不能从构造函数内“逸出”](#为什么final引用不能从构造函数内逸出)
-  * [final语义在处理器中的实现](#final语义在处理器中的实现)
-  * [JSR-133为什么要增强final的语义](#jsr-133为什么要增强final的语义)
-  * [参考文献](#参考文献)
-
-
-**本文转载自互联网，侵删**
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-文章首发于我的个人博客：
-> www.how2playlife.com
-
-本文是微信公众号【Java技术江湖】的《Java并发指南》其中一篇，本文大部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何全面深入地学习Java并发技术，从Java多线程基础，再到并发编程的基础知识，从Java并发包的入门和实战，再到JUC的源码剖析，一步步地学习Java并发编程，并上手进行实战，以便让你更完整地了解整个Java并发编程知识体系，形成自己的知识框架。
-
-为了更好地总结和检验你的学习成果，本系列文章也会提供一些对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-## 前言
-
-与前面介绍的锁和volatile相比较，对final域的读和写更像是普通的变量访问。对于final域，编译器和处理器要遵守两个重排序规则：
-
-1.  在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用变量，这两个操作之间不能重排序。
-2.  初次读一个包含final域的对象的引用，与随后初次读这个final域，这两个操作之间不能重排序。
-
-下面，我们通过一些示例性的代码来分别说明这两个规则：
-
-
-
-```
-public class FinalExample {
-    int i;                            //普通变量
-    final int j;                      //final变量
-    static FinalExample obj;
-
-    public void FinalExample () {     //构造函数
-        i = 1;                        //写普通域
-        j = 2;                        //写final域
-    }
-
-    public static void writer () {    //写线程A执行
-        obj = new FinalExample ();
-    }
-
-    public static void reader () {       //读线程B执行
-        FinalExample object = obj;       //读对象引用
-        int a = object.i;                //读普通域
-        int b = object.j;                //读final域
-    }
-}
-
-```
-
-![](data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw== "点击并拖拽以移动")
-
-这里假设一个线程A执行writer ()方法，随后另一个线程B执行reader ()方法。下面我们通过这两个线程的交互来说明这两个规则。
-
-## 写final域的重排序规则
-
-写final域的重排序规则禁止把final域的写重排序到构造函数之外。这个规则的实现包含下面2个方面：
-
-*   JMM禁止编译器把final域的写重排序到构造函数之外。
-*   编译器会在final域的写之后，构造函数return之前，插入一个StoreStore屏障。这个屏障禁止处理器把final域的写重排序到构造函数之外。
-
-现在让我们分析writer ()方法。writer ()方法只包含一行代码：finalExample = new FinalExample ()。这行代码包含两个步骤：
-
-1.  构造一个FinalExample类型的对象；
-2.  把这个对象的引用赋值给引用变量obj。
-
-假设线程B读对象引用与读对象的成员域之间没有重排序（马上会说明为什么需要这个假设），下图是一种可能的执行时序：
-
-在上图中，写普通域的操作被编译器重排序到了构造函数之外，读线程B错误的读取了普通变量i初始化之前的值。而写final域的操作，被写final域的重排序规则“限定”在了构造函数之内，读线程B正确的读取了final变量初始化之后的值。
-
-写final域的重排序规则可以确保：在对象引用为任意线程可见之前，对象的final域已经被正确初始化过了，而普通域不具有这个保障。以上图为例，在读线程B“看到”对象引用obj时，很可能obj对象还没有构造完成（对普通域i的写操作被重排序到构造函数外，此时初始值2还没有写入普通域i）。
-
-## 读final域的重排序规则
-
-读final域的重排序规则如下：
-
-*   在一个线程中，初次读对象引用与初次读该对象包含的final域，JMM禁止处理器重排序这两个操作（注意，这个规则仅仅针对处理器）。编译器会在读final域操作的前面插入一个LoadLoad屏障。
-
-初次读对象引用与初次读该对象包含的final域，这两个操作之间存在间接依赖关系。由于编译器遵守间接依赖关系，因此编译器不会重排序这两个操作。大多数处理器也会遵守间接依赖，大多数处理器也不会重排序这两个操作。但有少数处理器允许对存在间接依赖关系的操作做重排序（比如alpha处理器），这个规则就是专门用来针对这种处理器。
-
-reader()方法包含三个操作：
-
-1.  初次读引用变量obj;
-2.  初次读引用变量obj指向对象的普通域j。
-3.  初次读引用变量obj指向对象的final域i。
-
-现在我们假设写线程A没有发生任何重排序，同时程序在不遵守间接依赖的处理器上执行，下面是一种可能的执行时序：
-
-在上图中，读对象的普通域的操作被处理器重排序到读对象引用之前。读普通域时，该域还没有被写线程A写入，这是一个错误的读取操作。而读final域的重排序规则会把读对象final域的操作“限定”在读对象引用之后，此时该final域已经被A线程初始化过了，这是一个正确的读取操作。
-
-读final域的重排序规则可以确保：在读一个对象的final域之前，一定会先读包含这个final域的对象的引用。在这个示例程序中，如果该引用不为null，那么引用对象的final域一定已经被A线程初始化过了。
-
-## 如果final域是引用类型
-
-上面我们看到的final域是基础数据类型，下面让我们看看如果final域是引用类型，将会有什么效果？
-
-请看下列示例代码：
-
-
-
-```
-public class FinalReferenceExample {
-final int[] intArray;                     //final是引用类型
-static FinalReferenceExample obj;
-
-public FinalReferenceExample () {        //构造函数
-    intArray = new int[1];              //1
-    intArray[0] = 1;                   //2
-}
-
-public static void writerOne () {          //写线程A执行
-    obj = new FinalReferenceExample ();  //3
-}
-
-public static void writerTwo () {          //写线程B执行
-    obj.intArray[0] = 2;                 //4
-}
-
-public static void reader () {              //读线程C执行
-    if (obj != null) {                    //5
-        int temp1 = obj.intArray[0];       //6
-    }
-}
-}
-
-```
-
-![](data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw== "点击并拖拽以移动")
-
-这里final域为一个引用类型，它引用一个int型的数组对象。对于引用类型，写final域的重排序规则对编译器和处理器增加了如下约束：
-
-1.  在构造函数内对一个final引用的对象的成员域的写入，与随后在构造函数外把这个被构造对象的引用赋值给一个引用变量，这两个操作之间不能重排序。
-
-对上面的示例程序，我们假设首先线程A执行writerOne()方法，执行完后线程B执行writerTwo()方法，执行完后线程C执行reader ()方法。下面是一种可能的线程执行时序：
-
-在上图中，1是对final域的写入，2是对这个final域引用的对象的成员域的写入，3是把被构造的对象的引用赋值给某个引用变量。这里除了前面提到的1不能和3重排序外，2和3也不能重排序。
-
-JMM可以确保读线程C至少能看到写线程A在构造函数中对final引用对象的成员域的写入。即C至少能看到数组下标0的值为1。而写线程B对数组元素的写入，读线程C可能看的到，也可能看不到。JMM不保证线程B的写入对读线程C可见，因为写线程B和读线程C之间存在数据竞争，此时的执行结果不可预知。
-
-如果想要确保读线程C看到写线程B对数组元素的写入，写线程B和读线程C之间需要使用同步原语（lock或volatile）来确保内存可见性。
-
-## 为什么final引用不能从构造函数内“逸出”
-
-前面我们提到过，写final域的重排序规则可以确保：在引用变量为任意线程可见之前，该引用变量指向的对象的final域已经在构造函数中被正确初始化过了。其实要得到这个效果，还需要一个保证：在构造函数内部，不能让这个被构造对象的引用为其他线程可见，也就是对象引用不能在构造函数中“逸出”。为了说明问题，让我们来看下面示例代码：
-
-
-
-```
-public class FinalReferenceEscapeExample {
-final int i;
-static FinalReferenceEscapeExample obj;
-
-public FinalReferenceEscapeExample () {
-    i = 1;                              //1写final域
-    obj = this;                          //2 this引用在此“逸出”
-}
-
-public static void writer() {
-    new FinalReferenceEscapeExample ();
-}
-
-public static void reader {
-    if (obj != null) {                     //3
-        int temp = obj.i;                 //4
-    }
-}
-}
-
-```
-
-![](data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw== "点击并拖拽以移动")
-
-假设一个线程A执行writer()方法，另一个线程B执行reader()方法。这里的操作2使得对象还未完成构造前就为线程B可见。即使这里的操作2是构造函数的最后一步，且即使在程序中操作2排在操作1后面，执行read()方法的线程仍然可能无法看到final域被初始化后的值，因为这里的操作1和操作2之间可能被重排序。实际的执行时序可能如下图所示：
-
-从上图我们可以看出：在构造函数返回前，被构造对象的引用不能为其他线程可见，因为此时的final域可能还没有被初始化。在构造函数返回后，任意线程都将保证能看到final域正确初始化之后的值。
-
-## final语义在处理器中的实现
-
-现在我们以x86处理器为例，说明final语义在处理器中的具体实现。
-
-上面我们提到，写final域的重排序规则会要求译编器在final域的写之后，构造函数return之前，插入一个StoreStore障屏。读final域的重排序规则要求编译器在读final域的操作前面插入一个LoadLoad屏障。
-
-由于x86处理器不会对写-写操作做重排序，所以在x86处理器中，写final域需要的StoreStore障屏会被省略掉。同样，由于x86处理器不会对存在间接依赖关系的操作做重排序，所以在x86处理器中，读final域需要的LoadLoad屏障也会被省略掉。也就是说在x86处理器中，final域的读/写不会插入任何内存屏障！
-
-## JSR-133为什么要增强final的语义
-
-在旧的Java内存模型中 ，最严重的一个缺陷就是线程可能看到final域的值会改变。比如，一个线程当前看到一个整形final域的值为0（还未初始化之前的默认值），过一段时间之后这个线程再去读这个final域的值时，却发现值变为了1（被某个线程初始化之后的值）。最常见的例子就是在旧的Java内存模型中，String的值可能会改变（参考文献2中有一个具体的例子，感兴趣的读者可以自行参考，这里就不赘述了）。
-
-为了修补这个漏洞，JSR-133专家组增强了final的语义。通过为final域增加写和读重排序规则，可以为java程序员提供初始化安全保证：只要对象是正确构造的（被构造对象的引用在构造函数中没有“逸出”），那么不需要使用同步（指lock和volatile的使用），就可以保证任意线程都能看到这个final域在构造函数中被初始化之后的值。
-
-## 参考文献
-
-1.  [ Java Concurrency in Practice](http://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601/ref=pd_sim_b_1)
-
-2.  [ JSR 133 (Java Memory Model) FAQ](http://www.cs.umd.edu/users/pugh/java/memoryModel/jsr-133-faq.html)
-
-3.  [ Java Concurrency in Practice](http://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601/ref=pd_sim_b_1)
-
-4.  [ The JSR-133 Cookbook for Compiler Writers](http://gee.cs.oswego.edu/dl/jmm/cookbook.html)
-
-[Intel® 64 and IA-32 ArchitecturesvSoftware Developer’s Manual Volume 3A: System Programming Guide, Part 1](http://download.intel.com/products/processor/manual/253668.pdf)
diff --git "a/docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2174\357\274\232JDK\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2174\357\274\232JDK\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md"
deleted file mode 100644
index 65b241a..0000000
--- "a/docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2174\357\274\232JDK\344\270\255\347\232\204\350\256\276\350\256\241\346\250\241\345\274\217.md"
+++ /dev/null
@@ -1,955 +0,0 @@
-# Table of Contents
-
-  * [设计模式是什么](#设计模式是什么)
-  * [学习JDK中设计模式的好处](#学习jdk中设计模式的好处)
-  * [类间关系](#类间关系)
-  * [介绍方式](#介绍方式)
-  * [经典设计模式在JDK中的体现](#经典设计模式在jdk中的体现)
-    * [静态工厂](#静态工厂)
-    * [工厂方法](#工厂方法)
-    * [建造者模式](#建造者模式)
-    * [原型模型](#原型模型)
-    * [适配器模式](#适配器模式)
-    * [桥接模式](#桥接模式)
-    * [组合模式](#组合模式)
-    * [装饰者模式](#装饰者模式)
-    * [外观模式](#外观模式)
-    * [享元模式](#享元模式)
-    * [代理模式](#代理模式)
-    * [迭代器模式](#迭代器模式)
-    * [观察者模式](#观察者模式)
-    * [模板方法模式](#模板方法模式)
-    * [策略模式](#策略模式)
-    * [责任链模式](#责任链模式)
-    * [命令模式](#命令模式)
-    * [状态模式](#状态模式)
-  * [结构型模式](#结构型模式)
-    * [代理模式](#代理模式-1)
-    * [适配器模式](#适配器模式-1)
-    * [桥梁模式](#桥梁模式)
-    * [装饰模式](#装饰模式)
-    * [门面模式](#门面模式)
-    * [组合模式](#组合模式-1)
-    * [享元模式](#享元模式-1)
-    * [结构型模式总结](#结构型模式总结)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-
-
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star、fork哈
-
-文章也将发表在我的个人博客，阅读体验更佳：
-
-> www.how2playlife.com
-
-本文主要是归纳了JDK中所包含的设计模式，包括作用和其设计类图。
-首先来个总结，具体的某个模式可以一个一个慢慢写，希望能对研究JDK和设计模式有所帮助。
-
-## 设计模式是什么
-（1）反复出现问题的解决方案
-（2）增强软件的灵活性
-（3）适应软件不断变化
-
-## 学习JDK中设计模式的好处
-（1）借鉴优秀代码的设计，有助于提高代码设计能力
-（2）JDK的设计中体现了大多数设计模式，是学习设计模式的较好的方式
-（3）可以更加深入的了解JDK
-
-## 类间关系
-继承、委托、依赖、聚合、组合
-![](http://hi.csdn.net/attachment/201101/3/0_1294058465rSf1.gif)
-## 介绍方式
-（1）作用：归纳某设计模式的基本要点
-（2）JDK中体现：某设计模式在JDK中是怎样体现出来的
-（3）类图：某设计模式在JDK中所对应的类图
-
-## 经典设计模式在JDK中的体现
-
-**1.Singleton（单例）** 
-作用：保证类只有一个实例；提供一个全局访问点
-JDK中体现：
-（1）Runtime
-（2）NumberFormat
-类图：
-![](http://hi.csdn.net/attachment/201101/3/0_1294058629PD9z.gif)
-
-### 静态工厂
-    作用：
-    （1）代替构造函数创建对象
-    （2）方法名比构造函数清晰
-    JDK中体现：
-    （1）Integer.valueOf
-    （2）Class.forName
-类图：
-![](http://hi.csdn.net/attachment/201101/3/0_1294058705f0y7.gif)
-
-### 工厂方法
-
-    作用：子类决定哪一个类实例化
-    JDK中体现：Collection.iterator方法
-类图：
-![](http://hi.csdn.net/attachment/201101/3/0_129405877799Eh.gif)
-
-### 建造者模式
-    作用：
-    （1）将构造逻辑提到单独的类中
-    （2）分离类的构造逻辑和表现
-    JDK中体现：DocumentBuilder(org.w3c.dom)
-类图：
-
-![](http://hi.csdn.net/attachment/201101/3/0_1294058900z0nk.gif)
-
-### 原型模型
-作用：
-（1）复制对象
-（2）浅复制、深复制
-JDK中体现：Object.clone；Cloneable
-类图：
-
-![](http://hi.csdn.net/attachment/201101/3/0_1294058951u556.gif)
-
-### 适配器模式
-    作用：使不兼容的接口相容
-    JDK中体现：
-    （1）java.io.InputStreamReader(InputStream)
-    （2）java.io.OutputStreamWriter(OutputStream)
-类图：
-![](http://hi.csdn.net/attachment/201101/3/0_1294058999cvJS.gif)
-
-### 桥接模式
-    作用：将抽象部分与其实现部分分离，使它们都可以独立地变化
-    JDK中体现：java.util.logging中的Handler和Formatter
-类图： 
-![](http://hi.csdn.net/attachment/201101/3/0_1294059065CHyJ.gif)
-
-### 组合模式
-
-    作用：一致地对待组合对象和独立对象
-        JDK中体现：
-        （1）org.w3c.dom
-        （2）javax.swing.JComponent#add(Component)
-类图：
-![](http://hi.csdn.net/attachment/201101/3/0_12940591438tt5.gif)
-
-### 装饰者模式
-
-    作用：为类添加新的功能；防止类继承带来的爆炸式增长
-    JDK中体现：
-    （1）java.io包
-    （2）java.util.Collections#synchronizedList(List)
-类图：
-![](http://hi.csdn.net/attachment/201101/3/0_1294059189Z6z9.gif)
-
-### 外观模式
-    作用：
-    （1）封装一组交互类，一致地对外提供接口
-    （2）封装子系统，简化子系统调用
-    JDK中体现：java.util.logging包
-    
-类图：
-![](http://hi.csdn.net/attachment/201101/3/0_1294059242iBI6.gif)
-
-### 享元模式
-    
-    作用：共享对象，节省内存
-    JDK中体现：
-    （1）Integer.valueOf(int i)；Character.valueOf(char c)
-    （2）String常量池
-类图：
-**![](http://hi.csdn.net/attachment/201101/3/0_1294059313R7gf.gif)
-### 代理模式
-
-    作用：
-    （1）透明调用被代理对象，无须知道复杂实现细节
-    （2）增加被代理类的功能
-    JDK中体现：动态代理；RMI
-类图：
-**![](http://hi.csdn.net/attachment/201101/3/0_1294059364KAKJ.gif)
-### 迭代器模式
-    
-    作用：将集合的迭代和集合本身分离
-    JDK中体现：Iterator、Enumeration接口
-    
-类图：
-![](http://hi.csdn.net/attachment/201101/3/0_1294059440PtTX.gif)
-
-### 观察者模式
-    作用：通知对象状态改变
-    JDK中体现：
-    （1）java.util.Observer,Observable
-    （2）Swing中的Listener
-类图：
-**![](http://hi.csdn.net/attachment/201101/3/0_12940594862KCk.gif) 
-
-### 模板方法模式
-
-    作用：定义算法的结构，子类只实现不同的部分
-    JDK中体现：ThreadPoolExecutor.Worker
-类图：
-![](http://hi.csdn.net/attachment/201101/3/0_129405958555W9.gif)
-### 策略模式
-
-    作用：提供不同的算法
-    JDK中的体现：ThreadPoolExecutor中的四种拒绝策略
-类图：
-![](http://hi.csdn.net/attachment/201101/3/0_1294059635WZ13.gif)
-
-### 责任链模式
-    作用：请求会被链上的对象处理，但是客户端不知道请求会被哪些对象处理
-    JDK中体现：
-    （1）java.util.logging.Logger会将log委托给parent logger
-    （2）ClassLoader的委托模型
-类图：
-![](http://hi.csdn.net/attachment/201101/3/0_12940596873g03.gif)
-
-### 命令模式
-
-    作用：
-    （1）封装操作，使接口一致
-    （2）将调用者和接收者在空间和时间上解耦合
-    JDK中体现：Runnable；Callable；ThreadPoolExecutor
-    
-类图：
-![](http://hi.csdn.net/attachment/201101/3/0_1294059739iKYQ.gif) 
-
-### 状态模式
-
-    作用：将主对象和其状态分离，状态对象负责主对象的状态转换，使主对象类功能减轻
-    JDK中体现：未发现
-类图：
-![](http://hi.csdn.net/attachment/201101/3/0_1294059912fL5S.gif) 
-
-
-六、参考文献
-
-> 1\. Design Pattern（GoF）
-
-> 2\. Software Architecture Design Patterns in Java
-
-> 3\. JDK 5 Documentation
-
-> 4\. http://stackoverflow.com/questions/1673841/examples-of-gof-design-patterns
-
-> 5\. http://java.csdn.net/a/20101129/282644.html**
-
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star、fork哈
-
-文章也将发表在我的个人博客，阅读体验更佳：
-
-> www.how2playlife.com
-
-## 结构型模式
-
-前面创建型模式介绍了创建对象的一些设计模式，这节介绍的结构型模式旨在通过改变代码结构来达到解耦的目的，使得我们的代码容易维护和扩展。
-
-### 代理模式
-
-第一个要介绍的代理模式是最常使用的模式之一了，用一个代理来隐藏具体实现类的实现细节，通常还用于在真实的实现的前后添加一部分逻辑。
-
-既然说是**代理**，那就要对客户端隐藏真实实现，由代理来负责客户端的所有请求。当然，代理只是个代理，它不会完成实际的业务逻辑，而是一层皮而已，但是对于客户端来说，它必须表现得就是客户端需要的真实实现。
-
-> 理解**代理**这个词，这个模式其实就简单了。
-
-```
-public interface FoodService {
-    Food makeChicken();
-    Food makeNoodle();
-}
-
-public class FoodServiceImpl implements FoodService {
-    public Food makeChicken() {
-          Food f = new Chicken()
-        f.setChicken("1kg");
-          f.setSpicy("1g");
-          f.setSalt("3g");
-        return f;
-    }
-    public Food makeNoodle() {
-        Food f = new Noodle();
-        f.setNoodle("500g");
-        f.setSalt("5g");
-        return f;
-    }
-}
-
-// 代理要表现得“就像是”真实实现类，所以需要实现 FoodService
-public class FoodServiceProxy implements FoodService {
-
-    // 内部一定要有一个真实的实现类，当然也可以通过构造方法注入
-    private FoodService foodService = new FoodServiceImpl();
-
-    public Food makeChicken() {
-        System.out.println("我们马上要开始制作鸡肉了");
-
-        // 如果我们定义这句为核心代码的话，那么，核心代码是真实实现类做的，
-        // 代理只是在核心代码前后做些“无足轻重”的事情
-        Food food = foodService.makeChicken();
-
-        System.out.println("鸡肉制作完成啦，加点胡椒粉"); // 增强
-          food.addCondiment("pepper");
-
-        return food;
-    }
-    public Food makeNoodle() {
-        System.out.println("准备制作拉面~");
-        Food food = foodService.makeNoodle();
-        System.out.println("制作完成啦")
-        return food;
-    }
-}
-
-```
-
-客户端调用，注意，我们要用代理来实例化接口：
-
-```
-// 这里用代理类来实例化
-FoodService foodService = new FoodServiceProxy();
-foodService.makeChicken();
-
-```
-
-![](https://javadoop.com/blogimages/design-pattern/proxy-1.png)
-我们发现没有，代理模式说白了就是做 **“方法包装”** 或做 **“方法增强”**。在面向切面编程中，算了还是不要吹捧这个名词了，在 AOP 中，其实就是动态代理的过程。比如 Spring 中，我们自己不定义代理类，但是 Spring 会帮我们动态来定义代理，然后把我们定义在 @Before、@After、@Around 中的代码逻辑动态添加到代理中。
-
-说到动态代理，又可以展开说 …… Spring 中实现动态代理有两种，一种是如果我们的类定义了接口，如 UserService 接口和 UserServiceImpl 实现，那么采用 JDK 的动态代理，感兴趣的读者可以去看看 java.lang.reflect.Proxy 类的源码；另一种是我们自己没有定义接口的，Spring 会采用 CGLIB 进行动态代理，它是一个 jar 包，性能还不错。
-
-### 适配器模式
-
-说完代理模式，说适配器模式，是因为它们很相似，这里可以做个比较。
-
-适配器模式做的就是，有一个接口需要实现，但是我们现成的对象都不满足，需要加一层适配器来进行适配。
-
-适配器模式总体来说分三种：默认适配器模式、对象适配器模式、类适配器模式。先不急着分清楚这几个，先看看例子再说。
-
-默认适配器模式
-
-首先，我们先看看最简单的适配器模式**默认适配器模式(Default Adapter)**是怎么样的。
-
-我们用 Appache commons-io 包中的 FileAlterationListener 做例子，此接口定义了很多的方法，用于对文件或文件夹进行监控，一旦发生了对应的操作，就会触发相应的方法。
-
-```
-public interface FileAlterationListener {
-    void onStart(final FileAlterationObserver observer);
-    void onDirectoryCreate(final File directory);
-    void onDirectoryChange(final File directory);
-    void onDirectoryDelete(final File directory);
-    void onFileCreate(final File file);
-    void onFileChange(final File file);
-    void onFileDelete(final File file);
-    void onStop(final FileAlterationObserver observer);
-}
-
-```
-
-此接口的一大问题是抽象方法太多了，如果我们要用这个接口，意味着我们要实现每一个抽象方法，如果我们只是想要监控文件夹中的**文件创建**和**文件删除**事件，可是我们还是不得不实现所有的方法，很明显，这不是我们想要的。
-
-所以，我们需要下面的一个**适配器**，它用于实现上面的接口，但是**所有的方法都是空方法**，这样，我们就可以转而定义自己的类来继承下面这个类即可。
-
-```
-public class FileAlterationListenerAdaptor implements FileAlterationListener {
-
-    public void onStart(final FileAlterationObserver observer) {
-    }
-
-    public void onDirectoryCreate(final File directory) {
-    }
-
-    public void onDirectoryChange(final File directory) {
-    }
-
-    public void onDirectoryDelete(final File directory) {
-    }
-
-    public void onFileCreate(final File file) {
-    }
-
-    public void onFileChange(final File file) {
-    }
-
-    public void onFileDelete(final File file) {
-    }
-
-    public void onStop(final FileAlterationObserver observer) {
-    }
-}
-
-```
-
-比如我们可以定义以下类，我们仅仅需要实现我们想实现的方法就可以了：
-
-```
-public class FileMonitor extends FileAlterationListenerAdaptor {
-    public void onFileCreate(final File file) {
-        // 文件创建
-        doSomething();
-    }
-
-    public void onFileDelete(final File file) {
-        // 文件删除
-        doSomething();
-    }
-}
-
-```
-
-当然，上面说的只是适配器模式的其中一种，也是最简单的一种，无需多言。下面，再介绍**“正统的”**适配器模式。
-
-对象适配器模式
-
-来看一个《Head First 设计模式》中的一个例子，我稍微修改了一下，看看怎么将鸡适配成鸭，这样鸡也能当鸭来用。因为，现在鸭这个接口，我们没有合适的实现类可以用，所以需要适配器。
-
-```
-public interface Duck {
-    public void quack(); // 鸭的呱呱叫
-      public void fly(); // 飞
-}
-
-public interface Cock {
-    public void gobble(); // 鸡的咕咕叫
-      public void fly(); // 飞
-}
-
-public class WildCock implements Cock {
-    public void gobble() {
-        System.out.println("咕咕叫");
-    }
-      public void fly() {
-        System.out.println("鸡也会飞哦");
-    }
-}
-
-```
-
-鸭接口有 fly() 和 quare() 两个方法，鸡 Cock 如果要冒充鸭，fly() 方法是现成的，但是鸡不会鸭的呱呱叫，没有 quack() 方法。这个时候就需要适配了：
-
-```
-// 毫无疑问，首先，这个适配器肯定需要 implements Duck，这样才能当做鸭来用
-public class CockAdapter implements Duck {
-
-    Cock cock;
-    // 构造方法中需要一个鸡的实例，此类就是将这只鸡适配成鸭来用
-      public CockAdapter(Cock cock) {
-        this.cock = cock;
-    }
-
-    // 实现鸭的呱呱叫方法
-      @Override
-      public void quack() {
-        // 内部其实是一只鸡的咕咕叫
-        cock.gobble();
-    }
-
-      @Override
-      public void fly() {
-        cock.fly();
-    }
-}
-
-```
-
-客户端调用很简单了：
-
-```
-public static void main(String[] args) {
-    // 有一只野鸡
-      Cock wildCock = new WildCock();
-      // 成功将野鸡适配成鸭
-      Duck duck = new CockAdapter(wildCock);
-      ...
-}
-
-```
-
-到这里，大家也就知道了适配器模式是怎么回事了。无非是我们需要一只鸭，但是我们只有一只鸡，这个时候就需要定义一个适配器，由这个适配器来充当鸭，但是适配器里面的方法还是由鸡来实现的。
-
-我们用一个图来简单说明下：
-
-![](https://javadoop.com/blogimages/design-pattern/adapter-1.png)
-
-上图应该还是很容易理解的，我就不做更多的解释了。下面，我们看看类适配模式怎么样的。
-
-类适配器模式
-
-废话少说，直接上图：
-
-![](https://javadoop.com/blogimages/design-pattern/adapter-2.png)
-
-看到这个图，大家应该很容易理解的吧，通过继承的方法，适配器自动获得了所需要的大部分方法。这个时候，客户端使用更加简单，直接 `Target t = new SomeAdapter();` 就可以了。
-
-适配器模式总结
-
-1.  类适配和对象适配的异同
-
-    > 一个采用继承，一个采用组合；
-    > 
-    > 类适配属于静态实现，对象适配属于组合的动态实现，对象适配需要多实例化一个对象。
-    > 
-    > 总体来说，对象适配用得比较多。
-
-2.  适配器模式和代理模式的异同
-
-    比较这两种模式，其实是比较对象适配器模式和代理模式，在代码结构上，它们很相似，都需要一个具体的实现类的实例。但是它们的目的不一样，代理模式做的是增强原方法的活；适配器做的是适配的活，为的是提供“把鸡包装成鸭，然后当做鸭来使用”，而鸡和鸭它们之间原本没有继承关系。
-
-![](https://javadoop.com/blogimages/design-pattern/adapter-5.png)
-
-### 桥梁模式
-
-理解桥梁模式，其实就是理解代码抽象和解耦。
-
-我们首先需要一个桥梁，它是一个接口，定义提供的接口方法。
-
-```
-public interface DrawAPI {
-   public void draw(int radius, int x, int y);
-}
-
-```
-
-然后是一系列实现类：
-
-```
-public class RedPen implements DrawAPI {
-   @Override
-   public void draw(int radius, int x, int y) {
-      System.out.println("用红色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
-   }
-}
-public class GreenPen implements DrawAPI {
-   @Override
-   public void draw(int radius, int x, int y) {
-      System.out.println("用绿色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
-   }
-}
-public class BluePen implements DrawAPI {
-   @Override
-   public void draw(int radius, int x, int y) {
-      System.out.println("用蓝色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
-   }
-}
-
-```
-
-定义一个抽象类，此类的实现类都需要使用 DrawAPI：
-
-```
-public abstract class Shape {
-   protected DrawAPI drawAPI;
-
-   protected Shape(DrawAPI drawAPI){
-      this.drawAPI = drawAPI;
-   }
-   public abstract void draw();    
-}
-
-```
-
-定义抽象类的子类：
-
-```
-// 圆形
-public class Circle extends Shape {
-   private int radius;
-
-   public Circle(int radius, DrawAPI drawAPI) {
-      super(drawAPI);
-      this.radius = radius;
-   }
-
-   public void draw() {
-      drawAPI.draw(radius, 0, 0);
-   }
-}
-// 长方形
-public class Rectangle extends Shape {
-    private int x;
-      private int y;
-
-      public Rectangle(int x, int y, DrawAPI drawAPI) {
-        super(drawAPI);
-          this.x = x;
-          this.y = y;
-    }
-      public void draw() {
-      drawAPI.draw(0, x, y);
-   }
-}
-
-```
-
-最后，我们来看客户端演示：
-
-```
-public static void main(String[] args) {
-    Shape greenCircle = new Circle(10, new GreenPen());
-      Shape redRectangle = new Rectangle(4, 8, new RedPen());
-
-      greenCircle.draw();
-      redRectangle.draw();
-}
-
-```
-
-可能大家看上面一步步还不是特别清晰，我把所有的东西整合到一张图上：
-
-![](https://javadoop.com/blogimages/design-pattern/bridge-1.png)
-
-这回大家应该就知道抽象在哪里，怎么解耦了吧。桥梁模式的优点也是显而易见的，就是非常容易进行扩展。
-
-> 本节引用了[这里](https://www.tutorialspoint.com/design_pattern/bridge_pattern.htm)的例子，并对其进行了修改。
-
-### 装饰模式
-
-要把装饰模式说清楚明白，不是件容易的事情。也许读者知道 Java IO 中的几个类是典型的装饰模式的应用，但是读者不一定清楚其中的关系，也许看完就忘了，希望看完这节后，读者可以对其有更深的感悟。
-
-首先，我们先看一个简单的图，看这个图的时候，了解下层次结构就可以了：
-
-![](https://javadoop.com/blogimages/design-pattern/decorator-1.png)
-
-我们来说说装饰模式的出发点，从图中可以看到，接口 `Component` 其实已经有了 `ConcreteComponentA` 和 `ConcreteComponentB` 两个实现类了，但是，如果我们要**增强**这两个实现类的话，我们就可以采用装饰模式，用具体的装饰器来**装饰**实现类，以达到增强的目的。
-
-> 从名字来简单解释下装饰器。既然说是装饰，那么往往就是**添加小功能**这种，而且，我们要满足可以添加多个小功能。最简单的，代理模式就可以实现功能的增强，但是代理不容易实现多个功能的增强，当然你可以说用代理包装代理的方式，但是那样的话代码就复杂了。
-
-首先明白一些简单的概念，从图中我们看到，所有的具体装饰者们 ConcreteDecorator_ 都可以作为 Component 来使用，因为它们都实现了 Component 中的所有接口。它们和 Component 实现类 ConcreteComponent_ 的区别是，它们只是装饰者，起**装饰**作用，也就是即使它们看上去牛逼轰轰，但是它们都只是在具体的实现中**加了层皮来装饰**而已。
-
-> 注意这段话中混杂在各个名词中的 Component 和 Decorator，别搞混了。
-
-下面来看看一个例子，先把装饰模式弄清楚，然后再介绍下 java io 中的装饰模式的应用。
-
-最近大街上流行起来了“快乐柠檬”，我们把快乐柠檬的饮料分为三类：红茶、绿茶、咖啡，在这三大类的基础上，又增加了许多的口味，什么金桔柠檬红茶、金桔柠檬珍珠绿茶、芒果红茶、芒果绿茶、芒果珍珠红茶、烤珍珠红茶、烤珍珠芒果绿茶、椰香胚芽咖啡、焦糖可可咖啡等等，每家店都有很长的菜单，但是仔细看下，其实原料也没几样，但是可以搭配出很多组合，如果顾客需要，很多没出现在菜单中的饮料他们也是可以做的。
-
-在这个例子中，红茶、绿茶、咖啡是最基础的饮料，其他的像金桔柠檬、芒果、珍珠、椰果、焦糖等都属于装饰用的。当然，在开发中，我们确实可以像门店一样，开发这些类：LemonBlackTea、LemonGreenTea、MangoBlackTea、MangoLemonGreenTea......但是，很快我们就发现，这样子干肯定是不行的，这会导致我们需要组合出所有的可能，而且如果客人需要在红茶中加双份柠檬怎么办？三份柠檬怎么办？万一有个变态要四份柠檬，所以这种做法是给自己找加班的。
-
-不说废话了，上代码。
-
-首先，定义饮料抽象基类：
-
-```
-public abstract class Beverage {
-      // 返回描述
-      public abstract String getDescription();
-      // 返回价格
-      public abstract double cost();
-}
-
-```
-
-然后是三个基础饮料实现类，红茶、绿茶和咖啡：
-
-```
-public class BlackTea extends Beverage {
-      public String getDescription() {
-        return "红茶";
-    }
-      public double cost() {
-        return 10;
-    }
-}
-public class GreenTea extends Beverage {
-    public String getDescription() {
-        return "绿茶";
-    }
-      public double cost() {
-        return 11;
-    }
-}
-...// 咖啡省略
-
-```
-
-定义调料，也就是装饰者的基类，此类必须继承自 Beverage：
-
-```
-// 调料
-public abstract class Condiment extends Beverage {
-
-}
-
-```
-
-然后我们来定义柠檬、芒果等具体的调料，它们属于装饰者，毫无疑问，这些调料肯定都需要继承 Condiment 类：
-
-```
-public class Lemon extends Condiment {
-    private Beverage bevarage;
-      // 这里很关键，需要传入具体的饮料，如需要传入没有被装饰的红茶或绿茶，
-      // 当然也可以传入已经装饰好的芒果绿茶，这样可以做芒果柠檬绿茶
-      public Lemon(Beverage bevarage) {
-        this.bevarage = bevarage;
-    }
-      public String getDescription() {
-        // 装饰
-        return bevarage.getDescription() + ", 加柠檬";
-    }
-      public double cost() {
-          // 装饰
-        return beverage.cost() + 2; // 加柠檬需要 2 元
-    }
-}
-public class Mango extends Condiment {
-    private Beverage bevarage;
-      public Mango(Beverage bevarage) {
-        this.bevarage = bevarage;
-    }
-      public String getDescription() {
-        return bevarage.getDescription() + ", 加芒果";
-    }
-      public double cost() {
-        return beverage.cost() + 3; // 加芒果需要 3 元
-    }
-}
-...// 给每一种调料都加一个类
-
-```
-
-看客户端调用：
-
-```
-public static void main(String[] args) {
-      // 首先，我们需要一个基础饮料，红茶、绿茶或咖啡
-    Beverage beverage = new GreenTea();
-      // 开始装饰
-      beverage = new Lemon(beverage); // 先加一份柠檬
-      beverage = new Mongo(beverage); // 再加一份芒果
-
-      System.out.println(beverage.getDescription() + " 价格：￥" + beverage.cost());
-      //"绿茶, 加柠檬, 加芒果 价格：￥16"
-}
-
-```
-
-如果我们需要芒果珍珠双份柠檬红茶：
-
-```
-Beverage beverage = new Mongo(new Pearl(new Lemon(new Lemon(new BlackTea()))));
-
-```
-
-是不是很变态？
-
-看看下图可能会清晰一些：
-
-![](https://javadoop.com/blogimages/design-pattern/decorator-2.png)
-
-到这里，大家应该已经清楚装饰模式了吧。
-
-下面，我们再来说说 java IO 中的装饰模式。看下图 InputStream 派生出来的部分类：
-
-![](https://javadoop.com/blogimages/design-pattern/decorator-3.png)
-
-我们知道 InputStream 代表了输入流，具体的输入来源可以是文件（FileInputStream）、管道（PipedInputStream）、数组（ByteArrayInputStream）等，这些就像前面奶茶的例子中的红茶、绿茶，属于基础输入流。
-
-FilterInputStream 承接了装饰模式的关键节点，其实现类是一系列装饰器，比如 BufferedInputStream 代表用缓冲来装饰，也就使得输入流具有了缓冲的功能，LineNumberInputStream 代表用行号来装饰，在操作的时候就可以取得行号了，DataInputStream 的装饰，使得我们可以从输入流转换为 java 中的基本类型值。
-
-当然，在 java IO 中，如果我们使用装饰器的话，就不太适合面向接口编程了，如：
-
-```
-InputStream inputStream = new LineNumberInputStream(new BufferedInputStream(new FileInputStream("")));
-
-```
-
-这样的结果是，InputStream 还是不具有读取行号的功能，因为读取行号的方法定义在 LineNumberInputStream 类中。
-
-我们应该像下面这样使用：
-
-```
-DataInputStream is = new DataInputStream(
-                              new BufferedInputStream(
-                                  new FileInputStream("")));
-
-```
-
-> 所以说嘛，要找到纯的严格符合设计模式的代码还是比较难的。
-
-### 门面模式
-
-门面模式（也叫外观模式，Facade Pattern）在许多源码中有使用，比如 slf4j 就可以理解为是门面模式的应用。这是一个简单的设计模式，我们直接上代码再说吧。
-
-首先，我们定义一个接口：
-
-```
-public interface Shape {
-   void draw();
-}
-
-```
-
-定义几个实现类：
-
-```
-public class Circle implements Shape {
-
-   @Override
-   public void draw() {
-      System.out.println("Circle::draw()");
-   }
-}
-
-public class Rectangle implements Shape {
-
-   @Override
-   public void draw() {
-      System.out.println("Rectangle::draw()");
-   }
-}
-
-```
-
-客户端调用：
-
-```
-public static void main(String[] args) {
-    // 画一个圆形
-      Shape circle = new Circle();
-      circle.draw();
-
-      // 画一个长方形
-      Shape rectangle = new Rectangle();
-      rectangle.draw();
-}
-
-```
-
-以上是我们常写的代码，我们需要画圆就要先实例化圆，画长方形就需要先实例化一个长方形，然后再调用相应的 draw() 方法。
-
-下面，我们看看怎么用门面模式来让客户端调用更加友好一些。
-
-我们先定义一个门面：
-
-```
-public class ShapeMaker {
-   private Shape circle;
-   private Shape rectangle;
-   private Shape square;
-
-   public ShapeMaker() {
-      circle = new Circle();
-      rectangle = new Rectangle();
-      square = new Square();
-   }
-
-  /**
-   * 下面定义一堆方法，具体应该调用什么方法，由这个门面来决定
-   */
-
-   public void drawCircle(){
-      circle.draw();
-   }
-   public void drawRectangle(){
-      rectangle.draw();
-   }
-   public void drawSquare(){
-      square.draw();
-   }
-}
-
-```
-
-看看现在客户端怎么调用：
-
-```
-public static void main(String[] args) {
-  ShapeMaker shapeMaker = new ShapeMaker();
-
-  // 客户端调用现在更加清晰了
-  shapeMaker.drawCircle();
-  shapeMaker.drawRectangle();
-  shapeMaker.drawSquare();        
-}
-
-```
-
-门面模式的优点显而易见，客户端不再需要关注实例化时应该使用哪个实现类，直接调用门面提供的方法就可以了，因为门面类提供的方法的方法名对于客户端来说已经很友好了。
-
-### 组合模式
-
-组合模式用于表示具有层次结构的数据，使得我们对单个对象和组合对象的访问具有一致性。
-
-直接看一个例子吧，每个员工都有姓名、部门、薪水这些属性，同时还有下属员工集合（虽然可能集合为空），而下属员工和自己的结构是一样的，也有姓名、部门这些属性，同时也有他们的下属员工集合。
-
-```
-public class Employee {
-   private String name;
-   private String dept;
-   private int salary;
-   private List<Employee> subordinates; // 下属
-
-   public Employee(String name,String dept, int sal) {
-      this.name = name;
-      this.dept = dept;
-      this.salary = sal;
-      subordinates = new ArrayList<Employee>();
-   }
-
-   public void add(Employee e) {
-      subordinates.add(e);
-   }
-
-   public void remove(Employee e) {
-      subordinates.remove(e);
-   }
-
-   public List<Employee> getSubordinates(){
-     return subordinates;
-   }
-
-   public String toString(){
-      return ("Employee :[ Name : " + name + ", dept : " + dept + ", salary :" + salary+" ]");
-   }   
-}
-
-```
-
-通常，这种类需要定义 add(node)、remove(node)、getChildren() 这些方法。
-
-这说的其实就是组合模式，这种简单的模式我就不做过多介绍了，相信各位读者也不喜欢看我写废话。
-
-### 享元模式
-
-英文是 Flyweight Pattern，不知道是谁最先翻译的这个词，感觉这翻译真的不好理解，我们试着强行关联起来吧。Flyweight 是轻量级的意思，享元分开来说就是 共享 元器件，也就是复用已经生成的对象，这种做法当然也就是轻量级的了。
-
-复用对象最简单的方式是，用一个 HashMap 来存放每次新生成的对象。每次需要一个对象的时候，先到 HashMap 中看看有没有，如果没有，再生成新的对象，然后将这个对象放入 HashMap 中。
-
-这种简单的代码我就不演示了。
-
-### 结构型模式总结
-
-前面，我们说了代理模式、适配器模式、桥梁模式、装饰模式、门面模式、组合模式和享元模式。读者是否可以分别把这几个模式说清楚了呢？在说到这些模式的时候，心中是否有一个清晰的图或处理流程在脑海里呢？
-
-代理模式是做方法增强的，适配器模式是把鸡包装成鸭这种用来适配接口的，桥梁模式做到了很好的解耦，装饰模式从名字上就看得出来，适合于装饰类或者说是增强类的场景，门面模式的优点是客户端不需要关心实例化过程，只要调用需要的方法即可，组合模式用于描述具有层次结构的数据，享元模式是为了在特定的场景中缓存已经创建的对象，用于提高性能。
-
-## 参考文章
-
-转自https://javadoop.com/post/design-pattern
-
-
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2175\357\274\232Spring\346\266\211\345\217\212\345\210\260\347\232\2049\347\247\215\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2175\357\274\232Spring\346\266\211\345\217\212\345\210\260\347\232\2049\347\247\215\350\256\276\350\256\241\346\250\241\345\274\217.md"
deleted file mode 100644
index 8c23116..0000000
--- "a/docs/java/design-parttern/\345\210\235\346\216\242Java\350\256\276\350\256\241\346\250\241\345\274\2175\357\274\232Spring\346\266\211\345\217\212\345\210\260\347\232\2049\347\247\215\350\256\276\350\256\241\346\250\241\345\274\217.md"
+++ /dev/null
@@ -1,891 +0,0 @@
-# Table of Contents
-
-  * [结构型模式](#结构型模式)
-    * [代理模式](#代理模式)
-    * [适配器模式](#适配器模式)
-    * [桥梁模式](#桥梁模式)
-    * [装饰模式](#装饰模式)
-    * [门面模式](#门面模式)
-    * [组合模式](#组合模式)
-    * [享元模式](#享元模式)
-    * [结构型模式总结](#结构型模式总结)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-
-
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star、fork哈
-
-文章也将发表在我的个人博客，阅读体验更佳：
-
-> www.how2playlife.com
-
-**设计模式**作为工作学习中的枕边书，却时常处于勤说不用的尴尬境地，也不是我们时常忘记，只是一直没有记忆。
-
-今天，螃蟹在IT学习者网站就设计模式的内在价值做一番探讨，并以spring为例进行讲解，只有领略了其设计的思想理念，才能在工作学习中运用到“无形”。
-
-Spring作为业界的经典框架，无论是在架构设计方面，还是在代码编写方面，都堪称行内典范。好了，话不多说，开始今天的内容。
-
-spring中常用的设计模式达到九种，我们举例说明：
-
-**第一种：简单工厂**
-
-又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。 
-简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。 
-spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。如下配置，就是在 HelloItxxz 类中创建一个 itxxzBean。
-
-    <beans>
-    
-        <bean id="singletonBean" >
-    
-            <constructor-arg>
-    
-                <value>Hello! 这是singletonBean!value>
-    
-            </constructor-arg>
-    
-       </ bean>
-    
-        <bean id="itxxzBean"
-    
-            singleton="false">
-    
-            <constructor-arg>
-    
-                <value>Hello! 这是itxxzBean! value>
-    
-            </constructor-arg>
-    
-        </bean>
-    
-    </beans>
-
-**第二种：工厂方法（Factory Method）**
-
-通常由应用程序直接使用new创建新的对象，为了将对象的创建和使用相分离，采用工厂模式,即应用程序将对象的创建及初始化职责交给工厂对象。
-
-一般情况下,应用程序有自己的工厂对象来创建bean.如果将应用程序自己的工厂对象交给Spring管理,那么Spring管理的就不是普通的bean,而是工厂Bean。
-
-螃蟹就以工厂方法中的静态方法为例讲解一下：
-    
-    import java.util.Random;
-    
-    public class StaticFactoryBean {
-    
-          public static Integer createRandom() {
-    
-               return new Integer(new Random().nextInt());
-    
-           }
-    
-    }
-
-建一个config.xm配置文件，将其纳入Spring容器来管理,需要通过factory-method指定静态方法名称
-
-    <bean id="random"
-    
-    factory-method="createRandom" //createRandom方法必须是static的,才能找到 scope="prototype"
-    
-    />
-
-测试:
-
-    public static void main(String[] args) {
-          //调用getBean()时,返回随机数.如果没有指定factory-method,会返回StaticFactoryBean的实例,即返回工厂Bean的实例       XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("config.xml"));       System.out.println("我是IT学习者创建的实例:"+factory.getBean("random").toString());
-    
-    }
-
-**第三种：单例模式（Singleton）**
-
-保证一个类仅有一个实例，并提供一个访问它的全局访问点。 
-spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例，这是因为spring管理的是是任意的java对象。 
-核心提示点：Spring下默认的bean均为singleton，可以通过singleton=“true|false” 或者 scope=“？”来指定
-
-**第四种：适配器（Adapter）**
-
-在Spring的Aop中，使用的Advice（通知）来增强被代理类的功能。Spring实现这一AOP功能的原理就使用代理模式（1、JDK动态代理。2、CGLib字节码生成技术代理。）对类进行方法级别的切面增强，即，生成被代理类的代理类， 并在代理类的方法前，设置拦截器，通过执行拦截器重的内容增强了代理方法的功能，实现的面向切面编程。
-
-**Adapter类接口**：
-
-    public interface AdvisorAdapter {
-    
-    boolean supportsAdvice(Advice advice);
-    
-          MethodInterceptor getInterceptor(Advisor advisor);
-    
-    } **MethodBeforeAdviceAdapter类**，Adapter
-    
-    class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
-    
-          public boolean supportsAdvice(Advice advice) {
-    
-                return (advice instanceof MethodBeforeAdvice);
-    
-          }
-    
-          public MethodInterceptor getInterceptor(Advisor advisor) {
-    
-                MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
-    
-          return new MethodBeforeAdviceInterceptor(advice);
-    
-          }
-    
-    }
-
-**第五种：包装器（Decorator）**
-
-在我们的项目中遇到这样一个问题：我们的项目需要连接多个数据库，而且不同的客户在每次访问中根据需要会去访问不同的数据库。我们以往在spring和hibernate框架中总是配置一个数据源，因而sessionFactory的dataSource属性总是指向这个数据源并且恒定不变，所有DAO在使用sessionFactory的时候都是通过这个数据源访问数据库。
-
-但是现在，由于项目的需要，我们的DAO在访问sessionFactory的时候都不得不在多个数据源中不断切换，问题就出现了：如何让sessionFactory在执行数据持久化的时候，根据客户的需求能够动态切换不同的数据源？我们能不能在spring的框架下通过少量修改得到解决？是否有什么设计模式可以利用呢？ 
-
-
-首先想到在spring的applicationContext中配置所有的dataSource。这些dataSource可能是各种不同类型的，比如不同的数据库：Oracle、SQL Server、MySQL等，也可能是不同的数据源：比如apache 提供的org.apache.commons.dbcp.BasicDataSource、spring提供的org.springframework.jndi.JndiObjectFactoryBean等。然后sessionFactory根据客户的每次请求，将dataSource属性设置成不同的数据源，以到达切换数据源的目的。
-
-spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。 
-
-**第六种：代理（Proxy）**
-
-为其他对象提供一种代理以控制对这个对象的访问。  从结构上来看和Decorator模式类似，但Proxy是控制，更像是一种对功能的限制，而Decorator是增加职责。 
-spring的Proxy模式在aop中有体现，比如JdkDynamicAopProxy和Cglib2AopProxy。 
-
-**第七种：观察者（Observer）**
-
-定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
-spring中Observer模式常用的地方是listener的实现。如ApplicationListener。 
-
-**第八种：策略（Strategy）**
-
-定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。 
-spring中在实例化对象的时候用到Strategy模式
-在SimpleInstantiationStrategy中有如下代码说明了策略模式的使用情况： 
-
-**第九种：模板方法（Template Method）**
-
-定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
-Template Method模式一般是需要继承的。这里想要探讨另一种对Template Method的理解。
-
-spring中的JdbcTemplate，在用这个类时并不想去继承这个类，因为这个类的方法太多，但是我们还是想用到JdbcTemplate已有的稳定的、公用的数据库连接，那么我们怎么办呢？我们可以把变化的东西抽出来作为一个参数传入JdbcTemplate的方法中。但是变化的东西是一段代码，而且这段代码会用到JdbcTemplate中的变量。
-
-怎么办？那我们就用回调对象吧。在这个回调对象中定义一个操纵JdbcTemplate中变量的方法，我们去实现这个方法，就把变化的东西集中到这里了。然后我们再传入这个回调对象到JdbcTemplate，从而完成了调用。这可能是Template Method不需要继承的另一种实现方式吧。 
-
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star、fork哈
-
-文章也将发表在我的个人博客，阅读体验更佳：
-
-> www.how2playlife.com
-
-## 结构型模式
-
-前面创建型模式介绍了创建对象的一些设计模式，这节介绍的结构型模式旨在通过改变代码结构来达到解耦的目的，使得我们的代码容易维护和扩展。
-
-### 代理模式
-
-第一个要介绍的代理模式是最常使用的模式之一了，用一个代理来隐藏具体实现类的实现细节，通常还用于在真实的实现的前后添加一部分逻辑。
-
-既然说是**代理**，那就要对客户端隐藏真实实现，由代理来负责客户端的所有请求。当然，代理只是个代理，它不会完成实际的业务逻辑，而是一层皮而已，但是对于客户端来说，它必须表现得就是客户端需要的真实实现。
-
-> 理解**代理**这个词，这个模式其实就简单了。
-
-```
-public interface FoodService {
-    Food makeChicken();
-    Food makeNoodle();
-}
-
-public class FoodServiceImpl implements FoodService {
-    public Food makeChicken() {
-          Food f = new Chicken()
-        f.setChicken("1kg");
-          f.setSpicy("1g");
-          f.setSalt("3g");
-        return f;
-    }
-    public Food makeNoodle() {
-        Food f = new Noodle();
-        f.setNoodle("500g");
-        f.setSalt("5g");
-        return f;
-    }
-}
-
-// 代理要表现得“就像是”真实实现类，所以需要实现 FoodService
-public class FoodServiceProxy implements FoodService {
-
-    // 内部一定要有一个真实的实现类，当然也可以通过构造方法注入
-    private FoodService foodService = new FoodServiceImpl();
-
-    public Food makeChicken() {
-        System.out.println("我们马上要开始制作鸡肉了");
-
-        // 如果我们定义这句为核心代码的话，那么，核心代码是真实实现类做的，
-        // 代理只是在核心代码前后做些“无足轻重”的事情
-        Food food = foodService.makeChicken();
-
-        System.out.println("鸡肉制作完成啦，加点胡椒粉"); // 增强
-          food.addCondiment("pepper");
-
-        return food;
-    }
-    public Food makeNoodle() {
-        System.out.println("准备制作拉面~");
-        Food food = foodService.makeNoodle();
-        System.out.println("制作完成啦")
-        return food;
-    }
-}
-
-```
-
-客户端调用，注意，我们要用代理来实例化接口：
-
-```
-// 这里用代理类来实例化
-FoodService foodService = new FoodServiceProxy();
-foodService.makeChicken();
-
-```
-
-![](https://javadoop.com/blogimages/design-pattern/proxy-1.png)
-我们发现没有，代理模式说白了就是做 **“方法包装”** 或做 **“方法增强”**。在面向切面编程中，算了还是不要吹捧这个名词了，在 AOP 中，其实就是动态代理的过程。比如 Spring 中，我们自己不定义代理类，但是 Spring 会帮我们动态来定义代理，然后把我们定义在 @Before、@After、@Around 中的代码逻辑动态添加到代理中。
-
-说到动态代理，又可以展开说 …… Spring 中实现动态代理有两种，一种是如果我们的类定义了接口，如 UserService 接口和 UserServiceImpl 实现，那么采用 JDK 的动态代理，感兴趣的读者可以去看看 java.lang.reflect.Proxy 类的源码；另一种是我们自己没有定义接口的，Spring 会采用 CGLIB 进行动态代理，它是一个 jar 包，性能还不错。
-
-### 适配器模式
-
-说完代理模式，说适配器模式，是因为它们很相似，这里可以做个比较。
-
-适配器模式做的就是，有一个接口需要实现，但是我们现成的对象都不满足，需要加一层适配器来进行适配。
-
-适配器模式总体来说分三种：默认适配器模式、对象适配器模式、类适配器模式。先不急着分清楚这几个，先看看例子再说。
-
-默认适配器模式
-
-首先，我们先看看最简单的适配器模式**默认适配器模式(Default Adapter)**是怎么样的。
-
-我们用 Appache commons-io 包中的 FileAlterationListener 做例子，此接口定义了很多的方法，用于对文件或文件夹进行监控，一旦发生了对应的操作，就会触发相应的方法。
-
-```
-public interface FileAlterationListener {
-    void onStart(final FileAlterationObserver observer);
-    void onDirectoryCreate(final File directory);
-    void onDirectoryChange(final File directory);
-    void onDirectoryDelete(final File directory);
-    void onFileCreate(final File file);
-    void onFileChange(final File file);
-    void onFileDelete(final File file);
-    void onStop(final FileAlterationObserver observer);
-}
-
-```
-
-此接口的一大问题是抽象方法太多了，如果我们要用这个接口，意味着我们要实现每一个抽象方法，如果我们只是想要监控文件夹中的**文件创建**和**文件删除**事件，可是我们还是不得不实现所有的方法，很明显，这不是我们想要的。
-
-所以，我们需要下面的一个**适配器**，它用于实现上面的接口，但是**所有的方法都是空方法**，这样，我们就可以转而定义自己的类来继承下面这个类即可。
-
-```
-public class FileAlterationListenerAdaptor implements FileAlterationListener {
-
-    public void onStart(final FileAlterationObserver observer) {
-    }
-
-    public void onDirectoryCreate(final File directory) {
-    }
-
-    public void onDirectoryChange(final File directory) {
-    }
-
-    public void onDirectoryDelete(final File directory) {
-    }
-
-    public void onFileCreate(final File file) {
-    }
-
-    public void onFileChange(final File file) {
-    }
-
-    public void onFileDelete(final File file) {
-    }
-
-    public void onStop(final FileAlterationObserver observer) {
-    }
-}
-
-```
-
-比如我们可以定义以下类，我们仅仅需要实现我们想实现的方法就可以了：
-
-```
-public class FileMonitor extends FileAlterationListenerAdaptor {
-    public void onFileCreate(final File file) {
-        // 文件创建
-        doSomething();
-    }
-
-    public void onFileDelete(final File file) {
-        // 文件删除
-        doSomething();
-    }
-}
-
-```
-
-当然，上面说的只是适配器模式的其中一种，也是最简单的一种，无需多言。下面，再介绍**“正统的”**适配器模式。
-
-对象适配器模式
-
-来看一个《Head First 设计模式》中的一个例子，我稍微修改了一下，看看怎么将鸡适配成鸭，这样鸡也能当鸭来用。因为，现在鸭这个接口，我们没有合适的实现类可以用，所以需要适配器。
-
-```
-public interface Duck {
-    public void quack(); // 鸭的呱呱叫
-      public void fly(); // 飞
-}
-
-public interface Cock {
-    public void gobble(); // 鸡的咕咕叫
-      public void fly(); // 飞
-}
-
-public class WildCock implements Cock {
-    public void gobble() {
-        System.out.println("咕咕叫");
-    }
-      public void fly() {
-        System.out.println("鸡也会飞哦");
-    }
-}
-
-```
-
-鸭接口有 fly() 和 quare() 两个方法，鸡 Cock 如果要冒充鸭，fly() 方法是现成的，但是鸡不会鸭的呱呱叫，没有 quack() 方法。这个时候就需要适配了：
-
-```
-// 毫无疑问，首先，这个适配器肯定需要 implements Duck，这样才能当做鸭来用
-public class CockAdapter implements Duck {
-
-    Cock cock;
-    // 构造方法中需要一个鸡的实例，此类就是将这只鸡适配成鸭来用
-      public CockAdapter(Cock cock) {
-        this.cock = cock;
-    }
-
-    // 实现鸭的呱呱叫方法
-      @Override
-      public void quack() {
-        // 内部其实是一只鸡的咕咕叫
-        cock.gobble();
-    }
-
-      @Override
-      public void fly() {
-        cock.fly();
-    }
-}
-
-```
-
-客户端调用很简单了：
-
-```
-public static void main(String[] args) {
-    // 有一只野鸡
-      Cock wildCock = new WildCock();
-      // 成功将野鸡适配成鸭
-      Duck duck = new CockAdapter(wildCock);
-      ...
-}
-
-```
-
-到这里，大家也就知道了适配器模式是怎么回事了。无非是我们需要一只鸭，但是我们只有一只鸡，这个时候就需要定义一个适配器，由这个适配器来充当鸭，但是适配器里面的方法还是由鸡来实现的。
-
-我们用一个图来简单说明下：
-
-![](https://javadoop.com/blogimages/design-pattern/adapter-1.png)
-
-上图应该还是很容易理解的，我就不做更多的解释了。下面，我们看看类适配模式怎么样的。
-
-类适配器模式
-
-废话少说，直接上图：
-
-![](https://javadoop.com/blogimages/design-pattern/adapter-2.png)
-
-看到这个图，大家应该很容易理解的吧，通过继承的方法，适配器自动获得了所需要的大部分方法。这个时候，客户端使用更加简单，直接 `Target t = new SomeAdapter();` 就可以了。
-
-适配器模式总结
-
-1.  类适配和对象适配的异同
-
-    > 一个采用继承，一个采用组合；
-    > 
-    > 类适配属于静态实现，对象适配属于组合的动态实现，对象适配需要多实例化一个对象。
-    > 
-    > 总体来说，对象适配用得比较多。
-
-2.  适配器模式和代理模式的异同
-
-    比较这两种模式，其实是比较对象适配器模式和代理模式，在代码结构上，它们很相似，都需要一个具体的实现类的实例。但是它们的目的不一样，代理模式做的是增强原方法的活；适配器做的是适配的活，为的是提供“把鸡包装成鸭，然后当做鸭来使用”，而鸡和鸭它们之间原本没有继承关系。
-
-![](https://javadoop.com/blogimages/design-pattern/adapter-5.png)
-
-### 桥梁模式
-
-理解桥梁模式，其实就是理解代码抽象和解耦。
-
-我们首先需要一个桥梁，它是一个接口，定义提供的接口方法。
-
-```
-public interface DrawAPI {
-   public void draw(int radius, int x, int y);
-}
-
-```
-
-然后是一系列实现类：
-
-```
-public class RedPen implements DrawAPI {
-   @Override
-   public void draw(int radius, int x, int y) {
-      System.out.println("用红色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
-   }
-}
-public class GreenPen implements DrawAPI {
-   @Override
-   public void draw(int radius, int x, int y) {
-      System.out.println("用绿色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
-   }
-}
-public class BluePen implements DrawAPI {
-   @Override
-   public void draw(int radius, int x, int y) {
-      System.out.println("用蓝色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
-   }
-}
-
-```
-
-定义一个抽象类，此类的实现类都需要使用 DrawAPI：
-
-```
-public abstract class Shape {
-   protected DrawAPI drawAPI;
-
-   protected Shape(DrawAPI drawAPI){
-      this.drawAPI = drawAPI;
-   }
-   public abstract void draw();    
-}
-
-```
-
-定义抽象类的子类：
-
-```
-// 圆形
-public class Circle extends Shape {
-   private int radius;
-
-   public Circle(int radius, DrawAPI drawAPI) {
-      super(drawAPI);
-      this.radius = radius;
-   }
-
-   public void draw() {
-      drawAPI.draw(radius, 0, 0);
-   }
-}
-// 长方形
-public class Rectangle extends Shape {
-    private int x;
-      private int y;
-
-      public Rectangle(int x, int y, DrawAPI drawAPI) {
-        super(drawAPI);
-          this.x = x;
-          this.y = y;
-    }
-      public void draw() {
-      drawAPI.draw(0, x, y);
-   }
-}
-
-```
-
-最后，我们来看客户端演示：
-
-```
-public static void main(String[] args) {
-    Shape greenCircle = new Circle(10, new GreenPen());
-      Shape redRectangle = new Rectangle(4, 8, new RedPen());
-
-      greenCircle.draw();
-      redRectangle.draw();
-}
-
-```
-
-可能大家看上面一步步还不是特别清晰，我把所有的东西整合到一张图上：
-
-![](https://javadoop.com/blogimages/design-pattern/bridge-1.png)
-
-这回大家应该就知道抽象在哪里，怎么解耦了吧。桥梁模式的优点也是显而易见的，就是非常容易进行扩展。
-
-> 本节引用了[这里](https://www.tutorialspoint.com/design_pattern/bridge_pattern.htm)的例子，并对其进行了修改。
-
-### 装饰模式
-
-要把装饰模式说清楚明白，不是件容易的事情。也许读者知道 Java IO 中的几个类是典型的装饰模式的应用，但是读者不一定清楚其中的关系，也许看完就忘了，希望看完这节后，读者可以对其有更深的感悟。
-
-首先，我们先看一个简单的图，看这个图的时候，了解下层次结构就可以了：
-
-![](https://javadoop.com/blogimages/design-pattern/decorator-1.png)
-
-我们来说说装饰模式的出发点，从图中可以看到，接口 `Component` 其实已经有了 `ConcreteComponentA` 和 `ConcreteComponentB` 两个实现类了，但是，如果我们要**增强**这两个实现类的话，我们就可以采用装饰模式，用具体的装饰器来**装饰**实现类，以达到增强的目的。
-
-> 从名字来简单解释下装饰器。既然说是装饰，那么往往就是**添加小功能**这种，而且，我们要满足可以添加多个小功能。最简单的，代理模式就可以实现功能的增强，但是代理不容易实现多个功能的增强，当然你可以说用代理包装代理的方式，但是那样的话代码就复杂了。
-
-首先明白一些简单的概念，从图中我们看到，所有的具体装饰者们 ConcreteDecorator_ 都可以作为 Component 来使用，因为它们都实现了 Component 中的所有接口。它们和 Component 实现类 ConcreteComponent_ 的区别是，它们只是装饰者，起**装饰**作用，也就是即使它们看上去牛逼轰轰，但是它们都只是在具体的实现中**加了层皮来装饰**而已。
-
-> 注意这段话中混杂在各个名词中的 Component 和 Decorator，别搞混了。
-
-下面来看看一个例子，先把装饰模式弄清楚，然后再介绍下 java io 中的装饰模式的应用。
-
-最近大街上流行起来了“快乐柠檬”，我们把快乐柠檬的饮料分为三类：红茶、绿茶、咖啡，在这三大类的基础上，又增加了许多的口味，什么金桔柠檬红茶、金桔柠檬珍珠绿茶、芒果红茶、芒果绿茶、芒果珍珠红茶、烤珍珠红茶、烤珍珠芒果绿茶、椰香胚芽咖啡、焦糖可可咖啡等等，每家店都有很长的菜单，但是仔细看下，其实原料也没几样，但是可以搭配出很多组合，如果顾客需要，很多没出现在菜单中的饮料他们也是可以做的。
-
-在这个例子中，红茶、绿茶、咖啡是最基础的饮料，其他的像金桔柠檬、芒果、珍珠、椰果、焦糖等都属于装饰用的。当然，在开发中，我们确实可以像门店一样，开发这些类：LemonBlackTea、LemonGreenTea、MangoBlackTea、MangoLemonGreenTea......但是，很快我们就发现，这样子干肯定是不行的，这会导致我们需要组合出所有的可能，而且如果客人需要在红茶中加双份柠檬怎么办？三份柠檬怎么办？万一有个变态要四份柠檬，所以这种做法是给自己找加班的。
-
-不说废话了，上代码。
-
-首先，定义饮料抽象基类：
-
-```
-public abstract class Beverage {
-      // 返回描述
-      public abstract String getDescription();
-      // 返回价格
-      public abstract double cost();
-}
-
-```
-
-然后是三个基础饮料实现类，红茶、绿茶和咖啡：
-
-```
-public class BlackTea extends Beverage {
-      public String getDescription() {
-        return "红茶";
-    }
-      public double cost() {
-        return 10;
-    }
-}
-public class GreenTea extends Beverage {
-    public String getDescription() {
-        return "绿茶";
-    }
-      public double cost() {
-        return 11;
-    }
-}
-...// 咖啡省略
-
-```
-
-定义调料，也就是装饰者的基类，此类必须继承自 Beverage：
-
-```
-// 调料
-public abstract class Condiment extends Beverage {
-
-}
-
-```
-
-然后我们来定义柠檬、芒果等具体的调料，它们属于装饰者，毫无疑问，这些调料肯定都需要继承 Condiment 类：
-
-```
-public class Lemon extends Condiment {
-    private Beverage bevarage;
-      // 这里很关键，需要传入具体的饮料，如需要传入没有被装饰的红茶或绿茶，
-      // 当然也可以传入已经装饰好的芒果绿茶，这样可以做芒果柠檬绿茶
-      public Lemon(Beverage bevarage) {
-        this.bevarage = bevarage;
-    }
-      public String getDescription() {
-        // 装饰
-        return bevarage.getDescription() + ", 加柠檬";
-    }
-      public double cost() {
-          // 装饰
-        return beverage.cost() + 2; // 加柠檬需要 2 元
-    }
-}
-public class Mango extends Condiment {
-    private Beverage bevarage;
-      public Mango(Beverage bevarage) {
-        this.bevarage = bevarage;
-    }
-      public String getDescription() {
-        return bevarage.getDescription() + ", 加芒果";
-    }
-      public double cost() {
-        return beverage.cost() + 3; // 加芒果需要 3 元
-    }
-}
-...// 给每一种调料都加一个类
-
-```
-
-看客户端调用：
-
-```
-public static void main(String[] args) {
-      // 首先，我们需要一个基础饮料，红茶、绿茶或咖啡
-    Beverage beverage = new GreenTea();
-      // 开始装饰
-      beverage = new Lemon(beverage); // 先加一份柠檬
-      beverage = new Mongo(beverage); // 再加一份芒果
-
-      System.out.println(beverage.getDescription() + " 价格：￥" + beverage.cost());
-      //"绿茶, 加柠檬, 加芒果 价格：￥16"
-}
-
-```
-
-如果我们需要芒果珍珠双份柠檬红茶：
-
-```
-Beverage beverage = new Mongo(new Pearl(new Lemon(new Lemon(new BlackTea()))));
-
-```
-
-是不是很变态？
-
-看看下图可能会清晰一些：
-
-![](https://javadoop.com/blogimages/design-pattern/decorator-2.png)
-
-到这里，大家应该已经清楚装饰模式了吧。
-
-下面，我们再来说说 java IO 中的装饰模式。看下图 InputStream 派生出来的部分类：
-
-![](https://javadoop.com/blogimages/design-pattern/decorator-3.png)
-
-我们知道 InputStream 代表了输入流，具体的输入来源可以是文件（FileInputStream）、管道（PipedInputStream）、数组（ByteArrayInputStream）等，这些就像前面奶茶的例子中的红茶、绿茶，属于基础输入流。
-
-FilterInputStream 承接了装饰模式的关键节点，其实现类是一系列装饰器，比如 BufferedInputStream 代表用缓冲来装饰，也就使得输入流具有了缓冲的功能，LineNumberInputStream 代表用行号来装饰，在操作的时候就可以取得行号了，DataInputStream 的装饰，使得我们可以从输入流转换为 java 中的基本类型值。
-
-当然，在 java IO 中，如果我们使用装饰器的话，就不太适合面向接口编程了，如：
-
-```
-InputStream inputStream = new LineNumberInputStream(new BufferedInputStream(new FileInputStream("")));
-
-```
-
-这样的结果是，InputStream 还是不具有读取行号的功能，因为读取行号的方法定义在 LineNumberInputStream 类中。
-
-我们应该像下面这样使用：
-
-```
-DataInputStream is = new DataInputStream(
-                              new BufferedInputStream(
-                                  new FileInputStream("")));
-
-```
-
-> 所以说嘛，要找到纯的严格符合设计模式的代码还是比较难的。
-
-### 门面模式
-
-门面模式（也叫外观模式，Facade Pattern）在许多源码中有使用，比如 slf4j 就可以理解为是门面模式的应用。这是一个简单的设计模式，我们直接上代码再说吧。
-
-首先，我们定义一个接口：
-
-```
-public interface Shape {
-   void draw();
-}
-
-```
-
-定义几个实现类：
-
-```
-public class Circle implements Shape {
-
-   @Override
-   public void draw() {
-      System.out.println("Circle::draw()");
-   }
-}
-
-public class Rectangle implements Shape {
-
-   @Override
-   public void draw() {
-      System.out.println("Rectangle::draw()");
-   }
-}
-
-```
-
-客户端调用：
-
-```
-public static void main(String[] args) {
-    // 画一个圆形
-      Shape circle = new Circle();
-      circle.draw();
-
-      // 画一个长方形
-      Shape rectangle = new Rectangle();
-      rectangle.draw();
-}
-
-```
-
-以上是我们常写的代码，我们需要画圆就要先实例化圆，画长方形就需要先实例化一个长方形，然后再调用相应的 draw() 方法。
-
-下面，我们看看怎么用门面模式来让客户端调用更加友好一些。
-
-我们先定义一个门面：
-
-```
-public class ShapeMaker {
-   private Shape circle;
-   private Shape rectangle;
-   private Shape square;
-
-   public ShapeMaker() {
-      circle = new Circle();
-      rectangle = new Rectangle();
-      square = new Square();
-   }
-
-  /**
-   * 下面定义一堆方法，具体应该调用什么方法，由这个门面来决定
-   */
-
-   public void drawCircle(){
-      circle.draw();
-   }
-   public void drawRectangle(){
-      rectangle.draw();
-   }
-   public void drawSquare(){
-      square.draw();
-   }
-}
-
-```
-
-看看现在客户端怎么调用：
-
-```
-public static void main(String[] args) {
-  ShapeMaker shapeMaker = new ShapeMaker();
-
-  // 客户端调用现在更加清晰了
-  shapeMaker.drawCircle();
-  shapeMaker.drawRectangle();
-  shapeMaker.drawSquare();        
-}
-
-```
-
-门面模式的优点显而易见，客户端不再需要关注实例化时应该使用哪个实现类，直接调用门面提供的方法就可以了，因为门面类提供的方法的方法名对于客户端来说已经很友好了。
-
-### 组合模式
-
-组合模式用于表示具有层次结构的数据，使得我们对单个对象和组合对象的访问具有一致性。
-
-直接看一个例子吧，每个员工都有姓名、部门、薪水这些属性，同时还有下属员工集合（虽然可能集合为空），而下属员工和自己的结构是一样的，也有姓名、部门这些属性，同时也有他们的下属员工集合。
-
-```
-public class Employee {
-   private String name;
-   private String dept;
-   private int salary;
-   private List<Employee> subordinates; // 下属
-
-   public Employee(String name,String dept, int sal) {
-      this.name = name;
-      this.dept = dept;
-      this.salary = sal;
-      subordinates = new ArrayList<Employee>();
-   }
-
-   public void add(Employee e) {
-      subordinates.add(e);
-   }
-
-   public void remove(Employee e) {
-      subordinates.remove(e);
-   }
-
-   public List<Employee> getSubordinates(){
-     return subordinates;
-   }
-
-   public String toString(){
-      return ("Employee :[ Name : " + name + ", dept : " + dept + ", salary :" + salary+" ]");
-   }   
-}
-
-```
-
-通常，这种类需要定义 add(node)、remove(node)、getChildren() 这些方法。
-
-这说的其实就是组合模式，这种简单的模式我就不做过多介绍了，相信各位读者也不喜欢看我写废话。
-
-### 享元模式
-
-英文是 Flyweight Pattern，不知道是谁最先翻译的这个词，感觉这翻译真的不好理解，我们试着强行关联起来吧。Flyweight 是轻量级的意思，享元分开来说就是 共享 元器件，也就是复用已经生成的对象，这种做法当然也就是轻量级的了。
-
-复用对象最简单的方式是，用一个 HashMap 来存放每次新生成的对象。每次需要一个对象的时候，先到 HashMap 中看看有没有，如果没有，再生成新的对象，然后将这个对象放入 HashMap 中。
-
-这种简单的代码我就不演示了。
-
-### 结构型模式总结
-
-前面，我们说了代理模式、适配器模式、桥梁模式、装饰模式、门面模式、组合模式和享元模式。读者是否可以分别把这几个模式说清楚了呢？在说到这些模式的时候，心中是否有一个清晰的图或处理流程在脑海里呢？
-
-代理模式是做方法增强的，适配器模式是把鸡包装成鸭这种用来适配接口的，桥梁模式做到了很好的解耦，装饰模式从名字上就看得出来，适合于装饰类或者说是增强类的场景，门面模式的优点是客户端不需要关心实例化过程，只要调用需要的方法即可，组合模式用于描述具有层次结构的数据，享元模式是为了在特定的场景中缓存已经创建的对象，用于提高性能。
-
-## 参考文章
-
-转自https://javadoop.com/post/design-pattern
-
-
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\27210\357\274\232JVM\345\270\270\347\224\250\345\217\202\346\225\260\344\273\245\345\217\212\350\260\203\344\274\230\345\256\236\350\267\265.md" "b/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\27210\357\274\232JVM\345\270\270\347\224\250\345\217\202\346\225\260\344\273\245\345\217\212\350\260\203\344\274\230\345\256\236\350\267\265.md"
deleted file mode 100644
index 07a6b33..0000000
--- "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\27210\357\274\232JVM\345\270\270\347\224\250\345\217\202\346\225\260\344\273\245\345\217\212\350\260\203\344\274\230\345\256\236\350\267\265.md"
+++ /dev/null
@@ -1,432 +0,0 @@
-# Table of Contents
-
-  * [目录](#目录)
-  * [调优准备](#调优准备)
-  * [性能分析](#性能分析)
-    * [CPU分析](#cpu分析)
-    * [内存分析](#内存分析)
-    * [IO分析](#io分析)
-    * [其他分析工具](#其他分析工具)
-  * [性能调优](#性能调优)
-    * [CPU调优](#cpu调优)
-    * [内存调优](#内存调优)
-    * [IO调优](#io调优)
-  * [其他优化建议](#其他优化建议)
-  * [JVM参数进阶](#jvm参数进阶)
-  * [参考资料](#参考资料)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-
-本文转自：https://www.rowkey.me/blog/2016/11/02/java-profile/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-文章将同步到我的个人博客：
-> www.how2playlife.com
-
-本文是微信公众号【Java技术江湖】的《深入理解JVM虚拟机》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从入门到进阶，一步步地学习JVM基础知识，并上手进行JVM调优实战，JVM是每一个Java工程师必须要学习和理解的知识点，你必须要掌握其实现原理，才能更完整地了解整个Java技术体系，形成自己的知识框架。
-
-为了更好地总结和检验你的学习成果，本系列文章也会提供每个知识点对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-## 目录
-
-*   [调优准备](https://www.rowkey.me/blog/2016/11/02/java-profile/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E8%B0%83%E4%BC%98%E5%87%86%E5%A4%87)
-*   [性能分析](https://www.rowkey.me/blog/2016/11/02/java-profile/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E6%80%A7%E8%83%BD%E5%88%86%E6%9E%90)
-*   [性能调优](https://www.rowkey.me/blog/2016/11/02/java-profile/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E6%80%A7%E8%83%BD%E8%B0%83%E4%BC%98)
-*   [其他优化建议](https://www.rowkey.me/blog/2016/11/02/java-profile/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#%E5%85%B6%E4%BB%96%E4%BC%98%E5%8C%96%E5%BB%BA%E8%AE%AE)
-*   [JVM参数进阶](https://www.rowkey.me/blog/2016/11/02/java-profile/?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io#JVM%E5%8F%82%E6%95%B0%E8%BF%9B%E9%98%B6)
-
-对于调优这个事情来说，一般就是三个过程：
-
-*   性能监控：问题没有发生，你并不知道你需要调优什么。此时需要一些系统、应用的监控工具来发现问题。
-*   性能分析：问题已经发生，但是你并不知道问题到底出在哪里。此时就需要使用工具、经验对系统、应用进行瓶颈分析，以求定位到问题原因。
-*   性能调优：经过上一步的分析定位到了问题所在，需要对问题进行解决，使用代码、配置等手段进行优化。
-
-Java调优也不外乎这三步。
-
-此外，本文所讲的性能分析、调优等是抛开以下因素的：
-
-*   系统底层环境：硬件、操作系统等
-*   数据结构和算法的使用
-*   外部系统如数据库、缓存的使用
-
-## 调优准备
-
-调优是需要做好准备工作的，毕竟每一个应用的业务目标都不尽相同，性能瓶颈也不会总在同一个点上。在业务应用层面，我们需要：
-
-*   需要了解系统的总体架构，明确压力方向。比如系统的哪一个接口、模块是使用率最高的，面临高并发的挑战。
-*   需要构建测试环境来测试应用的性能，使用ab、loadrunner、jmeter都可以。
-*   对关键业务数据量进行分析，这里主要指的是对一些数据的量化分析，如数据库一天的数据量有多少；缓存的数据量有多大等
-*   了解系统的响应速度、吞吐量、TPS、QPS等指标需求，比如秒杀系统对响应速度和QPS的要求是非常高的。
-*   了解系统相关软件的版本、模式和参数等，有时候限于应用依赖服务的版本、模式等，性能也会受到一定的影响。
-
-此外，我们还需要了解Java相关的一些知识：
-
-1.  Java内存相关：这一部分可以参见[谈谈Java内存管理](http://www.rowkey.me/blog/2016/05/07/javamm/)一文
-2.  对Java代码进行基准性能测试：可以使用JMH来进行，[[译]使用JMH进行微基准测试：不要猜，要测试！](http://www.hollischuang.com/archives/1072)。
-3.  HotSpot VM相关知识：[http://www.oracle.com/technetwork/cn/java/javase/tech/index-jsp-136373-zhs.html](http://www.oracle.com/technetwork/cn/java/javase/tech/index-jsp-136373-zhs.html)
-4.  jdk自带各种java工具：[http://www.rowkey.me/blog/2016/11/03/jdk-tools/](http://www.rowkey.me/blog/2016/11/03/jdk-tools/)
-
-## 性能分析
-
-在系统层面能够影响应用性能的一般包括三个因素：CPU、内存和IO，可以从这三方面进行程序的性能瓶颈分析。
-
-### CPU分析
-
-当程序响应变慢的时候，首先使用top、vmstat、ps等命令查看系统的cpu使用率是否有异常，从而可以判断出是否是cpu繁忙造成的性能问题。其中，主要通过us（用户进程所占的%）这个数据来看异常的进程信息。当us接近100%甚至更高时，可以确定是cpu繁忙造成的响应缓慢。一般说来，cpu繁忙的原因有以下几个：
-
-*   线程中有无限空循环、无阻塞、正则匹配或者单纯的计算
-*   发生了频繁的gc
-*   多线程的上下文切换
-
-确定好cpu使用率最高的进程之后就可以使用jstack来打印出异常进程的堆栈信息：
-
-**jstack [pid]**
-
-![jstack](https://www.rowkey.me/images/blog_images/profile/jstack.jpg)
-
-接下来需要注意的一点是，Linux下所有线程最终还是以轻量级进程的形式存在系统中的，而使用jstack只能打印出进程的信息，这些信息里面包含了此进程下面所有线程（轻量级进程-LWP）的堆栈信息。因此，进一步的需要确定是哪一个线程耗费了大量CPU，此时可以使用top -p [processId] -H来查看，也可以直接通过ps -Le来显示所有进程,包括LWP的资源耗费信息。最后，通过在jstack的输出文件中查找对应的LWP的id即可以定位到相应的堆栈信息。其中需要注意的是线程的状态：RUNNABLE、WAITING等。对于Runnable的进程需要注意是否有耗费cpu的计算。对于Waiting的线程一般是锁的等待操作。
-
-也可以使用jstat来查看对应进程的gc信息，以判断是否是gc造成了cpu繁忙。
-
-**jstat -gcutil [pid]**
-
-![jstat](https://www.rowkey.me/images/blog_images/profile/jstat.jpg)
-
-还可以通过vmstat，通过观察内核状态的上下文切换(cs)次数，来判断是否是上下文切换造成的cpu繁忙。
-
-**vmstat 1 5**
-
-![jstat](https://www.rowkey.me/images/blog_images/profile/vmstat.jpg)
-
-此外，有时候可能会由jit引起一些cpu飚高的情形，如大量方法编译等。这里可以使用-XX:+PrintCompilation这个参数输出jit编译情况，以排查jit编译引起的cpu问题。
-
-### 内存分析
-
-对Java应用来说，内存主要是由堆外内存和堆内内存组成。
-
-1.  堆外内存
-
-    堆外内存主要是JNI、Deflater/Inflater、DirectByteBuffer（nio中会用到）使用的。对于这种堆外内存的分析，还是需要先通过vmstat、sar、top、pidstat(这里的sar,pidstat以及iostat都是[sysstat](http://sebastien.godard.pagesperso-orange.fr/documentation.html)软件套件的一部分，需要单独安装)等查看swap和物理内存的消耗状况再做判断的。此外，对于JNI、Deflater这种调用可以通过[Google-preftools](http://www.oschina.net/p/perftools)来追踪资源使用状况。
-
-2.  堆内内存
-
-    此部分内存为Java应用主要的内存区域。通常与这部分内存性能相关的有：
-
-    *   创建的对象：这个是存储在堆中的，需要控制好对象的数量和大小，尤其是大的对象很容易进入老年代
-    *   全局集合：全局集合通常是生命周期比较长的，因此需要特别注意全局集合的使用
-    *   缓存：缓存选用的数据结构不同，会很大程序影响内存的大小和gc
-    *   ClassLoader：主要是动态加载类容易造成永久代内存不足
-    *   多线程：线程分配会占用本地内存，过多的线程也会造成内存不足
-
-    以上使用不当很容易造成：
-
-    *   频繁GC -> Stop the world，使你的应用响应变慢
-    *   OOM，直接造成内存溢出错误使得程序退出。OOM又可以分为以下几种：
-        *   Heap space：堆内存不足
-        *   PermGen space：永久代内存不足
-        *   Native thread：本地线程没有足够内存可分配
-
-    排查堆内存问题的常用工具是jmap，是jdk自带的。一些常用用法如下：
-
-    *   查看jvm内存使用状况：jmap -heap
-    *   查看jvm内存存活的对象：jmap -histo:live
-    *   把heap里所有对象都dump下来，无论对象是死是活：jmap -dump:format=b,file=xxx.hprof
-    *   先做一次full GC，再dump，只包含仍然存活的对象信息：jmap -dump:format=b,live,file=xxx.hprof
-
-    此外，不管是使用jmap还是在OOM时产生的dump文件，可以使用Eclipse的MAT(MEMORY ANALYZER TOOL)来分析，可以看到具体的堆栈和内存中对象的信息。当然jdk自带的jhat也能够查看dump文件(启动web端口供开发者使用浏览器浏览堆内对象的信息)。此外，VisualVM也能够打开hprof文件，使用它的heap walker查看堆内存信息。
-
-    ![](https://www.rowkey.me/images/blog_images/profile/jhat.png)
-
-### IO分析
-
-通常与应用性能相关的包括：文件IO和网络IO。
-
-1.  文件IO
-
-    可以使用系统工具pidstat、iostat、vmstat来查看io的状况。这里可以看一张使用vmstat的结果图。
-
-    ![](https://www.rowkey.me/images/blog_images/profile/io.png)
-
-    这里主要注意bi和bo这两个值，分别表示块设备每秒接收的块数量和块设备每秒发送的块数量，由此可以判定io繁忙状况。进一步的可以通过使用strace工具定位对文件io的系统调用。通常，造成文件io性能差的原因不外乎：
-
-    *   大量的随机读写
-    *   设备慢
-    *   文件太大
-2.  网络IO
-
-    查看网络io状况，一般使用的是netstat工具。可以查看所有连接的状况、数目、端口信息等。例如：当time_wait或者close_wait连接过多时，会影响应用的相应速度。
-
-    ```
-     netstat -anp
-
-    ```
-
-    ![](https://www.rowkey.me/images/blog_images/profile/netstat.png)
-
-    此外，还可以使用tcpdump来具体分析网络io的数据。当然，tcpdump出的文件直接打开是一堆二进制的数据，可以使用wireshark阅读具体的连接以及其中数据的内容。
-
-    ```
-     tcpdump -i eth0 -w tmp.cap -tnn dst port 8080 #监听8080端口的网络请求并打印日志到tmp.cap中
-
-    ```
-
-    还可以通过查看/proc/interrupts来获取当前系统使用的中断的情况。
-
-    ![](https://www.rowkey.me/images/blog_images/profile/interrupts.png)
-
-    各个列依次是：
-
-    ```
-     irq的序号， 在各自cpu上发生中断的次数，可编程中断控制器，设备名称（request_irq的dev_name字段）
-
-    ```
-
-    通过查看网卡设备的终端情况可以判断网络io的状况。
-
-### 其他分析工具
-
-上面分别针对CPU、内存以及IO讲了一些系统/JDK自带的分析工具。除此之外，还有一些综合分析工具或者框架可以更加方便我们对Java应用性能的排查、分析、定位等。
-
-*   VisualVM
-
-    这个工具应该是Java开发者们非常熟悉的一款java应用监测工具，原理是通过jmx接口来连接jvm进程，从而能够看到jvm上的线程、内存、类等信息。 ![](https://www.rowkey.me/images/blog_images/profile/visualvm.png) 如果想进一步查看gc情况，可以安装visual gc插件。此外，visualvm也有btrace的插件，可以可视化直观的编写btrace代码并查看输出日志。 与VisualVm类似的，jconsole也是通过jmx查看远程jvm信息的一款工具，更进一步的，通过它还可以显示具体的线程堆栈信息以及内存中各个年代的占用情况，也支持直接远程执行MBEAN。当然，visualvm通过安装jconsole插件也可以拥有这些功能。 ![](https://www.rowkey.me/images/blog_images/profile/jconsole.png) 但由于这俩工具都是需要ui界面的，因此一般都是通过本地远程连接服务器jvm进程。服务器环境下，一般并不用此种方式。
-
-*   Java Mission Control(jmc)
-
-    此工具是jdk7 u40开始自带的，原来是JRockit上的工具，是一款采样型的集诊断、分析和监控与一体的非常强大的工具: [https://docs.oracle.com/javacomponents/jmc-5-5/jmc-user-guide/toc.htm](https://docs.oracle.com/javacomponents/jmc-5-5/jmc-user-guide/toc.htm)。但是此工具是基于JFR(jcmd <pid>JFR.start name=test duration=60s settings=template.jfc filename=output.jfr)的，而开启JFR需要商业证书：jcmd <pid>VM.unlock_commercial_features。</pid></pid>
-
-    ![](https://www.rowkey.me/images/blog_images/profile/jmc.png)
-
-*   Btrace
-
-    这里不得不提的是btrace这个神器，它使用java attach api+ java agent + instrument api能够实现jvm的动态追踪。在不重启应用的情况下可以加入拦截类的方法以打印日志等。具体的用法可以参考[Btrace入门到熟练小工完全指南](http://calvin1978.blogcn.com/articles/btrace1.html)。
-
-*   Jwebap
-
-    [Jwebap](http://www.oschina.net/p/jwebap)是一款JavaEE性能检测框架，基于asm增强字节码实现。支持：http请求、jdbc连接、method的调用轨迹跟踪以及次数、耗时的统计。由此可以获取最耗时的请求、方法，并可以查看jdbc连接的次数、是否关闭等。但此项目是2006年的一个项目，已经将近10年没有更新。根据笔者使用，已经不支持jdk7编译的应用。如果要使用，建议基于原项目二次开发，同时也可以加入对redis连接的轨迹跟踪。当然，基于字节码增强的原理，也可以实现自己的JavaEE性能监测框架。
-
-    ![](https://www.rowkey.me/images/blog_images/profile/jwebap.png)
-
-    上图来自笔者公司二次开发过的jwebap，已经支持jdk8和redis连接追踪。
-
-*   useful-scripts
-
-    这里有一个本人参与的开源的项目：[https://github.com/superhj1987/useful-scripts](https://github.com/superhj1987/useful-scripts)，封装了很多常用的性能分析命令，比如上文讲的打印繁忙java线程堆栈信息，只需要执行一个脚本即可。
-
-## 性能调优
-
-与性能分析相对应，性能调优同样分为三部分。
-
-### CPU调优
-
-*   不要存在一直运行的线程(无限while循环)，可以使用sleep休眠一段时间。这种情况普遍存在于一些pull方式消费数据的场景下，当一次pull没有拿到数据的时候建议sleep一下，再做下一次pull。
-*   轮询的时候可以使用wait/notify机制
-*   避免循环、正则表达式匹配、计算过多，包括使用String的format、split、replace方法(可以使用apache的commons-lang里的StringUtils对应的方法)，使用正则去判断邮箱格式(有时候会造成死循环)、序列/反序列化等。
-*   结合jvm和代码，避免产生频繁的gc，尤其是full GC。
-
-此外，使用多线程的时候，还需要注意以下几点：
-
-*   使用线程池，减少线程数以及线程的切换
-*   多线程对于锁的竞争可以考虑减小锁的粒度(使用ReetrantLock)、拆分锁(类似ConcurrentHashMap分bucket上锁), 或者使用CAS、ThreadLocal、不可变对象等无锁技术。此外，多线程代码的编写最好使用jdk提供的并发包、Executors框架以及ForkJoin等，此外[Discuptor](http://ifeve.com/disruptor-getting-started/)和[Actor](http://ifeve.com/introducing-actors-akka-notes-part-1/)在合适的场景也可以使用。
-
-### 内存调优
-
-内存的调优主要就是对jvm的调优。
-
-*   合理设置各个代的大小。避免新生代设置过小(不够用，经常minor gc并进入老年代)以及过大(会产生碎片)，同样也要避免Survivor设置过大和过小。
-*   选择合适的GC策略。需要根据不同的场景选择合适的gc策略。这里需要说的是，cms并非全能的。除非特别需要再设置，毕竟cms的新生代回收策略parnew并非最快的，且cms会产生碎片。此外，G1直到jdk8的出现也并没有得到广泛应用，并不建议使用。
-*   jvm启动参数配置-XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:[log_path]，以记录gc日志，便于排查问题。
-
-其中，对于第一点，具体的还有一点建议：
-
-*   **年轻代大小选择**：响应时间优先的应用，尽可能设大，直到接近系统的最低响应时间限制（根据实际情况选择）。在此种情况下，年轻代收集发生gc的频率是最小的。同时，也能够减少到达年老代的对象。吞吐量优先的应用，也尽可能的设置大，因为对响应时间没有要求，垃圾收集可以并行进行，建议适合8CPU以上的应用使用。
-*   **年老代大小选择**：响应时间优先的应用，年老代一般都是使用并发收集器，所以其大小需要小心设置，一般要考虑并发会话率和会话持续时间等一些参数。如果堆设置小了，会造成内存碎片、高回收频率以及应用暂停而使用传统的标记清除方式；如果堆大了，则需要较长的收集时间。最优化的方案，一般需要参考以下数据获得：
-    *   并发垃圾收集信息
-    *   持久代并发收集次数
-    *   传统GC信息
-    *   花在年轻代和年老代回收上的时间比例
-
-    一般吞吐量优先的应用都应该有一个很大的年轻代和一个较小的年老代。这样可以尽可能回收掉大部分短期对象，减少中期的对象，而年老代存放长期存活对象。
-
-此外，**较小堆引起的碎片问题**：因为年老代的并发收集器使用标记、清除算法，所以不会对堆进行压缩。当收集器回收时，会把相邻的空间进行合并，这样可以分配给较大的对象。但是，当堆空间较小时，运行一段时间以后，就会出现“碎片”，如果并发收集器找不到足够的空间，那么并发收集器将会停止，然后使用传统的标记、清除方式进行回收。如果出现“碎片”，可能需要进行如下配置：-XX:+UseCMSCompactAtFullCollection，使用并发收集器时，开启对年老代的压缩。同时使用-XX:CMSFullGCsBeforeCompaction=xx设置多少次Full GC后，对年老代进行压缩。
-
-其余对于jvm的优化问题可见后面**JVM参数进阶**一节。
-
-代码上，也需要注意：
-
-*   避免保存重复的String对象，同时也需要小心String.subString()与String.intern()的使用，尤其是后者其底层数据结构为StringTable，当字符串大量不重复时，会使得StringTable非常大(一个固定大小的hashmap，可以由参数-XX:StringTableSize=N设置大小)，从而影响young gc的速度。在jackson和fastjson中使用了此方法，某些场景下会引起gc问题: [YGC越来越慢，为什么](http://hellojava.info/?p=514)。
-*   尽量不要使用finalizer
-*   释放不必要的引用：ThreadLocal使用完记得释放以防止内存泄漏，各种stream使用完也记得close。
-*   使用对象池避免无节制创建对象，造成频繁gc。但不要随便使用对象池，除非像连接池、线程池这种初始化/创建资源消耗较大的场景，
-*   缓存失效算法，可以考虑使用SoftReference、WeakReference保存缓存对象
-*   谨慎热部署/加载的使用，尤其是动态加载类等
-*   不要用Log4j输出文件名、行号，因为Log4j通过打印线程堆栈实现，生成大量String。此外，使用log4j时，建议此种经典用法，先判断对应级别的日志是否打开，再做操作，否则也会生成大量String。
-
-    ```
-      if (logger.isInfoEnabled()) {
-          logger.info(msg);
-      }
-
-    ```
-
-### IO调优
-
-文件IO上需要注意：
-
-*   考虑使用异步写入代替同步写入，可以借鉴redis的aof机制。
-*   利用缓存，减少随机读
-*   尽量批量写入，减少io次数和寻址
-*   使用数据库代替文件存储
-
-网络IO上需要注意：
-
-*   和文件IO类似，使用异步IO、多路复用IO/事件驱动IO代替同步阻塞IO
-*   批量进行网络IO,减少IO次数
-*   使用缓存，减少对网络数据的读取
-*   使用协程: [Quasar](http://colobu.com/2016/07/14/Java-Fiber-Quasar/)
-
-## 其他优化建议
-
-*   算法、逻辑上是程序性能的首要，遇到性能问题，应该首先优化程序的逻辑处理
-*   优先考虑使用返回值而不是异常表示错误
-*   查看自己的代码是否对内联是友好的: [你的Java代码对JIT编译友好么？](http://www.infoq.com/cn/articles/Java-Application-Hostile-to-JIT-Compilation)
-
-此外，jdk7、8在jvm的性能上做了一些增强：
-
-*   通过-XX:+TieredCompilation开启JDK7的[多层编译（tiered compilation）支持](http://rednaxelafx.iteye.com/blog/1022095)。多层编译结合了客户端C1编译器和服务端C2编译器的优点(客户端编译能够快速启动和及时优化，服务器端编译可以提供更多的高级优化)，是一个非常高效利用资源的切面方案。在开始时先进行低层次的编译，同时收集信息，在后期再进一步进行高层次的编译进行高级优化。**需要注意的一点：**这个参数会消耗比较多的内存资源，因为同一个方法被编译了多次，存在多份native内存拷贝，建议把code cache调大一点儿（-XX:+ReservedCodeCacheSize，InitialCodeCacheSize）。否则有可能由于code cache不足，jit编译的时候不停的尝试清理code cache，丢弃无用方法，消耗大量资源在jit线程上。
-*   Compressed Oops：压缩指针在jdk7中的server模式下已经默认开启。
-*   Zero-Based Compressed Ordinary Object Pointers：当使用了上述的压缩指针时，在64位jvm上，会要求操作系统保留从一个虚拟地址0开始的内存。如果操作系统支持这种请求，那么就开启了Zero-Based Compressed Oops。这样可以使得无须在java堆的基地址添加任何地址补充即可把一个32位对象的偏移解码成64位指针。
-*   逃逸分析(Escape Analysis): Server模式的编译器会根据代码的情况，来判断相关对象的逃逸类型，从而决定是否在堆中分配空间，是否进行标量替换(在栈上分配原子类型局部变量)。此外，也可以根据调用情况来决定是否自动消除同步控制，如StringBuffer。这个特性从Java SE 6u23开始就默认开启。
-*   NUMA Collector Enhancements：这个重要针对的是The Parallel Scavenger垃圾回收器。使其能够利用NUMA (Non Uniform Memory Access，即每一个处理器核心都有本地内存，能够低延迟、高带宽访问) 架构的机器的优势来更快的进行gc。可以通过-XX:+UseNUMA开启支持。
-
-**此外，网上还有很多过时的建议，不要再盲目跟随**:
-
-*   变量用完设置为null，加快内存回收，这种用法大部分情况下并没有意义。一种情况除外：如果有个Java方法没有被JIT编译但里面仍然有代码会执行比较长时间，那么在那段会执行长时间的代码前显式将不需要的引用类型局部变量置null是可取的。具体的可以见R大的解释：[https://www.zhihu.com/question/48059457/answer/113538171](https://www.zhihu.com/question/48059457/answer/113538171)
-*   方法参数设置为final，这种用法也没有太大的意义，尤其在jdk8中引入了effective final，会自动识别final变量。
-
-## JVM参数进阶
-
-jvm的参数设置一直是比较理不清的地方，很多时候都搞不清都有哪些参数可以配置，参数是什么意思，为什么要这么配置等。这里主要针对这些做一些常识性的说明以及对一些容易让人进入陷阱的参数做一些解释。
-
-**_以下所有都是针对Oracle/Sun JDK 6来讲_**
-
-1.  启动参数默认值
-
-    Java有很多的启动参数，而且很多版本都并不一样。但是现在网上充斥着各种资料，如果不加辨别的全部使用，很多是没有效果或者本来就是默认值的。一般的，我们可以通过使用java -XX:+PrintFlagsInitial来查看所有可以设置的参数以及其默认值。也可以在程序启动的时候加入-XX:+PrintCommandLineFlags来查看与默认值不相同的启动参数。如果想查看所有启动参数(包括和默认值相同的)，可以使用-XX:+PrintFlagsFinal。 ![](https://www.rowkey.me/images/blog_images/profile/flags-1.png) ![](https://www.rowkey.me/images/blog_images/profile/flags-2.png)
-
-    输出里“=”表示使用的是初始默认值，而“:=”表示使用的不是初始默认值，可能是命令行传进来的参数、配置文件里的参数或者是[ergonomics](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/ergonomics.html)自动选择了别的值。
-
-    此外，还可以使用jinfo命令显示启动的参数。
-
-    *   jinfo -flags [pid] #查看目前启动使用的有效参数
-    *   jinfo -flag [flagName] [pid] #查看对应参数的值
-
-    **这里需要指出的是，当你配置jvm参数时，最好是先通过以上命令查看对应参数的默认值再确定是否需要设置。也最好不要配置你搞不清用途的参数，毕竟默认值的设置是有它的合理之处的。**
-
-2.  动态设置参数
-
-    当Java应用启动后，定位到了是GC造成的性能问题，但是你启动的时候并没有加入打印gc的参数，很多时候的做法就是重新加参数然后重启应用。但这样会造成一定时间的服务不可用。最佳的做法是能够在不重启应用的情况下，动态设置参数。使用jinfo可以做到这一点(本质上还是基于jmx的)。
-
-    ```
-     jinfo -flag [+/-][flagName] [pid] #启用/禁止某个参数
-     jinfo -flag [flagName=value] [pid] #设置某个参数
-
-    ```
-
-    对于上述的gc的情况，就可以使用以下命令打开heap dump并设置dump路径。
-
-    ```
-     jinfo -flag +HeapDumpBeforeFullGC [pid] 
-     jinfo -flag +HeapDumpAfterFullGC [pid]
-     jinfo -flag HeapDumpPath=/home/dump/dir [pid]
-
-    ```
-
-    同样的也可以动态关闭。
-
-    ```
-     jinfo -flag -HeapDumpBeforeFullGC [pid] 
-     jinfo -flag -HeapDumpAfterFullGC [pid]
-
-    ```
-
-    其他的参数设置类似。
-
-3.  -verbose:gc 与 -XX:+PrintGCDetails
-
-    很多gc推荐设置都同时设置了这两个参数，其实，只要打开了-XX:+PrintGCDetails，前面的选项也会同时打开，无须重复设置。
-
-4.  -XX:+DisableExplicitGC
-
-    这个参数的作用就是使得system.gc变为空调用，很多推荐设置里面都是建议开启的。但是，如果你用到了NIO或者其他使用到堆外内存的情况，使用此选项会造成oom。可以用XX:+ExplicitGCInvokesConcurrent或XX:+ExplicitGCInvokesConcurrentAndUnloadsClasses(配合CMS使用，使得system.gc触发一次并发gc)代替。
-
-    此外，还有一个比较有意思的地方。如果你不设置此选项的话，当你使用了RMI的时候，会周期性地来一次full gc。这个现象是由于分布式gc造成的，为RMI服务。具体的可见此链接内容中与dgc相关的：[http://docs.oracle.com/javase/6/docs/technotes/guides/rmi/sunrmiproperties.html](http://docs.oracle.com/javase/6/docs/technotes/guides/rmi/sunrmiproperties.html)
-
-5.  MaxDirectMemorySize
-
-    此参数是设置的堆外内存的上限值。当不设置的时候为-1，此值为-Xmx减去一个survivor space的预留大小。
-
-6.  由于遗留原因，作用相同的参数
-
-    *   -Xss 与 -XX:ThreadStackSize
-    *   -Xmn 与 -XX:NewSize，此外这里需要注意的是设置了-Xmn的话，NewRatio就没作用了。
-7.  -XX:MaxTenuringThreshold
-
-    使用工具查看此值默认值为15，但是选择了CMS的时候，此值会变成4。当此值设置为0时，所有eden里的活对象在经历第一次minor GC的时候就会直接晋升到old gen，survivor space直接就没用。**还有值得注意的一点，当使用并行回收器时，此值是没有作用的，并行回收器默认是自动调整这些参数以求达到吞吐量最大的。**此外，即使是使用CMS等回收器，晋升到老年代的age也不是不变的，当某一age的对象的大小达到年轻代的50%时，这个age会被动态调整为晋升年龄。
-
-8.  -XX:HeapDumpPath
-
-    使用此参数可以指定-XX:+HeapDumpBeforeFullGC、-XX:+HeapDumpAfterFullGC、-XX:+HeapDumpOnOutOfMemoryError触发heap dump文件的存储位置。
-
-9.  -XX:+UseAdaptiveSizePolicy
-
-    此参数在并行回收器时是默认开启的，会根据应用运行状况做自我调整，如MaxTenuringThreshold、survivor区大小等。其中第一次晋升老年代的年龄以InitialTenuringThreshold（默认为7）开始，后续会自动调整。如果希望跟踪每次minor GC后新的存活周期的阈值，可在启动参数上增加：-XX:+PrintTenuringDistribution。如果想要可以配置这些参数，可以关闭此选项，但paralle的性能很难达到最佳。其他垃圾回收期则慎重开启此开关。
-
-## 参考资料
-
-*   [Java HotSpot™ Virtual Machine Performance Enhancements](http://docs.oracle.com/javase/8/docs/technotes/guides/vm/performance-enhancements-7.html)
-*   [Java HotSpot Virtual Machine Garbage Collection Tuning Guide](http://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/index.html)
-*   [[HotSpot VM] JVM调优的”标准参数”的各种陷阱](http://hllvm.group.iteye.com/group/topic/27945)
-
-
-## 参考文章
-
-<https://segmentfault.com/a/1190000009707894>
-
-<https://www.cnblogs.com/hysum/p/7100874.html>
-
-<http://c.biancheng.net/view/939.html>
-
-<https://www.runoob.com/>
-
-https://blog.csdn.net/android_hl/article/details/53228348
-
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2727\357\274\232JNDI\357\274\214OSGI\357\274\214Tomcat\347\261\273\345\212\240\350\275\275\345\231\250\345\256\236\347\216\260.md" "b/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2727\357\274\232JNDI\357\274\214OSGI\357\274\214Tomcat\347\261\273\345\212\240\350\275\275\345\231\250\345\256\236\347\216\260.md"
deleted file mode 100644
index 1c3b52d..0000000
--- "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\2727\357\274\232JNDI\357\274\214OSGI\357\274\214Tomcat\347\261\273\345\212\240\350\275\275\345\231\250\345\256\236\347\216\260.md"
+++ /dev/null
@@ -1,403 +0,0 @@
-# Table of Contents
-
-  * [打破双亲委派模型](#打破双亲委派模型)
-    * [JNDI](#jndi)
-    * [[JNDI 的理解](https://yq.aliyun.com/go/articleRenderRedirect?url=https%3A%2F%2Fwww.cnblogs.com%2Fzhchoutai%2Fp%2F7389089.html)](#[jndi-的理解]httpsyqaliyuncomgoarticlerenderredirecturlhttps3a2f2fwwwcnblogscom2fzhchoutai2fp2f7389089html)
-  * [OSGI](#osgi)
-    * [1.如何正确的理解和认识OSGI技术？](#1如何正确的理解和认识osgi技术？)
-  * [Tomcat类加载器以及应用间class隔离与共享](#tomcat类加载器以及应用间class隔离与共享)
-    * [类加载器](#类加载器)
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-
-本文转自互联网，侵删
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-文章将同步到我的个人博客：
-> www.how2playlife.com
-
-本文是微信公众号【Java技术江湖】的《深入理解JVM虚拟机》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-
-该系列博文会告诉你如何从入门到进阶，一步步地学习JVM基础知识，并上手进行JVM调优实战，JVM是每一个Java工程师必须要学习和理解的知识点，你必须要掌握其实现原理，才能更完整地了解整个Java技术体系，形成自己的知识框架。
-
-为了更好地总结和检验你的学习成果，本系列文章也会提供每个知识点对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-## 打破双亲委派模型
-
-### JNDI
-
-### [JNDI 的理解](https://yq.aliyun.com/go/articleRenderRedirect?url=https%3A%2F%2Fwww.cnblogs.com%2Fzhchoutai%2Fp%2F7389089.html)
-
-
-
-
-
-JNDI是 Java 命名与文件夹接口（Java Naming and Directory Interface），在J2EE规范中是重要的规范之中的一个，不少专家觉得，没有透彻理解JNDI的意义和作用，就没有真正掌握J2EE特别是EJB的知识。 
-
-那么，JNDI究竟起什么作用？//带着问题看文章是最有效的 
-
-要了解JNDI的作用，我们能够从“假设不用JNDI我们如何做？用了JNDI后我们又将如何做？”这个问题来探讨。 
-
-没有JNDI的做法： 
-
-程序猿开发时，知道要开发訪问MySQL数据库的应用，于是将一个对 MySQL JDBC 驱动程序类的引用进行了编码，并通过使用适当的 JDBC URL 连接到数据库。 
-就像以下代码这样： 
-
-    
-    
-    
-    1.  Connection conn=null;  
-    2.  try {  
-    3.    Class.forName("com.mysql.jdbc.Driver",  
-    4.                  true, Thread.currentThread().getContextClassLoader());  
-    5.    conn=DriverManager.  
-    6.      getConnection("jdbc:mysql://MyDBServer?user=qingfeng&password=mingyue");  
-    7.    ......  
-    8.    conn.close();  
-    9.  } catch(Exception e) {  
-    10.    e.printStackTrace();  
-    11.  } finally {  
-    12.    if(conn!=null) {  
-    13.      try {  
-    14.        conn.close();  
-    15.      } catch(SQLException e) {}  
-    16.    }  
-    17.  }  
-
-
-
-这是传统的做法，也是曾经非Java程序猿（如Delphi、VB等）常见的做法。
-
-这种做法一般在小规模的开发过程中不会产生问题，仅仅要程序猿熟悉Java语言、了解JDBC技术和MySQL，能够非常快开发出对应的应用程序。 
-
-没有JNDI的做法存在的问题：
-
-    1、数据库server名称MyDBServer 、username和口令都可能须要改变，由此引发JDBC URL须要改动； 
-    2、数据库可能改用别的产品，如改用DB2或者Oracle，引发JDBC驱动程序包和类名须要改动； 
-    3、随着实际使用终端的添加，原配置的连接池參数可能须要调整； 
-    4、...... 
-
-解决的方法： 
-
-程序猿应该不须要关心“详细的数据库后台是什么？JDBC驱动程序是什么？JDBC URL格式是什么？訪问数据库的username和口令是什么？”等等这些问题。
-
-程序猿编写的程序应该没有对 JDBC驱动程序的引用，没有server名称，没实username称或口令 —— 甚至没有数据库池或连接管理。
-
-而是把这些问题交给J2EE容器（比方weblogic）来配置和管理，程序猿仅仅须要对这些配置和管理进行引用就可以。 
-
-由此，就有了JNDI。
-
-//看的出来。是为了一个最最核心的问题：是为了解耦，是为了开发出更加可维护、可扩展//的系统 
-
-用了JNDI之后的做法： 
-首先。在在J2EE容器中配置JNDI參数，定义一个数据源。也就是JDBC引用參数，给这个数据源设置一个名称；然后，在程序中，通过数据源名称引用数据源从而訪问后台数据库。 
-
-//红色的字能够看出。JNDI是由j2ee容器提供的功能 
-
-详细操作例如以下（以JBoss为例）： 
-1、配置数据源 
-在JBoss 的 D:\jboss420GA\docs\examples\jca 文件夹以下。有非常多不同数据库引用的数据源定义模板。
-
-将当中的 mysql-ds.xml 文件Copy到你使用的server下，如 D:\jboss420GA\server\default\deploy。 
-改动 mysql-ds.xml 文件的内容，使之能通过JDBC正确訪问你的MySQL数据库。例如以下： 
-
-
-    
-    
-    1.  <?
-    
-        xml version="1.0" encoding="UTF-8"?>  
-    
-    2.  <datasources>  
-    3.  <local-tx-datasource>  
-    4.      <jndi-name>MySqlDS</jndi-name>  
-    5.      <connection-url>jdbc:mysql://localhost:3306/lw</connection-url>  
-    6.      <driver-class>com.mysql.jdbc.Driver</driver-class>  
-    7.      <user-name>root</user-name>  
-    8.      <password>rootpassword</password>  
-    9.  <exception-sorter-class-name>  
-    10.  org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter  
-    11.  </exception-sorter-class-name>  
-    12.      <metadata>  
-    13.         <type-mapping>mySQL</type-mapping>  
-    14.      </metadata>  
-    15.  </local-tx-datasource>  
-    16.  </datasources>  
-
-
-
-这里，定义了一个名为MySqlDS的数据源。其參数包含JDBC的URL。驱动类名，username及密码等。 
-
-2、在程序中引用数据源： 
-
-
-
-
-    
-    1.  Connection conn=null;  
-    2.  try {  
-    3.    Context ctx=new InitialContext();  
-    4.    Object datasourceRef=ctx.lookup("java:MySqlDS"); //引用数据源  
-    5.    DataSource ds=(Datasource)datasourceRef;  
-    6.    conn=ds.getConnection();  
-    7.    ......  
-    8.    c.close();  
-    9.  } catch(Exception e) {  
-    10.    e.printStackTrace();  
-    11.  } finally {  
-    12.    if(conn!=null) {  
-    13.      try {  
-    14.        conn.close();  
-    15.      } catch(SQLException e) { }  
-    16.    }  
-    17.  }  
-    
-
-
-直接使用JDBC或者通过JNDI引用数据源的编程代码量相差无几，可是如今的程序能够不用关心详细JDBC參数了。
-
-//解藕了。可扩展了 
-在系统部署后。假设数据库的相关參数变更。仅仅须要又一次配置 mysql-ds.xml 改动当中的JDBC參数，仅仅要保证数据源的名称不变，那么程序源码就无需改动。
-
-由此可见。JNDI避免了程序与数据库之间的紧耦合，使应用更加易于配置、易于部署。
-
-JNDI的扩展： 
-JNDI在满足了数据源配置的要求的基础上。还进一步扩充了作用：全部与系统外部的资源的引用，都能够通过JNDI定义和引用。
-
-//注意什么叫资源 
-
-所以，在J2EE规范中，J2EE 中的资源并不局限于 JDBC 数据源。
-
-引用的类型有非常多，当中包含资源引用（已经讨论过）、环境实体和 EJB 引用。
-
-特别是 EJB 引用，它暴露了 JNDI 在 J2EE 中的另外一项关键角色：查找其它应用程序组件。 
-
-EJB 的 JNDI 引用非常相似于 JDBC 资源的引用。在服务趋于转换的环境中，这是一种非常有效的方法。能够对应用程序架构中所得到的全部组件进行这类配置管理，从 EJB 组件到 JMS 队列和主题。再到简单配置字符串或其它对象。这能够降低随时间的推移服务变更所产生的维护成本，同一时候还能够简化部署，降低集成工作。外部资源”。
-
-总结： 
-
-J2EE 规范要求全部 J2EE 容器都要提供 JNDI 规范的实现。//sun 果然喜欢制定规范JNDI 在 J2EE 中的角色就是“交换机” —— J2EE 组件在执行时间接地查找其它组件、资源或服务的通用机制。在多数情况下，提供 JNDI 供应者的容器能够充当有限的数据存储。这样管理员就能够设置应用程序的执行属性，并让其它应用程序引用这些属性（Java 管理扩展（Java Management Extensions，JMX）也能够用作这个目的）。JNDI 在 J2EE 应用程序中的主要角色就是提供间接层，这样组件就能够发现所须要的资源，而不用了解这些间接性。 
-
-在 J2EE 中，JNDI 是把 J2EE 应用程序合在一起的粘合剂。JNDI 提供的间接寻址同意跨企业交付可伸缩的、功能强大且非常灵活的应用程序。
-
-这是 J2EE 的承诺，并且经过一些计划和预先考虑。这个承诺是全然能够实现的。 
-
- 从上面的文章中能够看出： 
-1、JNDI 提出的目的是为了解藕，是为了开发更加easy维护，easy扩展。easy部署的应用。 
-2、JNDI 是一个sun提出的一个规范(相似于jdbc),详细的实现是各个j2ee容器提供商。sun   仅仅是要求，j2ee容器必须有JNDI这种功能。
-
-3、JNDI 在j2ee系统中的角色是“交换机”，是J2EE组件在执行时间接地查找其它组件、资源或服务的通用机制。 
-4、JNDI 是通过资源的名字来查找的，资源的名字在整个j2ee应用中(j2ee容器中)是唯一的。 
-
-
-   上文提到过双亲委派模型并不是一个强制性的约束模型，而是 Java设计者推荐给开发者的类加载器实现方式。在Java 的世界中大部分的类加载器都遵循这个模型，但也有例外。
-
-   双亲委派模型的一次“被破坏”是由这个模型自身的缺陷所导致的，双亲委派很好地解决了各个类加载器的基础类的统一问题（越基础的类由越上层的加载器进行加载），基础类之所以称为“基础”，是因为它们总是作为被用户代码调用的API ，但世事往往没有绝对的完美，如果基础类又要调用回用户的代码，那该怎么办？
-
-这并非是不可能的事情，一个典型的例子便是JNDI 服务，JNDI现在已经是Java的标准服务，它的代码由启动类加载器去加载（在 JDK 1.3时放进去的rt.jar），但JNDI 的目的就是对资源进行集中管理和查找，它需要调用由独立厂商实现并部署在应用程序的Class Path下的JNDI 接口提供者（SPI，Service Provider Interface）的代码，但启动类加载器不可能“认识” 这些代码 ，因为启动类加载器的搜索范围中找不到用户应用程序类，那该怎么办？
-
-
-为了解决这个问题，Java设计团队只好引入了一个不太优雅的设计：线程上下文类加载器（Thread Context ClassLoader）。这个类加载器可以通过java.lang.Thread类的setContextClassLoader()方法进行设置，如果创建线程时还未设置，它将会从父线程中继承一个，如果在应用程序的全局范围内都没有设置过的话，那这个类加载器默认就是应用程序类加载器（Application ClassLoader）。
-
-   有了线程上下文类加载器，就可以做一些“舞弊”的事情了，JNDI服务使用这个线程上下文类加载器去加载所需要的 SPI代码，也就是父类加载器请求子类加载器去完成类加载的动作，这种行为实际上就是打通了双亲委派模型的层次结构来逆向使用类加载器 ，实际上已经违背了双亲委派模型的一般性原则，但这也是无可奈何的事情。Java中所有涉及SPI的加载动作基本上都采用这种方式，例如JNDI 、JDBC、JCE、 JAXB 和JBI等。
-
-  
-
-## OSGI
-
-  
-
-目前，业内关于OSGI技术的学习资源或者技术文档还是很少的。我在某宝网搜索了一下“OSGI”的书籍，结果倒是有，但是种类少的可怜，而且几乎没有人购买。
-因为工作的原因我需要学习OSGI，所以我不得不想尽办法来主动学习OSGI。我将用文字记录学习OSGI的整个过程，通过整理书籍和视频教程，来让我更加了解这门技术，同时也让需要学习这门技术的同志们有一个清晰的学习路线。
-
-我们需要解决一下几问题:
-
-### 1.如何正确的理解和认识OSGI技术？
-
-我们从外文资料上或者从翻译过来的资料上看到OSGi解释和定义，都是直译过来的，但是OSGI的真实意义未必是中文直译过来的意思。OSGI的解释就是Open Service Gateway Initiative，直译过来就是“开放的服务入口(网关)的初始化”，听起来非常费解，什么是服务入口初始化？
-
-所以我们不去直译这个OSGI，我们换一种说法来描述OSGI技术。
-
-我们来回到我们以前的某些开发场景中去，假设我们使用SSH(struts+spring+hibernate)框架来开发我们的Web项目，我们做产品设计和开发的时候都是分模块的，我们分模块的目的就是实现模块之间的“解耦”，更进一步的目的是方便对一个项目的控制和管理。
-我们对一个项目进行模块化分解之后，我们就可以把不同模块交给不同的开发人员来完成开发，然后项目经理把大家完成的模块集中在一起，然后拼装成一个最终的产品。一般我们开发都是这样的基本情况。
-
-那么我们开发的时候预计的是系统的功能，根据系统的功能来进行模块的划分，也就是说，这个产品的功能或客户的需求是划分的重要依据。
-
-但是我们在开发过程中，我们模块之间还要彼此保持联系，比如A模块要从B模块拿到一些数据，而B模块可能要调用C模块中的一些方法(除了公共底层的工具类之外)。所以这些模块只是一种逻辑意义上的划分。
-
-最重要的一点是，我们把最终的项目要去部署到tomcat或者jBoss的服务器中去部署。那么我们启动服务器的时候，能不能关闭项目的某个模块或功能呢？很明显是做不到的，一旦服务器启动，所有模块就要一起启动，都要占用服务器资源，所以关闭不了模块，假设能强制拿掉，就会影响其它的功能。
-
-以上就是我们传统模块式开发的一些局限性。
-
-我们做软件开发一直在追求一个境界，就是模块之间的真正“解耦”、“分离”，这样我们在软件的管理和开发上面就会更加的灵活，甚至包括给客户部署项目的时候都可以做到更加的灵活可控。但是我们以前使用SSH框架等架构模式进行产品开发的时候我们是达不到这种要求的。
-
-所以我们“架构师”或顶尖的技术高手都在为模块化开发努力的摸索和尝试，然后我们的OSGI的技术规范就应运而生。
-
-现在我们的OSGI技术就可以满足我们之前所说的境界:在不同的模块中做到彻底的分离，而不是逻辑意义上的分离，是物理上的分离，也就是说在运行部署之后都可以在不停止服务器的时候直接把某些模块拿下来，其他模块的功能也不受影响。
-
-由此，OSGI技术将来会变得非常的重要，因为它在实现模块化解耦的路上，走得比现在大家经常所用的SSH框架走的更远。这个技术在未来大规模、高访问、高并发的Java模块化开发领域，或者是项目规范化管理中，会大大超过SSH等框架的地位。
-
-现在主流的一些应用服务器，Oracle的weblogic服务器，IBM的WebSphere，JBoss，还有Sun公司的glassfish服务器，都对OSGI提供了强大的支持，都是在OSGI的技术基础上实现的。有那么多的大型厂商支持OSGI这门技术，我们既可以看到OSGI技术的重要性。所以将来OSGI是将来非常重要的技术。 
-
-但是OSGI仍然脱离不了框架的支持，因为OSGI本身也使用了很多spring等框架的基本控件(因为要实现AOP依赖注入等功能)，但是哪个项目又不去依赖第三方jar呢？
-
-  
-   双亲委派模型的另一次“被破坏”是由于用户对程序动态性的追求而导致的，这里所说的“ 动态性”指的是当前一些非常“热门”的名词：代码热替换（HotSwap）、模块热部署（HotDeployment）等 ，说白了就是希望应用程序能像我们的计算机外设那样，接上鼠标、U盘，不用重启机器就能立即使用，鼠标有问题或要升级就换个鼠标，不用停机也不用重启。
-
-   对于个人计算机来说，重启一次其实没有什么大不了的，但对于一些生产系统来说，关机重启一次可能就要被列为生产事故，这种情况下热部署就对软件开发者，尤其是企业级软件开发者具有很大的吸引力。Sun 公司所提出的JSR-294、JSR-277规范在与 JCP组织的模块化规范之争中落败给JSR-291（即 OSGi R4.2），虽然Sun不甘失去Java 模块化的主导权，独立在发展 Jigsaw项目，但目前OSGi已经成为了业界“ 事实上” 的Java模块化标准，而OSGi实现模块化热部署的关键则是它自定义的类加载器机制的实现。
-
-   每一个程序模块（ OSGi 中称为Bundle）都有一个自己的类加载器，当需要更换一个Bundle 时，就把Bundle连同类加载器一起换掉以实现代码的热替换。
-
-   在OSGi环境下，类加载器不再是双亲委派模型中的树状结构，而是进一步发展为更加复杂的网状结构，当收到类加载请求时，OSGi 将按照下面的顺序进行类搜索：
-
-    1）将以java.*开头的类委派给父类加载器加载。
-    
-    2）否则，将委派列表名单内的类委派给父类加载器加载。
-    
-    3）否则，将Import列表中的类委派给 Export这个类的Bundle的类加载器加载。
-    
-    4）否则，查找当前Bundle的 Class Path，使用自己的类加载器加载。
-    
-    5）否则，查找类是否在自己的Fragment Bundle中，如果在，则委派给 Fragment Bundle的类加载器加载。
-    
-    6）否则，查找Dynamic Import列表的 Bundle，委派给对应Bundle的类加载器加载。
-    
-    7）否则，类查找失败。
-
-   上面的查找顺序中只有开头两点仍然符合双亲委派规则，其余的类查找都是在平级的类加载器中进行的。
-
-   只要有足够意义和理由，突破已有的原则就可认为是一种创新。正如OSGi中的类加载器并不符合传统的双亲委派的类加载器，并且业界对其为了实现热部署而带来的额外的高复杂度还存在不少争议，但在Java 程序员中基本有一个共识：OSGi中对类加载器的使用是很值得学习的，弄懂了OSGi的实现，就可以算是掌握了类加载器的精髓。
-
-
-## Tomcat类加载器以及应用间class隔离与共享
-
-
-
-Tomcat的用户一定都使用过其应用部署功能，无论是直接拷贝文件到webapps目录，还是修改server.xml以目录的形式部署，或者是增加虚拟主机，指定新的appBase等等。
-
-但部署应用时，不知道你是否曾注意过这几点：
-
-1.  如果在一个Tomcat内部署多个应用，甚至多个应用内使用了某个类似的几个不同版本，但它们之间却互不影响。这是如何做到的。
-
-2.  如果多个应用都用到了某类似的相同版本，是否可以统一提供，不在各个应用内分别提供，占用内存呢。
-
-3.  还有时候，在开发Web应用时，在pom.xml中添加了servlet-api的依赖，那实际应用的class加载时，会加载你的servlet-api 这个jar吗
-
-以上提到的这几点，在Tomcat以及各类的应用服务器中，都是通过类加载器（ClasssLoader）来实现的。通过本文，你可以了解到Tomcat内部提供的各种类加载器，Web应用的class和资源等加载的方式，以及其内部的实现原理。在遇到类似问题时，更胸有成竹。
-
-### 类加载器
-
-Java语言本身，以及现在其它的一些基于JVM之上的语言(Groovy，Jython， Scala...)，都是在将代码编译生成class文件，以实现跨多平台，write once, run anywhere。最终的这些class文件，在应用中，又被加载到JVM虚拟机中，开始工作。而把class文件加载到JVM的组件，就是我们所说的类加载器。而对于类加载器的抽象，能面对更多的class数据提供形式，例如网络、文件系统等。
-
-Java中常见的那个ClassNotFoundException和NoClassDefFoundError就是类加载器告诉我们的。
-
-Servlet规范指出，容器用于加载Web应用内Servlet的class loader, 允许加载位于Web应用内的资源。但不允许重写java.*, javax.*以及容器实现的类。同时
-
-每个应用内使用Thread.currentThread.getContextClassLoader()获得的类加载器，都是该应用区别于其它应用的类加载器等等。
-
-根据Servlet规范，各个应用服务器厂商自行实现。所以像其他的一些应用服务器一样， Tomcat也提供了多种的类加载器，以便应用服务器内的class以及部署的Web应用类文件运行在容器中时，可以使用不同的class repositories。
-
-在Java中，类加载器是以一种父子关系树来组织的。除Bootstrap外，都会包含一个parent 类加载器。(这里写parent 类加载器，而不是父类加载器，不是为了装X，是为了避免和Java里的父类混淆) 一般以类加载器需要加载一个class或者资源文件的时候，他会先委托给他的parent类加载器，让parent类加载器先来加载，如果没有，才再在自己的路径上加载。这就是人们常说的双亲委托，即把类加载的请求委托给parent。
-
-但是...，这里需要注意一下
-
-> 对于Web应用的类加载，和上面的双亲委托是有区别的。
-
-   主流的Java Web服务器（也就是Web容器） ，如Tomcat、Jetty、WebLogic、WebSphere 或其他笔者没有列举的服务器，都实现了自己定义的类加载器（一般都不止一个）。因为一个功能健全的 Web容器，要解决如下几个问题：
-
-   1）部署在同一个Web容器上 的两个Web应用程序所使用的Java类库可以实现相互隔离。这是最基本的需求，两个不同的应用程序可能会依赖同一个第三方类库的不同版本，不能要求一个类库在一个服务器中只有一份，服务器应当保证两个应用程序的类库可以互相独立使用。
-
-   2）部署在同一个Web容器上 的两个Web应用程序所使用的Java类库可以互相共享 。这个需求也很常见，例如，用户可能有10个使用[spring](https://yq.aliyun.com/go/articleRenderRedirect?url=https%3A%2F%2Flink.juejin.im%2F%3Ftarget%3Dhttp%253A%252F%252Flib.csdn.net%252Fbase%252Fjavaee "Java EE知识库") 组织的应用程序部署在同一台服务器上，如果把10份Spring分别存放在各个应用程序的隔离目录中，将会是很大的资源浪费——这主要倒不是浪费磁盘空间的问题，而是指类库在使用时都要被加载到Web容器的内存，如果类库不能共享，虚拟机的方法区就会很容易出现过度膨胀的风险。
-
-   3）Web容器需要尽可能地保证自身的安全不受部署的Web应用程序影响。目前，有许多主流的Java Web容器自身也是使用Java语言来实现的。因此，Web容器本身也有类库依赖的问题，一般来说，基于安全考虑，容器所使用的类库应该与应用程序的类库互相独立。
-
-   4）支持JSP应用的Web容器，大多数都需要支持 HotSwap功能。我们知道，JSP文件最终要编译成Java Class才能由虚拟机执行，但JSP文件由于其纯文本存储的特性，运行时修改的概率远远大于第三方类库或程序自身的Class文件 。而且ASP、[PHP](https://yq.aliyun.com/go/articleRenderRedirect?url=https%3A%2F%2Flink.juejin.im%2F%3Ftarget%3Dhttp%253A%252F%252Flib.csdn.net%252Fbase%252Fphp "PHP知识库") 和JSP这些网页应用也把修改后无须重启作为一个很大的“优势”来看待 ，因此“主流”的Web容器都会支持JSP生成类的热替换 ，当然也有“非主流”的，如运行在生产模式（Production Mode）下的WebLogic服务器默认就不会处理JSP文件的变化。
-
-   由于存在上述问题，在部署Web应用时，单独的一个Class Path就无法满足需求了，所以各种 Web容都“不约而同”地提供了好几个Class Path路径供用户存放第三方类库，这些路径一般都以“lib”或“classes ”命名。被放置到不同路径中的类库，具备不同的访问范围和服务对象，通常，每一个目录都会有一个相应的自定义类加载器去加载放置在里面的Java类库 。现在，就以Tomcat 容器为例，看一看Tomcat具体是如何规划用户类库结构和类加载器的。
-
-   在Tomcat目录结构中，有3组目录（“/common/*”、“/server/*”和“/shared/*”）可以存放Java类库，另外还可以加上Web 应用程序自身的目录“/WEB-INF/*” ，一共4组，把Java类库放置在这些目录中的含义分别如下：
-
-   ①放置在/common目录中：类库可被Tomcat和所有的 Web应用程序共同使用。
-
-   ②放置在/server目录中：类库可被Tomcat使用，对所有的Web应用程序都不可见。
-
-   ③放置在/shared目录中：类库可被所有的Web应用程序共同使用，但对Tomcat自己不可见。
-
-   ④放置在/WebApp/WEB-INF目录中：类库仅仅可以被此Web应用程序使用，对 Tomcat和其他Web应用程序都不可见。
-
-   为了支持这套目录结构，并对目录里面的类库进行加载和隔离，Tomcat自定义了多个类加载器，这些类加载器按照经典的双亲委派模型来实现，其关系如下图所示。
-
-  
-
-![](https://user-gold-cdn.xitu.io/2017/5/8/0dddae151e8fe1eba5db1a35d2b7b9b2?imageView2/0/w/1280/h/960/format/webp/ignore-error/1) 
-
-  
-
-  
-
-
-
-   上图中灰色背景的3个类加载器是JDK默认提供的类加载器，这3个加载器的作用已经介绍过了。而CommonClassLoader、CatalinaClassLoader、SharedClassLoader和WebappClassLoader则是Tomcat自己定义的类加载器，它们分别加载/common/*、/server/*、/shared/*和/WebApp/WEB-INF/*中的Java类库。其中WebApp类加载器和Jsp类加载器通常会存在多个实例，每一个Web应用程序对应一个WebApp类加载器，每一个JSP文件对应一个Jsp类加载器。
-
-   从图中的委派关系中可以看出，CommonClassLoader能加载的类都可以被Catalina ClassLoader和SharedClassLoader使用，而CatalinaClassLoader和Shared  ClassLoader自己能加载的类则与对方相互隔离。WebAppClassLoader可以使用SharedClassLoader加载到的类，但各个WebAppClassLoader实例之间相互隔离。
-
-   而JasperLoader的加载范围仅仅是这个JSP文件所编译出来的那一个.Class文件，它出现的目的就是为了被丢弃：当Web容器检测到JSP文件被修改时，会替换掉目前的JasperLoader的实例，并通过再建立一个新的Jsp类加载器来实现JSP文件的HotSwap功能。
-
-   对于Tomcat的6.x版本，只有指定了tomcat/conf/catalina.properties配置文件的server.loader和share.loader项后才会真正建立Catalina ClassLoader和Shared ClassLoader的实例，否则在用到这两个类加载器的地方都会用Common ClassLoader的实例代替，而默认的配置文件中没有设置这两个loader项，所以Tomcat 6.x顺理成章地把/common、/server和/shared三个目录默认合并到一起变成一个/lib目录，这个目录里的类库相当于以前/common目录中类库的作用。
-
-   这是Tomcat设计团队为了简化大多数的部署场景所做的一项改进，如果默认设置不能满足需要，用户可以通过修改配置文件指定server.loader和share.loader的方式重新启用Tomcat 5.x的加载器[架构](https://yq.aliyun.com/go/articleRenderRedirect?url=https%3A%2F%2Flink.juejin.im%2F%3Ftarget%3Dhttp%253A%252F%252Flib.csdn.net%252Fbase%252Farchitecture "大型网站架构知识库")。
-
-    Tomcat加载器的实现清晰易懂，并且采用了官方推荐的“正统”的使用类加载器的方式。如果读者阅读完上面的案例后，能完全理解Tomcat设计团队这样布置加载器架构的用意，那说明已经大致掌握了类加载器“主流”的使用方式，那么笔者不妨再提一个问题让读者思考一下：前面曾经提到过一个场景，如果有10个Web应用程序都是用Spring来进行组织和管理的话，可以把Spring放到Common或Shared目录下让这些程序共享。
-
-    Spring要对用户程序的类进行管理，自然要能访问到用户程序的类，而用户的程序显然是放在/WebApp/WEB-INF目录中的，那么被CommonClassLoader或SharedClassLoader加载的Spring如何访问并不在其加载范围内的用户程序呢？如果研究过虚拟机类加载器机制中的双亲委派模型，相信读者可以很容易地回答这个问题。
-
-  分析：如果按主流的双亲委派机制，显然无法做到让父类加载器加载的类 去访问子类加载器加载的类，上面在类加载器一节中提到过通过线程上下文方式传播类加载器。
-
-  答案是使用线程上下文类加载器来实现的，使用线程上下文加载器，可以让父类加载器请求子类加载器去完成类加载的动作。
-
-  看spring源码发现，spring加载类所用的Classloader是通过Thread.currentThread().getContextClassLoader()来获取的，而当线程创建时会默认setContextClassLoader(AppClassLoader)，即线程上下文类加载器被设置为 AppClassLoader，spring中始终可以获取到这个AppClassLoader( 在 Tomcat里就是WebAppClassLoader)子类加载器来加载bean ，以后任何一个线程都可以通过 getContextClassLoader()获取到WebAppClassLoader来getbean 了 。
-
-  
-
-本篇博文内容取材自《深入理解Java虚拟机：JVM高级特性与最佳实践》
-
-## 参考文章
-
-<https://segmentfault.com/a/1190000009707894>
-
-<https://www.cnblogs.com/hysum/p/7100874.html>
-
-<http://c.biancheng.net/view/939.html>
-
-<https://www.runoob.com/>
-
-https://blog.csdn.net/android_hl/article/details/53228348
-
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232GC\350\260\203\344\274\230\346\200\235\350\267\257\344\270\216\345\270\270\347\224\250\345\267\245\345\205\267.md" "b/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232GC\350\260\203\344\274\230\346\200\235\350\267\257\344\270\216\345\270\270\347\224\250\345\267\245\345\205\267.md"
deleted file mode 100644
index 01adef6..0000000
--- "a/docs/java/jvm/\346\267\261\345\205\245\347\220\206\350\247\243JVM\350\231\232\346\213\237\346\234\272\357\274\232GC\350\260\203\344\274\230\346\200\235\350\267\257\344\270\216\345\270\270\347\224\250\345\267\245\345\205\267.md"
+++ /dev/null
@@ -1,54 +0,0 @@
-# Table of Contents
-
-  * [参考文章](#参考文章)
-  * [微信公众号](#微信公众号)
-    * [Java技术江湖](#java技术江湖)
-    * [个人公众号：黄小斜](#个人公众号：黄小斜)
-
-
-本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
-> https://github.com/h2pl/Java-Tutorial
-
-喜欢的话麻烦点下Star哈
-
-文章首发于我的个人博客：
-> www.how2playlife.com
-
-本文是微信公众号【Java技术江湖】的《深入理解JVM虚拟机》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我认为不错的技术博客内容，引用其中了一些比较好的博客文章，如有侵权，请联系作者。
-该系列博文会告诉你如何从入门到进阶，一步步地学习JVM基础知识，并上手进行JVM调优实战，JVM是每一个Java工程师必须要学习和理解的知识点，你必须要掌握其实现原理，才能更完整地了解整个Java技术体系，形成自己的知识框架。为了更好地总结和检验你的学习成果，本系列文章也会提供每个知识点对应的面试题以及参考答案。
-
-如果对本系列文章有什么建议，或者是有什么疑问的话，也可以关注公众号【Java技术江湖】联系作者，欢迎你参与本系列博文的创作和修订。
-
-<!-- more -->
-
-
-
-## 参考文章
-
-<https://segmentfault.com/a/1190000009707894>
-
-<https://www.cnblogs.com/hysum/p/7100874.html>
-
-<http://c.biancheng.net/view/939.html>
-
-<https://www.runoob.com/>
-
-https://blog.csdn.net/android_hl/article/details/53228348
-
-## 微信公众号
-
-### Java技术江湖
-
-如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号【Java技术江湖】一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-
-**Java工程师必备学习资源:** 一些Java工程师常用学习资源，关注公众号后，后台回复关键字 **“Java”** 即可免费无套路获取。
-
-![我的公众号](https://img-blog.csdnimg.cn/20190805090108984.jpg)
-
-### 个人公众号：黄小斜
-
-作者是 985 硕士，蚂蚁金服 JAVA 工程师，专注于 JAVA 后端技术栈：SpringBoot、MySQL、分布式、中间件、微服务，同时也懂点投资理财，偶尔讲点算法和计算机理论基础，坚持学习和写作，相信终身学习的力量！
-
-**程序员3T技术学习资源：** 一些程序员学习技术的资源大礼包，关注公众号后，后台回复关键字 **“资料”** 即可免费无套路获取。	
-
-![](https://img-blog.csdnimg.cn/20190829222750556.jpg)
diff --git a/docs/monitor/Spring Actuator.md b/docs/monitor/Spring Actuator.md
new file mode 100644
index 0000000..a1ee5ef
--- /dev/null
+++ b/docs/monitor/Spring Actuator.md	
@@ -0,0 +1,578 @@
+## ǰ��
+
+��΢����ϵͳ�ܹ��У�����ļ���DZز����ٵġ�Ŀǰ�����΢����Ӧ�����ǻ���Spring Cloudϵ�У�Ҳ����˵�ǻ���Spring Bootϵ�еġ���ʱʹ��Spring Boot Actuator������΢����ļ�أ���������ȫ�棬���ҷdz����㡣
+
+����ƪ���¡�[Spring Boot Actuator���ɣ��ѵ���������ã�](https://link.juejin.cn?target=https%3A%2F%2Fmp.weixin.qq.com%2Fs%2FBaNQWygQb8UXxktrXetOcw "https://mp.weixin.qq.com/s/BaNQWygQb8UXxktrXetOcw")���������Ѿ���������ν�Actuator���ɵ�Spring Boot��Ŀ�У����ҽ���������Զ���Endpoint���˵㣩������������˵�������룬��ô����ƪ�����أ����ǽ�����Actuatorԭ���˵�Ĺ��ܼ�����ʹ�ó�����
+
+## Endpoints ����
+
+Actuator����ν�� Endpoints ������Ϊ�˵㣩�ṩ���ⲿ����Ӧ�ó�����з��ʺͽ����Ĺ��ܡ� ����˵/health�˵��ṩ��Ӧ�ý����������Ϣ��metrics �˵��ṩ��Ӧ�ó����ָ�꣨JVM �ڴ�ʹ�á�ϵͳCPUʹ�õȣ���Ϣ��
+
+Actuatorԭ���Ķ˵�ɷ�Ϊ�����ࣺ
+
+*   Ӧ�������ࣺ��ȡӦ�ó����м��ص�Ӧ�����á������������Զ������ñ������Spring BootӦ��������ص���������Ϣ��
+*   ����ָ���ࣺ��ȡӦ�ó������й��������ڼ�صĶ���ָ�꣬���磺�ڴ���Ϣ���̳߳���Ϣ��HTTP����ͳ�Ƶȡ�
+*   ���������ࣺ�ṩ�˶�Ӧ�õĹرյȲ����๦�ܡ�
+
+��ͬ�汾��Actuator�ṩ��ԭ���˵��������룬��ʹ�õĹ������������ʹ�ð汾�Ĺٷ��ĵ�Ϊ׼��ͬʱ��ÿ��ԭ���Ķ˵㶼����ͨ�������������Ľ��û����á�
+
+����Actuator 2.x ��Ĭ�϶˵�������/actuatorǰ׺��ͬʱĬ��ֻ��¶�������˵�Ϊ/actuator/health�� /actuator/info�����ڶ˵㱩¶�����ã��ɲο�ǰһƪ���¡��������Spring Boot 2.2.2.RELEASE�汾���ص㽲��ÿ���˵�Ĺ��ܺ�Ӧ�ó�����
+
+## actuator�˵�
+
+Actuator 2.x������Ĭ�϶˵㣬����չʾĿǰӦ���б�¶�����Ķ˵���ܣ����������Ϊ���ö˵��Ŀ¼��
+
+����URL��[http://localhost:8080/actuator](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator "http://localhost:8080/actuator") ����Ӧչʾ�������ͼ��
+
+![image-20230530233537559](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530233537559.png)
+
+����ֻչʾ��һ���ֵĶ˵㣬���ؽ��Ϊ�����������������IJ��-Handler�����˸�ʽ������ͨ��actuator����ֱ�۵Ŀ���Ŀǰ��������Щ�˵㣬�Լ���Щ�˵�����ƺ�����·����
+
+�������ǾͰ�����ʾactuator�˵�չʾ���б���һ���ܡ�
+
+## auditevents�˵�
+
+auditevents�˵�������ʾӦ�ñ�¶������¼� (������֤���롢����ʧ��)����ʹ���Ǵ������ж˵㣬Ĭ�������Ҳ�ǿ���������˵�ġ���Ϊʹ������ǰ������Ҫ��Spring�����д���һ������ΪAuditEventRepository��Bean�ġ�
+
+�鿴�������ϴ�����̳̣������϶��ǽ�����auditevents�˵㹦�ܣ���δչʾ����ʵ�������߾����෽���ԣ����ڸ����д��һ������������
+
+�����漰��Ȩ����֤����Ҫ������spring-boot-starter-security������
+
+````
+<dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-security</artifactId>
+</dependency>` 
+````
+
+������������������Dz����ģ�����Ҫ����security�����ã���ȻAuthorizationAuditListener,AuthenticationAuditListener ����ʲô�¼���? ���,���Ǽ������´��룺
+
+
+````
+@Configuration
+public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
+
+ @Override
+ protected void configure(AuthenticationManagerBuilder auth) throws Exception {
+
+ auth.inMemoryAuthentication()
+ .withUser("admin")
+ .password(bcryptPasswordEncoder().encode("admin"))
+ .roles("admin");
+ }
+````
+
+````
+ @Bean
+ public PasswordEncoder bcryptPasswordEncoder() {
+ return new BCryptPasswordEncoder();
+ }
+}
+````
+
+���������securityĬ�ϵĵ�¼�����Ȩ�޿��ƣ�Ҳ����˵���еķ��ʶ���Ҫ���е�¼������¼���û����������Ϊadmin��
+
+���⣬ǰ���ᵽ��Ҫ�õ�AuditEventRepository��Bean�������ʼ��һ����Ӧ��Bean��
+
+
+
+
+````
+@Configuration
+public class AuditEventConfig {
+
+ @Bean
+ public InMemoryAuditEventRepository repository(){
+ return new InMemoryAuditEventRepository();
+ }
+}
+````
+
+InMemoryAuditEventRepository��AuditEventRepository�ӿڵ�Ψһʵ���ࡣ
+
+������Ŀ��auditevents�˵������ˡ�����[http://localhost:8080/actuator](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator "http://localhost:8080/actuator") ,��ʱ����ת��Security�ṩ�ĵ�¼ҳ�棺
+
+![image-20230530233604253](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530233604253.png)
+
+���������ָ�����û��������룬��¼�ɹ�����ת��/actuatorҳ�棺
+
+![image-20230530233625068](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530233625068.png)
+
+���Կ���auditevents�˵��Ѿ��ɹ���ʾ�����ˡ��¿�ҳ�����[http://localhost:8080/actuator/auditevents](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fauditevents "http://localhost:8080/actuator/auditevents") ��չʾ�������£�
+
+![image-20230530233716752](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530233716752.png)
+
+���Կ����Ѿ���¼����Ȩ����ص��¼������е�һ���¼�������ֱ�ӷ���actuator�˵�ʱ������֮ǰΪ��Ȩ�����棬�����¼�����Ϊ"AUTHORIZATION_FAILURE"��Ҳ������֤ʧ�ܡ���ʱ��ת����¼ҳ�棬Ȼ���ڵ�¼ҳ�������û��������룬��¼�ɹ�����Ӧ���¼�Ϊ"AUTHENTICATION_SUCCESS"��
+
+Ҳ����˵auditevents��¼���û���֤��¼ϵͳ��ص��¼���Ϣ������ʱ�������֤�û����¼����͡����ʵ�ַ��sessionId�ȡ�
+
+ʾ��Դ���ַ��[github.com/secbr/sprin��](https://link.juejin.cn?target=https%3A%2F%2Fgithub.com%2Fsecbr%2Fspringboot-all%2Ftree%2Fmaster%2Fspringboot-actuator-auditevents "https://github.com/secbr/springboot-all/tree/master/springboot-actuator-auditevents") ��
+
+## beans�˵�
+
+/beans�˵�᷵��Spring����������bean�ı��������͡��Ƿ�������������Ϣ��
+
+����·��Ϊ[http://localhost:8080/actuator/beans](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fbeans "http://localhost:8080/actuator/beans") ����Χ������£�
+
+![image-20230530233748286](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530233748286.png)
+
+����˵��չʾĿǰSpring�����г�ʼ��������Bean������һ�£������������һ��Bean������ȷ���Ƿ�ɹ�ʵ�������Dz��ǾͿ���ͨ������˿ڲ�ѯһ���أ�
+
+��������Ŀ�ж���һ��TestController����ע��һ��UserService��
+
+
+````
+@Controller
+public class TestController {
+
+ @Resource
+ private UserService userService;
+}
+````
+
+�������������ʸö˵㣬�ῴ��������Ϣ��
+
+![image-20230530233805161](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530233805161.png)
+
+���Կ���TestController��ʵ�����ˣ�����������UserService��
+
+## caches�˵�
+
+caches�˵���Ҫ���ڱ�¶Ӧ�ó����еĻ��塣������Spring Boot�ṩ��Cache�����չʾһ��ʵ����
+
+����Ŀ�м���spring-boot-starter-cache������������
+
+
+````
+<dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-cache</artifactId>
+</dependency>
+````
+
+Ȼ����������������@EnableCaching���������湦�ܡ�
+
+����һ��CacheController�����䷽��queryAllʹ�û�����ƣ�
+
+
+````
+@RestController
+public class CacheController {
+
+ @RequestMapping("/queryAll")
+ @Cacheable(value = "queryAll")
+ public Map<String, String> queryAll() {
+ Map<String, String> map = new HashMap<>();
+ map.put("1", "Tom");
+ map.put("2", "Steven");
+ return map;
+ }
+}
+````
+
+����ʹ��@Cacheableע����ʵ�ֻ��湦�ܣ������keyΪqueryAll����ʱ������[http://localhost:8080/actuator/caches](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fcaches "http://localhost:8080/actuator/caches") ����չʾ����ĸ����ݣ������沢û�л��档
+
+����һ��[http://localhost:8080/queryAll](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2FqueryAll "http://localhost:8080/queryAll") ��Ҳ���Ǵ���һ�»������ݵ����ɡ���ʱ�ٷ�����������ӣ�����Կ���Ӧ�ó����еĻ�����Ϣ�ˣ�
+
+![image-20230530233852486](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530233852486.png)
+
+���Կ��������ص����ݲ���չʾ��Ӧ�ó���Ļ����������ͬʱҲչʾ�˻����Key�ͻ������ݴ洢������Ϣ��
+
+## caches-cache�˵�
+
+caches-cache�˵��Ƕ�����caches�˵����չ��caches�˵�չʾ�����еĻ�����Ϣ�������ֱ�ӿ��������һ��������Ϣ�������ʹ��caches-cache�˵㡣
+
+���ʵ�URLΪ��[http://localhost:8080/actuator/caches/{cache}](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fcaches%2F%257Bcache%257D "http://localhost:8080/actuator/caches/%7Bcache%7D") �����д������ڵ�ֵ�����滻Ϊ�����key��
+
+
+
+
+`http://localhost:8080/actuator/caches/queryAll`
+
+�������ռλ������queryAll�������key����ִ�н�����£�
+
+![image-20230530233906164](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530233906164.png)
+
+���Կ�����ֻ��ѯ����ָ���Ļ�����Ϣ������������������������ƣ�key��������Ĵ洢���͡�
+
+## health�˵�
+
+health�˵��������Ӧ�õ�����״̬�����Ƶʹ�õ�һ���˵㡣���Ӧ��ʵ��������״̬�Լ�Ӧ�ò�����������ԭ�򣬱������ݿ����ӡ����̿ռ䲻���ȡ�
+
+���ʵ�ַ��[http://localhost:8080/actuator/health](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fhealth "http://localhost:8080/actuator/health")
+
+չʾ�����
+
+`{
+"status": "UP"
+}`
+
+�����ʵ�����ڼ򵥣�����Ŀ�а����ݿ�����ɽ�ȥ��
+
+`<!--���ݿ��������-->
+
+````
+<dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-jdbc</artifactId>
+</dependency>
+<dependency>
+ <groupId>mysql</groupId>
+ <artifactId>mysql-connector-java</artifactId>
+</dependency>` 
+````
+
+Ȼ����application�����ļ��н������ã�
+
+
+
+```
+spring:
+ datasource:
+ url: jdbc:mysql://xxx:3333/xxx?characterEncoding=utf8&serverTimezone=Asia/Shanghai
+ username: root
+ password: root
+ driver-class-name: com.mysql.cj.jdbc.Driver
+```
+
+ͬʱ������Ҫ��application�����ļ�������һ��management.endpoint.health.show-details��ֵ����������������ѡ�
+
+*   never ����չʾ��ϸ��Ϣ��up ���� down ��״̬��Ĭ�����ã�
+*   when-authorized����ϸ��Ϣ����չʾ��ͨ����֤���û�����Ȩ�Ľ�ɫ����ͨ��management.endpoint.health.roles ���ã�
+*   always���������û���¶��ϸ��Ϣ��
+
+Ĭ��ֵ��never����������ֱ�ӷ��ʿ�����ֻ��UP��DOWN�����ڼ��������ݿ⣬ͬʱ�Ѹ���ֵ����Ϊalways����һ�����飺
+
+![image-20230530233934501](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530233934501.png)
+
+���Կ�������״̬ΪUP��������������������ΪUP�������ݿ���MYSQL��������ݿ�����Ϊ��SELECT 1����ͬʱ����չʾ�˴�����Ϣ��ping��״̬��
+
+�������ǰ����ݿ���û������������Ĵ����������ʿɵã�
+
+![image-20230530233951145](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530233951145.png)
+
+״̬ΪDOWN�������db���������⣬״̬ΪDOWN�������������error��չʾ�����Կ����ǽ�������ʱ�����ˡ���ʵ���У����ǿ���ͨ��health�˿ڼ�����ݿ⡢Redis��MongoDB�����̵Ƚ��������ActuatorԤ����Ĵ�����Ϊ��DataSourceHealthIndicator, DiskSpaceHealthIndicator, MongoHealthIndicator, RedisHealthIndicator�ȡ�
+
+����ÿ��ָ�궼���Ե����Ľ��п����͹رգ������ݿ��Ϊ����
+
+
+````
+management:
+ health:
+ db:
+ enabled: true` 
+````
+
+## info�˵�
+
+/info �˵������鿴�����ļ� application����info��ͷ��������Ϣ��Ĭ������� application�в�û�� info �ڵ����ã�����Ĭ��Ϊ�ա�
+
+application�������������ã�
+
+
+
+````
+info:
+ user:
+ type: ���ں�
+ name: �������ӽ�
+ wechat: zhuan2quan
+````
+
+����[http://localhost:8080/actuator/info](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Finfo "http://localhost:8080/actuator/info") ��չʾ������£�
+
+![image-20230530234019487](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530234019487.png)
+
+## conditions�˵�
+
+Spring Boot�ṩ���Զ����ù��ܣ�ʹ�������dz����㡣����Щ�Զ���������ʲô�������Ч�ģ��Ƿ���Ч�DZȽ����Ų�ġ���ʱ������ʹ�� conditions ��Ӧ������ʱ�鿴ij����������ʲô��������Ч����Ϊʲôû����Ч��
+
+����URL��[http://localhost:8080/actuator/conditions](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fconditions "http://localhost:8080/actuator/conditions") �����ַ�����Ϣ���£�
+
+![image-20230530234053134](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530234053134.png)
+
+���Կ���ij���Զ��������Ӧ����Ч��������ʾ��Ϣ��
+
+## shutdown�˵�
+
+shutdown�˵����ڲ���������˵㣬�������Źر� Spring Boot Ӧ�á���Ҫ�������ļ��п�����
+
+
+````
+management:
+ endpoint:
+ shutdown:
+ enabled: true
+````
+
+�ö˵�ֻ֧��POST����ִ��������ؽ�����£�
+
+
+```
+curl -X POST "http://localhost:8080/actuator/shutdown" 
+{
+ "message": "Shutting down, bye..."
+}
+```
+
+ִ��֮�󣬻ᷢ��Ӧ�ó����Ѿ����ر��ˡ����ڸö˵��ر�Ӧ�ó������ʹ������ҪС�ġ�
+
+## configprops�˵�
+
+��Spring Boot��Ŀ�У����Ǿ������õ�@ConfigurationPropertiesע��������ע��һЩ���ԣ���configprops�˵����������ʾ��Щ����ע���ע�������ࡣ
+
+����ǰ���info���ã����ǾͿ��Զ���һ����InfoProperties��
+
+
+````
+@Component
+@ConfigurationProperties(prefix = "info")
+public class InfoProperties {
+
+ private String type;
+
+ private String name;
+
+ private String wechat;
+  
+ // ʡ��getter/setter 
+}
+````
+
+����URL��[http://localhost:8080/actuator/configprops](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fconfigprops "http://localhost:8080/actuator/configprops") ��������Ϣ���£�
+
+![image-20230530234110515](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530234110515.png)
+
+�������Կ���ϵͳ��Ĭ�ϼ��ɵ���������Ϣ�������Կ��������Զ������������Ϣ��������Ҫע����Ƕ�Ӧ������Ҫ����ʵ������@Component��������ܹ�������
+
+�����Զ�������з�����Bean�����ơ�����ǰ׺�������ProjectInfoProperties��������������Ϣ��
+
+## env�˵�
+
+env�˵����ڻ�ȡȫ���������ԣ�����application�����ļ��е����ݡ�ϵͳ�����ȡ�
+
+����URL��[http://localhost:8080/actuator/env�����ز�����Ϣ��](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fenv%25EF%25BC%258C%25E8%25BF%2594%25E5%259B%259E%25E9%2583%25A8%25E5%2588%2586%25E4%25BF%25A1%25E6%2581%25AF%25EF%25BC%259A "http://localhost:8080/actuator/env%EF%BC%8C%E8%BF%94%E5%9B%9E%E9%83%A8%E5%88%86%E4%BF%A1%E6%81%AF%EF%BC%9A")
+
+![image-20230530234200949](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530234200949.png)
+
+## env-toMatch�˵�
+
+env-toMatch�˵���caches��caches-cache���ƣ�һ���ǻ�ȡ���еģ�һ���ǻ�ȡָ���ġ������env-toMatch�˵��ǻ�ȡָ��key�Ļ����������ԡ�
+
+������ʽΪ��[http://localhost:8080/actuator/env/{toMatch}��](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fenv%2F%257BtoMatch%257D%25E3%2580%2582 "http://localhost:8080/actuator/env/%7BtoMatch%7D%E3%80%82") ʵ��URL��[http://localhost:8080/actuator/env/info.user.name](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fenv%2Finfo.user.name "http://localhost:8080/actuator/env/info.user.name") �����ؽ������ͼ��
+
+![image-20230530234238073](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530234238073.png)
+
+����������Ϣ���������Ե���Դ��valueֵ����Ϣ��
+
+## loggers�˵�
+
+/loggers �˵㱩¶�˳����ڲ����õ����� logger ����Ϣ��������ͬ��package����ͬ�������־������Ϣ��
+
+����URL��[http://localhost:8080/actuator/loggers](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Floggers "http://localhost:8080/actuator/loggers") �����ַ��ؽ����
+
+![image-20230530234301625](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530234301625.png)
+
+## loggers-name�˵�
+
+loggers-name�˵�Ҳ��logger�˵��ϸ�֣�����ͨ��name����ijһ��logger��
+
+���������ʽ��[http://localhost:8080/actuator/loggers/{name}](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Floggers%2F%257Bname%257D "http://localhost:8080/actuator/loggers/%7Bname%7D") ʾ������URL��[http://localhost:8080/actuator/loggers/com.secbro2.SpringbootActuatorApplication](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Floggers%2Fcom.secbro2.SpringbootActuatorApplication "http://localhost:8080/actuator/loggers/com.secbro2.SpringbootActuatorApplication") �����ؽ�����£�
+
+
+
+`{
+"configuredLevel": null,
+"effectiveLevel": "INFO"
+}`
+
+���Կ��������������־����ΪINFO��
+
+## heapdump�˵�
+
+heapdump�˵�᷵��һ��JVM ��dump��ͨ��JVM�Դ��ļ�ع���VisualVM�ɴ򿪴��ļ��鿴�ڴ���ա������ڴ��Ż������ڶ�ջ��������Ų��������
+
+����URL��[http://localhost:8080/actuator/heapdump](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fheapdump "http://localhost:8080/actuator/heapdump") ��Mac����ϵͳ����������ʻ�����һ������Ϊheapdump���ļ����޺�׺��30M��
+
+������ִ��jvisualvm�����VisualVM�����ε�����ļ�������װ�롱���ǵ��ļ�����Ҫѡ�񡰶�Dump(_.hprof,_.*)����Ȼ��ѡ��heapdump��
+
+![image-20230530234346098](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530234346098.png)
+
+��ʱ�����ͨ�����������ж�ջ��Ϣ�ķ����ˡ�������������ķ����ṩ�˼�Ϊ�����ķ�ʽ��
+
+## threaddump�˵�
+
+/threaddump �˵�����ɵ�ǰ�̻߳�Ŀ��ա����ճ���λ�����ʱ��鿴�̵߳�����dz����ã���Ҫչʾ���߳������߳�ID���̵߳�״̬���Ƿ�ȴ�����Դ����Ϣ��
+
+����URL��[http://localhost:8080/actuator/threaddump](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fthreaddump "http://localhost:8080/actuator/threaddump") �����ַ��ؽ����
+
+![image-20230530234405331](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530234405331.png)
+
+���ǿ�ͨ���߳̿������Ų��������������⡣
+
+## metrics�˵�
+
+/metrics �˵�������¶��ǰӦ�õĸ�����Ҫ����ָ�꣬���磺�ڴ���Ϣ���߳���Ϣ������������Ϣ��tomcat�����ݿ����ӳصȡ�2.x�汾����ֻ��ʾ��һ��ָ����б���
+
+����URL��[http://localhost:8080/actuator/metrics](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fmetrics "http://localhost:8080/actuator/metrics") ��
+
+````
+{
+ "names": [
+ "jvm.memory.max",
+ "jvm.threads.states",
+ "jvm.gc.pause",
+ "http.server.requests",
+ "process.files.max",
+ "jvm.gc.memory.promoted",
+ "system.load.average.1m",
+ "jvm.memory.used",
+ "jvm.gc.max.data.size",
+ "jvm.memory.committed",
+ "system.cpu.count",
+ "logback.events",
+ "jvm.buffer.memory.used",
+ "tomcat.sessions.created",
+ "jvm.threads.daemon",
+ "system.cpu.usage",
+ "jvm.gc.memory.allocated",
+ "tomcat.sessions.expired",
+ "jvm.threads.live",
+ "jvm.threads.peak",
+ "process.uptime",
+ "tomcat.sessions.rejected",
+ "process.cpu.usage",
+ "jvm.classes.loaded",
+ "jvm.classes.unloaded",
+ "tomcat.sessions.active.current",
+ "tomcat.sessions.alive.max",
+ "jvm.gc.live.data.size",
+ "process.files.open",
+ "jvm.buffer.count",
+ "jvm.buffer.total.capacity",
+ "tomcat.sessions.active.max",
+ "process.start.time"
+ ]
+}
+````
+
+/metrics�˵�����ṩӦ������״̬����������ָ�걨�棬����ܷdz���ʵ�ã����Ƕ��ڼ��ϵͳ�еĸ����ع��ܣ����ǵļ�����ݡ������ռ�Ƶ�ʶ�������ͬ���������ÿ�ζ�ͨ��ȫ����ȡ����ķ�ʽ���ռ������Դֱ����ٷ�Ҳ�ǿ����Ǵ��ڴ˷���Ŀ��ǣ���Spring Boot 2.x֮��/metrics�˵�ֻ��ʾ��ָ����б���
+
+�����Ҫ�鿴�����ij��ָ�꣬���ͨ��/metrics-requiredMetricName�˵���ʵ�֡�
+
+## metrics-requiredMetricName�˵�
+
+metrics-requiredMetricName�˵㣬���ڷ���ָ��ָ��ı��棬һ������/metrics�˵��Ȳ��ָ���б���Ȼ���ٲ�ѯ�����ij��ָ�ꡣ
+
+������ʽ��[http://localhost:8080/actuator/metrics/{requiredMetricName}��](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fmetrics%2F%257BrequiredMetricName%257D%25E3%2580%2582 "http://localhost:8080/actuator/metrics/%7BrequiredMetricName%7D%E3%80%82") ʵ��URL��[http://localhost:8080/actuator/metrics/jvm.memory.max](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fmetrics%2Fjvm.memory.max "http://localhost:8080/actuator/metrics/jvm.memory.max") �����ؽ�����£�
+
+
+````
+{
+ "name": "jvm.memory.max",
+ "description": "The maximum amount of memory in bytes that can be used for memory management",
+ "baseUnit": "bytes",
+ "measurements": [
+ {
+ "statistic": "VALUE",
+ "value": 5606211583
+ }
+ ],
+ "availableTags": [
+ {
+ "tag": "area",
+ "values": [
+ "heap",
+ "nonheap"
+ ]
+ },
+ {
+ "tag": "id",
+ "values": [
+ "Compressed Class Space",
+ "PS Survivor Space",
+ "PS Old Gen",
+ "Metaspace",
+ "PS Eden Space",
+ "Code Cache"
+ ]
+ }
+ ]
+}
+````
+
+�������չʾ���������ڴ��������������ָ���չʾ�滻��Ӧ�����ֽ��в鿴���ɡ�
+
+## scheduledtasks�˵�
+
+/scheduledtasks�˵�����չʾӦ���еĶ�ʱ������Ϣ��
+
+������Ŀ�й���������ʱ����������������������@EnableScheduling������ʱ�����ܡ�Ȼ�󴴽���ʱ�����ࣺ
+
+````
+@Component
+public class MyTask {
+
+ @Scheduled(cron = "0/10 * * * * *")
+ public void work() {
+ System.out.println("I am a cron job.");
+ }
+
+ @Scheduled(fixedDelay = 10000)
+ public void work1() {
+ System.out.println("I am a fixedDelay job.");
+ }
+}
+````
+
+���ж������������͵Ķ�ʱ����work�ǻ���cronʵ�ֵĶ�ʱ����work1�ǻ���fixedDelayʵ�ֵĶ�ʱ����
+
+����URL��[http://localhost:8080/actuator/scheduledtasks](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fscheduledtasks "http://localhost:8080/actuator/scheduledtasks") �����ؽ����Ϣ���£�
+
+```
+{
+ "cron": [
+ {
+ "runnable": {
+ "target": "com.secbro2.job.MyTask.work"
+ },
+ "expression": "0/10 * * * * *"
+ }
+ ],
+ "fixedDelay": [
+ {
+ "runnable": {
+ "target": "com.secbro2.job.MyTask.work1"
+ },
+ "initialDelay": 0,
+ "interval": 10000
+ }
+ ],
+ "fixedRate": [],
+ "custom": []
+}
+```
+
+���Կ�����ͨ���ö˵������ȷ��֪����ǰӦ���ж���Ķ�ʱ�����Լ�ִ��ģʽ��Ƶ�Ρ�
+
+## mappings�˵�
+
+/mappings�˵���������ȫ���� URI ·�����Լ��Ϳ�������ӳ���ϵ������������DZȽϳ��õ��ˣ������ϵͳ�IJ鿴URL��Ӧ��Controller������������ʹ�ô˶˵㡣
+
+����URL��[http://localhost:8080/actuator/mappings](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8080%2Factuator%2Fmappings "http://localhost:8080/actuator/mappings") �����ַ��ؽ�����£�
+
+![image-20230530234501440](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230530234501440.png)
+
+���˹���Spring Boot Actuator�ṩ�����ж˵������ϡ�
+
+## ��
+
+����ͨ����Spring Boot Actuator�ṩ���ж˵㹹��ʵ������ʾ��������Ĵ�������ݺ�ʵ������ȫ����һ�����ϡ��ÿ�ܶ��Ų��������⣬�����Ż��ȶ��м���İ���������д���ĵĹ�����ҲԽ��Խ��̾Actuator�Ĺ���֮ǿ��ǿ���Ƽ���������
+
+## �����
+
+���ߣ��������ӽ�
+���ӣ�https://juejin.cn/post/6984550846876876814
+��Դ��ϡ�����
+����Ȩ���������С���ҵת������ϵ���߻����Ȩ������ҵת����ע��������
+
diff --git a/docs/monitor/SpringBoot Admin.md b/docs/monitor/SpringBoot Admin.md
new file mode 100644
index 0000000..7b0c8ab
--- /dev/null
+++ b/docs/monitor/SpringBoot Admin.md	
@@ -0,0 +1,495 @@
+## ժҪ
+
+Spring Boot Admin ���Զ�SpringBootӦ�õĸ���ָ����м�أ�������Ϊ΢����ܹ��еļ��������ʹ�ã����Ľ������÷�������ϸ���ܡ�
+
+## Spring Boot Admin ���
+
+SpringBootӦ�ÿ���ͨ��Actuator����¶Ӧ�����й����еĸ���ָ�꣬Spring Boot Adminͨ����Щָ�������SpringBootӦ�ã�Ȼ��ͨ��ͼ�λ�������ֳ�����Spring Boot Admin�������Լ�ص���Ӧ�ã������Ժ�Spring Cloud��ע���������������΢����Ӧ�á�
+
+Spring Boot Admin �����ṩӦ�õ����¼����Ϣ��
+
+*   ���Ӧ�����й����еĸ�����Ϣ��
+*   ����ָ����Ϣ������JVM��Tomcat��������Ϣ��
+*   ����������Ϣ������ϵͳ���ԡ�ϵͳ���������Լ�Ӧ��������Ϣ��
+*   �鿴���д�����Bean��Ϣ��
+*   �鿴Ӧ���е�����������Ϣ��
+*   �鿴Ӧ��������־��Ϣ��
+*   �鿴JVM��Ϣ��
+*   �鿴���Է��ʵ�Web�˵㣻
+*   �鿴HTTP������Ϣ��
+
+## ����admin-serverģ��
+
+> �������Ǵ���һ��admin-serverģ������Ϊ���������ʾ�书�ܡ�
+
+*   ��pom.xml���������������
+
+
+
+
+
+````
+<dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-web</artifactId>
+</dependency>
+<dependency>
+ <groupId>de.codecentric</groupId>
+ <artifactId>spring-boot-admin-starter-server</artifactId>
+</dependency>
+
+````
+
+*   ��application.yml�н������ã�
+
+
+
+
+
+````spring:
+ application:
+ name: admin-server
+server:
+ port: 9301
+````
+
+*   ��������������@EnableAdminServer������admin-server���ܣ�
+
+
+
+
+````
+@EnableAdminServer
+@SpringBootApplication
+public class AdminServerApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(AdminServerApplication.class, args);
+ }
+
+}
+````
+
+## ����admin-clientģ��
+
+> �������Ǵ���һ��admin-clientģ����Ϊ�ͻ���ע�ᵽadmin-server��
+
+*   ��pom.xml���������������
+
+
+
+````
+<dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-web</artifactId>
+</dependency>
+<dependency>
+ <groupId>de.codecentric</groupId>
+ <artifactId>spring-boot-admin-starter-client</artifactId>
+</dependency>
+````
+
+*   ��application.yml�н������ã�
+
+
+
+
+
+
+
+
+```
+spring:
+ application:
+ name: admin-client
+ boot:
+ admin:
+ client:
+ url: http://localhost:9301 #����admin-server��ַ
+server:
+ port: 9305
+management:
+ endpoints:
+ web:
+ exposure:
+ include: '*'
+ endpoint:
+ health:
+ show-details: always
+logging:
+ file: admin-client.log #���ӿ���admin����־���
+```
+
+*   ����admin-server��admin-client����
+
+## �����Ϣ��ʾ
+
+*   �������µ�ַ��Spring Boot Admin����ҳ��[http://localhost:9301](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A9301 "http://localhost:9301")
+
+![image-20230531001002163](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230531001002163.png)
+
+
+
+
+
+*   ���wallboard��ť��ѡ��admin-client�鿴�����Ϣ��
+
+*   �����Ϣ������
+
+![image-20230531001023644](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230531001023644.png)
+
+
+
+
+
+*   ����ָ����Ϣ������JVM��Tomcat��������Ϣ��
+
+![image-20230531001053279](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230531001053279.png)
+
+
+
+
+
+*   ����������Ϣ������ϵͳ���ԡ�ϵͳ���������Լ�Ӧ��������Ϣ��
+
+![image-20230531001103093](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230531001103093.png)
+
+
+
+
+
+*   �鿴���д�����Bean��Ϣ��
+
+![image-20230531001111221](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230531001111221.png)
+
+
+
+
+
+*   �鿴Ӧ���е�����������Ϣ��
+
+![image-20230531001124678](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230531001124678.png)
+
+
+
+
+
+*   �鿴��־��Ϣ����Ҫ�����������ò��ܿ�����
+
+
+
+`logging:
+file: admin-client.log #���ӿ���admin����־���`
+
+![image-20230531001136184](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230531001136184.png)
+
+
+
+
+*   �鿴JVM��Ϣ��
+
+![image-20230531001144614](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230531001144614.png)
+
+
+
+
+
+*   �鿴���Է��ʵ�Web�˵㣻
+
+![image-20230531001156191](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230531001156191.png)
+
+
+
+
+
+*   �鿴HTTP������Ϣ��
+
+![image-20230531001206364](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230531001206364.png)
+
+
+
+
+
+## ���ע������ʹ��
+
+> Spring Boot Admin���Spring Cloud ע������ʹ�ã�ֻ�轫admin-server��ע���������ϼ��ɣ�admin-server ���Զ���ע�����Ļ�ȡ�����б���Ȼ�󰤸���ȡ�����Ϣ��������Eurekaע������Ϊ���������¸ù��ܡ�
+
+### �޸�admin-server
+
+*   ��pom.xml���������������
+
+
+
+
+````
+<dependency>
+ <groupId>org.springframework.cloud</groupId>
+ <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
+</dependency>
+````
+
+*   ��application-eureka.yml�н������ã�ֻ������ע���������ü��ɣ�
+
+
+
+
+````
+spring:
+ application:
+ name: admin-server
+server:
+ port: 9301
+eureka:
+ client:
+ register-with-eureka: true
+ fetch-registry: true
+ service-url:
+ defaultZone: http://localhost:8001/eureka/
+````
+
+*   ��������������@EnableDiscoveryClient�����÷���ע�Ṧ�ܣ�
+
+
+
+
+
+````
+`@EnableDiscoveryClient
+@EnableAdminServer
+@SpringBootApplication
+public class AdminServerApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(AdminServerApplication.class, args);
+ }
+
+}
+````
+
+### �޸�admin-client
+
+*   ��pom.xml���������������
+
+
+
+````
+<dependency>
+ <groupId>org.springframework.cloud</groupId>
+ <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
+</dependency>
+````
+
+*   ��application-eureka.yml�н������ã�ɾ��ԭ����admin-server��ַ���ã�����ע���������ü��ɣ�
+
+
+
+
+
+```
+spring:
+ application:
+ name: admin-client
+server:
+ port: 9305
+management:
+ endpoints:
+ web:
+ exposure:
+ include: '*'
+ endpoint:
+ health:
+ show-details: always
+logging:
+ file: admin-client.log #���ӿ���admin����־���
+eureka:
+ client:
+ register-with-eureka: true
+ fetch-registry: true
+ service-url:
+ defaultZone: http://localhost:8001/eureka/
+```
+
+*   ��������������@EnableDiscoveryClient�����÷���ע�Ṧ�ܣ�
+
+
+
+
+
+```
+@EnableDiscoveryClient
+@SpringBootApplication
+public class AdminClientApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(AdminClientApplication.class, args);
+ }
+
+}
+```
+
+### ������ʾ
+
+*   ����eureka-server��ʹ��application-eureka.yml��������admin-server��admin-client��
+
+*   �鿴ע�����ķ��ַ������ע�᣺[http://localhost:8001/](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A8001%2F "http://localhost:8001/")
+
+![image-20230531001221519](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230531001221519.png)
+
+
+*   �鿴Spring Boot Admin ��ҳ���ֿ��Կ���������Ϣ��[http://localhost:9301](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A9301 "http://localhost:9301")
+
+![image-20230531001232048](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230531001232048.png)
+
+
+## ���ӵ�¼��֤
+
+> ���ǿ���ͨ����admin-server����Spring Security֧������õ�¼��֤���ܡ�
+
+### ����admin-security-serverģ��
+
+*   ��pom.xml���������������
+
+
+
+```
+<dependency>
+ <groupId>org.springframework.cloud</groupId>
+ <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
+</dependency>
+<dependency>
+ <groupId>de.codecentric</groupId>
+ <artifactId>spring-boot-admin-starter-server</artifactId>
+ <version>2.1.5</version>
+</dependency>
+<dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-security</artifactId>
+</dependency>
+<dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-web</artifactId>
+</dependency>
+```
+
+*   ��application.yml�н������ã����õ�¼�û��������룬����admin-security-server�ļ����Ϣ��
+
+
+
+
+
+```
+spring:
+ application:
+ name: admin-security-server
+ security: # ���õ�¼�û���������
+ user:
+ name: macro
+ password: 123456
+ boot:  # ����ʾadmin-security-server�ļ����Ϣ
+ admin:
+ discovery:
+ ignored-services: ${spring.application.name}
+server:
+ port: 9301
+eureka:
+ client:
+ register-with-eureka: true
+ fetch-registry: true
+ service-url:
+ defaultZone: http://localhost:8001/eureka/
+```
+
+*   ��SpringSecurity�������ã��Ա�admin-client����ע�᣺
+
+
+
+
+
+scss
+
+���ƴ���
+
+
+
+
+
+```
+/**
+ * Created by macro on 2019/9/30.
+ */
+@Configuration
+public class SecuritySecureConfig extends WebSecurityConfigurerAdapter {
+ private final String adminContextPath;
+
+ public SecuritySecureConfig(AdminServerProperties adminServerProperties) {
+ this.adminContextPath = adminServerProperties.getContextPath();
+ }
+
+ @Override
+ protected void configure(HttpSecurity http) throws Exception {
+ SavedRequestAwareAuthenticationSuccessHandler successHandler = new SavedRequestAwareAuthenticationSuccessHandler();
+ successHandler.setTargetUrlParameter("redirectTo");
+ successHandler.setDefaultTargetUrl(adminContextPath + "/");
+
+ http.authorizeRequests()
+ //1.�������о�̬��Դ�͵�¼ҳ���Թ�������
+ .antMatchers(adminContextPath + "/assets/**").permitAll()
+ .antMatchers(adminContextPath + "/login").permitAll()
+ .anyRequest().authenticated()
+ .and()
+ //2.���õ�¼�͵dz�·��
+ .formLogin().loginPage(adminContextPath + "/login").successHandler(successHandler).and()
+ .logout().logoutUrl(adminContextPath + "/logout").and()
+ //3.����http basic֧�֣�admin-clientע��ʱ��Ҫʹ��
+ .httpBasic().and()
+ .csrf()
+ //4.��������cookie��csrf����
+ .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
+ //5.������Щ·����csrf�����Ա�admin-clientע��
+ .ignoringAntMatchers(
+ adminContextPath + "/instances",
+ adminContextPath + "/actuator/**"
+ );
+ }
+}
+```
+
+*   �޸������࣬����AdminServer��ע�ᷢ�ֹ��ܣ�
+
+
+
+
+
+```
+@EnableDiscoveryClient
+@EnableAdminServer
+@SpringBootApplication
+public class AdminSecurityServerApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(AdminSecurityServerApplication.class, args);
+ }
+}
+```
+
+*   ����eureka-server��admin-security-server������Spring Boot Admin ��ҳ������Ҫ��¼���ܷ��ʣ�[http://localhost:9301](https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A9301 "http://localhost:9301")
+
+![image-20230531001242361](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230531001242361.png)
+
+
+
+
+
+## ʹ�õ���ģ��
+
+
+
+
+
+```
+springcloud-learning
+������ eureka-server -- eurekaע������
+������ admin-server -- admin������ķ���
+������ admin-client -- admin������ļ�ص�Ӧ�÷���
+������ admin-security-server -- ����¼��֤��admin������ķ���` 
+```
\ No newline at end of file
diff --git "a/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\344\272\213\345\212\241\346\266\210\346\201\257\357\274\210\346\234\200\347\273\210\344\270\200\350\207\264\346\200\247\357\274\211.md" "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\344\272\213\345\212\241\346\266\210\346\201\257\357\274\210\346\234\200\347\273\210\344\270\200\350\207\264\346\200\247\357\274\211.md"
new file mode 100644
index 0000000..7b22bce
--- /dev/null
+++ "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\344\272\213\345\212\241\346\266\210\346\201\257\357\274\210\346\234\200\347\273\210\344\270\200\350\207\264\346\200\247\357\274\211.md"
@@ -0,0 +1,62 @@
+# [RocketMQϵ�У�һ����������](https://www.cnblogs.com/boboooo/p/13038950.html)
+
+
+
+
+
+RocketMQ�ǰ����Ʒ��һ�Դ����Ϣ�м����������������ľ�������������Ϣ�Ĺ��ܡ�����ҵ�У���Ϣ�м��ѡ��ʹ��RocketMQ�Ļ���ͦ��ģ���һϵ�е����¶������RocketMQ�ģ������ȴ�RocketMQ��һЩ��������ͻ����Ĵ��ʼ����
+
+RocketMQ��4������ɣ��ֱ��ǣ����Ʒ���Name Server������Ϣ���У�Brokers���������ߣ�producer���������ߣ�consumer������4���ֶ����Խ���ˮƽ��չ���Ӷ����ⵥ����ϣ�����ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1191201-20200603173058174-1551688390.png)
+
+����RocketMQ�����ϵ�һ��ͼ���dz��������г���4�����֣����Ҷ��Ǽ�Ⱥģʽ���������Ǿͷֱ�˵һ˵��4���֡�
+
+## ���Ʒ���NameServer��
+
+Name Server���ݵĽ�ɫ��һ��ע�����ģ���Zookeeper�����ò�ࡣ������Ҫ���������������£�
+
+*   broker�Ĺ�����broker��Ⱥ���Լ�����Ϣע�ᵽNameServer��NameServer�ṩ�������Ƽ��ÿһ��broker�Ƿ�������
+*   ·�ɹ�����ÿһ��NameServer��������broker��Ⱥ�Ͷ��е���Ϣ���Ա�ͻ��ˣ������ߺ������ߣ���ѯ��
+
+NameServerЭ���ŷֲ�ʽϵͳ�е�ÿһ����������ҹ�����ÿһ��Topic��·����Ϣ��
+
+## Broker
+
+Broker��Ҫ�Ǵ洢��Ϣ�������ṩTopic�Ļ��ơ����ṩ�ƺ�������ģʽ������һЩ���ֵĴ�ʩ���������������Ϣ�������������ǿ�һ��Brokcer�����ӻ��ơ�
+
+Broker�Ľ�ɫ��Ϊ���첽��������ͬ�������͡��ӡ�������ɫ������㲻��������Ϣ�Ķ�ʧ�����������һ����ͬ�������͡��ӡ�����Broker������������Ϣ��ʧҲ����ν��ֻҪ���п��þ�ok�Ļ�����������á��첽�����͡��ӡ�����broker�������ֻ����򵥵Ĵ��ֻ����һ�����첽�����������á��ӡ�Ҳ�ǿ��Եġ�
+
+�����ᵽ����broker֮��ı��ݣ�broker�����ϢҲ�ǿ��Ա��浽���̵ģ����浽���̵ķ�ʽҲ�����֣��Ƽ��ķ�ʽ���첽������̣�ͬ����������Ƿdz�������ܵġ�
+
+## ������
+
+������֧�ּ�Ⱥ����������broker��Ⱥ������Ϣ������֧�ֶ��ָ��ؾ���ķ�ʽ��
+
+����������broker������Ϣʱ����õ����ͽ�������ͽ������һ������״̬���������ǵ������У���Ϣ������`isWaitStoreMsgOK = true`���������Ĭ��Ҳ��`true`�����������Ϊ`false`���ڷ�����Ϣ�Ĺ����У�ֻҪ�������쳣�����ͽ������`SEND_OK`����`isWaitStoreMsgOK = true`�����ͽ�������¼��֣�
+
+*   `FLUSH_DISK_TIMEOUT`��������̳�ʱ����������̵ķ�ʽ����ΪSYNC_FLUSH��ͬ������������syncFlushTimeout���õ�ʱ���ڣ�Ĭ��5s����û����ɱ�����̵Ķ���������õ����״̬��
+*   `FLUSH_SLAVE_TIMEOUT`��ͬ�����ӡ���ʱ����broker�Ľ�ɫ����Ϊ��ͬ������ʱ�����������õ�ͬ��ʱ���ڣ�Ĭ��Ϊ5s��û���������֮���ͬ�����ͻ�õ����״̬��
+*   `SLAVE_NOT_AVAILABLE`�����ӡ������ã����������á�ͬ������������û�����á��ӡ�brokerʱ���᷵�����״̬��
+*   `SEND_OK`����Ϣ���ͳɹ���
+
+����������Ϣ�ظ�����Ϣ��ʧ�����㷢�������Ϣ��ʧʱ��ͨ��������ѡ��һ���Ƕ��Ͷ��ɣ�������Ϣ����Ķ��ˣ���һ��ѡ������Ϣ���·��ͣ������п���������Ϣ�ظ���ͨ������£������Ƽ����·��͵ģ�������������Ϣ��ʱ��Ҫȥ�����ظ�����Ϣ��
+
+����message�Ĵ�Сһ�㲻����512k��Ĭ�ϵķ�����Ϣ�ķ�ʽ��ͬ���ģ����ͷ�����һֱ������ֱ���ȵ����ص���Ӧ�������Ƚ��������ܣ�Ҳ������`send(msg, callback)`�첽�ķ�ʽ������Ϣ��
+
+## ������
+
+��������߿������**�������飨consumer group��**����ͬ��**��������**���Զ�����ͬ��Topic��Ҳ���Զ���������Topic��ÿһ���������鶼���Լ�������ƫ������
+
+��Ϣ�����ѷ�ʽһ�������֣�˳�����ѺͲ������ѡ�
+
+*   ˳�����ѣ������߽���ס��Ϣ���У�ȷ����Ϣ����˳��һ��һ���ı����ѵ���˳�����ѻ�����һ����������ʧ����������Ϣ��ʱ����������쳣��������ֱ���׳�������Ӧ�÷���`SUSPEND_CURRENT_QUEUE_A_MOMENT`���״̬���������������߹�һ��ʱ��󣬻��������������Ϣ��
+*   �������ѣ������߽�������������Ϣ�����ַ�ʽ�����ܷdz��ã�Ҳ���Ƽ������ѷ�ʽ�������ѵĹ����У���������쳣��������ֱ���׳������Ƿ���`RECONSUME_LATER`״̬�����������������ڲ�����ȷ������������һ��ʱ��󣬻��ٴ���������
+
+���������ڲ�����ʹ��`ThreadPoolExecutor`��Ϊ�̳߳صģ����ǿ���ͨ��`setConsumeThreadMin`��`setConsumeThreadMax`������С�����̺߳���������̡߳�
+
+��һ���µ��������齨���Ժ���Ҫ�����Ƿ�����֮ǰ����ʷ��Ϣ��`CONSUME_FROM_LAST_OFFSET`��������ʷ��Ϣ�������µ���Ϣ��`CONSUME_FROM_FIRST_OFFSET`�����Ѷ����е�ÿһ����Ϣ��֮ǰ����ʷ��ϢҲ��������һ�顣`CONSUME_FROM_TIMESTAMP`����ָ��������Ϣ��ʱ�䣬ָ��ʱ���Ժ����Ϣ�ᱻ���ѡ�
+
+������Ӧ�ò��������ظ����ѣ���ô��������Ϣ�Ĺ����У�Ҫ������Ϣ��У�顣
+
+���ˣ�����͵�����ɣ���һƪ���ǽ�����RocketMQ�Ļ������
\ No newline at end of file
diff --git "a/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\345\237\272\346\234\254\346\246\202\345\277\265.md" "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\345\237\272\346\234\254\346\246\202\345\277\265.md"
new file mode 100644
index 0000000..7b22bce
--- /dev/null
+++ "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\345\237\272\346\234\254\346\246\202\345\277\265.md"
@@ -0,0 +1,62 @@
+# [RocketMQϵ�У�һ����������](https://www.cnblogs.com/boboooo/p/13038950.html)
+
+
+
+
+
+RocketMQ�ǰ����Ʒ��һ�Դ����Ϣ�м����������������ľ�������������Ϣ�Ĺ��ܡ�����ҵ�У���Ϣ�м��ѡ��ʹ��RocketMQ�Ļ���ͦ��ģ���һϵ�е����¶������RocketMQ�ģ������ȴ�RocketMQ��һЩ��������ͻ����Ĵ��ʼ����
+
+RocketMQ��4������ɣ��ֱ��ǣ����Ʒ���Name Server������Ϣ���У�Brokers���������ߣ�producer���������ߣ�consumer������4���ֶ����Խ���ˮƽ��չ���Ӷ����ⵥ����ϣ�����ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1191201-20200603173058174-1551688390.png)
+
+����RocketMQ�����ϵ�һ��ͼ���dz��������г���4�����֣����Ҷ��Ǽ�Ⱥģʽ���������Ǿͷֱ�˵һ˵��4���֡�
+
+## ���Ʒ���NameServer��
+
+Name Server���ݵĽ�ɫ��һ��ע�����ģ���Zookeeper�����ò�ࡣ������Ҫ���������������£�
+
+*   broker�Ĺ�����broker��Ⱥ���Լ�����Ϣע�ᵽNameServer��NameServer�ṩ�������Ƽ��ÿһ��broker�Ƿ�������
+*   ·�ɹ�����ÿһ��NameServer��������broker��Ⱥ�Ͷ��е���Ϣ���Ա�ͻ��ˣ������ߺ������ߣ���ѯ��
+
+NameServerЭ���ŷֲ�ʽϵͳ�е�ÿһ����������ҹ�����ÿһ��Topic��·����Ϣ��
+
+## Broker
+
+Broker��Ҫ�Ǵ洢��Ϣ�������ṩTopic�Ļ��ơ����ṩ�ƺ�������ģʽ������һЩ���ֵĴ�ʩ���������������Ϣ�������������ǿ�һ��Brokcer�����ӻ��ơ�
+
+Broker�Ľ�ɫ��Ϊ���첽��������ͬ�������͡��ӡ�������ɫ������㲻��������Ϣ�Ķ�ʧ�����������һ����ͬ�������͡��ӡ�����Broker������������Ϣ��ʧҲ����ν��ֻҪ���п��þ�ok�Ļ�����������á��첽�����͡��ӡ�����broker�������ֻ����򵥵Ĵ��ֻ����һ�����첽�����������á��ӡ�Ҳ�ǿ��Եġ�
+
+�����ᵽ����broker֮��ı��ݣ�broker�����ϢҲ�ǿ��Ա��浽���̵ģ����浽���̵ķ�ʽҲ�����֣��Ƽ��ķ�ʽ���첽������̣�ͬ����������Ƿdz�������ܵġ�
+
+## ������
+
+������֧�ּ�Ⱥ����������broker��Ⱥ������Ϣ������֧�ֶ��ָ��ؾ���ķ�ʽ��
+
+����������broker������Ϣʱ����õ����ͽ�������ͽ������һ������״̬���������ǵ������У���Ϣ������`isWaitStoreMsgOK = true`���������Ĭ��Ҳ��`true`�����������Ϊ`false`���ڷ�����Ϣ�Ĺ����У�ֻҪ�������쳣�����ͽ������`SEND_OK`����`isWaitStoreMsgOK = true`�����ͽ�������¼��֣�
+
+*   `FLUSH_DISK_TIMEOUT`��������̳�ʱ����������̵ķ�ʽ����ΪSYNC_FLUSH��ͬ������������syncFlushTimeout���õ�ʱ���ڣ�Ĭ��5s����û����ɱ�����̵Ķ���������õ����״̬��
+*   `FLUSH_SLAVE_TIMEOUT`��ͬ�����ӡ���ʱ����broker�Ľ�ɫ����Ϊ��ͬ������ʱ�����������õ�ͬ��ʱ���ڣ�Ĭ��Ϊ5s��û���������֮���ͬ�����ͻ�õ����״̬��
+*   `SLAVE_NOT_AVAILABLE`�����ӡ������ã����������á�ͬ������������û�����á��ӡ�brokerʱ���᷵�����״̬��
+*   `SEND_OK`����Ϣ���ͳɹ���
+
+����������Ϣ�ظ�����Ϣ��ʧ�����㷢�������Ϣ��ʧʱ��ͨ��������ѡ��һ���Ƕ��Ͷ��ɣ�������Ϣ����Ķ��ˣ���һ��ѡ������Ϣ���·��ͣ������п���������Ϣ�ظ���ͨ������£������Ƽ����·��͵ģ�������������Ϣ��ʱ��Ҫȥ�����ظ�����Ϣ��
+
+����message�Ĵ�Сһ�㲻����512k��Ĭ�ϵķ�����Ϣ�ķ�ʽ��ͬ���ģ����ͷ�����һֱ������ֱ���ȵ����ص���Ӧ�������Ƚ��������ܣ�Ҳ������`send(msg, callback)`�첽�ķ�ʽ������Ϣ��
+
+## ������
+
+��������߿������**�������飨consumer group��**����ͬ��**��������**���Զ�����ͬ��Topic��Ҳ���Զ���������Topic��ÿһ���������鶼���Լ�������ƫ������
+
+��Ϣ�����ѷ�ʽһ�������֣�˳�����ѺͲ������ѡ�
+
+*   ˳�����ѣ������߽���ס��Ϣ���У�ȷ����Ϣ����˳��һ��һ���ı����ѵ���˳�����ѻ�����һ����������ʧ����������Ϣ��ʱ����������쳣��������ֱ���׳�������Ӧ�÷���`SUSPEND_CURRENT_QUEUE_A_MOMENT`���״̬���������������߹�һ��ʱ��󣬻��������������Ϣ��
+*   �������ѣ������߽�������������Ϣ�����ַ�ʽ�����ܷdz��ã�Ҳ���Ƽ������ѷ�ʽ�������ѵĹ����У���������쳣��������ֱ���׳������Ƿ���`RECONSUME_LATER`״̬�����������������ڲ�����ȷ������������һ��ʱ��󣬻��ٴ���������
+
+���������ڲ�����ʹ��`ThreadPoolExecutor`��Ϊ�̳߳صģ����ǿ���ͨ��`setConsumeThreadMin`��`setConsumeThreadMax`������С�����̺߳���������̡߳�
+
+��һ���µ��������齨���Ժ���Ҫ�����Ƿ�����֮ǰ����ʷ��Ϣ��`CONSUME_FROM_LAST_OFFSET`��������ʷ��Ϣ�������µ���Ϣ��`CONSUME_FROM_FIRST_OFFSET`�����Ѷ����е�ÿһ����Ϣ��֮ǰ����ʷ��ϢҲ��������һ�顣`CONSUME_FROM_TIMESTAMP`����ָ��������Ϣ��ʱ�䣬ָ��ʱ���Ժ����Ϣ�ᱻ���ѡ�
+
+������Ӧ�ò��������ظ����ѣ���ô��������Ϣ�Ĺ����У�Ҫ������Ϣ��У�顣
+
+���ˣ�����͵�����ɣ���һƪ���ǽ�����RocketMQ�Ļ������
\ No newline at end of file
diff --git "a/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\345\271\277\346\222\255\344\270\216\345\273\266\350\277\237\346\266\210\346\201\257.md" "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\345\271\277\346\222\255\344\270\216\345\273\266\350\277\237\346\266\210\346\201\257.md"
new file mode 100644
index 0000000..7b22bce
--- /dev/null
+++ "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\345\271\277\346\222\255\344\270\216\345\273\266\350\277\237\346\266\210\346\201\257.md"
@@ -0,0 +1,62 @@
+# [RocketMQϵ�У�һ����������](https://www.cnblogs.com/boboooo/p/13038950.html)
+
+
+
+
+
+RocketMQ�ǰ����Ʒ��һ�Դ����Ϣ�м����������������ľ�������������Ϣ�Ĺ��ܡ�����ҵ�У���Ϣ�м��ѡ��ʹ��RocketMQ�Ļ���ͦ��ģ���һϵ�е����¶������RocketMQ�ģ������ȴ�RocketMQ��һЩ��������ͻ����Ĵ��ʼ����
+
+RocketMQ��4������ɣ��ֱ��ǣ����Ʒ���Name Server������Ϣ���У�Brokers���������ߣ�producer���������ߣ�consumer������4���ֶ����Խ���ˮƽ��չ���Ӷ����ⵥ����ϣ�����ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1191201-20200603173058174-1551688390.png)
+
+����RocketMQ�����ϵ�һ��ͼ���dz��������г���4�����֣����Ҷ��Ǽ�Ⱥģʽ���������Ǿͷֱ�˵һ˵��4���֡�
+
+## ���Ʒ���NameServer��
+
+Name Server���ݵĽ�ɫ��һ��ע�����ģ���Zookeeper�����ò�ࡣ������Ҫ���������������£�
+
+*   broker�Ĺ�����broker��Ⱥ���Լ�����Ϣע�ᵽNameServer��NameServer�ṩ�������Ƽ��ÿһ��broker�Ƿ�������
+*   ·�ɹ�����ÿһ��NameServer��������broker��Ⱥ�Ͷ��е���Ϣ���Ա�ͻ��ˣ������ߺ������ߣ���ѯ��
+
+NameServerЭ���ŷֲ�ʽϵͳ�е�ÿһ����������ҹ�����ÿһ��Topic��·����Ϣ��
+
+## Broker
+
+Broker��Ҫ�Ǵ洢��Ϣ�������ṩTopic�Ļ��ơ����ṩ�ƺ�������ģʽ������һЩ���ֵĴ�ʩ���������������Ϣ�������������ǿ�һ��Brokcer�����ӻ��ơ�
+
+Broker�Ľ�ɫ��Ϊ���첽��������ͬ�������͡��ӡ�������ɫ������㲻��������Ϣ�Ķ�ʧ�����������һ����ͬ�������͡��ӡ�����Broker������������Ϣ��ʧҲ����ν��ֻҪ���п��þ�ok�Ļ�����������á��첽�����͡��ӡ�����broker�������ֻ����򵥵Ĵ��ֻ����һ�����첽�����������á��ӡ�Ҳ�ǿ��Եġ�
+
+�����ᵽ����broker֮��ı��ݣ�broker�����ϢҲ�ǿ��Ա��浽���̵ģ����浽���̵ķ�ʽҲ�����֣��Ƽ��ķ�ʽ���첽������̣�ͬ����������Ƿdz�������ܵġ�
+
+## ������
+
+������֧�ּ�Ⱥ����������broker��Ⱥ������Ϣ������֧�ֶ��ָ��ؾ���ķ�ʽ��
+
+����������broker������Ϣʱ����õ����ͽ�������ͽ������һ������״̬���������ǵ������У���Ϣ������`isWaitStoreMsgOK = true`���������Ĭ��Ҳ��`true`�����������Ϊ`false`���ڷ�����Ϣ�Ĺ����У�ֻҪ�������쳣�����ͽ������`SEND_OK`����`isWaitStoreMsgOK = true`�����ͽ�������¼��֣�
+
+*   `FLUSH_DISK_TIMEOUT`��������̳�ʱ����������̵ķ�ʽ����ΪSYNC_FLUSH��ͬ������������syncFlushTimeout���õ�ʱ���ڣ�Ĭ��5s����û����ɱ�����̵Ķ���������õ����״̬��
+*   `FLUSH_SLAVE_TIMEOUT`��ͬ�����ӡ���ʱ����broker�Ľ�ɫ����Ϊ��ͬ������ʱ�����������õ�ͬ��ʱ���ڣ�Ĭ��Ϊ5s��û���������֮���ͬ�����ͻ�õ����״̬��
+*   `SLAVE_NOT_AVAILABLE`�����ӡ������ã����������á�ͬ������������û�����á��ӡ�brokerʱ���᷵�����״̬��
+*   `SEND_OK`����Ϣ���ͳɹ���
+
+����������Ϣ�ظ�����Ϣ��ʧ�����㷢�������Ϣ��ʧʱ��ͨ��������ѡ��һ���Ƕ��Ͷ��ɣ�������Ϣ����Ķ��ˣ���һ��ѡ������Ϣ���·��ͣ������п���������Ϣ�ظ���ͨ������£������Ƽ����·��͵ģ�������������Ϣ��ʱ��Ҫȥ�����ظ�����Ϣ��
+
+����message�Ĵ�Сһ�㲻����512k��Ĭ�ϵķ�����Ϣ�ķ�ʽ��ͬ���ģ����ͷ�����һֱ������ֱ���ȵ����ص���Ӧ�������Ƚ��������ܣ�Ҳ������`send(msg, callback)`�첽�ķ�ʽ������Ϣ��
+
+## ������
+
+��������߿������**�������飨consumer group��**����ͬ��**��������**���Զ�����ͬ��Topic��Ҳ���Զ���������Topic��ÿһ���������鶼���Լ�������ƫ������
+
+��Ϣ�����ѷ�ʽһ�������֣�˳�����ѺͲ������ѡ�
+
+*   ˳�����ѣ������߽���ס��Ϣ���У�ȷ����Ϣ����˳��һ��һ���ı����ѵ���˳�����ѻ�����һ����������ʧ����������Ϣ��ʱ����������쳣��������ֱ���׳�������Ӧ�÷���`SUSPEND_CURRENT_QUEUE_A_MOMENT`���״̬���������������߹�һ��ʱ��󣬻��������������Ϣ��
+*   �������ѣ������߽�������������Ϣ�����ַ�ʽ�����ܷdz��ã�Ҳ���Ƽ������ѷ�ʽ�������ѵĹ����У���������쳣��������ֱ���׳������Ƿ���`RECONSUME_LATER`״̬�����������������ڲ�����ȷ������������һ��ʱ��󣬻��ٴ���������
+
+���������ڲ�����ʹ��`ThreadPoolExecutor`��Ϊ�̳߳صģ����ǿ���ͨ��`setConsumeThreadMin`��`setConsumeThreadMax`������С�����̺߳���������̡߳�
+
+��һ���µ��������齨���Ժ���Ҫ�����Ƿ�����֮ǰ����ʷ��Ϣ��`CONSUME_FROM_LAST_OFFSET`��������ʷ��Ϣ�������µ���Ϣ��`CONSUME_FROM_FIRST_OFFSET`�����Ѷ����е�ÿһ����Ϣ��֮ǰ����ʷ��ϢҲ��������һ�顣`CONSUME_FROM_TIMESTAMP`����ָ��������Ϣ��ʱ�䣬ָ��ʱ���Ժ����Ϣ�ᱻ���ѡ�
+
+������Ӧ�ò��������ظ����ѣ���ô��������Ϣ�Ĺ����У�Ҫ������Ϣ��У�顣
+
+���ˣ�����͵�����ɣ���һƪ���ǽ�����RocketMQ�Ļ������
\ No newline at end of file
diff --git "a/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\346\211\271\351\207\217\345\217\221\351\200\201\344\270\216\350\277\207\346\273\244.md" "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\346\211\271\351\207\217\345\217\221\351\200\201\344\270\216\350\277\207\346\273\244.md"
new file mode 100644
index 0000000..7b22bce
--- /dev/null
+++ "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\346\211\271\351\207\217\345\217\221\351\200\201\344\270\216\350\277\207\346\273\244.md"
@@ -0,0 +1,62 @@
+# [RocketMQϵ�У�һ����������](https://www.cnblogs.com/boboooo/p/13038950.html)
+
+
+
+
+
+RocketMQ�ǰ����Ʒ��һ�Դ����Ϣ�м����������������ľ�������������Ϣ�Ĺ��ܡ�����ҵ�У���Ϣ�м��ѡ��ʹ��RocketMQ�Ļ���ͦ��ģ���һϵ�е����¶������RocketMQ�ģ������ȴ�RocketMQ��һЩ��������ͻ����Ĵ��ʼ����
+
+RocketMQ��4������ɣ��ֱ��ǣ����Ʒ���Name Server������Ϣ���У�Brokers���������ߣ�producer���������ߣ�consumer������4���ֶ����Խ���ˮƽ��չ���Ӷ����ⵥ����ϣ�����ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1191201-20200603173058174-1551688390.png)
+
+����RocketMQ�����ϵ�һ��ͼ���dz��������г���4�����֣����Ҷ��Ǽ�Ⱥģʽ���������Ǿͷֱ�˵һ˵��4���֡�
+
+## ���Ʒ���NameServer��
+
+Name Server���ݵĽ�ɫ��һ��ע�����ģ���Zookeeper�����ò�ࡣ������Ҫ���������������£�
+
+*   broker�Ĺ�����broker��Ⱥ���Լ�����Ϣע�ᵽNameServer��NameServer�ṩ�������Ƽ��ÿһ��broker�Ƿ�������
+*   ·�ɹ�����ÿһ��NameServer��������broker��Ⱥ�Ͷ��е���Ϣ���Ա�ͻ��ˣ������ߺ������ߣ���ѯ��
+
+NameServerЭ���ŷֲ�ʽϵͳ�е�ÿһ����������ҹ�����ÿһ��Topic��·����Ϣ��
+
+## Broker
+
+Broker��Ҫ�Ǵ洢��Ϣ�������ṩTopic�Ļ��ơ����ṩ�ƺ�������ģʽ������һЩ���ֵĴ�ʩ���������������Ϣ�������������ǿ�һ��Brokcer�����ӻ��ơ�
+
+Broker�Ľ�ɫ��Ϊ���첽��������ͬ�������͡��ӡ�������ɫ������㲻��������Ϣ�Ķ�ʧ�����������һ����ͬ�������͡��ӡ�����Broker������������Ϣ��ʧҲ����ν��ֻҪ���п��þ�ok�Ļ�����������á��첽�����͡��ӡ�����broker�������ֻ����򵥵Ĵ��ֻ����һ�����첽�����������á��ӡ�Ҳ�ǿ��Եġ�
+
+�����ᵽ����broker֮��ı��ݣ�broker�����ϢҲ�ǿ��Ա��浽���̵ģ����浽���̵ķ�ʽҲ�����֣��Ƽ��ķ�ʽ���첽������̣�ͬ����������Ƿdz�������ܵġ�
+
+## ������
+
+������֧�ּ�Ⱥ����������broker��Ⱥ������Ϣ������֧�ֶ��ָ��ؾ���ķ�ʽ��
+
+����������broker������Ϣʱ����õ����ͽ�������ͽ������һ������״̬���������ǵ������У���Ϣ������`isWaitStoreMsgOK = true`���������Ĭ��Ҳ��`true`�����������Ϊ`false`���ڷ�����Ϣ�Ĺ����У�ֻҪ�������쳣�����ͽ������`SEND_OK`����`isWaitStoreMsgOK = true`�����ͽ�������¼��֣�
+
+*   `FLUSH_DISK_TIMEOUT`��������̳�ʱ����������̵ķ�ʽ����ΪSYNC_FLUSH��ͬ������������syncFlushTimeout���õ�ʱ���ڣ�Ĭ��5s����û����ɱ�����̵Ķ���������õ����״̬��
+*   `FLUSH_SLAVE_TIMEOUT`��ͬ�����ӡ���ʱ����broker�Ľ�ɫ����Ϊ��ͬ������ʱ�����������õ�ͬ��ʱ���ڣ�Ĭ��Ϊ5s��û���������֮���ͬ�����ͻ�õ����״̬��
+*   `SLAVE_NOT_AVAILABLE`�����ӡ������ã����������á�ͬ������������û�����á��ӡ�brokerʱ���᷵�����״̬��
+*   `SEND_OK`����Ϣ���ͳɹ���
+
+����������Ϣ�ظ�����Ϣ��ʧ�����㷢�������Ϣ��ʧʱ��ͨ��������ѡ��һ���Ƕ��Ͷ��ɣ�������Ϣ����Ķ��ˣ���һ��ѡ������Ϣ���·��ͣ������п���������Ϣ�ظ���ͨ������£������Ƽ����·��͵ģ�������������Ϣ��ʱ��Ҫȥ�����ظ�����Ϣ��
+
+����message�Ĵ�Сһ�㲻����512k��Ĭ�ϵķ�����Ϣ�ķ�ʽ��ͬ���ģ����ͷ�����һֱ������ֱ���ȵ����ص���Ӧ�������Ƚ��������ܣ�Ҳ������`send(msg, callback)`�첽�ķ�ʽ������Ϣ��
+
+## ������
+
+��������߿������**�������飨consumer group��**����ͬ��**��������**���Զ�����ͬ��Topic��Ҳ���Զ���������Topic��ÿһ���������鶼���Լ�������ƫ������
+
+��Ϣ�����ѷ�ʽһ�������֣�˳�����ѺͲ������ѡ�
+
+*   ˳�����ѣ������߽���ס��Ϣ���У�ȷ����Ϣ����˳��һ��һ���ı����ѵ���˳�����ѻ�����һ����������ʧ����������Ϣ��ʱ����������쳣��������ֱ���׳�������Ӧ�÷���`SUSPEND_CURRENT_QUEUE_A_MOMENT`���״̬���������������߹�һ��ʱ��󣬻��������������Ϣ��
+*   �������ѣ������߽�������������Ϣ�����ַ�ʽ�����ܷdz��ã�Ҳ���Ƽ������ѷ�ʽ�������ѵĹ����У���������쳣��������ֱ���׳������Ƿ���`RECONSUME_LATER`״̬�����������������ڲ�����ȷ������������һ��ʱ��󣬻��ٴ���������
+
+���������ڲ�����ʹ��`ThreadPoolExecutor`��Ϊ�̳߳صģ����ǿ���ͨ��`setConsumeThreadMin`��`setConsumeThreadMax`������С�����̺߳���������̡߳�
+
+��һ���µ��������齨���Ժ���Ҫ�����Ƿ�����֮ǰ����ʷ��Ϣ��`CONSUME_FROM_LAST_OFFSET`��������ʷ��Ϣ�������µ���Ϣ��`CONSUME_FROM_FIRST_OFFSET`�����Ѷ����е�ÿһ����Ϣ��֮ǰ����ʷ��ϢҲ��������һ�顣`CONSUME_FROM_TIMESTAMP`����ָ��������Ϣ��ʱ�䣬ָ��ʱ���Ժ����Ϣ�ᱻ���ѡ�
+
+������Ӧ�ò��������ظ����ѣ���ô��������Ϣ�Ĺ����У�Ҫ������Ϣ��У�顣
+
+���ˣ�����͵�����ɣ���һƪ���ǽ�����RocketMQ�Ļ������
\ No newline at end of file
diff --git "a/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\346\266\210\346\201\257\347\232\204\347\224\237\344\272\247\344\270\216\346\266\210\350\264\271.md" "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\346\266\210\346\201\257\347\232\204\347\224\237\344\272\247\344\270\216\346\266\210\350\264\271.md"
new file mode 100644
index 0000000..7b22bce
--- /dev/null
+++ "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\346\266\210\346\201\257\347\232\204\347\224\237\344\272\247\344\270\216\346\266\210\350\264\271.md"
@@ -0,0 +1,62 @@
+# [RocketMQϵ�У�һ����������](https://www.cnblogs.com/boboooo/p/13038950.html)
+
+
+
+
+
+RocketMQ�ǰ����Ʒ��һ�Դ����Ϣ�м����������������ľ�������������Ϣ�Ĺ��ܡ�����ҵ�У���Ϣ�м��ѡ��ʹ��RocketMQ�Ļ���ͦ��ģ���һϵ�е����¶������RocketMQ�ģ������ȴ�RocketMQ��һЩ��������ͻ����Ĵ��ʼ����
+
+RocketMQ��4������ɣ��ֱ��ǣ����Ʒ���Name Server������Ϣ���У�Brokers���������ߣ�producer���������ߣ�consumer������4���ֶ����Խ���ˮƽ��չ���Ӷ����ⵥ����ϣ�����ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1191201-20200603173058174-1551688390.png)
+
+����RocketMQ�����ϵ�һ��ͼ���dz��������г���4�����֣����Ҷ��Ǽ�Ⱥģʽ���������Ǿͷֱ�˵һ˵��4���֡�
+
+## ���Ʒ���NameServer��
+
+Name Server���ݵĽ�ɫ��һ��ע�����ģ���Zookeeper�����ò�ࡣ������Ҫ���������������£�
+
+*   broker�Ĺ�����broker��Ⱥ���Լ�����Ϣע�ᵽNameServer��NameServer�ṩ�������Ƽ��ÿһ��broker�Ƿ�������
+*   ·�ɹ�����ÿһ��NameServer��������broker��Ⱥ�Ͷ��е���Ϣ���Ա�ͻ��ˣ������ߺ������ߣ���ѯ��
+
+NameServerЭ���ŷֲ�ʽϵͳ�е�ÿһ����������ҹ�����ÿһ��Topic��·����Ϣ��
+
+## Broker
+
+Broker��Ҫ�Ǵ洢��Ϣ�������ṩTopic�Ļ��ơ����ṩ�ƺ�������ģʽ������һЩ���ֵĴ�ʩ���������������Ϣ�������������ǿ�һ��Brokcer�����ӻ��ơ�
+
+Broker�Ľ�ɫ��Ϊ���첽��������ͬ�������͡��ӡ�������ɫ������㲻��������Ϣ�Ķ�ʧ�����������һ����ͬ�������͡��ӡ�����Broker������������Ϣ��ʧҲ����ν��ֻҪ���п��þ�ok�Ļ�����������á��첽�����͡��ӡ�����broker�������ֻ����򵥵Ĵ��ֻ����һ�����첽�����������á��ӡ�Ҳ�ǿ��Եġ�
+
+�����ᵽ����broker֮��ı��ݣ�broker�����ϢҲ�ǿ��Ա��浽���̵ģ����浽���̵ķ�ʽҲ�����֣��Ƽ��ķ�ʽ���첽������̣�ͬ����������Ƿdz�������ܵġ�
+
+## ������
+
+������֧�ּ�Ⱥ����������broker��Ⱥ������Ϣ������֧�ֶ��ָ��ؾ���ķ�ʽ��
+
+����������broker������Ϣʱ����õ����ͽ�������ͽ������һ������״̬���������ǵ������У���Ϣ������`isWaitStoreMsgOK = true`���������Ĭ��Ҳ��`true`�����������Ϊ`false`���ڷ�����Ϣ�Ĺ����У�ֻҪ�������쳣�����ͽ������`SEND_OK`����`isWaitStoreMsgOK = true`�����ͽ�������¼��֣�
+
+*   `FLUSH_DISK_TIMEOUT`��������̳�ʱ����������̵ķ�ʽ����ΪSYNC_FLUSH��ͬ������������syncFlushTimeout���õ�ʱ���ڣ�Ĭ��5s����û����ɱ�����̵Ķ���������õ����״̬��
+*   `FLUSH_SLAVE_TIMEOUT`��ͬ�����ӡ���ʱ����broker�Ľ�ɫ����Ϊ��ͬ������ʱ�����������õ�ͬ��ʱ���ڣ�Ĭ��Ϊ5s��û���������֮���ͬ�����ͻ�õ����״̬��
+*   `SLAVE_NOT_AVAILABLE`�����ӡ������ã����������á�ͬ������������û�����á��ӡ�brokerʱ���᷵�����״̬��
+*   `SEND_OK`����Ϣ���ͳɹ���
+
+����������Ϣ�ظ�����Ϣ��ʧ�����㷢�������Ϣ��ʧʱ��ͨ��������ѡ��һ���Ƕ��Ͷ��ɣ�������Ϣ����Ķ��ˣ���һ��ѡ������Ϣ���·��ͣ������п���������Ϣ�ظ���ͨ������£������Ƽ����·��͵ģ�������������Ϣ��ʱ��Ҫȥ�����ظ�����Ϣ��
+
+����message�Ĵ�Сһ�㲻����512k��Ĭ�ϵķ�����Ϣ�ķ�ʽ��ͬ���ģ����ͷ�����һֱ������ֱ���ȵ����ص���Ӧ�������Ƚ��������ܣ�Ҳ������`send(msg, callback)`�첽�ķ�ʽ������Ϣ��
+
+## ������
+
+��������߿������**�������飨consumer group��**����ͬ��**��������**���Զ�����ͬ��Topic��Ҳ���Զ���������Topic��ÿһ���������鶼���Լ�������ƫ������
+
+��Ϣ�����ѷ�ʽһ�������֣�˳�����ѺͲ������ѡ�
+
+*   ˳�����ѣ������߽���ס��Ϣ���У�ȷ����Ϣ����˳��һ��һ���ı����ѵ���˳�����ѻ�����һ����������ʧ����������Ϣ��ʱ����������쳣��������ֱ���׳�������Ӧ�÷���`SUSPEND_CURRENT_QUEUE_A_MOMENT`���״̬���������������߹�һ��ʱ��󣬻��������������Ϣ��
+*   �������ѣ������߽�������������Ϣ�����ַ�ʽ�����ܷdz��ã�Ҳ���Ƽ������ѷ�ʽ�������ѵĹ����У���������쳣��������ֱ���׳������Ƿ���`RECONSUME_LATER`״̬�����������������ڲ�����ȷ������������һ��ʱ��󣬻��ٴ���������
+
+���������ڲ�����ʹ��`ThreadPoolExecutor`��Ϊ�̳߳صģ����ǿ���ͨ��`setConsumeThreadMin`��`setConsumeThreadMax`������С�����̺߳���������̡߳�
+
+��һ���µ��������齨���Ժ���Ҫ�����Ƿ�����֮ǰ����ʷ��Ϣ��`CONSUME_FROM_LAST_OFFSET`��������ʷ��Ϣ�������µ���Ϣ��`CONSUME_FROM_FIRST_OFFSET`�����Ѷ����е�ÿһ����Ϣ��֮ǰ����ʷ��ϢҲ��������һ�顣`CONSUME_FROM_TIMESTAMP`����ָ��������Ϣ��ʱ�䣬ָ��ʱ���Ժ����Ϣ�ᱻ���ѡ�
+
+������Ӧ�ò��������ظ����ѣ���ô��������Ϣ�Ĺ����У�Ҫ������Ϣ��У�顣
+
+���ˣ�����͵�����ɣ���һƪ���ǽ�����RocketMQ�Ļ������
\ No newline at end of file
diff --git "a/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\347\216\257\345\242\203\346\220\255\345\273\272.md" "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\347\216\257\345\242\203\346\220\255\345\273\272.md"
new file mode 100644
index 0000000..7b22bce
--- /dev/null
+++ "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\347\216\257\345\242\203\346\220\255\345\273\272.md"
@@ -0,0 +1,62 @@
+# [RocketMQϵ�У�һ����������](https://www.cnblogs.com/boboooo/p/13038950.html)
+
+
+
+
+
+RocketMQ�ǰ����Ʒ��һ�Դ����Ϣ�м����������������ľ�������������Ϣ�Ĺ��ܡ�����ҵ�У���Ϣ�м��ѡ��ʹ��RocketMQ�Ļ���ͦ��ģ���һϵ�е����¶������RocketMQ�ģ������ȴ�RocketMQ��һЩ��������ͻ����Ĵ��ʼ����
+
+RocketMQ��4������ɣ��ֱ��ǣ����Ʒ���Name Server������Ϣ���У�Brokers���������ߣ�producer���������ߣ�consumer������4���ֶ����Խ���ˮƽ��չ���Ӷ����ⵥ����ϣ�����ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1191201-20200603173058174-1551688390.png)
+
+����RocketMQ�����ϵ�һ��ͼ���dz��������г���4�����֣����Ҷ��Ǽ�Ⱥģʽ���������Ǿͷֱ�˵һ˵��4���֡�
+
+## ���Ʒ���NameServer��
+
+Name Server���ݵĽ�ɫ��һ��ע�����ģ���Zookeeper�����ò�ࡣ������Ҫ���������������£�
+
+*   broker�Ĺ�����broker��Ⱥ���Լ�����Ϣע�ᵽNameServer��NameServer�ṩ�������Ƽ��ÿһ��broker�Ƿ�������
+*   ·�ɹ�����ÿһ��NameServer��������broker��Ⱥ�Ͷ��е���Ϣ���Ա�ͻ��ˣ������ߺ������ߣ���ѯ��
+
+NameServerЭ���ŷֲ�ʽϵͳ�е�ÿһ����������ҹ�����ÿһ��Topic��·����Ϣ��
+
+## Broker
+
+Broker��Ҫ�Ǵ洢��Ϣ�������ṩTopic�Ļ��ơ����ṩ�ƺ�������ģʽ������һЩ���ֵĴ�ʩ���������������Ϣ�������������ǿ�һ��Brokcer�����ӻ��ơ�
+
+Broker�Ľ�ɫ��Ϊ���첽��������ͬ�������͡��ӡ�������ɫ������㲻��������Ϣ�Ķ�ʧ�����������һ����ͬ�������͡��ӡ�����Broker������������Ϣ��ʧҲ����ν��ֻҪ���п��þ�ok�Ļ�����������á��첽�����͡��ӡ�����broker�������ֻ����򵥵Ĵ��ֻ����һ�����첽�����������á��ӡ�Ҳ�ǿ��Եġ�
+
+�����ᵽ����broker֮��ı��ݣ�broker�����ϢҲ�ǿ��Ա��浽���̵ģ����浽���̵ķ�ʽҲ�����֣��Ƽ��ķ�ʽ���첽������̣�ͬ����������Ƿdz�������ܵġ�
+
+## ������
+
+������֧�ּ�Ⱥ����������broker��Ⱥ������Ϣ������֧�ֶ��ָ��ؾ���ķ�ʽ��
+
+����������broker������Ϣʱ����õ����ͽ�������ͽ������һ������״̬���������ǵ������У���Ϣ������`isWaitStoreMsgOK = true`���������Ĭ��Ҳ��`true`�����������Ϊ`false`���ڷ�����Ϣ�Ĺ����У�ֻҪ�������쳣�����ͽ������`SEND_OK`����`isWaitStoreMsgOK = true`�����ͽ�������¼��֣�
+
+*   `FLUSH_DISK_TIMEOUT`��������̳�ʱ����������̵ķ�ʽ����ΪSYNC_FLUSH��ͬ������������syncFlushTimeout���õ�ʱ���ڣ�Ĭ��5s����û����ɱ�����̵Ķ���������õ����״̬��
+*   `FLUSH_SLAVE_TIMEOUT`��ͬ�����ӡ���ʱ����broker�Ľ�ɫ����Ϊ��ͬ������ʱ�����������õ�ͬ��ʱ���ڣ�Ĭ��Ϊ5s��û���������֮���ͬ�����ͻ�õ����״̬��
+*   `SLAVE_NOT_AVAILABLE`�����ӡ������ã����������á�ͬ������������û�����á��ӡ�brokerʱ���᷵�����״̬��
+*   `SEND_OK`����Ϣ���ͳɹ���
+
+����������Ϣ�ظ�����Ϣ��ʧ�����㷢�������Ϣ��ʧʱ��ͨ��������ѡ��һ���Ƕ��Ͷ��ɣ�������Ϣ����Ķ��ˣ���һ��ѡ������Ϣ���·��ͣ������п���������Ϣ�ظ���ͨ������£������Ƽ����·��͵ģ�������������Ϣ��ʱ��Ҫȥ�����ظ�����Ϣ��
+
+����message�Ĵ�Сһ�㲻����512k��Ĭ�ϵķ�����Ϣ�ķ�ʽ��ͬ���ģ����ͷ�����һֱ������ֱ���ȵ����ص���Ӧ�������Ƚ��������ܣ�Ҳ������`send(msg, callback)`�첽�ķ�ʽ������Ϣ��
+
+## ������
+
+��������߿������**�������飨consumer group��**����ͬ��**��������**���Զ�����ͬ��Topic��Ҳ���Զ���������Topic��ÿһ���������鶼���Լ�������ƫ������
+
+��Ϣ�����ѷ�ʽһ�������֣�˳�����ѺͲ������ѡ�
+
+*   ˳�����ѣ������߽���ס��Ϣ���У�ȷ����Ϣ����˳��һ��һ���ı����ѵ���˳�����ѻ�����һ����������ʧ����������Ϣ��ʱ����������쳣��������ֱ���׳�������Ӧ�÷���`SUSPEND_CURRENT_QUEUE_A_MOMENT`���״̬���������������߹�һ��ʱ��󣬻��������������Ϣ��
+*   �������ѣ������߽�������������Ϣ�����ַ�ʽ�����ܷdz��ã�Ҳ���Ƽ������ѷ�ʽ�������ѵĹ����У���������쳣��������ֱ���׳������Ƿ���`RECONSUME_LATER`״̬�����������������ڲ�����ȷ������������һ��ʱ��󣬻��ٴ���������
+
+���������ڲ�����ʹ��`ThreadPoolExecutor`��Ϊ�̳߳صģ����ǿ���ͨ��`setConsumeThreadMin`��`setConsumeThreadMax`������С�����̺߳���������̡߳�
+
+��һ���µ��������齨���Ժ���Ҫ�����Ƿ�����֮ǰ����ʷ��Ϣ��`CONSUME_FROM_LAST_OFFSET`��������ʷ��Ϣ�������µ���Ϣ��`CONSUME_FROM_FIRST_OFFSET`�����Ѷ����е�ÿһ����Ϣ��֮ǰ����ʷ��ϢҲ��������һ�顣`CONSUME_FROM_TIMESTAMP`����ָ��������Ϣ��ʱ�䣬ָ��ʱ���Ժ����Ϣ�ᱻ���ѡ�
+
+������Ӧ�ò��������ظ����ѣ���ô��������Ϣ�Ĺ����У�Ҫ������Ϣ��У�顣
+
+���ˣ�����͵�����ɣ���һƪ���ǽ�����RocketMQ�Ļ������
\ No newline at end of file
diff --git "a/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\351\241\272\345\272\217\346\266\210\350\264\271.md" "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\351\241\272\345\272\217\346\266\210\350\264\271.md"
new file mode 100644
index 0000000..7b22bce
--- /dev/null
+++ "b/docs/mq/RocketMQ/RocketMQ\347\263\273\345\210\227\357\274\232\351\241\272\345\272\217\346\266\210\350\264\271.md"
@@ -0,0 +1,62 @@
+# [RocketMQϵ�У�һ����������](https://www.cnblogs.com/boboooo/p/13038950.html)
+
+
+
+
+
+RocketMQ�ǰ����Ʒ��һ�Դ����Ϣ�м����������������ľ�������������Ϣ�Ĺ��ܡ�����ҵ�У���Ϣ�м��ѡ��ʹ��RocketMQ�Ļ���ͦ��ģ���һϵ�е����¶������RocketMQ�ģ������ȴ�RocketMQ��һЩ��������ͻ����Ĵ��ʼ����
+
+RocketMQ��4������ɣ��ֱ��ǣ����Ʒ���Name Server������Ϣ���У�Brokers���������ߣ�producer���������ߣ�consumer������4���ֶ����Խ���ˮƽ��չ���Ӷ����ⵥ����ϣ�����ͼ��
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/1191201-20200603173058174-1551688390.png)
+
+����RocketMQ�����ϵ�һ��ͼ���dz��������г���4�����֣����Ҷ��Ǽ�Ⱥģʽ���������Ǿͷֱ�˵һ˵��4���֡�
+
+## ���Ʒ���NameServer��
+
+Name Server���ݵĽ�ɫ��һ��ע�����ģ���Zookeeper�����ò�ࡣ������Ҫ���������������£�
+
+*   broker�Ĺ�����broker��Ⱥ���Լ�����Ϣע�ᵽNameServer��NameServer�ṩ�������Ƽ��ÿһ��broker�Ƿ�������
+*   ·�ɹ�����ÿһ��NameServer��������broker��Ⱥ�Ͷ��е���Ϣ���Ա�ͻ��ˣ������ߺ������ߣ���ѯ��
+
+NameServerЭ���ŷֲ�ʽϵͳ�е�ÿһ����������ҹ�����ÿһ��Topic��·����Ϣ��
+
+## Broker
+
+Broker��Ҫ�Ǵ洢��Ϣ�������ṩTopic�Ļ��ơ����ṩ�ƺ�������ģʽ������һЩ���ֵĴ�ʩ���������������Ϣ�������������ǿ�һ��Brokcer�����ӻ��ơ�
+
+Broker�Ľ�ɫ��Ϊ���첽��������ͬ�������͡��ӡ�������ɫ������㲻��������Ϣ�Ķ�ʧ�����������һ����ͬ�������͡��ӡ�����Broker������������Ϣ��ʧҲ����ν��ֻҪ���п��þ�ok�Ļ�����������á��첽�����͡��ӡ�����broker�������ֻ����򵥵Ĵ��ֻ����һ�����첽�����������á��ӡ�Ҳ�ǿ��Եġ�
+
+�����ᵽ����broker֮��ı��ݣ�broker�����ϢҲ�ǿ��Ա��浽���̵ģ����浽���̵ķ�ʽҲ�����֣��Ƽ��ķ�ʽ���첽������̣�ͬ����������Ƿdz�������ܵġ�
+
+## ������
+
+������֧�ּ�Ⱥ����������broker��Ⱥ������Ϣ������֧�ֶ��ָ��ؾ���ķ�ʽ��
+
+����������broker������Ϣʱ����õ����ͽ�������ͽ������һ������״̬���������ǵ������У���Ϣ������`isWaitStoreMsgOK = true`���������Ĭ��Ҳ��`true`�����������Ϊ`false`���ڷ�����Ϣ�Ĺ����У�ֻҪ�������쳣�����ͽ������`SEND_OK`����`isWaitStoreMsgOK = true`�����ͽ�������¼��֣�
+
+*   `FLUSH_DISK_TIMEOUT`��������̳�ʱ����������̵ķ�ʽ����ΪSYNC_FLUSH��ͬ������������syncFlushTimeout���õ�ʱ���ڣ�Ĭ��5s����û����ɱ�����̵Ķ���������õ����״̬��
+*   `FLUSH_SLAVE_TIMEOUT`��ͬ�����ӡ���ʱ����broker�Ľ�ɫ����Ϊ��ͬ������ʱ�����������õ�ͬ��ʱ���ڣ�Ĭ��Ϊ5s��û���������֮���ͬ�����ͻ�õ����״̬��
+*   `SLAVE_NOT_AVAILABLE`�����ӡ������ã����������á�ͬ������������û�����á��ӡ�brokerʱ���᷵�����״̬��
+*   `SEND_OK`����Ϣ���ͳɹ���
+
+����������Ϣ�ظ�����Ϣ��ʧ�����㷢�������Ϣ��ʧʱ��ͨ��������ѡ��һ���Ƕ��Ͷ��ɣ�������Ϣ����Ķ��ˣ���һ��ѡ������Ϣ���·��ͣ������п���������Ϣ�ظ���ͨ������£������Ƽ����·��͵ģ�������������Ϣ��ʱ��Ҫȥ�����ظ�����Ϣ��
+
+����message�Ĵ�Сһ�㲻����512k��Ĭ�ϵķ�����Ϣ�ķ�ʽ��ͬ���ģ����ͷ�����һֱ������ֱ���ȵ����ص���Ӧ�������Ƚ��������ܣ�Ҳ������`send(msg, callback)`�첽�ķ�ʽ������Ϣ��
+
+## ������
+
+��������߿������**�������飨consumer group��**����ͬ��**��������**���Զ�����ͬ��Topic��Ҳ���Զ���������Topic��ÿһ���������鶼���Լ�������ƫ������
+
+��Ϣ�����ѷ�ʽһ�������֣�˳�����ѺͲ������ѡ�
+
+*   ˳�����ѣ������߽���ס��Ϣ���У�ȷ����Ϣ����˳��һ��һ���ı����ѵ���˳�����ѻ�����һ����������ʧ����������Ϣ��ʱ����������쳣��������ֱ���׳�������Ӧ�÷���`SUSPEND_CURRENT_QUEUE_A_MOMENT`���״̬���������������߹�һ��ʱ��󣬻��������������Ϣ��
+*   �������ѣ������߽�������������Ϣ�����ַ�ʽ�����ܷdz��ã�Ҳ���Ƽ������ѷ�ʽ�������ѵĹ����У���������쳣��������ֱ���׳������Ƿ���`RECONSUME_LATER`״̬�����������������ڲ�����ȷ������������һ��ʱ��󣬻��ٴ���������
+
+���������ڲ�����ʹ��`ThreadPoolExecutor`��Ϊ�̳߳صģ����ǿ���ͨ��`setConsumeThreadMin`��`setConsumeThreadMax`������С�����̺߳���������̡߳�
+
+��һ���µ��������齨���Ժ���Ҫ�����Ƿ�����֮ǰ����ʷ��Ϣ��`CONSUME_FROM_LAST_OFFSET`��������ʷ��Ϣ�������µ���Ϣ��`CONSUME_FROM_FIRST_OFFSET`�����Ѷ����е�ÿһ����Ϣ��֮ǰ����ʷ��ϢҲ��������һ�顣`CONSUME_FROM_TIMESTAMP`����ָ��������Ϣ��ʱ�䣬ָ��ʱ���Ժ����Ϣ�ᱻ���ѡ�
+
+������Ӧ�ò��������ظ����ѣ���ô��������Ϣ�Ĺ����У�Ҫ������Ϣ��У�顣
+
+���ˣ�����͵�����ɣ���һƪ���ǽ�����RocketMQ�Ļ������
\ No newline at end of file
diff --git "a/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka \345\277\253\351\200\237\344\270\212\346\211\213\357\274\210Java\347\211\210\357\274\211.md" "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka \345\277\253\351\200\237\344\270\212\346\211\213\357\274\210Java\347\211\210\357\274\211.md"
new file mode 100644
index 0000000..b4bc0a9
--- /dev/null
+++ "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka \345\277\253\351\200\237\344\270\212\346\211\213\357\274\210Java\347\211\210\357\274\211.md"	
@@ -0,0 +1,173 @@
+**前言**
+
+上篇文章讲解了 Kafka 的基础概念和架构，了解了基本概念之后，必须得实践一波了，所谓“实践才是检验真理的唯一办法”，后续系列关于 Kafka 的文章都以 kafka_2.11-0.9.0.0 为例；另外为了让大家快速入门，本文只提供单机版的安装实战教程，如果有想尝试集群方案的，后面在出一篇集群安装的教程，废话不多说了，直接开干。
+
+## **安装**
+
+### **1\. 下载**
+
+版本号：kafka_2.11-0.9.0.0
+
+下载地址：[http://kafka.apache.org/downloads](https://link.zhihu.com/?target=http%3A//kafka.apache.org/downloads)
+
+### **2\. 安装**
+
+
+
+```
+# 安装目录
+$ pwd
+/Users/my/software/study
+
+# 减压
+$ sudo tar -zxvf kafka_2.11-0.9.0.0.tgz
+
+# 重命名
+$ sudo mv kafka_2.11-0.9.0.0.tgz kafka-0.9
+
+# 查看目录结构
+$ cd kafka-0.9 && ls
+LICENSE   NOTICE    bin       config    libs      site-docs
+
+# 目录结构介绍：
+# bin: 			存放kafka 客户端和服务端的执行脚本
+# config:		存放kafka的一些配置文件
+# libs:			存放kafka运行的的jar包
+# site-docs:	存放kafka的配置文档说明
+
+# 配置环境变量，方便在任意目录下运行kafka命令
+# 博主使用的Mac，所以配置在了 ~/.bash_profile文件中，
+# Linux中则配置在 ~/.bashrc 或者  ~/.zshrc文件中
+$ vim ~/.bash_profile
+
+export KAFKA_HOME=/Users/haikuan1/software/study/kafka-0.9
+export PATH=$PATH:$JAVA_HOME:$KAFKA_HOME/bin
+
+# 使得环境变量生效
+$ source ~/.bash_profile
+
+```
+
+
+
+### **3.运行**
+
+### **3.1 启动 zookeeper**
+
+
+
+```
+# 启动zookeeper，因为kafka的元数据需要保存到zookeeper中
+$ bin/zookeeper-server-start.sh config/zookeeper.properties
+
+# 若出现如下信息，则证明zookeeper启动成功了
+[2020-04-25 16:23:44,493] INFO Server environment:user.dir=/Users/haikuan1/software/study/kafka-0.10 (org.apache.zookeeper.server.ZooKeeperServer)
+[2020-04-25 16:23:44,505] INFO tickTime set to 3000 (org.apache.zookeeper.server.ZooKeeperServer)
+[2020-04-25 16:23:44,505] INFO minSessionTimeout set to -1 (org.apache.zookeeper.server.ZooKeeperServer)
+[2020-04-25 16:23:44,505] INFO maxSessionTimeout set to -1 (org.apache.zookeeper.server.ZooKeeperServer)
+[2020-04-25 16:23:44,548] INFO binding to port 0.0.0.0/0.0.0.0:2181 (org.apache.zookeeper.server.NIOServerCnxnFactory)
+
+```
+
+
+
+### **3.2 启动 Kafka server**
+
+
+
+```
+# 以守护进程的方式启动kafka服务端，去掉 -daemon 参数则关闭当前窗口服务端自动退出
+$ bin/kafka-server-start.sh -daemon config/server.properties
+
+```
+
+
+
+### **3.3 kafka 基础命令使用**
+
+
+
+```
+# 1\. 创建一个topic
+# --replication-factor：指定副本个数
+# --partition：指定partition个数
+# --topic：指定topic的名字
+$ bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partition 1 --topic mytopic
+
+# 2\. 查看创建成功的topic
+$ kafka-topics.sh --list --zookeeper localhost:2181
+
+# 3\. 创建生产者和消费者
+
+# 3.1 启动kafka消费端
+# --from-beginning：从头开始消费，该特性也表明kafka消息具有持久性
+$ bin/kafka-console-consumer.sh --zookeeper localhost:2181 --topic mytopic --from-beginning
+
+# 3.2 启动kafka生产端
+# --broker-list：当前的Broker列表，即提供服务的列表
+$ bin/kafka-console-producer.sh --broker-list localhost:9092 --topic mytopic
+
+```
+
+
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-a1e0c6db02c2822b2ad88db1c3b0b8a7_720w.webp)
+
+</figure>
+
+### **4.使用 Java 连接 kafka 进行测试**
+
+### **4.1 创建一个 maven 工程，引入如下 pom 依赖**
+
+
+
+```
+<dependency>
+    <groupId>org.apache.kafka</groupId>
+    kafka-clients
+    <version>0.9.0.0</version>
+</dependency>
+
+<dependency>
+    <groupId>org.apache.kafka</groupId>
+    kafka_2.11
+    <version>0.9.0.0</version>
+</dependency>
+
+```
+
+
+
+### **4.2 消费者端代码**
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-5e9876ca0dc733fe8c2df51d2e42d1ce_720w.webp)
+
+</figure>
+
+### **4.3 生产者端代码**
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-d1e6bfdf23c2b42e23f30d4430c587e2_720w.webp)
+
+</figure>
+
+### **4.4 消费者端效果图**
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-1912f5b2b12ac766d746d88a04b9bd28_720w.webp)
+
+</figure>
+
+### **5.总结**
+
+本文介绍了 kafka 单机版安装及简单命令使用，然后使用 Java 实现了生产者和消费者的简单功能，虽然内容可能比较简单，但还是**强烈建议大家手动去实践一下**，从而对 kafka 的架构有一个更深入的理解。
\ No newline at end of file
diff --git "a/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\344\270\200\346\235\241\346\266\210\346\201\257\345\255\230\345\210\260broker\347\232\204\350\277\207\347\250\213.md" "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\344\270\200\346\235\241\346\266\210\346\201\257\345\255\230\345\210\260broker\347\232\204\350\277\207\347\250\213.md"
new file mode 100644
index 0000000..6af0292
--- /dev/null
+++ "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\344\270\200\346\235\241\346\266\210\346\201\257\345\255\230\345\210\260broker\347\232\204\350\277\207\347\250\213.md"
@@ -0,0 +1,112 @@
+**前言**
+
+经过上篇文章的简单实战之后，**今天来聊聊生产者将消息从客户端发送到 Broker 上背后发生了哪些故事**，看不看由你，但是我保证可以本篇文章你一定可以学到应用背后的一些实质东西。
+
+本文我们从以下 4 个方面来探讨下一条消息如何被准确的发送到 Broker 的 partition 上。
+
+**1\. 客户端组件**
+
+**2\. 客户端缓存存储模型**
+
+**3\. 确定消息的 partition 位置**
+
+**4\. 发送线程的工作原理**
+
+* * *
+
+## **客户端组件**
+
+*   **KafkaProducer:**
+
+KafkaProducer 是一个生产者客户端的进程，通过该对象启动生产者来发送消息。
+
+*   **RecordAccumulator:**
+
+RecordAccumulator 是一个记录收集器，用于收集客户端发送的消息，并将收集到的消息暂存到客户端缓存中。
+
+*   **Sender:**
+
+Sender 是一个发送线程，负责读取记录收集器中缓存的批量消息，经过一些中间转换操作，将要发送的数据准备好，然后交由 Selector 进行网络传输。
+
+*   **Selector:**
+
+Selector 是一个选择器，用于处理网络连接和读写处理，使用网络连接处理客户端上的网络请求。
+
+通过使用以上四大组件即可完成客户端消息的发送工作。消息在网络中传输的方式只能通过二级制的方式，所以首先需要将消息序列化为二进制形式缓存在客户端，kafka 使用了双端队列的方式将消息缓存起来，然后使用发送线程（Sender）读取队列中的消息交给 Selector 进行网络传输发送给服务端（Broker）
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-7d57acd1d7dc5942e999e6ffebb28679_720w.webp)
+
+</figure>
+
+以上为发送消息的主流程，附上部分源码供大家参考，接下来分析下几个非常重要流程的具体实现原理。
+
+* * *
+
+## **客户端缓存存储模型**
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-5da65c5f9f8c0c9082e07c6431e78cd2_720w.webp)
+
+</figure>
+
+从上图可以看出，一条消息首先需要确定要被存储到那个 partition 对应的双端队列上；其次，存储消息的双端队列是以批的维度存储的，即 N 条消息组成一批，一批消息最多存储 N 条，超过后则新建一个组来存储新消息；其次，新来的消息总是从左侧写入，即越靠左侧的消息产生的时间越晚；最后，只有当一批消息凑够 N 条后才会发送给 Broker，否则不会发送到 Broker 上。
+
+了解了客户端存储模型后，来探讨下确定消息的 partition（分区）位置？
+
+* * *
+
+## **确定消息的 partition 位置**
+
+消息可分为两种，一种是指定了 key 的消息，一种是没有指定 key 的消息。
+
+对于指定了 key 的消息，partition 位置的计算方式为：**`Utils.murmur2(key) % numPartitions`**，即先对 key 进行哈希计算，然后在于 partition 个数求余，从而得到该条消息应该被存储在哪个 partition 上。
+
+对于没有指定 key 的消息，partition 位置的计算方式为：**采用 round-robin 方式确定 partition 位置**，即采用轮询的方式，平均的将消息分布到不同的 partition 上，从而避免某些 partition 数据量过大影响 Broker 和消费端性能。
+
+### **注意**
+
+由于 partition 有主副的区分，此处参与计算的 partition 数量是当前有主 partition 的数量，即如果某个 partition 无主的时候，则此 partition 是不能够进行数据写入的。
+
+稍微解释一下，主副 partition 的机制是为了提高 kafka 系统的容错性的，即当某个 Broker 意外宕机时，在此 Broker 上的主 partition 状态为不可读写时（只有主 partition 可对外提供读写服务，副 partition 只有数据备份的功能），kafka 会从主 partition 对应的 N 个副 partition 中挑选一个，并将其状态改为主 partition，从而继续对外提供读写操作。
+
+消息被确定分配到某个 partition 对应记录收集器（即双端队列）后，接下来，发送线程（Sender）从记录收集器中收集满足条件的批数据发送给 Broker，那么发送线程是如何收集满足条件的批数据的？批数据是按照 partition 维度发送的还是按照 Broker 维度发送数据的？
+
+* * *
+
+## **发送线程的工作原理**
+
+Sender 线程的主要工作是收集满足条件的批数据，何为满足条件的批数据？缓存数据是以批维度存储的，当一批数据量达到指定的 N 条时，就满足发送给 Broker 的条件了。
+
+partition 维度和 Broker 维度发送消息模型对比。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-36b7c2761f17fb2d6481747523999011_720w.webp)
+
+</figure>
+
+从图中可以看出，左侧按照 partition 维度发送消息，每个 partition 都需要和 Broker 建连，总共发生了四次网络连接。而右侧将分布在同一个 Broker 的 partition 按组聚合后在与 Broker 建连，只需要两次网络连接即可。所以 Kafka 选择右侧的方式。
+
+### **Sender 的主要工作**
+
+第一步：扫描记录收集器中满足条件的批数据，然后将 partition -> 批数据映射转换成 BrokerId -> N 批数据的映射。第二步：Sender 线程会为每个 BrokerId 创建一个客户端请求，然后将请求交给 NetWorkClient，由 NetWrokClient 去真正发送网络请求到 Broker。
+
+### **NetWorkClient 的工作内容**
+
+Sender 线程准备好要发送的数据后，交由 NetWorkClient 来进行网络相关操作。主要包括客户端与服务端的建连、发送客户端请求、接受服务端响应。完成如上一系列的工作主要由如下方法完成。
+
+1.  reday()方法。从记录收集器获取准备完毕的节点，并连接所有准备好的节点。
+2.  send()方法。为每个节点创建一个客户端请求，然后将请求暂时存到节点对应的 Channel（通道）中。
+3.  poll()方法。该方法会真正轮询网络请求，发送请求给服务端节点和接受服务端的响应。
+
+* * *
+
+## **总结**
+
+以上，即为生产者客户端的一条消息从生产到发送到 Broker 上的全过程。现在是不是就很清晰了呢？也许有些朋友会比较疑惑它的**网络请求模型是什么样的**，作者就猜你会你会问，下一篇我们就来扒开它的神秘面纱看看其究竟是怎么实现的，敬请期待。
\ No newline at end of file
diff --git "a/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\344\273\213\347\273\215.md" "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\344\273\213\347\273\215.md"
new file mode 100644
index 0000000..bb4fd3b
--- /dev/null
+++ "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\344\273\213\347\273\215.md"
@@ -0,0 +1,122 @@
+## 一.官网Kafka介绍
+
+## 1.1 什么是事件流?
+
+事件流是相当于人体中枢神经系统的数字系统。它是“永远在线”世界的技术基础，在这个世界里，企业越来越多地由软件定义和自动化，软件的用户也更多地是软件。
+
+从技术上讲，事件流是指以事件流的形式从数据库、传感器、移动设备、云服务和软件应用等事件源实时捕获数据的实践;持久地存储这些事件流以备以后检索;实时和回顾性地操作、处理和响应事件流;并根据需要将事件流路由到不同的目的地技术。因此，事件流确保了数据的连续流动和解释，从而使正确的信息在正确的地点、正确的时间出现。
+
+## 1.2 我可以使用事件流做什么?
+
+事件流应用于众多行业和组织的各种用例。它的许多例子包括: 1. 实时处理支付和金融交易，如股票交易所、银行和保险。 2. 实时跟踪和监控汽车、卡车、车队和运输，如物流和汽车行业。 3. 持续捕获和分析来自物联网设备或其他设备的传感器数据，如工厂和风电场。 4. 收集并立即响应客户的互动和订单，如零售、酒店和旅游行业，以及移动应用程序。 5. 监测住院病人，预测病情变化，确保在紧急情况下及时治疗。 6. 连接、存储公司不同部门产生的数据并使其可用。 7. 作为数据平台、事件驱动架构和微服务的基础。
+
+## 1.3 Apache Kafka®是一个事件流平台。这是什么意思?
+
+Kafka结合了三个关键的功能，所以你可以用一个单一的战斗测试解决方案来实现端到端事件流的用例: 1. 发布(写)和订阅(读)事件流，包括从其他系统连续导入/导出数据。 2. 持久性和可靠地存储事件流，只要你想。 3. 在事件发生或回顾时处理事件流。
+
+所有这些功能都是以分布式、高度可伸缩、弹性、容错和安全的方式提供的。Kafka可以部署在裸金属硬件、虚拟机和容器上，也可以部署在云上。您可以选择自管理您的Kafka环境和使用由各种供应商提供的完全管理的服务。
+
+## 1.4 简而言之，Kafka是如何工作的?
+
+Kafka是一个分布式系统，由服务器和客户端组成，通过高性能的TCP网络协议进行通信。它可以部署在裸金属硬件、虚拟机和内部环境中的容器上，也可以部署在云环境中。
+
+**服务器:**Kafka作为一个集群运行一个或多个服务器，可以跨越多个数据中心或云区域。其中一些服务器构成存储层，称为代理。其他服务器运行Kafka Connect来持续导入和导出数据作为事件流，将Kafka与您现有的系统集成，如关系数据库以及其他Kafka集群。为了让你实现关键任务的用例，Kafka集群具有高度的可扩展性和容错性:如果它的任何一个服务器发生故障，其他服务器将接管它们的工作，以确保持续的操作而不丢失任何数据。
+
+**客户机:**它们允许您编写分布式应用程序和微服务，这些应用程序和微服务可以并行地、大规模地读取、写入和处理事件流，甚至在出现网络问题或机器故障的情况下也可以容错。Kafka附带了一些这样的客户端，这些客户端被Kafka社区提供的几十个客户端增强了:客户端可以用于Java和Scala，包括更高级别的Kafka Streams库，用于Go、Python、C/ c++和许多其他编程语言以及REST api。
+
+## 1.5 主要概念和术语
+
+事件记录了在世界上或你的企业中“发生了某事”的事实。在文档中也称为记录或消息。当你读或写数据到Kafka时，你以事件的形式做这件事。从概念上讲，事件具有键、值、时间戳和可选的元数据头。下面是一个例子: 1. 活动重点:“爱丽丝” 2. 事件值:“向Bob支付200美元” 3. 事件时间戳:“2020年6月25日下午2:06。”
+
+生产者是那些向Kafka发布(写)事件的客户端应用程序，而消费者是那些订阅(读和处理)这些事件的应用程序。在Kafka中，生产者和消费者是完全解耦的，彼此是不可知的，这是实现Kafka闻名的高可扩展性的一个关键设计元素。例如，生产者从不需要等待消费者。Kafka提供了各种各样的保证，比如精确处理一次事件的能力。
+
+事件被组织并持久地存储在主题中。很简单，一个主题类似于文件系统中的一个文件夹，事件就是该文件夹中的文件。一个示例主题名称可以是“payments”。Kafka中的主题总是多生产者和多订阅者:一个主题可以有0个、1个或多个生产者向它写入事件，也可以有0个、1个或多个消费者订阅这些事件。主题中的事件可以根据需要经常读取——与传统消息传递系统不同，事件在使用后不会删除。相反，你可以通过每个主题的配置设置来定义Kafka应该保留你的事件多长时间，之后旧的事件将被丢弃。Kafka的性能相对于数据大小来说是不变的，所以长时间存储数据是完全可以的。
+
+主题是分区的，这意味着一个主题分散在位于不同Kafka broker上的多个“桶”上。这种数据的分布式位置对于可伸缩性非常重要，因为它允许客户机应用程序同时从/向多个代理读取和写入数据。当一个新事件被发布到一个主题时，它实际上被附加到主题的一个分区中。具有相同事件键(例如，客户或车辆ID)的事件被写入同一个分区，Kafka保证任何给定主题分区的消费者都将始终以写入的完全相同的顺序读取该分区的事件。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-39059344afb24ff7436bf7fb06bddde4_720w.webp)
+
+</figure>
+
+让你的数据容错和可用性,每一个主题可以被复制,甚至跨geo-regions或数据中心,这样总有多个经纪人有一份数据以防出错,你想做代理维护,等等。一个常见的生产设置是复制因子3，也就是说，您的数据总是有三个副本。这个复制是在主题分区级别执行的。
+
+## 二.Kafka简介
+
+Kafka是一种消息队列，主要用来处理大量数据状态下的消息队列，一般用来做日志的处理。既然是消息队列，那么Kafka也就拥有消息队列的相应的特性了。
+
+**消息队列的好处** 1. 解耦合 耦合的状态表示当你实现某个功能的时候，是直接接入当前接口，而利用消息队列，可以将相应的消息发送到消息队列，这样的话，如果接口出了问题，将不会影响到当前的功能。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-e37a18ea7eddc69582d634cc881eb257_720w.webp)
+
+</figure>
+
+1.  异步处理 异步处理替代了之前的同步处理，异步处理不需要让流程走完就返回结果，可以将消息发送到消息队列中，然后返回结果，剩下让其他业务处理接口从消息队列中拉取消费处理即可。
+
+2.  流量削峰 高流量的时候，使用消息队列作为中间件可以将流量的高峰保存在消息队列中，从而防止了系统的高请求，减轻服务器的请求处理压力。
+
+## 2.1 Kafka消费模式
+
+Kafka的消费模式主要有两种：一种是一对一的消费，也即点对点的通信，即一个发送一个接收。第二种为一对多的消费，即一个消息发送到消息队列，消费者根据消息队列的订阅拉取消息消费。
+
+**一对一**
+
+<figure data-size="normal">
+
+
+![image-20230525200024084](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230525200024084.png)
+
+</figure>
+
+消息生产者发布消息到Queue队列中，通知消费者从队列中拉取消息进行消费。消息被消费之后则删除，Queue支持多个消费者，但对于一条消息而言，只有一个消费者可以消费，即一条消息只能被一个消费者消费。
+
+**一对多**
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-d97a2898f3bdc417262bc88be616281c_720w.webp)
+
+</figure>
+
+这种模式也称为发布/订阅模式，即利用Topic存储消息，消息生产者将消息发布到Topic中，同时有多个消费者订阅此topic，消费者可以从中消费消息，注意发布到Topic中的消息会被多个消费者消费，消费者消费数据之后，数据不会被清除，Kafka会默认保留一段时间，然后再删除。
+
+## 2.2 Kafka的基础架构
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-ef94691300117c049301d88c6337c9c2_720w.webp)
+
+</figure>
+
+Kafka像其他Mq一样，也有自己的基础架构，主要存在生产者Producer、Kafka集群Broker、消费者Consumer、注册中心Zookeeper.
+
+1. Producer：消息生产者，向Kafka中发布消息的角色。
+
+2. Consumer：消息消费者，即从Kafka中拉取消息消费的客户端。
+
+3. Consumer Group：消费者组，消费者组则是一组中存在多个消费者，消费者消费Broker中当前Topic的不同分区中的消息，消费者组之间互不影响，所有的消费者都属于某个消费者组，即消费者组是逻辑上的一个订阅者。某一个分区中的消息只能够一个消费者组中的一个消费者所消费
+
+4. Broker：经纪人，一台Kafka服务器就是一个Broker，一个集群由多个Broker组成，一个Broker可以容纳多个Topic。
+
+5. Topic：主题，可以理解为一个队列，生产者和消费者都是面向一个Topic
+
+6. Partition：分区，为了实现扩展性，一个非常大的Topic可以分布到多个Broker上，一个Topic可以分为多个Partition，每个Partition是一个有序的队列(分区有序，不能保证全局有序)
+
+7. Replica：副本Replication，为保证集群中某个节点发生故障，节点上的Partition数据不丢失，Kafka可以正常的工作，Kafka提供了副本机制，一个Topic的每个分区有若干个副本，一个Leader和多个Follower
+
+8. Leader：每个分区多个副本的主角色，生产者发送数据的对象，以及消费者消费数据的对象都是Leader。
+
+9. Follower：每个分区多个副本的从角色，实时的从Leader中同步数据，保持和Leader数据的同步，Leader发生故障的时候，某个Follower会成为新的Leader。
+
+上述一个Topic会产生多个分区Partition，分区中分为Leader和Follower，消息一般发送到Leader，Follower通过数据的同步与Leader保持同步，消费的话也是在Leader中发生消费，如果多个消费者，则分别消费Leader和各个Follower中的消息，当Leader发生故障的时候，某个Follower会成为主节点，此时会对齐消息的偏移量。
+
+## 参考文章
+https://blog.csdn.net/cao131502
+https://zhuanlan.zhihu.com/p/137811719
\ No newline at end of file
diff --git "a/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\345\216\237\347\220\206\345\210\206\346\236\220\346\200\273\347\273\223\347\257\207.md" "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\345\216\237\347\220\206\345\210\206\346\236\220\346\200\273\347\273\223\347\257\207.md"
new file mode 100644
index 0000000..58632b3
--- /dev/null
+++ "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\345\216\237\347\220\206\345\210\206\346\236\220\346\200\273\347\273\223\347\257\207.md"
@@ -0,0 +1,636 @@
+## 一、概述
+
+Kakfa起初是由LinkedIn公司开发的一个分布式的消息系统，后成为Apache的一部分，它使用Scala编写，以可水平扩展和高吞吐率而被广泛使用。目前越来越多的开源分布式处理系统如Cloudera、Apache Storm、Spark等都支持与Kafka集成。
+
+Kafka凭借着自身的优势，越来越受到互联网企业的青睐，唯品会也采用Kafka作为其内部核心消息引擎之一。Kafka作为一个商业级消息中间件，消息可靠性的重要性可想而知。如何确保消息的精确传输?如何确保消息的准确存储?如何确保消息的正确消费?这些都是需要考虑的问题。本文首先从Kafka的架构着手，先了解下Kafka的基本原理，然后通过对kakfa的存储机制、复制原理、同步原理、可靠性和持久性保证等等一步步对其可靠性进行分析，最后通过benchmark来增强对Kafka高可靠性的认知。
+
+
+
+
+
+[回到顶部](https://www.cnblogs.com/wangzhuxing/p/10051512.html#_labelTop)
+
+## 二、Kafka的使用场景
+
+（1）日志收集：一个公司可以用Kafka可以收集各种服务的log，通过kafka以统一接口服务的方式开放给各种consumer，例如Hadoop、Hbase、Solr等；
+
+（2）消息系统：解耦和生产者和消费者、缓存消息等；
+
+（3）用户活动跟踪：Kafka经常被用来记录web用户或者app用户的各种活动，如浏览网页、搜索、点击等活动，这些活动信息被各个服务器发布到kafka的topic中，然后订阅者通过订阅这些topic来做实时的监控分析，或者装载到Hadoop、数据仓库中做离线分析和挖掘；
+
+（4）运营指标：Kafka也经常用来记录运营监控数据。包括收集各种分布式应用的数据，生产各种操作的集中反馈，比如报警和报告；
+
+（5）流式处理：比如spark streaming和storm；
+
+（6）事件源；
+
+
+
+[回到顶部](https://www.cnblogs.com/wangzhuxing/p/10051512.html#_labelTop)
+
+## 三、Kafka基本架构
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181201215942487-1393117307.png)
+
+如上图所示，一个典型的Kafka体系架构包括：
+
+*   若干Producer(可以是服务器日志，业务数据，页面前端产生的page view等等)，
+*   若干broker(Kafka支持水平扩展，一般broker数量越多，集群吞吐率越高)，
+*   若干Consumer (Group)，以及一个Zookeeper集群。
+
+Kafka通过Zookeeper管理集群配置，选举leader，以及在consumer group发生变化时进行rebalance。Producer使用push(推)模式将消息发布到broker，Consumer使用pull(拉)模式从broker订阅并消费消息。
+
+
+
+### 1、Topic & Partition
+
+一个topic可以认为一个一类消息，每个topic将被分成多个partition，每个partition在存储层面是append log文件。任何发布到此partition的消息都会被追加到log文件的尾部，每条消息在文件中的位置称为offset(偏移量)，offset为一个long型的数字，它唯一标记一条消息。每条消息都被append到partition中，是顺序写磁盘，因此效率非常高(经验证，顺序写磁盘效率比随机写内存还要高，这是Kafka高吞吐率的一个很重要的保证)。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181201220820060-2075971944.png)
+
+每一条消息被发送到broker中，会根据partition规则选择被存储到哪一个partition。partition机制可以通过指定producer的partition.class这一参数来指定，该class必须实现kafka.producer.Partitioner接口。如果partition规则设置的合理，所有消息可以均匀分布到不同的partition里，这样就实现了水平扩展。(如果一个topic对应一个文件，那这个文件所在的机器I/O将会成为这个topic的性能瓶颈，而partition解决了这个问题)。在创建topic时可以在$KAFKA_HOME/config/server.properties中指定这个partition的数量(如下所示)，当然可以在topic创建之后去修改partition的数量。
+
+
+
+<pre># The default number of log partitions per topic. More partitions allow greater
+# parallelism for consumption, but this will also result in more files across
+# the brokers.
+#默认partitions数量
+num.partitions=1</pre>
+
+
+
+
+[回到顶部](https://www.cnblogs.com/wangzhuxing/p/10051512.html#_labelTop)
+
+## 四、高可靠性存储分析概述
+
+Kafka的高可靠性的保障来源于其健壮的副本(replication)策略。通过调节其副本相关参数，可以使得Kafka在性能和可靠性之间运转的游刃有余。Kafka从0.8.x版本开始提供partition级别的复制,replication的数量可以在$KAFKA_HOME/config/server.properties中配置(default.replication.refactor)。
+
+这里先从Kafka文件存储机制入手，从最底层了解Kafka的存储细节，进而对其的存储有个微观的认知。之后通过Kafka复制原理和同步方式来阐述宏观层面的概念。最后从ISR，HW，leader选举以及数据可靠性和持久性保证等等各个维度来丰富对Kafka相关知识点的认知。
+
+[回到顶部](https://www.cnblogs.com/wangzhuxing/p/10051512.html#_labelTop)
+
+## 五、Kafka文件存储机制
+
+Kafka中消息是以topic进行分类的，生产者通过topic向Kafka broker发送消息，消费者通过topic读取数据。然而topic在物理层面又能以partition为分组，一个topic可以分成若干个partition，那么topic以及partition又是怎么存储的呢?partition还可以细分为segment，一个partition物理上由多个segment组成，那么这些segment又是什么呢?下面我们来一一揭晓。
+
+为了便于说明问题，假设这里只有一个Kafka集群，且这个集群只有一个Kafka broker，即只有一台物理机。在这个Kafka broker中配置($KAFKA_HOME/config/server.properties中)log.dirs=/tmp/kafka-logs，以此来设置Kafka消息文件存储目录，与此同时创建一个topic：topic_zzh_test，partition的数量为4($KAFKA_HOME/bin/kafka-topics.sh –create –zookeeper localhost:2181 –partitions 4 –topic topic_vms_test –replication-factor 4)。那么我们此时可以在/tmp/kafka-logs目录中可以看到生成了4个目录：
+
+
+
+
+
+<pre>drwxr-xr-x 2 root root 4096 Apr 10 16:10 topic_zzh_test-0 
+drwxr-xr-x 2 root root 4096 Apr 10 16:10 topic_zzh_test-1 
+drwxr-xr-x 2 root root 4096 Apr 10 16:10 topic_zzh_test-2 
+drwxr-xr-x 2 root root 4096 Apr 10 16:10 topic_zzh_test-3  </pre>
+
+
+
+
+在Kafka文件存储中，同一个topic下有多个不同的partition，每个partiton为一个目录，partition的名称规则为：topic名称+有序序号，第一个序号从0开始计，最大的序号为partition数量减1，partition是实际物理上的概念，而topic是逻辑上的概念。
+
+上面提到partition还可以细分为segment，这个segment又是什么?如果就以partition为最小存储单位，我们可以想象当Kafka producer不断发送消息，必然会引起partition文件的无限扩张，这样对于消息文件的维护以及已经被消费的消息的清理带来严重的影响，所以这里以segment为单位又将partition细分。每个partition(目录)相当于一个巨型文件被平均分配到多个大小相等的segment(段)数据文件中(每个segment 文件中消息数量不一定相等)这种特性也方便old segment的删除，即方便已被消费的消息的清理，提高磁盘的利用率。每个partition只需要支持顺序读写就行，segment的文件生命周期由服务端配置参数(log.segment.bytes，log.roll.{ms,hours}等若干参数)决定。
+
+
+
+
+
+[![复制代码](https://common.cnblogs.com/images/copycode.gif)](javascript:void(0); "复制代码")
+
+<pre> #在强制刷新数据到磁盘允许接收消息的数量
+#log.flush.interval.messages=10000 # 在强制刷新之前，消息可以在日志中停留的最长时间
+#log.flush.interval.ms=1000 #一个日志的最小存活时间，可以被删除
+log.retention.hours=168 #  一个基于大小的日志保留策略。段将被从日志中删除只要剩下的部分段不低于log.retention.bytes。
+#log.retention.bytes=1073741824 #  每一个日志段大小的最大值。当到达这个大小时，会生成一个新的片段。
+log.segment.bytes=1073741824 # 检查日志段的时间间隔，看是否可以根据保留策略删除它们
+log.retention.check.interval.ms=300000</pre>
+
+
+[![复制代码](https://common.cnblogs.com/images/copycode.gif)](javascript:void(0); "复制代码")
+
+
+
+segment文件由两部分组成，分别为“.index”文件和“.log”文件，分别表示为segment索引文件和数据文件。这两个文件的命令规则为：partition全局的第一个segment从0开始，后续每个segment文件名为上一个segment文件最后一条消息的offset值，数值大小为64位，20位数字字符长度，没有数字用0填充，如下：
+
+
+
+
+
+
+
+[![复制代码](https://common.cnblogs.com/images/copycode.gif)](javascript:void(0); "复制代码")
+
+<pre>00000000000000000000.index 00000000000000000000.log 00000000000000170410.index 00000000000000170410.log 00000000000000239430.index 00000000000000239430.log  </pre>
+
+[![复制代码](https://common.cnblogs.com/images/copycode.gif)](javascript:void(0); "复制代码")
+
+
+
+以上面的segment文件为例，展示出segment：00000000000000170410的“.index”文件和“.log”文件的对应的关系，如下图：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181201224133022-2085407889.png)
+
+
+
+
+
+如上图，“.index”索引文件存储大量的元数据，“.log”数据文件存储大量的消息，索引文件中的元数据指向对应数据文件中message的物理偏移地址。其中以“.index”索引文件中的元数据[3, 348]为例，在“.log”数据文件表示第3个消息，即在全局partition中表示170410+3=170413个消息，该消息的物理偏移地址为348。
+
+那么如何从partition中通过offset查找message呢?
+
+以上图为例，读取offset=170418的消息，首先查找segment文件，其中00000000000000000000.index为最开始的文件，第二个文件为00000000000000170410.index(起始偏移为170410+1=170411)，而第三个文件为00000000000000239430.index(起始偏移为239430+1=239431)，所以这个offset=170418就落到了第二个文件之中。其他后续文件可以依次类推，以其实偏移量命名并排列这些文件，然后根据二分查找法就可以快速定位到具体文件位置。其次根据00000000000000170410.index文件中的[8,1325]定位到00000000000000170410.log文件中的1325的位置进行读取。
+
+要是读取offset=170418的消息，从00000000000000170410.log文件中的1325的位置进行读取，那么怎么知道何时读完本条消息，否则就读到下一条消息的内容了?
+
+这个就需要联系到消息的物理结构了，消息都具有固定的物理结构，包括：offset(8 Bytes)、消息体的大小(4 Bytes)、crc32(4 Bytes)、magic(1 Byte)、attributes(1 Byte)、key length(4 Bytes)、key(K Bytes)、payload(N Bytes)等等字段，可以确定一条消息的大小，即读取到哪里截止。
+
+[回到顶部](https://www.cnblogs.com/wangzhuxing/p/10051512.html#_labelTop)
+
+## 六、复制原理和同步方式
+
+Kafka中topic的每个partition有一个预写式的日志文件，虽然partition可以继续细分为若干个segment文件，但是对于上层应用来说可以将partition看成最小的存储单元(一个有多个segment文件拼接的“巨型”文件)，每个partition都由一些列有序的、不可变的消息组成，这些消息被连续的追加到partition中。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181201231403669-958736996.png)
+
+上图中有两个新名词：HW和LEO。这里先介绍下LEO，LogEndOffset的缩写，表示每个partition的log最后一条Message的位置。HW是HighWatermark的缩写，是指consumer能够看到的此partition的位置，这个涉及到多副本的概念，这里先提及一下，下节再详表。
+
+言归正传，为了提高消息的可靠性，Kafka每个topic的partition有N个副本(replicas)，其中N(大于等于1)是topic的复制因子(replica fator)的个数。Kafka通过多副本机制实现故障自动转移，当Kafka集群中一个broker失效情况下仍然保证服务可用。在Kafka中发生复制时确保partition的日志能有序地写到其他节点上，N个replicas中，其中一个replica为leader，其他都为follower, leader处理partition的所有读写请求，与此同时，follower会被动定期地去复制leader上的数据。
+
+如下图所示，Kafka集群中有4个broker, 某topic有3个partition,且复制因子即副本个数也为3：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181201231724531-2038730622.png)
+
+Kafka提供了数据复制算法保证，如果leader发生故障或挂掉，一个新leader被选举并被接受客户端的消息成功写入。Kafka确保从同步副本列表中选举一个副本为leader，或者说follower追赶leader数据。leader负责维护和跟踪ISR(In-Sync Replicas的缩写，表示副本同步队列，具体可参考下节)中所有follower滞后的状态。当producer发送一条消息到broker后，leader写入消息并复制到所有follower。消息提交之后才被成功复制到所有的同步副本。消息复制延迟受最慢的follower限制，重要的是快速检测慢副本，如果follower“落后”太多或者失效，leader将会把它从ISR中删除。
+
+[回到顶部](https://www.cnblogs.com/wangzhuxing/p/10051512.html#_labelTop)
+
+## 七、零拷贝
+
+Kafka中存在大量的网络数据持久化到磁盘（Producer到Broker）和磁盘文件通过网络发送（Broker到Consumer）的过程。这一过程的性能直接影响Kafka的整体吞吐量。
+
+
+
+### 1、传统模式下的四次拷贝与四次上下文切换
+
+以将磁盘文件通过网络发送为例。传统模式下，一般使用如下伪代码所示的方法先将文件数据读入内存，然后通过Socket将内存中的数据发送出去。
+
+
+
+<pre>buffer = File.read
+Socket.send(buffer)</pre>
+
+
+
+
+这一过程实际上发生了四次数据拷贝。首先通过系统调用将文件数据读入到内核态Buffer（DMA拷贝），然后应用程序将内存态Buffer数据读入到用户态Buffer（CPU拷贝），接着用户程序通过Socket发送数据时将用户态Buffer数据拷贝到内核态Buffer（CPU拷贝），最后通过DMA拷贝将数据拷贝到NIC Buffer。同时，还伴随着四次上下文切换，如下图所示。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181227142339448-1209004133.png)
+
+### 2、sendfile和transferTo实现零拷贝
+
+Linux 2.4+内核通过`sendfile`系统调用，提供了零拷贝。数据通过DMA拷贝到内核态Buffer后，直接通过DMA拷贝到NIC Buffer，无需CPU拷贝。这也是零拷贝这一说法的来源。除了减少数据拷贝外，因为整个读文件-网络发送由一个`sendfile`调用完成，整个过程只有两次上下文切换，因此大大提高了性能。零拷贝过程如下图所示。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181227142423000-1025665055.png)
+
+从具体实现来看，Kafka的数据传输通过TransportLayer来完成，其子类`PlaintextTransportLayer`通过[Java NIO](http://www.jasongj.com/java/nio_reactor/)的FileChannel的`transferTo`和`transferFrom`方法实现零拷贝，如下所示。
+
+
+
+<pre>@Override public long transferFrom(FileChannel fileChannel, long position, long count) throws IOException { return fileChannel.transferTo(position, count, socketChannel);
+}</pre>
+
+
+
+
+**注：** `transferTo`和`transferFrom`并不保证一定能使用零拷贝。实际上是否能使用零拷贝与操作系统相关，如果操作系统提供`sendfile`这样的零拷贝系统调用，则这两个方法会通过这样的系统调用充分利用零拷贝的优势，否则并不能通过这两个方法本身实现零拷贝。
+
+
+
+
+
+[回到顶部](https://www.cnblogs.com/wangzhuxing/p/10051512.html#_labelTop)
+
+## 八、 ISR（副本同步队列）
+
+上节我们涉及到ISR (In-Sync Replicas)，这个是指副本同步队列。副本数对Kafka的吞吐率是有一定的影响，但极大的增强了可用性。默认情况下Kafka的replica数量为1，即每个partition都有一个唯一的leader，为了确保消息的可靠性，通常应用中将其值(由broker的参数offsets.topic.replication.factor指定)大小设置为大于1，比如3。 所有的副本(replicas)统称为Assigned Replicas，即AR。ISR是AR中的一个子集，由leader维护ISR列表，follower从leader同步数据有一些延迟(包括延迟时间replica.lag.time.max.ms和延迟条数replica.lag.max.messages两个维度, 当前最新的版本0.10.x中只支持replica.lag.time.max.ms这个维度)，任意一个超过阈值都会把follower剔除出ISR, 存入OSR(Outof-Sync Replicas)列表，新加入的follower也会先存放在OSR中。AR=ISR+OSR
+
+Kafka 0.10.x版本后移除了replica.lag.max.messages参数，只保留了replica.lag.time.max.ms作为ISR中副本管理的参数。为什么这样做呢?replica.lag.max.messages表示当前某个副本落后leaeder的消息数量超过了这个参数的值，那么leader就会把follower从ISR中删除。假设设置replica.lag.max.messages=4，那么如果producer一次传送至broker的消息数量都小于4条时，因为在leader接受到producer发送的消息之后而follower副本开始拉取这些消息之前，follower落后leader的消息数不会超过4条消息，故此没有follower移出ISR，所以这时候replica.lag.max.message的设置似乎是合理的。但是producer发起瞬时高峰流量，producer一次发送的消息超过4条时，也就是超过replica.lag.max.messages，此时follower都会被认为是与leader副本不同步了，从而被踢出了ISR。但实际上这些follower都是存活状态的且没有性能问题。那么在之后追上leader,并被重新加入了ISR。于是就会出现它们不断地剔出ISR然后重新回归ISR，这无疑增加了无谓的性能损耗。而且这个参数是broker全局的。设置太大了，影响真正“落后”follower的移除;设置的太小了，导致follower的频繁进出。无法给定一个合适的replica.lag.max.messages的值，故此，新版本的Kafka移除了这个参数。注：ISR中包括：leader和follower。
+
+
+
+上面一节还涉及到一个概念，即HW。HW俗称高水位，HighWatermark的缩写，取一个partition对应的ISR中最小的LEO作为HW，consumer最多只能消费到HW所在的位置。另外每个replica都有HW,leader和follower各自负责更新自己的HW的状态。对于leader新写入的消息，consumer不能立刻消费，leader会等待该消息被所有ISR中的replicas同步后更新HW，此时消息才能被consumer消费。这样就保证了如果leader所在的broker失效，该消息仍然可以从新选举的leader中获取。对于来自内部broKer的读取请求，没有HW的限制。
+
+下图详细的说明了当producer生产消息至broker后，ISR以及HW和LEO的流转过程：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181202175002622-1830127657.png)
+
+由此可见，Kafka的复制机制既不是完全的同步复制，也不是单纯的异步复制。事实上，同步复制要求所有能工作的follower都复制完，这条消息才会被commit，这种复制方式极大的影响了吞吐率。而异步复制方式下，follower异步的从leader复制数据，数据只要被leader写入log就被认为已经commit，这种情况下如果follower都还没有复制完，落后于leader时，突然leader宕机，则会丢失数据。而Kafka的这种使用ISR的方式则很好的均衡了确保数据不丢失以及吞吐率。
+
+Kafka的ISR的管理最终都会反馈到Zookeeper节点上。具体位置为：/brokers/topics/[topic]/partitions/[partition]/state。
+
+目前有两个地方会对这个Zookeeper的节点进行维护：
+
+Controller来维护：Kafka集群中的其中一个Broker会被选举为Controller，主要负责Partition管理和副本状态管理，也会执行类似于重分配partition之类的管理任务。在符合某些特定条件下，Controller下的LeaderSelector会选举新的leader，ISR和新的leader_epoch及controller_epoch写入Zookeeper的相关节点中。同时发起LeaderAndIsrRequest通知所有的replicas。
+
+leader来维护：leader有单独的线程定期检测ISR中follower是否脱离ISR, 如果发现ISR变化，则会将新的ISR的信息返回到Zookeeper的相关节点中。
+
+
+
+
+
+[回到顶部](https://www.cnblogs.com/wangzhuxing/p/10051512.html#_labelTop)
+
+## 九、数据可靠性和持久性保证
+
+当producer向leader发送数据时，可以通过request.required.acks参数来设置数据可靠性的级别：
+
+
+
+* 1(默认)：这意味着producer在ISR中的leader已成功收到的数据并得到确认后发送下一条message。如果leader宕机了，则会丢失数据。
+
+* 0：这意味着producer无需等待来自broker的确认而继续发送下一批消息。这种情况下数据传输效率最高，但是数据可靠性确是最低的。
+
+* -1：producer需要等待ISR中的所有follower都确认接收到数据后才算一次发送完成，可靠性最高。但是这样也不能保证数据不丢失，比如当ISR中只有leader时(前面ISR那一节讲到，ISR中的成员由于某些情况会增加也会减少，最少就只剩一个leader)，这样就变成了acks=1的情况。
+
+  [官网配置说明](http://kafka.apache.org/documentation/#configuration)
+
+如果要提高数据的可靠性，在设置request.required.acks=-1的同时，也要min.insync.replicas这个参数(可以在broker或者topic层面进行设置)的配合，这样才能发挥最大的功效。min.insync.replicas这个参数设定ISR中的最小副本数是多少，默认值为1，当且仅当request.required.acks参数设置为-1时，此参数才生效。如果ISR中的副本数少于min.insync.replicas配置的数量时，客户端会返回异常：org.apache.kafka.common.errors.NotEnoughReplicasExceptoin: Messages are rejected since there are fewer in-sync replicas than required。
+
+
+
+接下来对acks=1和-1的两种情况进行详细分析：
+
+
+
+
+
+### 9.1、request.required.acks=1
+
+producer发送数据到leader，leader写本地日志成功，返回客户端成功;此时ISR中的副本还没有来得及拉取该消息，leader就宕机了，那么此次发送的消息就会丢失。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181202181329621-1088596676.png)
+
+
+
+### 9.2、request.required.acks=-1
+
+同步(Kafka默认为同步，即producer.type=sync)的发送模式，replication.factor>=2且min.insync.replicas>=2的情况下，不会丢失数据。
+
+有两种典型情况。acks=-1的情况下(如无特殊说明，以下acks都表示为参数request.required.acks)，数据发送到leader, ISR的follower全部完成数据同步后，leader此时挂掉，那么会选举出新的leader，数据不会丢失。
+
+![](https://img2018.cnblogs.com/blog/843808/201812/843808-20181202212242480-242555451.png)
+
+acks=-1的情况下，数据发送到leader后 ，部分ISR的副本同步，leader此时挂掉。比如follower1h和follower2都有可能变成新的leader, producer端会得到返回异常，producer端会重新发送数据，数据可能会重复
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181202212407453-662912091.png)
+
+当然上图中如果在leader crash的时候，follower2还没有同步到任何数据，而且follower2被选举为新的leader的话，这样消息就不会重复。
+
+注：Kafka只处理fail/recover问题,不处理Byzantine问题。
+
+
+
+
+
+### 9.3、关于HW的进一步探讨
+
+考虑上图(即acks=-1,部分ISR副本同步)中的另一种情况，如果在Leader挂掉的时候，follower1同步了消息4,5，follower2同步了消息4，与此同时follower2被选举为leader，那么此时follower1中的多出的消息5该做如何处理呢?
+
+这里就需要HW的协同配合了。如前所述，一个partition中的ISR列表中，leader的HW是所有ISR列表里副本中最小的那个的LEO。类似于木桶原理，水位取决于最低那块短板。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181203204010599-1107873190.png)
+
+
+
+如上图，某个topic的某partition有三个副本，分别为A、B、C。A作为leader肯定是LEO最高，B紧随其后，C机器由于配置比较低，网络比较差，故而同步最慢。这个时候A机器宕机，这时候如果B成为leader，假如没有HW，在A重新恢复之后会做同步(makeFollower)操作，在宕机时log文件之后直接做追加操作，而假如B的LEO已经达到了A的LEO，会产生数据不一致的情况，所以使用HW来避免这种情况。
+
+A在做同步操作的时候，先将log文件截断到之前自己的HW的位置，即3，之后再从B中拉取消息进行同步。
+
+如果失败的follower恢复过来，它首先将自己的log文件截断到上次checkpointed时刻的HW的位置，之后再从leader中同步消息。leader挂掉会重新选举，新的leader会发送“指令”让其余的follower截断至自身的HW的位置然后再拉取新的消息。
+
+当ISR中的个副本的LEO不一致时，如果此时leader挂掉，选举新的leader时并不是按照LEO的高低进行选举，而是按照ISR中的顺序选举。
+
+
+
+
+
+### 9.4、Leader选举
+
+一条消息只有被ISR中的所有follower都从leader复制过去才会被认为已提交。这样就避免了部分数据被写进了leader，还没来得及被任何follower复制就宕机了，而造成数据丢失。而对于producer而言，它可以选择是否等待消息commit，这可以通过request.required.acks来设置。这种机制确保了只要ISR中有一个或者以上的follower，一条被commit的消息就不会丢失。
+
+有一个很重要的问题是当leader宕机了，怎样在follower中选举出新的leader，因为follower可能落后很多或者直接crash了，所以必须确保选择“最新”的follower作为新的leader。一个基本的原则就是，如果leader不在了，新的leader必须拥有原来的leader commit的所有消息。这就需要做一个折中，如果leader在表名一个消息被commit前等待更多的follower确认，那么在它挂掉之后就有更多的follower可以成为新的leader，但这也会造成吞吐率的下降。
+
+一种非常常用的选举leader的方式是“少数服从多数”，Kafka并不是采用这种方式。这种模式下，如果我们有2f+1个副本，那么在commit之前必须保证有f+1个replica复制完消息，同时为了保证能正确选举出新的leader，失败的副本数不能超过f个。这种方式有个很大的优势，系统的延迟取决于最快的几台机器，也就是说比如副本数为3，那么延迟就取决于最快的那个follower而不是最慢的那个。“少数服从多数”的方式也有一些劣势，为了保证leader选举的正常进行，它所能容忍的失败的follower数比较少，如果要容忍1个follower挂掉，那么至少要3个以上的副本，如果要容忍2个follower挂掉，必须要有5个以上的副本。也就是说，在生产环境下为了保证较高的容错率，必须要有大量的副本，而大量的副本又会在大数据量下导致性能的急剧下降。这种算法更多用在Zookeeper这种共享集群配置的系统中而很少在需要大量数据的系统中使用的原因。HDFS的HA功能也是基于“少数服从多数”的方式，但是其数据存储并不是采用这样的方式。
+
+实际上，leader选举的算法非常多，比如Zookeeper的Zab、Raft以及Viewstamped Replication。而Kafka所使用的leader选举算法更像是微软的PacificA算法。
+
+Kafka在Zookeeper中为每一个partition动态的维护了一个ISR，这个ISR里的所有replication都跟上了leader，只有ISR里的成员才能有被选为leader的可能(unclean.leader.election.enable=false)。在这种模式下，对于f+1个副本，一个Kafka topic能在保证不丢失已经commit消息的前提下容忍f个副本的失败，在大多数使用场景下，这种模式是十分有利的。事实上，为了容忍f个副本的失败，“少数服从多数”的方式和ISR在commit前需要等待的副本的数量是一样的，但是ISR需要的总的副本的个数几乎是“少数服从多数”的方式的一半。
+
+上文提到，在ISR中至少有一个follower时，Kafka可以确保已经commit的数据不丢失，但如果某一个partition的所有replica都挂了，就无法保证数据不丢失了。这种情况下有两种可行的方案：
+
+等待ISR中任意一个replica“活”过来，并且选它作为leader
+
+选择第一个“活”过来的replica(并不一定是在ISR中)作为leader
+
+这就需要在可用性和一致性当中作出一个简单的抉择。如果一定要等待ISR中的replica“活”过来，那不可用的时间就可能会相对较长。而且如果ISR中所有的replica都无法“活”过来了，或者数据丢失了，这个partition将永远不可用。选择第一个“活”过来的replica作为leader,而这个replica不是ISR中的replica,那即使它并不保障已经包含了所有已commit的消息，它也会成为leader而作为consumer的数据源。默认情况下，Kafka采用第二种策略，即　　 
+
+
+
+*   unclean.leader.election.enable=true，也可以将此参数设置为false来启用第一种策略。
+*   unclean.leader.election.enable这个参数对于leader的选举、系统的可用性以及数据的可靠性都有至关重要的影响。
+
+下面我们来分析下几种典型的场景。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181203213455180-1212737615.png)
+
+如果上图所示，假设某个partition中的副本数为3，replica-0, replica-1, replica-2分别存放在broker0, broker1和broker2中。AR=(0,1,2)，ISR=(0,1)。
+
+设置request.required.acks=-1, min.insync.replicas=2，unclean.leader.election.enable=false。这里讲broker0中的副本也称之为broker0起初broker0为leader，broker1为follower。
+
+当ISR中的replica-0出现crash的情况时，broker1选举为新的leader[ISR=(1)]，因为受min.insync.replicas=2影响，write不能服务，但是read能继续正常服务。此种情况恢复方案：
+
+尝试恢复(重启)replica-0，如果能起来，系统正常;
+如果replica-0不能恢复，需要将min.insync.replicas设置为1，恢复write功能。
+
+
+当ISR中的replica-0出现crash，紧接着replica-1也出现了crash, 此时[ISR=(1),leader=-1],不能对外提供服务，此种情况恢复方案：
+
+尝试恢复replica-0和replica-1，如果都能起来，则系统恢复正常;
+如果replica-0起来，而replica-1不能起来，这时候仍然不能选出leader，因为当设置unclean.leader.election.enable=false时，leader只能从ISR中选举，当ISR中所有副本都失效之后，需要ISR中最后失效的那个副本能恢复之后才能选举leader, 即replica-0先失效，replica-1后失效，需要replica-1恢复后才能选举leader。保守的方案建议把unclean.leader.election.enable设置为true,但是这样会有丢失数据的情况发生，这样可以恢复read服务。同样需要将min.insync.replicas设置为1，恢复write功能;replica-1恢复，replica-0不能恢复，这个情况上面遇到过，read服务可用，需要将min.insync.replicas设置为1，恢复write功能;
+replica-0和replica-1都不能恢复，这种情况可以参考情形2.
+
+当ISR中的replica-0, replica-1同时宕机,此时[ISR=(0,1)],不能对外提供服务，此种情况恢复方案：尝试恢复replica-0和replica-1，当其中任意一个副本恢复正常时，对外可以提供read服务。直到2个副本恢复正常，write功能才能恢复，或者将将min.insync.replicas设置为1。
+
+
+
+
+
+### 9.5、Kafka的发送模式
+
+Kafka的发送模式由producer端的配置参数producer.type来设置，这个参数指定了在后台线程中消息的发送方式是同步的还是异步的，默认是同步的方式，即producer.type=sync。如果设置成异步的模式，即producer.type=async，可以是producer以batch的形式push数据，这样会极大的提高broker的性能，但是这样会增加丢失数据的风险。如果需要确保消息的可靠性，必须要将producer.type设置为sync。
+
+对于异步模式，还有4个配套的参数，如下：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181203213857717-291133501.png)
+
+以batch的方式推送数据可以极大的提高处理效率，kafka producer可以将消息在内存中累计到一定数量后作为一个batch发送请求。batch的数量大小可以通过producer的参数(batch.num.messages)控制。通过增加batch的大小，可以减少网络请求和磁盘IO的次数，当然具体参数设置需要在效率和时效性方面做一个权衡。在比较新的版本中还有batch.size这个参数。
+
+
+
+[回到顶部](https://www.cnblogs.com/wangzhuxing/p/10051512.html#_labelTop)
+
+## 十、高可靠性使用分析
+
+
+
+### 10.1、消息传输保障
+
+前面已经介绍了Kafka如何进行有效的存储，以及了解了producer和consumer如何工作。接下来讨论的是Kafka如何确保消息在producer和consumer之间传输。有以下三种可能的传输保障(delivery guarantee):
+
+
+
+*   At most once: 消息可能会丢，但绝不会重复传输
+*   At least once：消息绝不会丢，但可能会重复传输
+*   Exactly once：每条消息肯定会被传输一次且仅传输一次
+
+Kafka的消息传输保障机制非常直观。当producer向broker发送消息时，一旦这条消息被commit，由于副本机制(replication)的存在，它就不会丢失。但是如果producer发送数据给broker后，遇到的网络问题而造成通信中断，那producer就无法判断该条消息是否已经提交(commit)。虽然Kafka无法确定网络故障期间发生了什么，但是producer可以retry多次，确保消息已经正确传输到broker中，所以目前Kafka实现的是at least once。
+
+consumer从broker中读取消息后，可以选择commit，该操作会在Zookeeper中存下该consumer在该partition下读取的消息的offset。该consumer下一次再读该partition时会从下一条开始读取。如未commit，下一次读取的开始位置会跟上一次commit之后的开始位置相同。当然也可以将consumer设置为autocommit，即consumer一旦读取到数据立即自动commit。如果只讨论这一读取消息的过程，那Kafka是确保了exactly once, 但是如果由于前面producer与broker之间的某种原因导致消息的重复，那么这里就是at least once。
+
+考虑这样一种情况，当consumer读完消息之后先commit再处理消息，在这种模式下，如果consumer在commit后还没来得及处理消息就crash了，下次重新开始工作后就无法读到刚刚已提交而未处理的消息，这就对应于at most once了。
+
+读完消息先处理再commit。这种模式下，如果处理完了消息在commit之前consumer crash了，下次重新开始工作时还会处理刚刚未commit的消息，实际上该消息已经被处理过了，这就对应于at least once。
+
+要做到exactly once就需要引入消息去重机制。
+
+
+
+### 10.2、消息去重
+
+
+
+如上一节所述，Kafka在producer端和consumer端都会出现消息的重复，这就需要去重处理。
+
+Kafka文档中提及GUID(Globally Unique Identifier)的概念，通过客户端生成算法得到每个消息的unique id，同时可映射至broker上存储的地址，即通过GUID便可查询提取消息内容，也便于发送方的幂等性保证，需要在broker上提供此去重处理模块，最新版本已经支持。
+
+针对GUID, 如果从客户端的角度去重，那么需要引入集中式缓存，必然会增加依赖复杂度，另外缓存的大小难以界定。
+
+不只是Kafka, 类似RabbitMQ以及RocketMQ这类商业级中间件也只保障at least once, 且也无法从自身去进行消息去重。所以我们建议业务方根据自身的业务特点进行去重，比如业务消息本身具备幂等性，或者借助Redis等其他产品进行去重处理。
+
+
+
+
+
+### 10.3、高可靠性配置
+
+Kafka提供了很高的数据冗余弹性，对于需要数据高可靠性的场景，我们可以增加数据冗余备份数(replication.factor)，调高最小写入副本数的个数(min.insync.replicas)等等，但是这样会影响性能。反之，性能提高而可靠性则降低，用户需要自身业务特性在彼此之间做一些权衡性选择。
+
+要保证数据写入到Kafka是安全的，高可靠的，需要如下的配置：
+
+
+
+1.  topic的配置：replication.factor>=3,即副本数至少是3个;2<=min.insync.replicas<=replication.factor
+2.  broker的配置：leader的选举条件unclean.leader.election.enable=false
+3.  producer的配置：request.required.acks=-1(all)，producer.type=sync
+
+
+
+[回到顶部](https://www.cnblogs.com/wangzhuxing/p/10051512.html#_labelTop)
+
+## 十一、内部网络框架
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181212101055804-450926848.png)
+
+Broker的内部处理流水线化，分为多个阶段来进行(SEDA)，以提高吞吐量和性能，尽量避免Thead盲等待，以下为过程说明。
+
+*   Accept Thread负责与客户端建立连接链路，然后把Socket轮转交给Process Thread
+*   Process Thread负责接收请求和响应数据，Process Thread每次基于Selector事件循环，首先从Response Queue读取响应数据，向客户端回复响应，然后接收到客户端请求后，读取数据放入Request Queue。
+*   Work Thread负责业务逻辑、IO磁盘处理等，负责从Request Queue读取请求，并把处理结果放入Response Queue中，待Process Thread发送出去。
+
+[回到顶部](https://www.cnblogs.com/wangzhuxing/p/10051512.html#_labelTop)
+
+## 十二、rebalance机制
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181212101229091-1187958161.png)
+
+Kafka保证同一consumer group中只有一个consumer会消费某条消息，实际上，Kafka保证的是稳定状态下每一个consumer实例只会消费某一个或多个特定的数据，而某个partition的数据只会被某一个特定的consumer实例所消费。这样设计的劣势是无法让同一个consumer group里的consumer均匀消费数据，优势是每个consumer不用都跟大量的broker通信，减少通信开销，同时也降低了分配难度，实现也更简单。另外，因为同一个partition里的数据是有序的，这种设计可以保证每个partition里的数据也是有序被消费。
+
+如果某consumer group中consumer数量少于partition数量，则至少有一个consumer会消费多个partition的数据，如果consumer的数量与partition数量相同，则正好一个consumer消费一个partition的数据，而如果consumer的数量多于partition的数量时，会有部分consumer无法消费该topic下任何一条消息。
+
+**Consumer Rebalance算法如下 ：**
+
+
+
+<pre>1. 将目标 topic 下的所有 partirtion 排序，存于PT 2. 对某 consumer group 下所有 consumer 排序，存于 CG，第 i 个consumer 记为 Ci 3. N=size(PT)/size(CG)，向上取整 4. 解除 Ci 对原来分配的 partition 的消费权（i从0开始） 5. 将第i*N到（i+1）*N-1个 partition 分配给 Ci　</pre>
+
+
+
+目前consumer rebalance的控制策略是由每一个consumer通过Zookeeper完成的。具体的控制方式如下：
+
+
+
+<pre>在/consumers/[consumer-group]/下注册id
+设置对/consumers/[consumer-group] 的watcher
+设置对／brokers/ids的watcher
+zk下设置watcher的路径节点更改，触发consumer rebalance</pre>
+
+
+
+
+在这种策略下，**每一个consumer或者broker的增加或者减少都会触发consumer rebalance**。因为每个consumer只负责调整自己所消费的partition，为了保证整个consumer group的一致性，所以当一个consumer触发了rebalance时，该consumer group内的其它所有consumer也应该同时触发rebalance。
+
+*   Herd effect
+
+任何broker或者consumer的增减都会触发所有的consumer的rebalance
+
+*   Split Brain
+
+每个consumer分别单独通过Zookeeper判断哪些partition down了，那么不同consumer从Zookeeper“看”到的view就可能不一样，这就会造成错误的reblance尝试。而且有可能所有的consumer都认为rebalance已经完成了，但实际上可能并非如此。
+
+[回到顶部](https://www.cnblogs.com/wangzhuxing/p/10051512.html#_labelTop)
+
+## 十三、BenchMark
+
+Kafka在唯品会有着很深的历史渊源，根据唯品会消息中间件团队(VMS团队)所掌握的资料显示，在VMS团队运转的Kafka集群中所支撑的topic数已接近2000，每天的请求量也已达千亿级。这里就以Kafka的高可靠性为基准点来探究几种不同场景下的行为表现，以此来加深对Kafka的认知，为大家在以后高效的使用Kafka时提供一份依据。
+
+
+
+### 13.1、测试环境
+
+Kafka broker用到了4台机器，分别为broker[0/1/2/3]配置如下：
+
+CPU: 24core/2.6GHZ
+Memory: 62G
+Network: 4000Mb
+OS/kernel: CentOs release 6.6 (Final)
+Disk: 1089G
+Kafka版本：0.10.1.0
+broker端JVM参数设置：
+
+
+
+
+
+<pre>-Xmx8G -Xms8G -server -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:+CMSClassUnloadingEnabled -XX:+CMSScavengeBeforeRemark -XX:+DisableExplicitGC -Djava.awt.headless=true -Xloggc:/apps/service/kafka/bin/../logs/kafkaServer-gc.log -verbose:gc -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCTimeStamps -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.port=9999 </pre>
+
+
+
+客户端机器配置：
+
+*   CPU: 24core/2.6GHZ
+*   Memory: 3G
+*   Network: 1000Mb
+*   OS/kernel: CentOs release 6.3 (Final)
+*   Disk: 240G
+
+### 13.2、不同场景测试
+
+#### 场景1：
+
+测试不同的副本数、min.insync.replicas策略以及request.required.acks策略(以下简称acks策略)对于发送速度(TPS)的影响。
+
+具体配置：一个producer;发送方式为sync;消息体大小为1kB;partition数为12。副本数为：1/2/4;min.insync.replicas分别为1/2/4;acks分别为-1(all)/1/0。
+
+具体测试数据如下表(min.insync.replicas只在acks=-1时有效)：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181203221444373-736905445.png)
+
+测试结果分析：
+
+
+
+1.  客户端的acks策略对发送的TPS有较大的影响，TPS：acks_0 > acks_1 > ack_-1;
+2.  副本数越高，TPS越低;副本数一致时，min.insync.replicas不影响TPS;
+3.  acks=0/1时，TPS与min.insync.replicas参数以及副本数无关，仅受acks策略的影响。
+
+下面将partition的个数设置为1，来进一步确认下不同的acks策略、不同的min.insync.replicas策略以及不同的副本数对于发送速度的影响，详细请看情景2和情景3。
+
+#### 场景2：
+
+在partition个数固定为1，测试不同的副本数和min.insync.replicas策略对发送速度的影响。
+
+具体配置：一个producer;发送方式为sync;消息体大小为1kB;producer端acks=-1(all)。变换副本数：2/3/4; min.insync.replicas设置为：1/2/4。
+
+测试结果如下：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181203221832812-2007554062.png)
+
+测试结果分析：
+
+副本数越高，TPS越低(这点与场景1的测试结论吻合)，但是当partition数为1时差距甚微。min.insync.replicas不影响TPS。
+
+#### 场景3：
+
+在partition个数固定为1，测试不同的acks策略和副本数对发送速度的影响。
+
+具体配置：一个producer;发送方式为sync;消息体大小为1kB;min.insync.replicas=1。topic副本数为：1/2/4;acks： 0/1/-1。
+
+测试结果如下：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181203222003811-323209661.png)
+
+
+
+
+
+
+
+
+
+
+
+
+
+测试结果分析(与情景1一致)：
+
+*   副本数越多，TPS越低;
+*   客户端的acks策略对发送的TPS有较大的影响，TPS：acks_0 > acks_1 > ack_-1。
+
+#### 场景4：
+
+测试不同partition数对发送速率的影响
+
+具体配置：一个producer;消息体大小为1KB;发送方式为sync;topic副本数为2;min.insync.replicas=2;acks=-1。partition数量设置为1/2/4/8/12。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181203222113272-1167910484.png)
+
+测试结果分析：
+
+partition的不同会影响TPS，随着partition的个数的增长TPS会有所增长，但并不是一直成正比关系，到达一定临界值时，partition数量的增加反而会使TPS略微降低。
+
+#### 场景5：
+
+通过将集群中部分broker设置成不可服务状态，测试对客户端以及消息落盘的影响。
+
+具体配置：一个producer;消息体大小1KB;发送方式为sync;topic副本数为4;min.insync.replicas设置为2;acks=-1;retries=0/100000000;partition数为12。
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181203222220687-1891442968.png)
+
+测试结果分析：
+
+
+
+1.  kill两台broker后，客户端可以继续发送。broker减少后，partition的leader分布在剩余的两台broker上，造成了TPS的减小;
+2.  kill三台broker后，客户端无法继续发送。Kafka的自动重试功能开始起作用，当大于等于min.insync.replicas数量的broker恢复后，可以继续发送;
+3.  当retries不为0时，消息有重复落盘;客户端成功返回的消息都成功落盘，异常时部分消息可以落盘。
+
+#### 场景6：
+
+测试单个producer的发送延迟，以及端到端的延迟。
+
+具体配置：一个producer;消息体大小1KB;发送方式为sync;topic副本数为4;min.insync.replicas设置为2;acks=-1;partition数为12。
+
+测试数据及结果(单位为ms)：
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/843808-20181203222407063-2086989349.png)
+
+**各场景测试总结：**
+
+
+
+1.  当acks=-1时，Kafka发送端的TPS受限于topic的副本数量(ISR中)，副本越多TPS越低;
+2.  acks=0时，TPS最高，其次为1，最差为-1，即TPS：acks_0 > acks_1 > ack_-1
+3.  min.insync.replicas参数不影响TPS;
+4.  partition的不同会影响TPS，随着partition的个数的增长TPS会有所增长，但并不是一直成正比关系，到达一定临界值时，partition数量的增加反而会使TPS略微降低;
+5.  Kafka在acks=-1,min.insync.replicas>=1时，具有高可靠性，所有成功返回的消息都可以落盘。 
\ No newline at end of file
diff --git "a/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\345\270\270\350\247\201\345\221\275\344\273\244\345\217\212\351\205\215\347\275\256\346\200\273\347\273\223.md" "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\345\270\270\350\247\201\345\221\275\344\273\244\345\217\212\351\205\215\347\275\256\346\200\273\347\273\223.md"
new file mode 100644
index 0000000..a3eb8fd
--- /dev/null
+++ "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\345\270\270\350\247\201\345\221\275\344\273\244\345\217\212\351\205\215\347\275\256\346\200\273\347\273\223.md"
@@ -0,0 +1,517 @@
+## **启动zookeeper**
+
+bin/zookeeper-server-start.sh config/zookeeper.properties &
+
+## **启动kafka：**
+
+bin/kafka-server-start.sh config/server.properties
+
+这样启动又一个坏处，就是kafka启动完毕之后，不能关闭终端，为此，我们可以运行这条命令：
+
+nohup bin/kafka-server-start.sh config/server.properties > ./dev/null 2>&1 &
+
+![](https://img2022.cnblogs.com/blog/796632/202208/796632-20220812161146385-332776455.png)
+
+多个kafka的话，在各个虚拟机上运行kafka启动命令多次即可。
+
+当然这个是单机的命令，集群的命令后面再讲。
+
+## **查看是否启动**
+
+jps -lm
+
+![](https://img2022.cnblogs.com/blog/796632/202208/796632-20220812161210221-836644701.png)
+
+说明没有启动kfka
+
+![](https://img2022.cnblogs.com/blog/796632/202208/796632-20220812161224734-562363764.png)
+
+说明启动kafka了
+
+## 查看kafka版本
+
+find ./libs/ -name \*kafka_\* | head -1 | grep -o '\kafka[^\n]*'
+
+kafka_2.12-2.4.1.jar
+
+结果:
+
+就可以看到kafka的具体版本了。
+
+其中，2.12为scala版本，2.4.1为kafka版本。
+
+## **停止kafka**
+
+bin/kafka-server-stop.sh
+
+## **停止zookeeper**
+
+bin/zookeeper-server-stop.sh
+
+## **创建topic**
+
+bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test
+
+多集群创建，执行这个需要搭建多机器的kafka集群环境，zkq1/zkq2/zkq3分别代表了3台zookeeper集群的三台机器
+
+/bin/kafka-topics.sh —create —zookeeper zkq1:2181,zkq2:2181,zkq3:2181 -replication-factor 6 —partition 6 —topic test
+
+解释：
+
+--topic后面的test0是topic的名称
+
+--zookeeper应该和server.properties文件中的zookeeper.connect一样
+
+--config指定当前topic上有效的参数值
+
+--partitions指定topic的partition数量，如果不指定该数量，默认是server.properties文件中的num.partitions配置值
+
+--replication-factor指定每个partition的副本个数，默认是1个
+
+也可以向没有的topic发送消息的时候创建topic
+
+需要
+
+开启自动创建配置：auto.create.topics.enable=true
+
+使用程序直接往kafka中相应的topic发送数据，如果topic不存在就会按默认配置进行创建。
+
+## **展示topic**
+
+bin/kafka-topics.sh --list --zookeeper localhost:2181
+
+## **描述topic**
+
+bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic my-replicated-topic
+
+![](https://img2022.cnblogs.com/blog/796632/202208/796632-20220812161250801-1389051022.png)
+
+解释：
+
+要查看多个topic用逗号分割
+
+**leader**:
+
+是该partitons所在的所有broker中担任leader的broker id，每个broker都有可能成为leader，负责处理消息的读和写，leader是从所有节点中随机选择的.
+
+-1表示此broker移除了
+
+**Replicas**:
+
+显示该partiton所有副本所在的broker列表，包括leader，不管该broker是否是存活，不管是否和leader保持了同步。列出了所有的副本节点，不管节点是否在服务中.
+
+**Isr**:
+
+in-sync replicas的简写，表示存活且副本都已同步的的broker集合，是replicas的子集，是正在服务中的节点.
+
+举例：
+
+比如上面结果的第一行：Topic: test0 .Partition:0 ...Leader: 0 ......Replicas: 0,2,1 Isr: 1,0,2
+
+Partition: 0[该partition编号是0]
+
+Replicas: 0,2,1[代表partition0 在broker0，broker1，broker2上保存了副本]
+
+Isr: 1,0,2 [代表broker0，broker1，broker2都存活而且目前都和leader保持同步]
+
+Leader: 0
+
+代表保存在broker0，broker1，broker2上的这三个副本中，leader是broker0
+
+leader负责读写，broker1、broker2负责从broker0同步信息，平时没他俩什么事
+
+## **查看topic的partition及增加partition**
+
+/kafka-topics.sh –zookeeper 10.2.1.1:2181 –topic mcc-logs –describe.
+
+## **删除Topic**
+
+/bin/kafka-topics.sh --zookeeper localhost:2181 --delete --topic test
+
+如果你的server.properties内没有配置相关的配置的话，会出现如下错误：
+
+Topic test is marked for deletion.
+
+Note: This will have no impact if delete.topic.enable is not set to true.
+
+这边是说，你的Topic已经被标记为待删除的Topic，但是呢，你配置文件的开关没有打开，所以只是给它添加了一个标记，实际上，这个Topic并没有被删除。只有，你打开开关之后，会自动删除被标记删除的Topic。
+
+解决办法：
+
+设置server.properties文件内的“delete.topic.enable=true”，并且重启Kafka就可以了。
+
+如果不想修改配置也可以完全删除
+
+1、删除kafka存储目录（server.propertiewenjian log.dirs配置，默认为“/tmp/kafka-logs”）下对应的topic。(不同broker下存储的topic不一定相同，所有broker都要看一下)
+
+2、进入zookeeper客户端删掉对应topic
+
+zkCli.sh .-server 127.0.0.1:42182
+
+找到topic目录:
+
+ls ../brokers/topics
+
+删掉对应topic
+
+rmr ./brokers/topic/topic-name
+
+找到目录:
+
+ls .../config/topics
+
+删掉对应topic
+
+rmr ./config/topics/topic-name .
+
+这样就完全删除了
+
+## **删除topic中存储的内容**
+
+在config/server.properties中找到如下的位置
+
+![](https://img2022.cnblogs.com/blog/796632/202208/796632-20220812161312458-550425542.png)
+
+删除log.dirs指定的文件目录，
+
+登录zookeeper client。
+
+命令：
+
+/home/ZooKeeper/bin/zkCli.sh
+
+删除zookeeper中该topic相关的目录
+
+命令：
+
+rm -r /kafka/config/topics/test0
+
+rm -r /kafka/brokers/topics/test0
+
+rm -r /kafka/admin/delete_topics/test0 （topic被标记为marked for deletion时需要这个命令）
+
+重启zookeeper和broker
+
+## **生产者发送消息：**
+
+bin/kafka-console-producer.sh --broker-list 130.51.23.95:9092 --topic my-replicated-topic
+
+这里的ip和端口是broker的ip及端口，根据自己kafka机器的ip和端口写就可以
+
+## **消费者消费消息：**
+
+bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test --new-consumer --from-beginning --consumer.config config/consumer.properties
+
+## **查看topic某分区偏移量最大（小）值**
+
+bin/kafka-run-class.sh kafka.tools.GetOffsetShell --topic hive-mdatabase-hostsltable .--time -1 --broker-list node86:9092 --partitions 0
+
+注： time为-1时表示最大值，time为-2时表示最小值
+
+不指定--partitions 就是指这个topic整体的情况
+
+## 查看指定group的消费情况
+
+kafka-consumer-groups.sh --bootstrap-server 172.20.72.93:9092 --describe --group mygroup
+
+运行结果：
+
+![](https://img2022.cnblogs.com/blog/796632/202208/796632-20220816164455794-344440282.png)
+
+*   GROUP:消费者组
+*   TOPIC：topic名字
+*   PARTITION ：partition id
+*   CURRENT-OFFSET： .当前消费到的offset . . . . . . . .
+*   LOG-END-OFFSETSIZE ：最新的offset
+*   LAG:未消费的条数
+*   CONSUMER-ID:消费者组中消费者的id,为—代表没有active的消费者
+*   HOST：消费者的机器ip，为—代表没有active的消费者
+*   CLIENT-ID:消费者clientID，为—代表没有active的消费者
+
+## .查看所有group的消费情况
+
+kafka-consumer-groups.sh --bootstrap-server 172.20.72.93:9092 --all-groups --all-topics --describe
+
+![](https://img2022.cnblogs.com/blog/796632/202208/796632-20220816172442100-1560497638.png)
+
+## 修改group消费的offset
+
+kafka-consumer-groups.sh --bootstrap-server 172.20.72.93:9092 --group mygroup --reset-offsets --topic mytopic --to-offset 61 --execute
+
+上面就是把mygroup在mytopic的消费offset修改到了61
+
+重设位移有几种选项:
+
+--to-earliest：. .设置到最早位移处，也就是0
+
+--to-latest：. . .设置到最新处，也就是主题分区HW的位置
+
+--to-offset NUM： 指定具体的位移位置
+
+--shift-by NUM：. 基于当前位移向前回退多少
+
+--by-duration：. .回退到多长时间
+
+## 查看指定group中活跃的消费者
+
+kafka-consumer-groups.sh --bootstrap-server 172.20.72.93:9092 --describe --group mygroup --members
+
+## **增加topic分区数**
+
+（只能增加不能减少）
+
+为topic t_cdr 增加10个分区
+
+bin/kafka-topics.sh --zookeeper node01:2181 .--alter --topic t_cdr --partitions 10
+
+## **常用配置及说明**
+
+kafka 常见重要配置说明，分为四部分
+
+*   Broker Config：kafka 服务端的配置
+*   Producer Config：生产端的配置
+*   Consumer Config：消费端的配置
+*   Kafka Connect Config：kafka 连接相关的配置
+
+### **Broker Config**
+
+1.  **zookeeper.connect**
+
+连接 zookeeper 集群的地址，用于将 kafka 集群相关的元数据信息存储到指定的 zookeeper 集群中
+
+**2\. advertised.port**
+
+注册到 zookeeper 中的地址端口信息，在 IaaS 环境中，默认注册到 zookeeper 中的是内网地址，通过该配置指定外网访问的地址及端口，advertised.host.name 和 advertised.port 作用和 advertised.port 差不多，在 0.10.x 之后，直接配置 advertised.port 即可，前两个参数被废弃掉了。
+
+**3\. auto.create.topics.enable**
+
+自动创建 topic，默认为 true。其作用是当向一个还没有创建的 topic 发送消息时，此时会自动创建一个 topic，并同时设置 -num.partition 1 (partition 个数) 和 default.replication.factor (副本个数，默认为 1) 参数。
+
+一般该参数需要手动关闭，因为自动创建会影响 topic 的管理，我们可以通过 kafka-topic.sh 脚本手动创建 topic，通常也是建议使用这种方式创建 topic。在 0.10.x 之后提供了 kafka-admin 包，可以使用其来创建 topic。
+
+**4\. auto.leader.rebalance.enable**
+
+自动 rebalance，默认为 true。其作用是通过后台线程定期扫描检查，在一定条件下触发重新 leader 选举；在生产环境中，不建议开启，因为替换 leader 在性能上没有什么提升。
+
+**5\. background.threads**
+
+后台线程数，默认为 10。用于后台操作的线程，可以不用改动。
+
+**6\. broker.id**
+
+Broker 的唯一标识，用于区分不同的 Broker。kafka 的检查就是基于此 id 是否在 zookeeper 中/brokers/ids 目录下是否有相应的 id 目录来判定 Broker 是否健康。
+
+**7\. compression.type**
+
+压缩类型。此配置可以接受的压缩类型有 gzip、snappy、lz4。另外可以不设置，即保持和生产端相同的压缩格式。
+
+**8\. delete.topic.enable**
+
+启用删除 topic。如果关闭，则无法使用 admin 工具进行 topic 的删除操作。
+
+**9\. leader.imbalance.check.interval.seconds**
+
+partition 检查重新 rebalance 的周期时间
+
+**10\. leader.imbalance.per.broker.percentage**
+
+标识每个 Broker 失去平衡的比率，如果超过改比率，则执行重新选举 Broker 的 leader
+
+**11\. log.dir / log.dirs**
+
+保存 kafka 日志数据的位置。如果 log.dirs 没有设置，则使用 log.dir 指定的目录进行日志数据存储。
+
+**12\. log.flush.interval.messages**
+
+partition 分区的数据量达到指定大小时，对数据进行一次刷盘操作。比如设置了 1024k 大小，当 partition 积累的数据量达到这个数值时则将数据写入到磁盘上。
+
+**13\. log.flush.interval.ms**
+
+数据写入磁盘时间间隔，即内存中的数据保留多久就持久化一次，如果没有设置，则使用 log.flush.scheduler.interval.ms 参数指定的值。
+
+**14\. log.retention.bytes**
+
+表示 topic 的容量达到指定大小时，则对其数据进行清除操作，默认为-1，永远不删除。
+
+**15\. log.retention.hours**
+
+标示 topic 的数据最长保留多久，单位是小时
+
+**16\. log.retention.minutes**
+
+表示 topic 的数据最长保留多久，单位是分钟，如果没有设置该参数，则使用 log.retention.hours 参数
+
+**17\. log.retention.ms**
+
+表示 topic 的数据最长保留多久，单位是毫秒，如果没有设置该参数，则使用 log.retention.minutes 参数
+
+**18\. log.roll.hours**
+
+新的 segment 创建周期，单位小时。kafka 数据是以 segment 存储的，当周期时间到达时，就创建一个新的 segment 来存储数据。
+
+**19\. log.segment.bytes**
+
+segment 的大小。当 segment 大小达到指定值时，就新创建一个 segment。
+
+**20\. message.max.bytes**
+
+topic 能够接收的最大文件大小。需要注意的是 producer 和 consumer 端设置的大小需要一致。
+
+**21\. min.insync.replicas**
+
+最小副本同步个数。当 producer 设置了 request.required.acks 为-1 时，则 topic 的副本数要同步至该参数指定的个数，如果达不到，则 producer 端会产生异常。
+
+**22\. num.io.threads**
+
+指定 io 操作的线程数
+
+**23\. num.network.threads**
+
+执行网络操作的线程数
+
+**24\. num.recovery.threads.per.data.dir**
+
+每个数据目录用于恢复数据的线程数
+
+**25\. num.replica.fetchers**
+
+从 leader 备份数据的线程数
+
+**26\. offset.metadata.max.bytes**
+
+允许消费者端保存 offset 的最大个数
+
+**27\. offsets.commit.timeout.ms**
+
+offset 提交的延迟时间
+
+**28\. offsets.topic.replication.factor**
+
+topic 的 offset 的备份数量。该参数建议设置更高保证系统更高的可用性
+
+**29\. port**
+
+端口号，Broker 对外提供访问的端口号。
+
+**30\. request.timeout.ms**
+
+Broker 接收到请求后的最长等待时间，如果超过设定时间，则会给客户端发送错误信息
+
+**31\. zookeeper.connection.timeout.ms**
+
+客户端和 zookeeper 建立连接的超时时间，如果没有设置该参数，则使用 zookeeper.session.timeout.ms 值
+
+**32\. connections.max.idle.ms**
+
+空连接的超时时间。即空闲连接超过该时间时则自动销毁连接。
+
+### **Producer Config**
+
+1.  **bootstrap.servers**
+
+服务端列表。即接收生产消息的服务端列表
+
+**2\. key.serializer**
+
+消息键的序列化方式。指定 key 的序列化类型
+
+3..**value.serializer**
+
+消息内容的序列化方式。指定 value 的序列化类型
+
+4..**acks**
+
+消息写入 Partition 的个数。通常可以设置为 0，1，all；当设置为 0 时，只需要将消息发送完成后就完成消息发送功能；当设置为 1 时，即 Leader Partition 接收到数据并完成落盘；当设置为 all 时，即主从 Partition 都接收到数据并落盘。
+
+5..**buffer.memory**
+
+客户端缓存大小。即 Producer 生产的数据量缓存达到指定值时，将缓存数据一次发送的 Broker 上。
+
+6..**compression.type**
+
+压缩类型。指定消息发送前的压缩类型，通常有 none, gzip, snappy, or, lz4 四种。不指定时消息默认不压缩。
+
+7..**retries**
+
+消息发送失败时重试次数。当该值设置大于 0 时，消息因为网络异常等因素导致消息发送失败进行重新发送的次数。
+
+### **Consumer Config**
+
+1.  **bootstrap.servers**
+
+服务端列表。即消费端从指定的服务端列表中拉取消息进行消费。
+
+2..**key.deserializer**
+
+消息键的反序列化方式。指定 key 的反序列化类型，与序列化时指定的类型相对应。
+
+3..**value.deserializer**
+
+消息内容的反序列化方式。指定 value 的反序列化类型，与序列化时指定的类型相对应。
+
+4..**fetch.min.bytes**
+
+抓取消息的最小内容。指定每次向服务端拉取的最小消息量。
+
+5..**group.id**
+
+消费组中每个消费者的唯一表示。
+
+6..**heartbeat.interval.ms**
+
+心跳检查周期。即在周期性的向 group coordinator 发送心跳，当服务端发生 rebalance 时，会将消息发送给各个消费者。该参数值需要小于 session.timeout.ms，通常为后者的 1/3。
+
+7..**max.partition.fetch.bytes**
+
+Partition 每次返回的最大数据量大小。
+
+**8\. session.timeout.ms**
+
+consumer 失效的时间。即 consumer 在指定的时间后，还没有响应则认为该 consumer 已经发生故障了。
+
+**9\. auto.offset.reset**
+
+当 kafka 中没有初始偏移量或服务器上不存在偏移量时，指定从哪个位置开始消息消息。earliest：指定从头开始；latest：从最新的数据开始消费。
+
+### **Kafka Connect Config**
+
+1.  **group.id**
+
+消费者在消费组中的唯一标识
+
+**2\. internal.key.converter**
+
+内部 key 的转换类型。
+
+**3\. internal.value.converter**
+
+内部 value 的转换类型。
+
+**4\. key.converter**
+
+服务端接收到 key 时指定的转换类型。
+
+5..**value.converter**
+
+服务端接收到 value 时指定的转换类型。
+
+**6\. bootstrap.servers**
+
+服务端列表。
+
+**7\. heartbeat.interval.ms**
+
+心跳检测，与 consumer 中指定的配置含义相同。
+
+**8\. session.timeout.ms**
+
+session 有效时间，与 consumer 中指定的配置含义相同。
+
+## **总结**
+
+本文总结了平时经常用到的一些 Kafka 配置及命令说明，方便随时查看；喜欢的朋友可以收藏以备不时之需。
+
+
+## 参考文章
+https://blog.csdn.net/cao131502
+https://zhuanlan.zhihu.com/p/137811719
\ No newline at end of file
diff --git "a/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\346\236\266\346\236\204\344\273\213\347\273\215.md" "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\346\236\266\346\236\204\344\273\213\347\273\215.md"
new file mode 100644
index 0000000..2d35efe
--- /dev/null
+++ "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\346\236\266\346\236\204\344\273\213\347\273\215.md"
@@ -0,0 +1,298 @@
+## 一. 工作流程
+
+Kafka中消息是以topic进行分类的，Producer生产消息，Consumer消费消息，都是面向topic的。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-b9d626794f6625526598db6627b780e7_720w.webp)
+
+</figure>
+
+Topic是逻辑上的改变，Partition是物理上的概念，每个Partition对应着一个log文件，该log文件中存储的就是producer生产的数据，topic=N*partition；partition=log
+
+Producer生产的数据会被不断的追加到该log文件的末端，且每条数据都有自己的offset，consumer组中的每个consumer，都会实时记录自己消费到了哪个offset，以便出错恢复的时候，可以从上次的位置继续消费。流程：Producer => Topic（Log with offset）=> Consumer.
+
+## 二. 文件存储
+
+Kafka文件存储也是通过本地落盘的方式存储的，主要是通过相应的log与index等文件保存具体的消息文件。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-116ebd7dffd85595d69f080e5b5f6948_720w.webp)
+
+</figure>
+
+生产者不断的向log文件追加消息文件，为了防止log文件过大导致定位效率低下，Kafka的log文件以1G为一个分界点，当.log文件大小超过1G的时候，此时会创建一个新的.log文件，同时为了快速定位大文件中消息位置，Kafka采取了分片和索引的机制来加速定位。
+
+在kafka的存储log的地方，即文件的地方，会存在消费的偏移量以及具体的分区信息，分区信息的话主要包括.index和.log文件组成
+
+<figure data-size="normal">
+
+
+![](https://pic3.zhimg.com/80/v2-c6de61f43ecbe58d4f3e7aa29541220e_720w.webp)
+
+</figure>
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-8345e4966d8c5274a1e74e29151bd9c6_720w.webp)
+
+</figure>
+
+副本目的是为了备份，所以同一个分区存储在不同的broker上，即当third-2存在当前机器kafka01上，实际上再kafka03中也有这个分区的文件（副本），分区中包含副本，即一个分区可以设置多个副本，副本中有一个是leader，其余为follower。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-6e8de9e7dcbdac0b7bd424eaaf4f8568_720w.webp)
+
+</figure>
+
+如果.log文件超出大小，则会产生新的.log文件。如下所示:
+
+
+
+```
+00000000000000000000.index
+00000000000000000000.log
+00000000000000170410.index
+00000000000000170410.log
+00000000000000239430.index
+00000000000000239430.log
+
+```
+
+
+
+**此时如何快速定位数据，步骤：**
+
+
+
+```
+.index文件存储的消息的offset+真实的起始偏移量。.log中存放的是真实的数据。
+
+```
+
+
+
+首先通过二分查找.index文件到查找到当前消息具体的偏移，如上图所示，查找为2，发现第二个文件为6，则定位到一个文件中。 然后通过第一个.index文件通过seek定位元素的位置3，定位到之后获取起始偏移量+当前文件大小=总的偏移量。 获取到总的偏移量之后，直接定位到.log文件即可快速获得当前消息大小。
+
+## 三. 生产者分区策略
+
+**分区的原因** 1\. 方便在集群中扩展：每个partition通过调整以适应它所在的机器，而一个Topic又可以有多个partition组成，因此整个集群可以适应适合的数据。 2\. 可以提高并发：以Partition为单位进行读写。类似于多路。
+
+**分区的原则** 1\. 指明partition（这里的指明是指第几个分区）的情况下，直接将指明的值作为partition的值 2\. 没有指明partition的情况下，但是存在值key，此时将key的hash值与topic的partition总数进行取余得到partition值 3\. 值与partition均无的情况下，第一次调用时随机生成一个整数，后面每次调用在这个整数上自增，将这个值与topic可用的partition总数取余得到partition值，即round-robin算法。
+
+## 四. 生产者ISR
+
+为保证producer发送的数据能够可靠的发送到指定的topic中，topic的每个partition收到producer发送的数据后，都需要向producer发送ackacknowledgement，如果producer收到ack就会进行下一轮的发送，否则重新发送数据。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-409ea1af4f66bd2f44398850cc2ba9e2_720w.webp)
+
+</figure>
+
+**发送ack的时机** 确保有follower与leader同步完成，leader再发送ack，这样可以保证在leader挂掉之后，follower中可以选出新的leader（主要是确保follower中数据不丢失）
+
+**follower同步完成多少才发送ack** 1\. 半数以上的follower同步完成，即可发送ack 2\. 全部的follower同步完成，才可以发送ack
+
+## 4.1 副本数据同步策略
+
+### 4.1.1 半数follower同步完成即发送ack
+
+优点是延迟低
+
+缺点是选举新的leader的时候，容忍n台节点的故障，需要2n+1个副本（因为需要半数同意，所以故障的时候，能够选举的前提是剩下的副本超过半数），容错率为1/2
+
+### 4.1.2 全部follower同步完成完成发送ack
+
+优点是容错率搞，选举新的leader的时候，容忍n台节点的故障只需要n+1个副本即可，因为只需要剩下的一个人同意即可发送ack了
+
+缺点是延迟高，因为需要全部副本同步完成才可
+
+### 4.1.3 kafka的选择
+
+kafka选择的是第二种，因为在容器率上面更加有优势，同时对于分区的数据而言，每个分区都有大量的数据，第一种方案会造成大量数据的冗余。虽然第二种网络延迟较高，但是网络延迟对于Kafka的影响较小。
+
+## 4.2 ISR(同步副本集)
+
+**猜想** 采用了第二种方案进行同步ack之后，如果leader收到数据，所有的follower开始同步数据，但有一个follower因为某种故障，迟迟不能够与leader进行同步，那么leader就要一直等待下去，直到它同步完成，才可以发送ack，此时需要如何解决这个问题呢？
+
+**解决** leader中维护了一个动态的ISR（in-sync replica set），即与leader保持同步的follower集合，当ISR中的follower完成数据的同步之后，给leader发送ack，如果follower长时间没有向leader同步数据，则该follower将从ISR中被踢出，该之间阈值由replica.lag.time.max.ms参数设定。当leader发生故障之后，会从ISR中选举出新的leader。
+
+## 五. 生产者ack机制
+
+对于某些不太重要的数据，对数据的可靠性要求不是很高，能够容忍数据的少量丢失，所以没有必要等到ISR中所有的follower全部接受成功。
+
+Kafka为用户提供了三种可靠性级别，用户根据可靠性和延迟的要求进行权衡选择不同的配置。
+
+**ack参数配置** 0：producer不等待broker的ack，这一操作提供了最低的延迟，broker接收到还没有写入磁盘就已经返回，当broker故障时有可能丢失数据
+
+1：producer等待broker的ack，partition的leader落盘成功后返回ack，如果在follower同步成功之前leader故障，那么将丢失数据。（只是leader落盘）
+
+<figure data-size="normal">
+
+
+![](https://pic1.zhimg.com/80/v2-a219d261edd97432347f4edf5794e170_720w.webp)
+
+</figure>
+
+-1(all)：producer等待broker的ack，partition的leader和ISR的follower全部落盘成功才返回ack，但是如果在follower同步完成后，broker发送ack之前，如果leader发生故障，会造成数据重复。(这里的数据重复是因为没有收到，所以继续重发导致的数据重复)
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-c9741a10f418f7ea4eed929f0f266bbb_720w.webp)
+
+</figure>
+
+producer返ack，0无落盘直接返，1只leader落盘然后返，-1全部落盘然后返
+
+## 六. 数据一致性问题
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-031d84a2012f64b122dd64ab67a4e52a_720w.webp)
+
+</figure>
+
+LEO(Log End Offset)：每个副本最后的一个offset HW(High Watermark)：高水位，指代消费者能见到的最大的offset，ISR队列中最小的LEO。
+
+**follower故障和leader故障** 1\. follower故障：follower发生故障后会被临时踢出ISR，等待该follower恢复后，follower会读取本地磁盘记录的上次的HW，并将log文件高于HW的部分截取掉，从HW开始向leader进行同步，等待该follower的LEO大于等于该partition的HW，即follower追上leader之后，就可以重新加入ISR了。 2\. leader故障：leader发生故障之后，会从ISR中选出一个新的leader，为了保证多个副本之间的数据的一致性，其余的follower会先将各自的log文件高于HW的部分截掉，然后从新的leader中同步数据。
+
+**这只能保证副本之间的数据一致性，并不能保证数据不丢失或者不重复**
+
+## 七. ExactlyOnce
+
+将服务器的ACK级别设置为-1（all），可以保证producer到Server之间不会丢失数据，即At Least Once至少一次语义。将服务器ACK级别设置为0，可以保证生产者每条消息只会被发送一次，即At Most Once至多一次。
+
+At Least Once可以保证数据不丢失，但是不能保证数据不重复，而At Most Once可以保证数据不重复，但是不能保证数据不丢失，对于重要的数据，则要求数据不重复也不丢失，即Exactly Once即精确的一次。
+
+在0.11版本的Kafka之前，只能保证数据不丢失，在下游对数据的重复进行去重操作，多余多个下游应用的情况，则分别进行全局去重，对性能有很大影响。
+
+0.11版本的kafka，引入了一项重大特性：幂等性，幂等性指代Producer不论向Server发送了多少次重复数据，Server端都只会持久化一条数据。幂等性结合At Least Once语义就构成了Kafka的Exactly Once语义。
+
+启用幂等性，即在Producer的参数中设置enable.idempotence=true即可，Kafka的幂等性实现实际是将之前的去重操作放在了数据上游来做，开启幂等性的Producer在初始化的时候会被分配一个PID，发往同一个Partition的消息会附带Sequence Number，而Broker端会对做缓存，当具有相同主键的消息的时候，Broker只会持久化一条。
+
+但PID在重启之后会发生变化，同时不同的Partition也具有不同的主键，所以幂等性无法保证跨分区跨会话的Exactly Once。
+
+要解决跨分区跨会话的Exactly Once，就引入了生产者事务的概念。
+
+## 八. Kafka消费者分区分配策略
+
+**消费方式:** consumer采用pull拉的方式来从broker中读取数据。
+
+push推的模式很难适应消费速率不同的消费者，因为消息发送率是由broker决定的，它的目标是尽可能以最快的速度传递消息，但是这样容易造成consumer来不及处理消息，典型的表现就是拒绝服务以及网络拥塞。而pull方式则可以让consumer根据自己的消费处理能力以适当的速度消费消息。
+
+pull模式不足在于如果Kafka中没有数据，消费者可能会陷入循环之中 (因为消费者类似监听状态获取数据消费的)，一直返回空数据，针对这一点，Kafka的消费者在消费数据时会传入一个时长参数timeout，如果当前没有数据可供消费，consumer会等待一段时间之后再返回，时长为timeout。
+
+## 8.1\. 分区分配策略
+
+一个consumer group中有多个consumer，一个topic有多个partition，所以必然会涉及到partition的分配问题，即确定那个partition由那个consumer消费的问题。
+
+**Kafka的两种分配策略：** 1\. round-robin循环 2\. range
+
+**Round-Robin** 主要采用轮询的方式分配所有的分区，该策略主要实现的步骤： 假设存在三个topic：t0/t1/t2，分别拥有1/2/3个分区，共有6个分区，分别为t0-0/t1-0/t1-1/t2-0/t2-1/t2-2，这里假设我们有三个Consumer，C0、C1、C2，订阅情况为C0：t0，C1：t0、t1，C2：t0/t1/t2。
+
+此时round-robin采取的分配方式，则是按照分区的字典对分区和消费者进行排序，然后对分区进行循环遍历，遇到自己订阅的则消费，否则向下轮询下一个消费者。即按照分区轮询消费者，继而消息被消费。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-21eed325191d7d72c9d4c39455c4cae5_720w.webp)
+
+</figure>
+
+分区在循环遍历消费者，自己被当前消费者订阅，则消息与消费者共同向下（消息被消费），否则消费者向下消息继续遍历（消息没有被消费）。轮询的方式会导致每个Consumer所承载的分区数量不一致，从而导致各个Consumer压力不均。上面的C2因为订阅的比较多，导致承受的压力也相对较大。
+
+**Range** Range的重分配策略，首先计算各个Consumer将会承载的分区数量，然后将指定数量的分区分配给该Consumer。假设存在两个Consumer，C0和C1，两个Topic，t0和t1，这两个Topic分别都有三个分区，那么总共的分区有6个，t0-0，t0-1，t0-2，t1-0，t1-1，t1-2。分配方式如下：
+
+range按照topic一次进行分配，即消费者遍历topic，t0，含有三个分区，同时有两个订阅了该topic的消费者，将这些分区和消费者按照字典序排列。 按照平均分配的方式计算每个Consumer会得到多少个分区，如果没有除尽，多出来的分区则按照字典序挨个分配给消费者。按照此方式以此分配每一个topic给订阅的消费者，最后完成topic分区的分配。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-d642ed5512a4abdca9a8f35f2d27c277_720w.webp)
+
+</figure>
+
+## 8.2\. 消费者offset的存储
+
+由于Consumer在消费过程中可能会出现断电宕机等故障，Consumer恢复以后，需要从故障前的位置继续消费，所以Consumer需要实时记录自己消费到了那个offset，以便故障恢复后继续消费。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-f2a50fd7f054821e36a80b1f6d99ecb0_720w.webp)
+
+</figure>
+
+Kafka0.9版本之前，consumer默认将offset保存在zookeeper中，从0.9版本之后，consumer默认将offset保存在kafka一个内置的topic中，该topic为__consumer_offsets
+
+## 九. 高效读写&Zookeeper作用
+
+## 9.1 高效读写
+
+**顺序写磁盘** Kafka的producer生产数据，需要写入到log文件中，写的过程是追加到文件末端，顺序写的方式，官网有数据表明，同样的磁盘，顺序写能够到600M/s，而随机写只有200K/s，这与磁盘的机械结构有关，顺序写之所以快，是因为其省去了大量磁头寻址的时间。
+
+**零复制技术**
+
+NIC：Network Interface Controller网络接口控制器
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-2807d010381d304949bf8cea16ba1744_720w.webp)
+
+</figure>
+
+这是常规的读取操作： 1\. 操作系统将数据从磁盘文件中读取到内核空间的页面缓存 2\. 应用程序将数据从内核空间读入到用户空间缓冲区 3\. 应用程序将读到的数据写回内核空间并放入到socket缓冲区 4\. 操作系统将数据从socket缓冲区复制到网卡接口，此时数据通过网络发送给消费者
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-390cbabdeaba6f9e79a8ba6f4d08d75f_720w.webp)
+
+</figure>
+
+零拷贝技术只用将磁盘文件的数据复制到页面缓存中一次，然后将数据从页面缓存直接发送到网络中（发送给不同的订阅者时，都可以使用同一个页面缓存），从而避免了重复复制的操作。
+
+如果有10个消费者，传统方式下，数据复制次数为4*10=40次，而使用“零拷贝技术”只需要1+10=11次，一次为从磁盘复制到页面缓存，10次表示10个消费者各自读取一次页面缓存。
+
+## 9.2 zookeeper作用
+
+Kafka集群中有一个broker会被选举为Controller，负责管理集群broker的上下线、所有topic的分区副本分配和leader的选举等工作。Controller的工作管理是依赖于zookeeper的。
+
+**Partition的Leader的选举过程**
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-fc64ea72cba32e702b15344767bdace9_720w.webp)
+
+</figure>
+
+## 十. 事务
+
+kafka从0.11版本开始引入了事务支持，事务可以保证Kafka在Exactly Once语义的基础上，生产和消费可以跨分区的会话，要么全部成功，要么全部失败。
+
+## 10.1 Producer事务
+
+为了按跨分区跨会话的事务，需要引入一个全局唯一的Transaction ID，并将Producer获得的PID(可以理解为Producer ID)和Transaction ID进行绑定，这样当Producer重启之后就可以通过正在进行的Transaction ID获得原来的PID。
+
+为了管理Transaction，Kafka引入了一个新的组件Transaction Coordinator，Producer就是通过有和Transaction Coordinator交互获得Transaction ID对应的任务状态，Transaction Coordinator还负责将事务信息写入内部的一个Topic中，这样即使整个服务重启，由于事务状态得到保存，进行中的事务状态可以恢复，从而继续进行。
+
+## 10.2 Consumer事务
+
+对于Consumer而言，事务的保证相比Producer相对较弱，尤其是无法保证Commit的信息被精确消费，这是由于Consumer可以通过offset访问任意信息，而且不同的Segment File声明周期不同，同一事务的消息可能会出现重启后被删除的情况。
+
+## 参考文章
+
+https://blog.csdn.net/cao131502
+https://zhuanlan.zhihu.com/p/137811719
\ No newline at end of file
diff --git "a/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\347\232\204\351\233\206\347\276\244\345\267\245\344\275\234\345\216\237\347\220\206.md" "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\347\232\204\351\233\206\347\276\244\345\267\245\344\275\234\345\216\237\347\220\206.md"
new file mode 100644
index 0000000..cd6122e
--- /dev/null
+++ "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\347\232\204\351\233\206\347\276\244\345\267\245\344\275\234\345\216\237\347\220\206.md"
@@ -0,0 +1,127 @@
+**前言**
+
+上篇文章讲到了消息在 Partition 上的存储形式，本来准备接着来聊聊生产中的一些使用方式，想了想还有些很重要的工作组件原理没有讲清楚，比如一个 Topic 由 N 个 Partition 组成，那么这些 Partition 是如何均匀的分布在不同的 Broker 上？再比如当一个 Broker 宕机后，其上负责读写请求的主 Partition 无法正常访问，如何让从 Partition 转变成主 Partition 来继续提供正常的读写服务？想要解决这些问题，就必须先要了解一下 Kafka 集群内部的管理机制，其中一个非常重要的控制器就是 KafkaController。本文我们就来讲讲 KafkaController 是如何来解决上面提到的那些问题的。
+
+### **文章概览**
+
+1.  KafkaController 是什么及其选举策略。
+2.  KafkaController 监控 ZK 的目录分布。
+3.  Partition 分布算法。
+4.  Partition 的状态转移。
+5.  Kafka 集群的负载均衡处理流程解析。
+
+## **KafkaController 是什么及其选举策略**
+
+Kafka 集群由多台 Broker 构成，每台 Broker 都有一个 KafkaController 用于管理当前的 Broker。试想一下，如果一个集群没有一个“领导者”，那么谁去和“外界”（比如 ZK）沟通呢？谁去协调 Partition 应该如何分布在集群中的不同 Broker 上呢？谁去处理 Broker 宕机后，在其 Broker 上的主 Partition 无法正常提供读写服务后，将对应的从 Partition 转变成主 Partition 继续正常对外提供服务呢？那么由哪个 Broker 的 KafkaController 来担当“领导者”这个角色呢？
+
+Kafka 的设计者很聪明，Zookeeper 既然是分布式应用协调服务，那么干脆就让它来帮 Kafka 集群选举一个“领导者”出来，这个“领导者”对应的 KafkaController 称为 Leader，其他的 KafkaController 被称为 Follower，在同一时刻，一个 Kafka 集群只能有一个 Leader 和 N 个 Follower。
+
+### **Zookeeper 是怎么实现 KafkaController 的选主工作呢？**
+
+稍微熟悉 Zookeeper 的小伙伴应该都比较清楚，Zookeeper 是通过监控目录（zNode）的变化，从而做出一些相应的动作。
+
+Zookeeper 的目录分为四种，第一种是永久的，被称作为 `Persistent`；
+
+第二种是顺序且永久的，被称作为 `Persistent_Sequential`；
+
+第三种是临时的，被称为 `Ephemeral`；
+
+第四种是顺序且临时的，被称作为 `Ephemeral_Sequential`。
+
+KafkaController 正是利用了临时的这一特性来完成选主的，在 Broker 启动时，每个 Broker 的 KafkaController 都会向 ZK 的 `/controller` 目录写入 BrokerId，谁先写入谁就是 Leader，剩余的 KafkaController 是 Follower，当 Leader 在周期内没有向 ZK 发送报告的话，则认为 Leader 挂了，此时 ZK 删除临时的 `/controller` 目录，Kafka 集群中的其他 KafkaController 开始新的一轮争主操作，流程和上面一样。下面是选 Leader 的流程图。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-af1f22f109f85fe6b169c6e4a271016f_720w.webp)
+
+<figcaption>Leader选举流程图</figcaption>
+
+</figure>
+
+从上图可以看出，第一次，Broker1 成功抢先在 Zookeeper 的 /controller 目录上写入信息，所以 Broker1 的 KafkaController 为 Leader，其他两个为 Follower。第二次，Broker1 宕机或者下线，此时 Broker2 和 Broker3 检测到，于是开始新一轮的争抢将信息写入 Zookeeper，从图中可以看出，Broker2 争到了 Leader，所以 Broker3 是 Follower 状态。
+
+正常情况下，上面这个流程没有问题，但是如果在 Broker1 离线的情况下，Zookeeper 准备删除 /controller 的临时 node 时，系统 hang 住没办法删除，改怎么办呢？这里留个小疑问供大家思考。后面会用一篇文章专门来解答 Kafka 相关的问题（包括面试题哦，敬请期待）。
+
+## **KafkaController 监控的 ZK 目录分布**
+
+KafkaController 在初始化的时候，会针对不同的 zNode 注册各种各样的监听器，以便处理不同的用户请求或者系统内部变化请求。监控 ZK 的目录大概可以分为两部分，分别是 `/admin` 目录和 `/brokers` 目录。各目录及其对应的功能如下表所示，需要的朋友自提。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-2a603adc2e06f3663e693259e8bf16d4_720w.webp)
+
+</figure>
+
+## **Partition 分布算法**
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-36d40cb264f6432a81ad83c9365d7997_720w.webp)
+
+<figcaption>Partition分布算法图</figcaption>
+
+</figure>
+
+图解：假设集群有 3 个 Broker，Partition 因子为 2。
+
+1.  随机选取 Broker 集群中的一个 Broker 节点，然后以轮询的方式将主 Partition 均匀的分布到不同的 Broker 上。
+2.  主 Partition 分布完成后，将从 Partition 按照 AR 组内顺序以轮询的方式将 Partition 均匀的分布到不同的 Broker 上。
+
+## **Partition 的状态转移**
+
+用户针对特定的 Topic 创建了相应的 Partition ，但是这些 Partition 不一定时刻都能够正常工作，所有 Partition 在同一时刻会对应 4 个状态中的某一个；其整个生命周期会经历如下状态的转移，分别是 NonExistentPartition、NewPartition、OnlinePartition、OfflinePartition，其对应的状态转移情况如下图所示。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-58a8609aa2698130679d9fb80541d19b_720w.webp)
+
+<figcaption>Partition状态转移图</figcaption>
+
+</figure>
+
+从上图可以看出，Partition 的状态会由前置状态才能够转移到目标状态的，而不是胡乱转移状态的。
+
+`NonExistentPartition：`代表没有创建 Partition 时的状态，也有可能是离线的 Partition 被删除后的状态。
+
+`NewPartition：`当 Partition 被创建时，此时只有 AR（Assigned Replica），还没有 ISR（In-Synic Replica），此时还不能接受数据的写入和读取。
+
+`OnlinePartition：`由 NewPartition 状态转移为 OnlinePartition 状态，此时 Partition 的 Leader 已经被选举出来了，并且也有对应的 ISR 列表等。此时已经可以对外提供读写请求了。
+
+`OfflinePartition：`当 Partition 对应的 Broker 宕机或者网络异常等问题，由 OnlinePartition 转移到 OfflinePartition，此时的 Partition 已经不能在对外提供读写服务。当 Partition 被彻底删除后状态就转移成 NonExistentPartition，当网络恢复或者 Broker 恢复后，其状态又可以转移到 OnlinePartition，从而继续对外提供读写服务。
+
+## **Kafka 集群的负载均衡处理流程解析**
+
+前面的文章讲到过，Partition 有 Leader Replica 和 Preferred Replica 两种角色，Leader Replica 负责对外提供读写服务 Preferred Replica 负责同步 Leader Replica 上的数据。现在集群中假设有 3 个 Broker，3 个 Partition，每个 Partition 有 3 个 Replica，当集群运行一段时候后，集群中某些 Broker 宕机，Leader Replica 进行转移，其过程如下图所示。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-dc0bcd6f072f7e6cef8289882259d59e_720w.webp)
+
+<figcaption>Partition的Leader转移图</figcaption>
+
+</figure>
+
+从上图可以看出，集群运行一段时间后，Broker1 挂掉了，在其上运行的 Partition0 对应的 Leader Replica 转移到了 Broker2 上。假设一段时间后 Broker3 也挂了，则 Broker3 上的 Partition3 对应的 Leader Replica 也转移到了 Broker2 上，集群中只有 Broker2 上的 Partition 在对外提供读写服务，从而造成 Broker2 上的服务压力比较大，之后 Broker1 和 Broker3 恢复后，其上只有 Preferred Replica 做备份操作。
+
+针对以上这种随着时间的推移，集群不在像刚开始时那样平衡，需要通过后台线程将 Leader Replica 重新分配到不同 Broker 上，从而使得读写服务尽量均匀的分布在不同的节点上。
+
+重平衡操作是由 partition-rebalance-thread 后台线程操作的，由于其优先级很低，所以只会在集群空闲的时候才会执行。集群的不平衡的评判标准是由`leader.imbalance.per.broker.percentage`配置决定的，当集群的不平衡度达到 10%（默认）时，会触发后台线程启动重平衡操作，其具体执行步骤如下：
+
+1.  对 Partition 的 AR 列表根据 Preferred Replica 进行分组操作。
+2.  遍历 Broker，对其上的 Partition 进行处理。
+3.  统计 Broker 上的 Leader Replica 和 Preferred Replica 不相等的 Partition 个数。
+4.  统计 Broker 上的 Partition 个数。
+5.  Partition 个数 / 不相等的 Partition 个数，如果大于 10%，则触发重平衡操作；反之，则不做任何处理。
+
+## **总结**
+
+本文主要介绍了 Kafka 集群服务内部的一些工作机制，相信小伙伴们掌握了这部分内容后，对 Broker 服务端的工作流程有了进一步的理解，从而更好的把控整体集群服务。下篇文章我们来正式介绍一下**Kafka 常用的命令行操作**，敬请期待。
+
+# 参考文章
+https://blog.csdn.net/cao131502
+https://zhuanlan.zhihu.com/p/137811719
\ No newline at end of file
diff --git "a/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\351\207\215\350\246\201\347\237\245\350\257\206\347\202\271+\351\235\242\350\257\225\351\242\230\345\244\247\345\205\250.md" "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\351\207\215\350\246\201\347\237\245\350\257\206\347\202\271+\351\235\242\350\257\225\351\242\230\345\244\247\345\205\250.md"
new file mode 100644
index 0000000..77ac95f
--- /dev/null
+++ "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232Kafka\351\207\215\350\246\201\347\237\245\350\257\206\347\202\271+\351\235\242\350\257\225\351\242\230\345\244\247\345\205\250.md"
@@ -0,0 +1,518 @@
+## 重要面试知识点
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-75cd70ad3052ba44bf706a3ab39e59d5_720w.webp)
+
+
+Kafka 消费端确保一个 Partition 在一个消费者组内只能被一个消费者消费。这句话改怎么理解呢？
+
+1.  在同一个消费者组内，一个 Partition 只能被一个消费者消费。
+2.  在同一个消费者组内，所有消费者组合起来必定可以消费一个 Topic 下的所有 Partition。
+3.  在同一个消费组内，一个消费者可以消费多个 Partition 的信息。
+4.  在不同消费者组内，同一个分区可以被多个消费者消费。
+5.  每个消费者组一定会完整消费一个 Topic 下的所有 Partition。
+
+### **消费组存在的意义**
+
+了解了消费者与消费组的关系后，有朋友会比较疑惑消费者组有啥实际存在的意义呢？或者说消费组的作用是什么？
+
+作者对消费组的作用归结了如下两点。
+
+1.  在实际生产中，对于同一个 Topic，可能有 A、B、C 等 N 个消费方想要消费。比如一份用户点击日志，A 消费方想用来做一个用户近 N 天点击过哪些商品；B 消费方想用来做一个用户近 N 天点击过前 TopN 个相似的商品；C 消费方想用来做一个根据用户点击过的商品推荐相关周边的商品需求。对于多应用场景，就可以使用消费组来隔离不同的业务使用场景，从而达到一个 Topic 可以被多个消费组重复消费的目的。
+2.  消费组与 Partition 的消费进度绑定。当有新的消费者加入或者有消费者从消费组退出时，会触发消费组的 Repartition 操作（后面会详细介绍 Repartition）；在 Repartition 前，Partition1 被消费组的消费者 A 进行消费，Repartition 后，Partition1 消费组的消费者 B 进行消费，为了避免消息被重复消费，需要从消费组记录的 Partition 消费进度读取当前消费到的位置（即 OffSet 位置），然后在继续消费，从而达到消费者的平滑迁移，同时也提高了系统的可用性。
+
+## **Repartition 触发时机**
+
+使用过 Kafka 消费者客户端的同学肯定知道，消费者组内偶尔会触发 Repartition 操作，所谓 Repartition 即 Partition 在某些情况下重新被分配给参与消费的消费者。基本可以分为如下几种情况。
+
+1.  消费组内某消费者宕机，触发 Repartition 操作，如下图所示。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-a9ef6a29cb9ba3456a05ad75cb91cb03_720w.webp)
+
+<figcaption>消费者宕机情况</figcaption>
+
+</figure>
+
+2\. 消费组内新增消费者，触发 Repartition 操作，如下图所示。一般这种情况是为了提高消费端的消费能力，从而加快消费进度。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-8803223d712fdde035b8e7b9170dd3fb_720w.webp)
+
+<figcaption>新增消费者情况</figcaption>
+
+</figure>
+
+3.Topic 下的 Partition 增多，触发 Repartition 操作，如下图所示。一般这种调整 Partition 个数的情况也是为了提高消费端消费速度的，因为当消费者个数大于等于 Partition 个数时，在增加消费者个数是没有用的（原因是：在一个消费组内，消费者:Partition = 1:N，当 N 小于 1 时，相当于消费者过剩了），所以一方面增加 Partition 个数同时增加消费者个数可以提高消费端的消费速度。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-8f1a427c6842d9babf139454ce23cfa3_720w.webp)
+
+<figcaption>新增Partition个数情况</figcaption>
+
+</figure>
+
+## **消费者与 ZK 的关系**
+
+众所周知，ZK 不仅保存了消费者消费 partition 的进度，同时也保存了消费组的成员列表、partition 的所有者。消费者想要消费 Partition，需要从 ZK 中获取该消费者对应的分区信息及当前分区对应的消费进度，即 OffSert 信息。那么 Partition 应该由那个消费者进行消费，决定因素有哪些呢？从之前的图中不难得出，两个重要因素分别是：消费组中存活的消费者列表和 Topic 对应的 Partition 列表。通过这两个因素结合 Partition 分配算法，即可得出消费者与 Partition 的对应关系，然后将信息存储到 ZK 中。Kafka 有高级 API 和低级 API，如果不需要操作 OffSet 偏移量的提交，可通过高级 API 直接使用，从而降低使用者的难度。对于一些比较特殊的使用场景，比如想要消费特定 Partition 的信息，Kafka 也提供了低级 API 可进行手动操作。
+
+## **消费端工作流程**
+
+在介绍消费端工作流程前，先来熟悉一下用到的一些组件。
+
+*   `KakfaConsumer`：消费端，用于启动消费者进程来消费消息。
+*   `ConsumerConfig`：消费端配置管理，用于给消费端配置相关参数，比如指定 Kafka 集群，设置自动提交和自动提交时间间隔等等参数，都由其来管理。
+*   `ConsumerConnector`：消费者连接器，通过消费者连接器可以获得 Kafka 消息流，然后通过消息流就能获得消息从而使得客户端开始消费消息。
+
+以上三者之间的关系可以概括为：消费端使用消费者配置管理创建出了消费者连接器，通过消费者连接器创建队列（这个队列的作用也是为了缓存数据），其中队列中的消息由专门的拉取线程从服务端拉取然后写入，最后由消费者客户端轮询队列中的消息进行消费。具体操作流程如下图所示。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-122b4a706de39655d257928005a83ff1_720w.webp)
+
+<figcaption>消费端工作流程</figcaption>
+
+</figure>
+
+我们在从消费者与 ZK 的角度来看看其工作流程是什么样的？
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-4ed25ebb9236986b2084ce8a042f65b9_720w.webp)
+
+<figcaption>消费端与ZK之间的工作流程</figcaption>
+
+</figure>
+
+从上图可以看出，首先拉取线程每拉取一次消息，同步更新一次拉取状态，其作用是为了下一次拉取消息时能够拉取到最新产生的消息；拉取线程将拉取到的消息写入到队列中等待消费消费线程去真正读取处理。消费线程以轮询的方式持续读取队列中的消息，只要发现队列中有消息就开始消费，消费完消息后更新消费进度，此处需要注意的是，消费线程不是每次都和 ZK 同步消费进度，而是将消费进度暂时写入本地。这样做的目的是为了减少消费者与 ZK 的频繁同步消息，从而降低 ZK 的压力。
+
+## **消费者的三种消费情况**
+
+消费者从服务端的 Partition 上拉取到消息，消费消息有三种情况，分别如下：
+
+1.  至少一次。即一条消息至少被消费一次，消息不可能丢失，但是可能会被重复消费。
+2.  至多一次。即一条消息最多可以被消费一次，消息不可能被重复消费，但是消息有可能丢失。
+3.  正好一次。即一条消息正好被消费一次，消息不可能丢失也不可能被重复消费。
+
+### **1.至少一次**
+
+消费者读取消息，先处理消息，在保存消费进度。消费者拉取到消息，先消费消息，然后在保存偏移量，当消费者消费消息后还没来得及保存偏移量，则会造成消息被重复消费。如下图所示：
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-1a047ed616ba44daebdb4b6ce786a61a_720w.webp)
+
+<figcaption>先消费后保存消费进度</figcaption>
+
+</figure>
+
+### **2.至多一次**
+
+消费者读取消息，先保存消费进度，在处理消息。消费者拉取到消息，先保存了偏移量，当保存了偏移量后还没消费完消息，消费者挂了，则会造成未消费的消息丢失。如下图所示：
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-1f9f91ae54396c5e5d93ae89251eb1ed_720w.webp)
+
+<figcaption>先保存消费进度后消费消息</figcaption>
+
+</figure>
+
+### **3.正好一次**
+
+正好消费一次的办法可以通过将消费者的消费进度和消息处理结果保存在一起。只要能保证两个操作是一个原子操作，就能达到正好消费一次的目的。通常可以将两个操作保存在一起，比如 HDFS 中。正好消费一次流程如下图所示。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-a0bbb114e2ad551227f81c1f26d4bd5d_720w.webp)
+
+<figcaption>正好消费一次</figcaption>
+
+</figure>
+
+## Partition、Replica、Log 和 LogSegment 的关系
+
+假设有一个 Kafka 集群，Broker 个数为 3，Topic 个数为 1，Partition 个数为 3，Replica 个数为 2。Partition 的物理分布如下图所示。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-f8f21631b138321f25c8821c677c5579_720w.webp)
+
+<figcaption>Partition分布图</figcaption>
+
+</figure>
+
+从上图可以看出，该 Topic 由三个 Partition 构成，并且每个 Partition 由主从两个副本构成。每个 Partition 的主从副本分布在不同的 Broker 上，通过这点也可以看出，当某个 Broker 宕机时，可以将分布在其他 Broker 上的从副本设置为主副本，因为只有主副本对外提供读写请求，当然在最新的 2.x 版本中从副本也可以对外读请求了。将主从副本分布在不同的 Broker 上从而提高系统的可用性。
+
+Partition 的实际物理存储是以 Log 文件的形式展示的，而每个 Log 文件又以多个 LogSegment 组成。Kafka 为什么要这么设计呢？其实原因比较简单，随着消息的不断写入，Log 文件肯定是越来越大，Kafka 为了方便管理，将一个大文件切割成一个一个的 LogSegment 来进行管理；每个 LogSegment 由数据文件和索引文件构成，数据文件是用来存储实际的消息内容，而索引文件是为了加快消息内容的读取。
+
+可能又有朋友会问，Kafka 本身消费是以 Partition 维度顺序消费消息的，磁盘在顺序读的时候效率很高完全没有必要使用索引啊。其实 Kafka 为了满足一些特殊业务需求，比如要随机消费 Partition 中的消息，此时可以先通过索引文件快速定位到消息的实际存储位置，然后进行处理。
+
+总结一下 Partition、Replica、Log 和 LogSegment 之间的关系。消息是以 Partition 维度进行管理的，为了提高系统的可用性，每个 Partition 都可以设置相应的 Replica 副本数，一般在创建 Topic 的时候同时指定 Replica 的个数；Partition 和 Replica 的实际物理存储形式是通过 Log 文件展现的，为了防止消息不断写入，导致 Log 文件大小持续增长，所以将 Log 切割成一个一个的 LogSegment 文件。
+
+**注意：** 在同一时刻，每个主 Partition 中有且只有一个 LogSegment 被标识为可写入状态，当一个 LogSegment 文件大小超过一定大小后（比如当文件大小超过 1G，这个就类似于 HDFS 存储的数据文件，HDFS 中数据文件达到 128M 的时候就会被分出一个新的文件来存储数据），就会新创建一个 LogSegment 来继续接收新写入的消息。
+
+## 写入消息流程分析
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-eb66e4ecf7cf07fcb6b12029bfdd9b71_720w.webp)
+
+<figcaption>消息写入及落盘流程</figcaption>
+
+</figure>
+
+流程解析
+
+在第 3 篇文章讲过，生产者客户端对于每个 Partition 一次会发送一批消息到服务端，服务端收到一批消息后写入相应的 Partition 上。上图流程主要分为如下几步：
+
+1.  **客户端消息收集器收集属于同一个分区的消息，并对每条消息设置一个偏移量，且每一批消息总是从 0 开始单调递增。比如第一次发送 3 条消息，则对三条消息依次编号 [0,1,2]，第二次发送 4 条消息，则消息依次编号为 [0,1,2,3]。注意此处设置的消息偏移量是相对偏移量。**
+2.  **客户端将消息发送给服务端，服务端拿到下一条消息的绝对偏移量，将传到服务端的这批消息的相对偏移量修改成绝对偏移量。**
+3.  **将修改后的消息以追加的方式追加到当前活跃的 LogSegment 后面，然后更新绝对偏移量。**
+4.  **将消息集写入到文件通道。**
+5.  **文件通道将消息集 flush 到磁盘，完成消息的写入操作。**
+
+了解以上过程后，我们在来看看消息的具体构成情况。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-6e993c95decd5d274b032cd423936504_720w.webp)
+
+<figcaption>消息构成细节图</figcaption>
+
+</figure>
+
+一条消息由如下三部分构成：
+
+*   **OffSet：偏移量，消息在客户端发送前将相对偏移量存储到该位置，当消息存储到 LogSegment 前，先将其修改为绝对偏移量在写入磁盘。**
+*   **Size：本条 Message 的内容大小**
+*   **Message：消息的具体内容，其具体又由 7 部分组成，crc 用于校验消息，Attribute 代表了属性，key-length 和 value-length 分别代表 key 和 value 的长度，key 和 value 分别代表了其对应的内容。**
+
+### 消息偏移量的计算过程
+
+通过以上流程可以看出，每条消息在被实际存储到磁盘时都会被分配一个绝对偏移量后才能被写入磁盘。在同一个分区内，消息的绝对偏移量都是从 0 开始，且单调递增；在不同分区内，消息的绝对偏移量是没有任何关系的。接下来讨论下消息的绝对偏移量的计算规则。
+
+确定消息偏移量有两种方式，一种是顺序读取每一条消息来确定，此种方式代价比较大，实际上我们并不想知道消息的内容，而只是想知道消息的偏移量；第二种是读取每条消息的 Size 属性，然后计算出下一条消息的起始偏移量。比如第一条消息内容为 “abc”，写入磁盘后的偏移量为：8（OffSet）+ 4（Message 大小）+ 3（Message 内容的长度）= 15。第二条写入的消息内容为“defg”，其起始偏移量为 15，下一条消息的起始偏移量应该是：15+8+4+4=31，以此类推。
+
+## 消费消息及副本同步流程分析
+
+和写入消息流程不同，读取消息流程分为两种情况，分别是消费端消费消息和从副本（备份副本）同步主副本的消息。在开始分析读取流程之前，需要先明白几个用到的变量，不然流程分析可能会看的比较糊涂。
+
+*   **BaseOffSet**：基准偏移量，每个 Partition 由 N 个 LogSegment 组成，每个 LogSegment 都有基准偏移量，大概由如下构成，数组中每个数代表一个 LogSegment 的基准偏移量：[0,200,400,600, ...]。
+*   **StartOffSet**：起始偏移量，由消费端发起读取消息请求时，指定从哪个位置开始消费消息。
+*   **MaxLength**：拉取大小，由消费端发起读取消息请求时，指定本次最大拉取消息内容的数据大小。该参数可以通过[max.partition.fetch.bytes](https://link.zhihu.com/?target=https%3A//xie.infoq.cn/draft/3020%23)来指定，默认大小为 1M。
+*   **MaxOffSet**：最大偏移量，消费端拉取消息时，最高可拉取消息的位置，即俗称的“高水位”。该参数由服务端指定，其作用是为了防止生产端还未写入的消息就被消费端进行消费。此参数对于从副本同步主副本不会用到。
+*   **MaxPosition**：LogSegment 的最大位置，确定了起始偏移量在某个 LogSegment 上开始，读取 MaxLength 后，不能超过 MaxPosition。MaxPosition 是一个实际的物理位置，而非偏移量。
+
+假设消费端从 000000621 位置开始消费消息，关于几个变量的关系如下图所示。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-cd9c62a71cddccd7bc8a5d810d5af216_720w.webp)
+
+<figcaption>位置关系图</figcaption>
+
+</figure>
+
+消费端和从副本拉取流程如下：
+
+1.  **客户端确定拉取的位置，即 StartOffSet 的值，找到主副本对应的 LogSegment。**
+2.  **LogSegment 由索引文件和数据文件构成，由于索引文件是从小到大排列的，首先从索引文件确定一个小于等于 StartOffSet 最近的索引位置。**
+3.  **根据索引位置找到对应的数据文件位置，由于数据文件也是从小到大排列的，从找到的数据文件位置顺序向后遍历，直到找到和 StartOffSet 相等的位置，即为消费或拉取消息的位置。**
+4.  **从 StartOffSet 开始向后拉取 MaxLength 大小的数据，返回给消费端或者从副本进行消费或备份操作。**
+
+假设拉取消息起始位置为 00000313，消息拉取流程图如下：
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-9417ca60a0c5e9474ec49a77fff18b1b_720w.webp)
+
+<figcaption>消息拉取流程图</figcaption>
+
+</figure>
+
+## kafka 如何保证系统的高可用、数据的可靠性和数据的一致性的？
+
+### kafka 的高可用性：
+
+1.  **Kafka 本身是一个分布式系统，同时采用了 Zookeeper 存储元数据信息，提高了系统的高可用性。**
+2.  **Kafka 使用多副本机制，当状态为 Leader 的 Partition 对应的 Broker 宕机或者网络异常时，Kafka 会通过选举机制从对应的 Replica 列表中重新选举出一个 Replica 当做 Leader，从而继续对外提供读写服务（当然，需要注意的一点是，在新版本的 Kafka 中，Replica 也可以对外提供读请求了），利用多副本机制在一定程度上提高了系统的容错性，从而提升了系统的高可用。**
+
+### Kafka 的可靠性：
+
+1.  **从 Producer 端来看，可靠性是指生产的消息能够正常的被存储到 Partition 上且消息不会丢失。Kafka 通过 [request.required.acks](https://link.zhihu.com/?target=https%3A//xie.infoq.cn/edit/49a133ad2b2f2671aa60706b0%23)和[min.insync.replicas](https://link.zhihu.com/?target=https%3A//xie.infoq.cn/edit/49a133ad2b2f2671aa60706b0%23) 两个参数配合，在一定程度上保证消息不会丢失。**
+2.  **[request.required.acks](https://link.zhihu.com/?target=https%3A//xie.infoq.cn/edit/49a133ad2b2f2671aa60706b0%23) 可设置为 1、0、-1 三种情况。**
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-7946f258c85fb8ca3d4aa423269c483a_720w.webp)
+
+<figcaption>request.required.acks=1</figcaption>
+
+</figure>
+
+设置为 1 时代表当 Leader 状态的 Partition 接收到消息并持久化时就认为消息发送成功，如果 ISR 列表的 Replica 还没来得及同步消息，Leader 状态的 Partition 对应的 Broker 宕机，则消息有可能丢失。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-382c9f37f644feb37dd975c67bc1038f_720w.webp)
+
+<figcaption>request.required.acks=0</figcaption>
+
+</figure>
+
+设置为 0 时代表 Producer 发送消息后就认为成功，消息有可能丢失。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-592996f264baadc64967d6f4b28f4d23_720w.webp)
+
+<figcaption>request.required.acks=-1</figcaption>
+
+</figure>
+
+设置为-1 时，代表 ISR 列表中的所有 Replica 将消息同步完成后才认为消息发送成功；但是如果只存在主 Partition 的时候，Broker 异常时同样会导致消息丢失。所以此时就需要[min.insync.replicas](https://link.zhihu.com/?target=https%3A//xie.infoq.cn/edit/49a133ad2b2f2671aa60706b0%23)参数的配合，该参数需要设定值大于等于 2，当 Partition 的个数小于设定的值时，Producer 发送消息会直接报错。
+
+上面这个过程看似已经很完美了，但是假设如果消息在同步到部分从 Partition 上时，主 Partition 宕机，此时消息会重传，虽然消息不会丢失，但是会造成同一条消息会存储多次。在新版本中 Kafka 提出了幂等性的概念，通过给每条消息设置一个唯一 ID，并且该 ID 可以唯一映射到 Partition 的一个固定位置，从而避免消息重复存储的问题（作者到目前还没有使用过该特性，感兴趣的朋友可以自行在深入研究一下）。
+
+### Kafka 的一致性：
+
+1.  **从 Consumer 端来看，同一条消息在多个 Partition 上读取到的消息是一直的，Kafka 通过引入 HW（High Water）来实现这一特性。**
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-9975539d98bf1a4e1a3038f2eceb2bb9_720w.webp)
+
+<figcaption>消息同步图</figcaption>
+
+</figure>
+
+从上图可以看出，假设 Consumer 从主 Partition1 上消费消息，由于 Kafka 规定只允许消费 HW 之前的消息，所以最多消费到 Message2。假设当 Partition1 异常后，Partition2 被选举为 Leader，此时依旧可以从 Partition2 上读取到 Message2。其实 HW 的意思利用了木桶效应，始终保持最短板的那个位置。
+
+从上面我们也可以看出，使用 HW 特性后会使得消息只有被所有副本同步后才能被消费，所以在一定程度上降低了消费端的性能，可以通过设置[replica.lag.time.max.ms](https://link.zhihu.com/?target=https%3A//xie.infoq.cn/edit/49a133ad2b2f2671aa60706b0%23)参数来保证消息同步的最大时间。
+
+## kafka 为什么那么快？
+
+kafka 使用了顺序写入和“零拷贝”技术，来达到每秒钟 200w（Apache 官方给出的数据） 的磁盘数据写入量，另外 Kafka 通过压缩数据，降低 I/O 的负担。
+
+1.  **顺序写入**
+
+大家都知道，对于磁盘而已，如果是随机写入数据的话，每次数据在写入时要先进行寻址操作，该操作是通过移动磁头完成的，极其耗费时间，而顺序读写就能够避免该操作。
+
+1.  **“零拷贝”技术**
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-6930901956f341f1ab4a6e5650a0680b_720w.webp)
+
+<figcaption>普通数据拷贝流程图</figcaption>
+
+</figure>
+
+普通的数据拷贝流程如上图所示，数据由磁盘 copy 到内核态，然后在拷贝到用户态，然后再由用户态拷贝到 socket，然后由 socket 协议引擎，最后由协议引擎将数据发送到网络中。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-9e44873a63d8addca917e658667f0b61_720w.webp)
+
+<figcaption>&amp;quot;零拷贝&amp;quot;流程图</figcaption>
+
+</figure>
+
+采用了“零拷贝”技术后可以看出，数据不在经过用户态传输，而是直接在内核态完成操作，减少了两次 copy 操作。从而大大提高了数据传输速度。
+
+1.  **压缩**
+
+Kafka 官方提供了多种压缩协议，包括 gzip、snappy、lz4 等等，从而降低了数据传输的成本。
+
+## Kafka 中的消息是否会丢失和重复消费？
+
+1.  **Kafka 是否会丢消息，答案相信仔细看过前面两个问题的同学都比较清楚了，这里就不在赘述了。**
+2.  **在低版本中，比如作者公司在使用的 Kafka0.8 版本中，还没有幂等性的特性的时候，消息有可能会重复被存储到 Kafka 上（原因见上一个问题的），在这种情况下消息肯定是会被重复消费的。**
+
+**这里给大家一个解决重复消费的思路，作者公司使用了 Redis 记录了被消费的 key，并设置了过期时间，在 key 还没有过期内，对于同一个 key 的消息全部当做重复消息直接抛弃掉。** 在网上看到过另外一种解决方案，使用 HDFS 存储被消费过的消息，是否具有可行性存疑（需要读者朋友自行探索），读者朋友们可以根据自己的实际情况选择相应的策略，如果朋友们还有其他比较好的方案，欢迎留言交流。
+
+## 为什么要使用 kafka，为什么要使用消息队列？
+
+### 先来说说为什么要使用消息队列？
+
+这道题比较主观一些（自认为没有网上其他文章写得话，轻喷），但是都相信大家使用消息队列无非就是为了 **解耦**、**异步**、**消峰**。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-f7c1bb87ab46ddd03255c58109ce360f_720w.webp)
+
+<figcaption>系统调用图</figcaption>
+
+</figure>
+
+随着业务的发展，相信有不少朋友公司遇到过如上图所示的情况，系统 A 处理的结构被 B、C、D 系统所依赖，当新增系统 E 时，也需要系统 A 配合进行联调和上线等操作；还有当系统 A 发生变更时同样需要告知 B、C、D、E 系统需要同步升级改造。
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-0f0c8f9531a38f6d79b2cbb2973bfbfc_720w.webp)
+
+<figcaption>引入消息队列图</figcaption>
+
+</figure>
+
+引入消息队列后有两个好处：
+
+1.  **各个系统进行了解耦，从上图也可以看出，当系统 A 突然发生热点事件时，同一时间产生大量结果，MQ 充当了消息暂存的效果，防止 B、C、D、E 系统也跟着崩溃。**
+2.  **当新系统 E 需要接入系统 A 的数据，只需要和 MQ 对接就可以了，从而避免了与系统 A 的调试上线等操作。**
+
+引入消息队列的坏处：
+
+万事皆具备两面性，看似引入消息队列这件事情很美好，但是同时也增加了系统的复杂度、系统的维护成本提高（如果 MQ 挂了怎么办）、引入了一致性等等问题需要去解决。
+
+## 为什么要使用 Kafka?
+
+作者认为采用 Kafka 的原因有如下几点：
+
+1.  **Kafka 目前在业界被广泛使用，社区活跃度高，版本更新迭代速度也快。**
+2.  **Kafka 的生产者和消费者都用 Java 语言进行了重写，在一定程度降低了系统的维护成本（作者的主观意见，因为当下 Java 的使用群体相当庞大）。**
+3.  **Kafka 系统的吞吐量高，达到了每秒 10w 级别的处理速度。**
+4.  **Kafka 可以和很多当下优秀的大数据组件进行集成，包括 Spark、Flink、Flume、Storm 等等。**
+
+## 为什么 Kafka 不支持读写分离？
+
+这个问题有个先决条件，我们只讨论 Kafka0.9 版本的情况。对于高版本，从 Partition 也可以承担读请求了，这里不多赘述。
+
+Kafka 如果支持读写分离的话，有如下几个问题。
+
+1.  **系统设计的复杂度会比较大，当然这个比较牵强，毕竟高版本的 Kafka 已经实现了。**
+
+<figure data-size="normal">
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/v2-98093ad82970feb7a0c52954c6942aa1_720w.webp)
+
+</figure>
+
+**2\. 从上图可以看出，从从 Partition 上读取数据会有两个问题。一、数据从主 Partition 上同步到从 Partition 有数据延迟问题，因为数据从生产到消费会经历 3 次网络传输才能够被消费，对于时效性要求比较高的场景本身就不适合了。二、数据一致性问题，假设主 Partition 将数据第一次修改成了 A，然后又将该数据修改成了 B，由于从主 Partition 同步到从 Partition 会有延迟问题，所以也就会产生数据一致性问题。**
+
+分析得出，通过解决以上问题来换取从 Partition 承担读请求，成本可想而知，而且对于写入压力大，读取压力小的场景，本身也就没有什么意义了。
+
+## 总结
+
+本文介绍了几个常见的 Kafka 的面试题
+
+### 常见面试题一览
+
+#### 1.1 Kafka 中的 ISR(InSyncRepli)、 OSR(OutSyncRepli)、 AR(AllRepli)代表什么？
+
+ISR：速率和leader相差低于10s的follower的集合
+
+OSR：速率和leader相差大于10s的follwer
+
+AR：所有分区的follower
+
+#### 1.2 Kafka 中的 HW、 LEO 等分别代表什么？
+
+HW：High Water高水位，根据同一分区中最低的LEO决定（Log End Offset）
+
+LEO：每个分区最大的Offset
+
+#### 1.3 Kafka 中是怎么体现消息顺序性的？
+
+在每个分区内，每条消息都有offset，所以消息在同一分区内有序，无法做到全局有序性
+
+#### 1.4 Kafka 中的分区器、序列化器、拦截器是否了解？它们之间的处理顺序是什么？
+
+分区器Partitioner用来对分区进行处理的，即消息发送到哪一个分区的问题。序列化器，这个是对数据进行序列化和反序列化的工具。拦截器，即对于消息发送进行一个提前处理和收尾处理的类Interceptor，处理顺利首先通过拦截器=>序列化器=>分区器
+
+#### 1.5 Kafka 生产者客户端的整体结构是什么样子的？使用了几个线程来处理？分别是什么？
+
+使用两个线程：main和sender 线程，main线程会一次经过拦截器、序列化器、分区器将数据发送到RecoreAccumulator线程共享变量，再由sender线程从共享变量中拉取数据发送到kafka broker
+
+batch.size达到此规模消息才发送，linger.ms未达到规模，等待当前时长就发送数据。
+
+#### 1.6 消费组中的消费者个数如果超过 topic 的分区，那么就会有消费者消费不到数据”这句 话是否正确？
+
+这句话是对的，超过分区个数的消费者不会在接收数据，主要原因是一个分区的消息只能够被一个消费者组中的一个消费者消费。
+
+#### 1.7 消费者提交消费位移时提交的是当前消费到的最新消息的 offset 还是 offset+1？
+
+生产者发送数据的offset是从0开始的，消费者消费的数据的offset是从1开始，故最新消息是offset+1
+
+#### 1.8 有哪些情形会造成重复消费？
+
+先消费后提交offset，如果消费完宕机了，则会造成重复消费
+
+#### 1.9 那些情景会造成消息漏消费？
+
+先提交offset，还没消费就宕机了，则会造成漏消费
+
+#### 1.10 当你使用 kafka-topics.sh 创建（删除）了一个 topic 之后， Kafka 背后会执行什么逻辑？
+
+会在 zookeeper 中的/brokers/topics 节点下创建一个新的 topic 节点，如：/brokers/topics/first 触发 Controller 的监听程序 kafka Controller 负责 topic 的创建工作，并更新 metadata cache
+
+#### 1.11 topic 的分区数可不可以增加？如果可以怎么增加？如果不可以，那又是为什么？
+
+可以增加，修改分区个数--alter可以修改分区个数
+
+#### 1.12 topic 的分区数可不可以减少？如果可以怎么减少？如果不可以，那又是为什么？
+
+不可以减少，减少了分区之后，之前的分区中的数据不好处理
+
+#### 1.13 Kafka 有内部的 topic 吗？如果有是什么？有什么所用？
+
+有，__consumer_offsets主要用来在0.9版本以后保存消费者消费的offset
+
+#### 1.14 Kafka 分区分配的概念？
+
+Kafka分区对于Kafka集群来说，分区可以做到负载均衡，对于消费者来说分区可以提高并发度，提高读取效率
+
+#### 1.15 简述 Kafka 的日志目录结构？
+
+每一个分区对应着一个文件夹，命名为topic-0/topic-1…，每个文件夹内有.index和.log文件。
+
+#### 1.16 如果我指定了一个 offset， Kafka Controller 怎么查找到对应的消息？
+
+offset表示当前消息的编号，首先可以通过二分法定位当前消息属于哪个.index文件中，随后采用seek定位的方法查找到当前offset在.index中的位置，此时可以拿到初始的偏移量。通过初始的偏移量再通过seek定位到.log中的消息即可找到。
+
+#### 1.17 聊一聊 Kafka Controller 的作用？
+
+Kafka集群中有一个broker会被选举为Controller，负责管理集群broker的上下线、所有topic的分区副本分配和leader的选举等工作。Controller的工作管理是依赖于zookeeper的。
+
+#### 1.18 Kafka 中有那些地方需要选举？这些地方的选举策略又有哪些？
+
+在ISR中需要选举出Leader，选择策略为先到先得。在分区中需要选举，需要选举出Leader和follower。
+
+#### 1.19 失效副本是指什么？有那些应对措施？
+
+失效副本为速率比leader相差大于10s的follower，ISR会将这些失效的follower踢出，等速率接近leader的10s内，会重新加入ISR
+
+#### 1.20 Kafka 的哪些设计让它有如此高的性能？
+
+1.  Kafka天生的分布式架构
+2.  对log文件进行了分segment，并对segment建立了索引
+3.  对于单节点使用了顺序读写，顺序读写是指的文件的顺序追加，减少了磁盘寻址的开销，相比随机写速度提升很多
+4.  使用了零拷贝技术，不需要切换到用户态，在内核态即可完成读写操作，且数据的拷贝次数也更少。
+
+## 参考文章
+https://blog.csdn.net/cao131502
+https://zhuanlan.zhihu.com/p/137811719
\ No newline at end of file
diff --git "a/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232\345\246\202\344\275\225\345\256\236\347\216\260\345\273\266\350\277\237\351\230\237\345\210\227.md" "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232\345\246\202\344\275\225\345\256\236\347\216\260\345\273\266\350\277\237\351\230\237\345\210\227.md"
new file mode 100644
index 0000000..584cb61
--- /dev/null
+++ "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232\345\246\202\344\275\225\345\256\236\347\216\260\345\273\266\350\277\237\351\230\237\345\210\227.md"
@@ -0,0 +1,173 @@
+Kafka��һ���ֲ�ʽ��Ϣϵͳ�����㷺Ӧ���ڻ������ʹ�����������ʵ��Ӧ���У�������Ҫʵ���ӳٶ��еĹ��ܣ��Ա���һ��ʱ���ִ��ijЩ������߷���ijЩ��Ϣ��Kafka�ṩ�˶��ַ�ʽ��ʵ���ӳٶ��У����Ľ���������һ�ֳ�����ʵ�ַ�����
+
+
+
+
+
+### һ���ӳٶ��и���
+
+
+
+
+
+�ӳٶ�����һ��������һ��ʱ���ִ�����������Ϣ�Ļ��ơ�������Ӧ�ó���������ʱ������Ϣ���͡�������ʱ�ȵȡ��ӳٶ��е�ʵ�ַ�ʽ�ж��֣�����һ�ֱȽϳ�����ʵ�ַ����ǻ�����Ϣ���е��ӳ���Ϣ���ơ�
+
+
+
+
+
+��Kafka�У��ӳ���Ϣ��ָ�ڷ�����Ϣʱ��ָ��һ���ӳ�ʱ�䣬��Ϣ�����ӳ�ʱ�䵽���ű����������ѡ�Kafka�ṩ��һЩ�����Topic���ڴ洢�ӳ���Ϣ������"delayed-messages"�������߽��̿��Զ��ڴ���ЩTopic��������Ϣ��������Ϣ���·��͵�Ŀ��Topic�У��Ӷ�ʵ���ӳٶ��еĹ��ܡ�
+
+
+
+
+
+### ����Kafka�е��ӳ���Ϣʵ��ԭ��
+
+
+
+
+
+Kafka���ӳ���Ϣʵ��ԭ���Ƚϼ򵥣���Ҫ�漰����Ϣ��key��ʱ���������Ϣ��key�У���������һ��ʱ�������ʾ��Ϣ���ӳ�ʱ�䡣�������߷�����Ϣʱ������Ϣ���͵�"delayed-messages" Topic�У���������Ϣ��key�е�ʱ����������߽��̻ᶨ�ڴ�"delayed-messages" Topic��������Ϣ�������Ϣ��key�е�ʱ����Ƿ��Ѿ����ڡ����ʱ����Ѿ����ڣ�����Ϣ���·��͵�Ŀ��Topic�У�����"target-messages"�����ʱ�����δ���ڣ�����Ϣ���·��͵�"delayed-messages" Topic�У�������һ���µ��ӳ�ʱ������������Ϳ���ʵ���ӳٶ��еĹ��ܡ�
+
+
+
+![image-20230526211424767](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230526211424767.png)
+
+
+
+
+
+### ����Kafka���ӳٶ��е�ʵ�ֲ���
+
+
+
+
+
+ʵ��Kafka�е��ӳٶ��У����԰������²�����У�
+
+
+
+
+
+1.����һ��ר�ŵ�Topic���ڴ洢�ӳ���Ϣ������"delayed-messages"������ʹ��Kafka�����й��߻�Kafka API���д�����
+
+
+
+
+
+2.����Ϣ��key�������ӳ�ʱ���������ʹ�õ�ǰʱ��������ӳ�ʱ����Ϊkey�����磺"key":"message_body"������ʹ��Kafka API������Ϣ��"delayed-messages" Topic�С�
+
+
+
+
+
+3.����һ�������߽��̣���������"delayed-messages" Topic�е���Ϣ������ʹ��Kafka APIʵ�������߽��̡�
+
+
+
+
+
+4.�������߽����У������Ϣ��key�е�ʱ����Ƿ��Ѿ����ڡ�����ʹ�õ�ǰʱ�������Ϣ��key�е�ʱ������бȽϡ����ʱ����Ѿ����ڣ�����Ϣ���·��͵�Ŀ��Topic�У�����"target-messages"������ʹ��Kafka APIʵ����Ϣ�����·��͡�
+
+
+
+
+
+5.���ʱ�����δ���ڣ�����Ϣ���·��͵�"delayed-messages" Topic�У�������һ���µ��ӳ�ʱ���������ʹ��Kafka APIʵ����Ϣ�����·��ͣ�������Ϣ��key�������µ��ӳ�ʱ�����
+
+
+
+
+
+6.�ȴ�һ��ʱ����ظ�ִ�е�4�͵�5����ֱ����Ϣ��key�е�ʱ����Ѿ����ڡ�
+
+
+
+
+
+ͨ�����ϲ��裬�Ϳ���ʵ��Kafka�е��ӳٶ��й��ܡ���Ҫע����ǣ������߽�����Ҫ���ڴ�"delayed-messages" Topic��������Ϣ���������Ϣ��key�е�ʱ����Ƿ��Ѿ����ڡ����Ը��ݾ����Ӧ�ó������ò�ͬ���ӳ�ʱ�䡣
+
+
+
+
+
+![image-20230526211452328](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230526211452328.png)
+
+
+
+
+
+### �ġ��ӳ���Ϣʵ�ֵ���ȱ��
+
+
+
+
+
+![image-20230526211506828](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230526211506828.png)
+
+
+
+
+
+Kafka��ʵ���ӳٶ��еķ������������ŵ㣺
+
+
+
+
+
+1.�����ڷֲ�ʽϵͳ��ʵ���ӳٶ��й��ܣ����нϸߵĿ���չ�ԺͿɿ��ԡ�
+
+
+
+
+
+2.ʵ�ּ򵥣�ֻ��Ҫʹ��Kafka API���ɣ�������������򹤾ߡ�
+
+
+
+
+
+3.֧����Ϣ���������ͺ����ѣ�����������ܺ���������
+
+
+
+
+
+4.�������ص����ӳ�ʱ���Ŀ��Topic�������ڲ�ͬ��Ӧ�ó�����
+
+
+
+
+
+���ǣ�Kafka��ʵ���ӳٶ���Ҳ����һЩȱ�㣺
+
+
+
+
+
+1.��Ҫ�����߽��̶��ڴ�"delayed-messages" Topic��������Ϣ����������߽���崻�����ֹͣ���������Ӱ���ӳٶ��еĹ��ܡ�
+
+
+
+
+
+2.�����߽�����Ҫ����Ϣ�������·��ͺͼ�飬��Ҫ����һ������Դ��ʱ�䡣
+
+
+
+
+
+3.�ӳ�ʱ�侫�����ޣ���Сֻ�ܴﵽ���뼶��
+
+
+
+
+
+### �ġ��ܽ�
+
+
+
+
+
+Kafka��һ������ǿ��ķֲ�ʽ��Ϣϵͳ������ʵ���ӳٶ��еĹ��ܡ�ͨ������Ϣ��key�������ӳ�ʱ�������������߽��̵Ķ������Ѻ����·��ͣ�����ʵ���ӳٶ��еĹ��ܡ�Kafka��ʵ���ӳٶ��еķ�������ʵ�ּ򵥡�����չ�Ըߡ����ܺõ��ŵ㣬��Ҳ����һЩȱ�㡣��ʵ��Ӧ���У���Ҫ���ݾ����Ӧ�ó���������ѡ����ʵ��ӳٶ���ʵ�ַ�����
\ No newline at end of file
diff --git "a/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232\345\246\202\344\275\225\345\256\236\347\216\260\346\255\273\344\277\241\351\230\237\345\210\227.md" "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232\345\246\202\344\275\225\345\256\236\347\216\260\346\255\273\344\277\241\351\230\237\345\210\227.md"
new file mode 100644
index 0000000..5617b88
--- /dev/null
+++ "b/docs/mq/kafka/\346\266\210\346\201\257\351\230\237\345\210\227kafka\350\257\246\350\247\243\357\274\232\345\246\202\344\275\225\345\256\236\347\216\260\346\255\273\344\277\241\351\230\237\345\210\227.md"
@@ -0,0 +1,578 @@
+### Apache Kafka �����ڴ����������Ŷ��У����� Uber �� Crowdstrike ��������������ʵ���Ͱ����о���
+
+
+
+
+
+ʶ��ʹ�����������κοɿ����������ܵ����DZز����ٵġ���ƪ����̽����** �� Apache Kafka �����ܹ���****ʹ�����Ŷ���ʵ�ִ����������ʵ��**����Щѡ������Զ���ʵ�֡�Kafka Streams��Kafka Connect��Spring ��ܺͲ��������ߡ���ʵ�����о�չʾ�� Uber��CrowdStrike ��ɣ̹����������Լ��˹�ģ�����ɿ���ʵʱ��������
+
+
+
+
+
+Apache Kafka ��Ϊ������ҵ�ܹ���ϲ���ļ����м������ʹ����������ս�ԣ���ҵҲ�������� Kafka ����������Ϊ��ԭ������ƽ̨������ (iPaaS)��
+
+
+
+
+
+### Apache Kafka �������е���Ϣ����ģʽ
+
+
+
+
+
+���ҿ�ʼ��ƪ����֮ǰ����������֪�����������**���ڡ�JMS����Ϣ���к� Apache Kafka���IJ���ϵ��**��һ���֣�
+
+
+
+
+
+*   JMS ��Ϣ������ Apache Kafka ��������**10 ���Ƚϱ�׼**
+*   _**��ƪ����**_**�C ͨ��Apache Kafka �е����Ŷ��� (DQL)**���д��������������
+*   ʹ�� Apache Kafkaʵ��**����-�ظ�ģʽ**
+*   _����_�Ƴ�����**����ѡ����ȷ��Ϣϵͳ�ľ�����**��JMS �� Apache Kafka��
+*   _�����Ƴ�_������ JMS ��Ϣ������ Apache Kafka��**���ɡ�Ǩ�ƺ�/���滻**
+
+
+
+
+
+### ʲô�����Ŷ��м���ģʽ���� Apache Kafka �У���
+
+
+
+
+
+**���Ŷ��� (DLQ)**����Ϣϵͳ��������ƽ̨�ڵ�һ�ַ���ʵ�֣�����**�洢δ�ɹ���������Ϣ**��ϵͳ���DZ�����ת����Ϣ�����ǽ����ƶ������Ŷ��С�
+
+
+
+
+
+��ҵ**����ģʽ (EIP)**��Ϊ�������ģʽ����ͨ�������ǿ��Խ���������ͬ��ʡ�
+
+
+
+
+
+![image-20230526224702433](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230526224702433.png)
+
+
+
+
+
+�����ص����������ƽ̨ Apache Kafka��**�� Kafka �н���Ϣ���� DLQ ��**��Ҫԭ��ͨ������Ϣ��ʽ�������Ϣ������Ч/ȱʧ�����磬���Ԥ��ֵ���������������߷������ַ�������ᷢ��Ӧ�ó�������ڸ���̬�Ļ����У������ⲻ���ڡ��쳣�������޷�������Ϣ����һ������
+
+
+
+
+
+��ˣ�ͨ����Ҫʹ�������м�������е�֪ʶ��Message Queue �м��������� JMS �� IBM MQ��TIBCO EMS �� RabbitMQ����ֲ�ʽ�ύ��־���� Kafka���Ĺ�����ʽ��ͬ��������������ԭ����Ϣ�����е� DLQ ������Ϣ����ϵͳ����Щԭ����һ��һ��ӳ�䵽 Kafka�����磬MQ ϵͳ�е���Ϣ����ÿ����Ϣ�� TTL������ʱ�䣩�����ڡ�
+
+
+
+
+
+��ˣ�**�� Kafka �н���Ϣ���� DLQ ����Ҫԭ������Ϣ��ʽ�������Ϣ������Ч/ȱʧ**��
+
+
+
+
+
+### Apache Kafka �����Ŷ��е��������
+
+
+
+
+
+Kafka �е����Ŷ�����һ������ Kafka ���⣬����**���պʹ洢���ڴ�����޷�����һ�����ܵ��д�������Ϣ**���˸�������ʹ�����´�����Ϣ������Ϣ����������������Ч��Ϣ�Ĵ����ֹͣ��������
+
+
+
+
+
+### Kafka Broker �ܱ��������ܶ˵��ṩ������
+
+
+
+
+
+**Kafka �ܹ���֧�� broker** r �е�DLQ������أ�Kafka ���������ִ�΢������ͬ��ԭ���ϣ�ʹ�á��ƹܵ������ܶ˵㡱ԭ�������Ϊʲô�봫ͳ��Ϣ������ȣ�Kafka ����չ�����֮�á����˺ʹ����������ڿͻ���Ӧ�ó����С�
+
+
+
+
+
+������ƽ̨�������������ʵ�ָ��ɾ�������������ơ�**ÿ��΢�����Ӧ�ó���ͨ���Լ�ѡ��ļ�����ͨ�ŷ�ʽ�ʹ�������ʵ�����߼�**��
+
+
+
+
+
+�ڴ�ͳ���м������Ϣ�����У������ṩ�������߼�����������еĿ���չ�Ժ�����Խϲ��Ϊֻ���м���ŶӲ���ʵ�ּ����߼���
+
+
+
+
+
+### ���κα�������Զ���ʵ�� Kafka ���Ŷ���
+
+
+
+
+
+Kafka �е����Ŷ��ж�������ʹ�õĿ�ܡ�һЩ���Ϊ�����������Ŷ����ṩ�˿��伴�õĹ��ܡ����ǣ�ʹ��Java��Go��C++��Python ��**�κα������Ϊ Kafka Ӧ�ó����д���Ŷ����߼�**Ҳ�����ס�
+
+
+
+
+
+**���Ŷ���ʵ��**��Դ�������һ�� try-catch ��������Ԥ�ڻ������쳣�����û�з���������������Ϣ����������κ��쳣���뽫��Ϣ���͵�ר�õ� DLQ Kafka ���⡣
+
+
+
+
+
+**ʧ��ԭ��Ӧ���ӵ� Kafka ��Ϣ�ı�ͷ**�С���Ӧ���ļ���ֵ���Ա㽫������ʷ�¼��������´����͹��Ϸ�����
+
+
+
+
+
+### ���Ŷ��еĿ��伴�� Kafka ʵ��
+
+
+
+
+
+�㲢��������Ҫʵ��������Ŷ��С�**��������Ϳ���Ѿ��ṩ�����ǵ� DLQ ʵ��**��
+
+
+
+
+
+ʹ�����Լ���Ӧ�ó�����ͨ�����Կ��ƴ�����ڳ��ִ���ʱ�޸����롣���ǣ�**�� 3rd ��Ӧ�ó���ļ��ɲ���һ���������������ܿ缯���ϰ�����Ĵ���**����ˣ�DLQ ��ø�����Ҫ������������ijЩ����С�
+
+
+
+
+
+### Kafka Connect �������Ŷ���
+
+
+
+
+
+**Kafka Connect �� Kafka �ļ��ɿ��**���������ڿ�Դ Kafka �����С�����Ҫ������������������� Connect ��Ⱥ�е���������������
+
+
+
+
+
+Ĭ������£��������ʹ����Ч��Ϣ��������������ʹ�ô���� JSON ת������������ȷ�� AVRO ת����ʱ����Kafka Connect ����ֹͣ��ɾ����Ч��Ϣ����һ��ѡ�񡣺������̴���
+
+
+
+
+
+Kafka Connect �� DLQ �����úܼ򵥡�ֻ�轫��������ѡ�� ' errors.tolerance' �� ' errors.deadletterqueue.topic.name' ��ֵ����Ϊ��ȷ��ֵ��
+
+
+
+
+
+![image-20230526224856544](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230526224856544.png)
+
+
+
+
+
+�������¡� Kafka Connect Deep Dive �C �����������Ŷ��С���ʾ��ʹ�� DLQ ����ϸ���ִ���ʾ����
+
+
+
+
+
+**Kafka Connect �����������ڴ��� DLQ �еĴ�����Ϣ**��ֻ�貿����һ��ʹ�� te DLQ ����������������磬�������Ӧ�ó����� Avro ��Ϣ���Ҵ�����Ϣ�� JSON ��ʽ��Ȼ��������ʹ�� JSON ��Ϣ������ת��Ϊ AVRO ��Ϣ�Գɹ����´�����
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/61aa7624a01c5016d3ab9aaa8ee6938d5514.jpeg)��ע�⣬Kafka Connect **û������Դ�����������Ŷ���**��
+
+
+
+
+
+### Kafka Streams Ӧ�ó����еĴ�����
+
+
+
+
+
+**Kafka Streams �� Kafka ����������**��������������ʽ������������������ Apache Flink��Storm��Beam �����ƹ��ߡ����ǣ����� Kafka ԭ���ġ�����ζ���������ڵ�������չ�ҿɿ��Ļ����ܹ��й��������Ķ˵�����������
+
+
+
+
+
+������ֱ�ʹ�� Java��JVM ��̬ϵͳ�������� Kafka Ӧ�ó���**���鼸������ʹ�� Kafka Streams ������ Kafka �ı�׼ Java �ͻ���**��Ϊʲô��
+
+
+
+
+
+*   Kafka Streams��ֻ�ǡ�һ��Χ�Ƴ��� Java �����ߺ������� API �İ�װ�����Լ��������õĸ��ӹ��ܡ�
+*   ���߶�ֻ��Ƕ�뵽 Java Ӧ�ó����еĿ⣨JAR �ļ�����
+*   ���߶��ǿ�Դ Kafka ���ص�һ���� - û�ж���������������֤���ġ�
+*   ���������Ѿ����伴�õؽ�����Թ�����������������������ܡ���״̬��Ƕ��ʽ�洢���������ڡ�����ʽ��ѯ���������ȵȣ���
+
+
+
+
+
+Kafka Streams��**���ù���֮һ��Ĭ�ϵķ����л��쳣��������**���������������޷������л���**��¼�쳣��**�𻵵����ݡ�����ȷ�����л��߼���δ�����ļ�¼���Ͷ����ܵ��´��󡣸ù��ܲ���Ϊ���Ŷ��У������伴�õؽ������ͬ�����⡣
+
+
+
+
+
+### Spring Kafka �� Spring Cloud Stream �Ĵ�����
+
+
+
+
+
+Spring ��ܶ� Apache Kafka �кܺõ�֧�֡����ṩ������ģ���Ա����Լ���д������롣**Spring-Kafka �� Spring Cloud Stream Kafka ֧�ָ������Ժʹ�����ѡ��**����������ʱ��/���������ԡ����Ŷ��еȡ�
+
+
+
+
+
+���� Spring ��ܹ��ܷdz��ḻ�������е��أ�������һ��ѧϰ���ߡ���ˣ����dz��ʺ��½���Ŀ������������Ѿ��� Spring ����������������Ŀ��
+
+
+
+
+
+�кܶ�ܰ��IJ�������չʾ�˲�ͬ��ʾ��������ѡ������������Ŷ��еĹٷ� Spring Cloud Stream ʾ����Spring ����ʹ�ü򵥵�ע�͹����߼������� DLQ�����ֱ�̷�����һЩ������Ա�Ӱ��ķ���������һЩ��ϲ������ֻ���˽�ѡ�Ϊ�Լ�ѡ����ʵ�ѡ��ɡ�
+
+
+
+
+
+### Apache Kafka ���������ߵĿ���չ�����ʹ�����
+
+
+
+
+
+������ͻ��Ի��У���ʵ֤����**�������Ŷ��е���Ҫԭ��ͨ���Ǵ������ӵ��ⲿ Web ��������ݿ��ʧ��**����ʱ�� Kafka �޷����з��͸�������ᵼ��ijЩӦ�ó���̱�������������һ���ܺõĽ��������
+
+
+
+
+
+Apache Kafka��**����������**��Apache 2.0 ������**�Ŀ�Դ��Ŀ��**���ṩ��һ�����пͻ��˶��еIJ��� Apache Kafka �ͻ��˰�װ����һ������**�ؼ������Եĸ��򵥵�������/������ API��**�Լ�**����չ�ķ����� IO**������
+
+
+
+
+
+�ÿ�������**ͨ������ Kafka Consumer ���д�����Ϣ������ζ���������ڲ�����**Ҫ�����������еķ������������������ Kafka Consumer ���жȡ�**����������������ͨ������ Kafka �����ĸ�����**������������ӳ١������������µ����������缫�˲����ԡ��ⲿ���ݷḻ���Ŷӡ�
+
+
+
+
+
+һ���ؼ�������**�ڵ��� Kafka ������Ӧ�ó����д���/�ظ� Web ��������ݿ����**�����л�������һ�η��͵��� Web �������Ҫ��
+
+
+
+
+
+![image-20230526224910457](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230526224910457.png)
+
+
+
+
+
+**Parallel Consumer �ͻ��˾���ǿ�������**�߼�������������õ��ӳٺͶ�̬�������������Ҳ���Է��͵����Ŷ��С�
+
+
+
+
+
+### ʹ�����Ŷ����е���Ϣ
+
+
+
+
+
+**�������͵����Ŷ��к�����û����ɣ�����Ϣ��Ҫ�����������ٱ���أ�**
+
+
+
+
+
+���Ŷ�����**���¼������д��⴦�����ݴ�����**�ľ��ѷ�ʽ������ζ�Ŵ���������������¼���������ֿ��������ݱ䡣
+
+
+
+
+
+���ڴ���ʹ�����Ŷ��еĴ��������ԡ�DO �� DONT ̽�����ʵ���;����ѵ��
+
+
+
+
+
+### ����������
+
+
+
+
+
+�м���ѡ������ڴ����洢�����Ŷ����е���Ϣ��
+
+
+
+
+
+*   **���´���**��DLQ�е�һЩ��Ϣ��Ҫ���´��������ǣ����ȣ���Ҫ���������⡣��������������Զ��ű����༭��Ϣ���˹����������������߷��ش���Ҫ�����·��ͣ������ģ���Ϣ��
+*   **ɾ��������Ϣ��������һ��������**�������������ã����ܻ���ִ�����Ϣ�����ǣ���ɾ������֮ǰ��ҵ������Ӧ�ü�����ǡ����磬�DZ���Ӧ�ó������ʹ�ô�����Ϣ�������ǿ��ӻ���
+*   **�߼�����**����һ��ѡ���Ƿ������������Ի�ȡʵʱ��������⣬�����Ǵ��� DLQ �е�ÿ����Ϣ�����磬һ���򵥵� ksqlDB Ӧ�ó������Ӧ�����������м��㣬����ÿСʱ������Ϣ��ƽ���������κ�����������ȷ�� Kafka Ӧ�ó����еĴ���ļ��⡣
+*   **ֹͣ������**��������ٻ���ֻ���Ϣ�����������ֹͣ����ҵ�����̡��ö����������Զ��ģ�Ҳ�������˾�������Ȼ��ֹͣ������Ҳ�������׳������ Kafka Ӧ�ó�������ɡ������Ҫ��DLQ ������;����ⲿ����
+*   **����**����������������������ѡ��ֻ�������Ŷ���������ʲô��������Ȼ������ʹ������ijЩ������Ҳ�ܺã������� Kafka Ӧ�ó����������Ϊ�����ס��Kafka ������б���ʱ�䣬�����ڸ�ʱ��֮���������ɾ����Ϣ��ֻ��Ϊ��������ȷ�ķ�ʽ���ɡ������ DQL �����Ƿ����������Ϊ���������̫�죩��
+
+
+
+
+
+### Apache Kafka �����Ŷ��е����ʵ��
+
+
+
+
+
+�������� Kafka Ӧ�ó�����ʹ�����Ŷ��н��д�������һЩ**���ʵ���;����ѵ��**
+
+
+
+
+
+*   ����**������Ч��Ϣ��ҵ������**���Զ����˹���
+    *   ��ʵ��ͨ��������û���˴��� DLQ ��Ϣ
+    *   ��ѡ���� 1��������������Ҫ���վ��������������ǻ����ܹ��Ŷ�
+    *   ��ѡ���� 2������Ӧ֪ͨ��¼�Ŷ�ϵͳ���ݴ������ǽ���Ҫ�Ӽ�¼ϵͳ���·���/�޸����ݡ�
+    *   ���û���˹��Ļ�Թ���뿼�����ɺ���� DLQ ���ڵı�Ҫ�ԡ��෴����Щ��ϢҲ�����ڳ�ʼ Kafka Ӧ�ó����б����ԡ����ʡ�˴��������縺�ء�������ʩ���ʽ�
+*   ����**�����ʵ��������DZ���**����������Ŷӣ����磬ͨ�������ʼ��� Slack ������
+*   ����ÿ�� Kafka �����**���������ȼ���ֹͣ��ɾ�������´�����**
+*   **�����������ԵĴ�����Ϣ���͵� DLQ** - ����������������Ӧ�ó�������Ρ�
+*   **����ԭʼ��Ϣ**�������Ǵ洢�� DLQ �У����ж���ı�ͷ�����������Ϣ������ʱ�䡢���������Ӧ�ó������Ƶȣ�������ʹ�����´����͹����ų���ø������ס�
+*   **��������Ҫ���� Dead Letter Queue Kafka ����**��������ȡ�ᡣ���ǽ����д���洢�ڵ��� DLQ �п��ܶԽ�һ�����������´���û�����塣
+
+
+
+
+
+���ס��**DLQ �����б�֤��˳����ֹ��������ʹ�κ����͵����ߴ�����ø�������**����ˣ�Kafka DQL �����ʺ�ÿ��������
+
+
+
+
+
+### ��ʱ���� Kafka ��ʹ�����Ŷ��У�
+
+
+
+
+
+������̽��һ�²�Ӧ�ý���Щ���͵���Ϣ���� Kafka �����Ŷ����У�
+
+
+
+
+
+*   **DLQ ���ڱ�ѹ������**���ڴ�����Ϣ�ķ�ֵ��ʹ�� DLQ ���н���������һ�������⡣Kafka ��־����Ĵ洢���Զ�������ѹ���������������԰��Լ����ٶȻ�ȡ���ݵķ�ʽ��ȡ���ݣ��������ô��󣩡�������ܵĻ������Ե���չ�����ߡ���ʹ���Ĵ洢�ռ�������DLQ Ҳ�޼����¡������������⣬���Ƿ�ʹ�� DLQ �޹ء�
+*   **����ʧ�ܵ�DLQ��**��������ʧ�ܶ�����Ϣ���� DQL �޼����£���ʹ�ڶ������֮�󣩡�������ϢҲ�޷����ӵ���ϵͳ������Ҫ����������⡣��Ϣ���Ը�����Ҫ�洢�ڳ��������У�ȡ���ڱ���ʱ�䣩��
+
+
+
+
+
+### �������������ʹ���Ԥ����ģʽע���
+
+
+
+
+
+���ͬ����Ҫ���ǣ�������̽����ijЩ�����**�����������������Ŷ��е�����Ŀ����ԡ�**
+
+
+
+
+
+**����**��Schema Registry**��һ��ȷ�����������Է�ֹ�������ڸ����г����ķ���**������ Kafka ��������ǿ��ִ����ȷ����Ϣ�ṹ��
+
+![image-20230526224926155](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230526224926155.png)
+
+
+
+
+
+ģʽע�����ģʽ�Ŀͻ��˼�顣Confluent Server ��һЩʵ���ڴ������ṩ�˶����ģʽ��飬�Ծܾ�����δʹ��ģʽע����������ߵ���Ч�������Ϣ��
+
+
+
+
+
+### Kafka ���Ŷ��еİ����о�
+
+
+
+
+
+�����ǿ���**Uber��CrowdStrike �� Santander Bank �����������о��������� Kafka ������ʩ��ʵ�ʲ������Ŷ���**�����ס����Щ���Ƿdz���������ӡ�����ÿ����Ŀ����Ҫ��ô���ӡ�
+
+
+
+
+
+### Uber - �����ɿ����ٴ��������Ŷ���
+
+
+
+
+
+�ڷֲ�ʽϵͳ�У������Dz��ɱ���ġ���������󵽸������⣬��������������ϵ���жϣ����ģ���еķ������׼���þ��������ŵ�������ʶ��ʹ������ϡ�
+
+
+
+
+
+���� Uber ����Ӫ��Χ���ٶȣ�����ϵͳ�������**�ݴ�����������������ʧ��ʱ������Э**��Uber �� Apache Kafka ���ڸ��ּ��˹�ģ��������ʵ����һĿ�ꡣ
+
+
+
+
+
+������Щ���ԣ�Uber ���չ����Ŷ���չ�� Kafka ���������¼������ܹ��е����ã�ͨ��ʹ�� n**�������������´��������Ŷ�����ʵ�ֽ���ɹ۲�Ĵ��������������ж�ʵʱ����**���ò�������������ѡ�����ļ�ʻԱ�˺������ƻ��� 200 ������пɿ����У���Ϊע���ʻԱ�۳�ÿ���г̵�ÿӢ�ﱣ�ѡ�
+
+
+
+
+
+���� Uber ��������ʾ��������ή����������ļ���ֱ����½ DLQ��
+
+
+
+
+
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230526225030750.png)
+
+
+
+
+
+�йظ�����Ϣ�����Ķ� Uber �dz���ϸ�ļ������£���ʹ�� Apache Kafka �����ɿ����ٴ��������Ŷ��С���
+
+
+
+
+
+### CrowdStrike - �����������¼��Ĵ���
+
+
+
+
+
+CrowdStrike ��һ��λ�ڵ¿���˹�ݰ�˹͡��**���簲ȫ������˾��**���ṩ**�ƹ������غͶ˵㰲ȫ����в�鱨�����繥����Ӧ����**��
+
+
+
+
+
+CrowdStrike �Ļ�����ʩ** ÿ��ʹ�� Apache Kafka ���������ڸ��¼�**�����ҵġ� Apache Kaka ���簲ȫ����ϵ�С��У��ҽ��������κι�ģʵʱ����̬�Ƹ�֪����в�鱨�����������
+
+
+
+
+
+CrowdStrike �������������ʵ�� ���ɹ�ʵ�����Ŷ��кʹ�������
+
+
+
+
+
+*   **����ȷ��ϵͳ�д洢������Ϣ**�����������ʩ�ʹ����Բ���ͼ������š�CrowdStrike ʹ�� S3 ����洢���洢DZ�ڵĴ���������Ϣ����ע�⣬Kafka �ķֲ�洢���伴�õؽ����������⣬���������洢�ӿڣ����磬���� Confluent Cloud �е����޴洢����
+*   **ʹ���Զ���**�����ù�����ʹ�޸�����һʧ����Ϊ�ֶ���ɴ��������ܷdz����׳�����
+*   **��¼ҵ�����̲�Ƹ������Ŷ�**����׼���ͼ�¼������ȷ������ʹ�á��������й���ʦ����Ϥ��֯����������Ϣ�IJ��ԡ�
+
+
+
+
+
+��**�� CrowdStrike ���������簲ȫƽ̨�У����ģʵʱ���ݴ���������Ҫ**����Ҫ��Ҳ�����ڴ�������**��һ�����繥�������ǹ���������ʵ�����Ч���ݵĶ�����Ϣ**���� JavaScript ©�����ã�����ˣ�����ͨ�����Ŷ���ʵʱ��������
+
+
+
+
+
+### ɣ̹������ - �������Ժ� DLQ ��ϵ����� 2.0
+
+
+
+
+
+ɣ̹������**������Ӧ�ó����д����������ݵ�ͬ�����ݴ������پ޴���ս**���������¼ܹ������ǵĻ����ܹ���������һ�������ҿ���չ�ļܹ�����Ϊ��Santander Mailbox 2.0����
+
+
+
+
+
+Santander �Ĺ������ز�ת�Ƶ�**�� Apache Kafka �ṩ֧�ֵ��¼���Դ**��
+
+
+
+
+
+![image-20230526225045196](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230526225045196.png)
+
+
+
+
+
+�µĻ����첽�¼��ļܹ��е�һ���ؼ���ս�Ǵ�������** Santander ʹ�����Ժ� DQL Kafka ���⹹���Ĵ�����**�������Щ���⣺
+
+
+
+
+
+![image-20230526225057151](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/image-20230526225057151.png)
+
+
+
+
+
+�鿴���� Santander �ļ��ɺ������ Consdata�� Kafka ����ݽ����������Բ��Ժ���������� Apache Kafka �еĿɿ��¼����ݡ��е���ϸ��Ϣ��
+
+
+
+
+
+### Apache Kafka �пɿ��ҿ���չ�Ĵ�����
+
+
+
+
+
+**���������ڹ����ɿ����������ܵ���ƽ̨������Ҫ**�����ڲ�ͬ��������������������⡣�ý�������������Ŷ��е��Զ���ʵ�ֻ���������ʹ�õĿ�ܣ����� Kafka Streams��Kafka Connect��Spring ��ܻ� Kafka �IJ��������ߡ�
+
+
+
+
+
+�Ų���CrowdStrike ��ɣ̹�����еİ����о��������������������Ǻ�����ʵ�֡���������µ�Ӧ�ó����ܹ�ʱ����Ҫ��һ��ʼ�Ϳ��ǵ���һ�㡣**ʹ�� Apache Kafka ����ʵʱ�����������������������ֻ�������ܹ�����������Ϊʱ���ܳɹ�**�����Ŷ��������ೡ���ľ���ѡ��
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index 2cca927..a91c75e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -7,15 +7,77 @@
     <groupId>groupId</groupId>
     <artifactId>JavaTutorial</artifactId>
     <version>1.0-SNAPSHOT</version>
-
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.0.5</version>
+        <relativePath/>
+        <!-- lookup parent from repository -->
+    </parent>
 
     <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>com.github.houbb</groupId>
             <artifactId>markdown-toc</artifactId>
             <version>1.0.6</version>
         </dependency>
+        <!--对分词索引查询解析-->
+        <dependency>
+            <groupId>org.apache.lucene</groupId>
+            <artifactId>lucene-queryparser</artifactId>
+            <version>7.1.0</version>
+        </dependency>
+        <!--高亮 -->
+        <dependency>
+            <groupId>org.apache.lucene</groupId>
+            <artifactId>lucene-highlighter</artifactId>
+            <version>7.1.0</version>
+        </dependency>
+        <!--smartcn 中文分词器 SmartChineseAnalyzer  smartcn分词器 需要lucene依赖 且和lucene版本同步-->
+        <dependency>
+            <groupId>org.apache.lucene</groupId>
+            <artifactId>lucene-analyzers-smartcn</artifactId>
+            <version>7.1.0</version>
+        </dependency>
+        <!--ik-analyzer 中文分词器-->
+        <dependency>
+            <groupId>cn.bestwu</groupId>
+            <artifactId>ik-analyzers</artifactId>
+            <version>5.1.0</version>
+        </dependency> <!--MMSeg4j 分词器-->
+        <dependency>
+            <groupId>com.chenlb.mmseg4j</groupId>
+            <artifactId>mmseg4j-solr</artifactId>
+            <version>2.4.0</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.apache.solr</groupId>
+                    <artifactId>solr-core</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
     </dependencies>
 
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
 
 </project>
\ No newline at end of file
diff --git a/src/main/java/Test.java b/src/main/java/Test.java
new file mode 100644
index 0000000..269694c
--- /dev/null
+++ b/src/main/java/Test.java
@@ -0,0 +1,22 @@
+import org.springframework.beans.factory.annotation.Lookup;
+import org.springframework.stereotype.Service;
+
+/**
+ * @author hpl
+ * @date 2023/4/15 14:40
+ */
+@Service
+public class Test {
+
+
+
+
+    public static void main(String[] args) {
+
+    }
+
+
+    public void test(){
+
+    }
+}
diff --git a/src/main/java/md/AtxMarkdownTocFileTest.java b/src/main/java/md/AtxMarkdownTocFileTest.java
deleted file mode 100644
index 531617d..0000000
--- a/src/main/java/md/AtxMarkdownTocFileTest.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package md;
-
-public class AtxMarkdownTocFileTest {
-}
diff --git a/src/main/java/md/codeFormat.java b/src/main/java/md/codeFormat.java
new file mode 100644
index 0000000..19f22c0
--- /dev/null
+++ b/src/main/java/md/codeFormat.java
@@ -0,0 +1,9 @@
+package md;
+
+/**
+ * @author hpl
+ * @date 2023/4/7 21:17
+ */
+public class codeFormat {
+    //
+}
diff --git a/src/main/java/md/mdToc.java b/src/main/java/md/mdToc.java
index 3650a29..2fb42bd 100644
--- a/src/main/java/md/mdToc.java
+++ b/src/main/java/md/mdToc.java
@@ -4,7 +4,7 @@
 
 public class mdToc {
     public static void main(String[] args) {
-        String path = "D:\\javaTutorial\\docs\\distrubuted\\practice\\";
+        String path = "D:\\idea_project\\JavaTutorial\\docs\\java-web\\temp";
         AtxMarkdownToc.newInstance().genTocDir(path);
     }
 }
diff --git "a/\345\217\202\350\200\203.md" "b/\345\217\202\350\200\203.md"
deleted file mode 100644
index 8b13789..0000000
--- "a/\345\217\202\350\200\203.md"
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git "a/\346\234\200\347\273\210\346\225\210\346\236\234.md" "b/\346\234\200\347\273\210\346\225\210\346\236\234.md"
deleted file mode 100644
index dc34623..0000000
--- "a/\346\234\200\347\273\210\346\225\210\346\236\234.md"
+++ /dev/null
@@ -1,162 +0,0 @@
-点击订阅[Java面试进阶指南](https://xiaozhuanlan.com/java-coder)(专为Java面试方向准备)
-
-
-## 目录
-
-- [Java](#Java)
-    - [基础](#基础)
-    - [容器](#容器)
-    - [并发](#并发)
-    - [JVM](#jvm)
-    - [Java网络编程](#Java网络编程)
-    - [设计模式](#设计模式)
-- [JavaWeb](#JavaWeb)
-    - [Maven](#Maven)
-    - [Srping](#Srping)
-    - [SpringMVC](#SpringMVC)
-    - [SpringBoot](#SpringBoot)
-- [计算机网络](#计算机网络)
-- [操作系统](#操作系统)
-    - [Linux相关](#linux相关)
-- [数据结构与算法](#数据结构与算法)
-    - [数据结构](#数据结构)
-    - [算法](#算法)
-- [数据库](#数据库)
-    - [MySQL](#mysql)
-- [缓存](#缓存)
-    - [Redis](#Redis)
-- [消息队列](#消息队列)
-    - [Kafka](#Kafka)
-- [面试指南](#面试指南)
-    - [校招指南](#校招指南)
-    - [面经](#面经)
-- [工具](#工具)
-    - [Git](#git)
-- [资料](#资料)
-    - [书单](#书单)
-- [待办](#待办)
-- [说明](#说明)
-
-## Java
-
-### 基础
-
-* [1、面向对象基础](docs/java/basic/1、面向对象基础.md)
-* [2、Java基本数据类型](docs/java/basic/2、Java基本数据类型.md)
-* [3、string和包装类.md](docs/java/basic/3、string和包装类.md)
-* [4、final关键字特性.md](docs/java/basic/4、final关键字特性.md)
-* [5、Java类和包.md](docs/java/basic/5、Java类和包.md)
-
-### 容器
-* [1 面向对象基础](docs/java/collection/Java集合类总结.md)
-
-
-### 并发
-* [1 面向对象基础](docs/java/currency/Java并发总结.md)
-
-
-### JVM
-* [1 面向对象基础](docs/java/jvm/JVM总结.md)
-
-
-### Java网络编程
-* [1 面向对象基础](docs/java/network-programing/Java网络与NIO总结.md)
-
-### 设计模式
-* [1 面向对象基础](docs/java/design-parttern/设计模式学习总结.md)
-
-## JavaWeb
-
-### Maven
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-### Spring
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-### SpringMVC
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-### SpringBoot
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-## 计算机网络
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-
-## 操作系统
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-### Linux相关
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-
-## 数据结构与算法
-
-### 数据结构
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-
-### 算法
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-
-## 数据库
-
-### MySQL
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-
-
-## 缓存
-
-### Redis
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-## 消息队列
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-### Kafka
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-
-
-## 面试指南
-
-### 校招指南
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-
-### 面经
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-## 工具
-
-### Git
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-## 资料
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-
-### 书单
-* [1 面向对象基础](docs/java/basic/1、面向对象基础.md)
-
-***
-
-## 待办
-
-- [x] Java集合类
-- [x] Java并发编程
-- [x] Java网络编程
-- [x] JVM
-- [x] 设计面试
-
-## 公众号
-
-- 如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。
-- 微信公众号【Java技术江湖】一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！
-- 一些Java工程师常用学习资源公众号后台回复关键字 **“Java”** 即可免费无套路获取。 
-
-<p align="center">
-<img src="https://img-blog.csdnimg.cn/20190805090108984.jpg" width=""/>
-</p>