增加了spring的学习笔记，到第五章节

修改了云平台安装环境的文档错误

前端/文档/jsdoc-vue.md

@@ -1,6 +1,7 @@
 # 1、安装cnpm和jsdoc
 
 ```shell
+npm config set registry https://registry.npm.taobao.org/
 npm install cnpm -g 
 npm install jsdoc -g
 ```
@@ -13,10 +14,84 @@ cd example
 cnpm i
 ```
 
-# 3、执行脚本生成文档
+# 3、示例
+
+```vue
+<template>
+  <div>
+    {{ message }}
+    <button @click="increment">+1</button>
+    <button @click="decrement">-1</button>
+    <button @click="showDialog(counter)">Show counter value in dialog</button>
+  </div>
+</template>
+
+<script>
+  import { mapState } from 'vuex';
+
+  /**
+   * @module better-components/BetterCounter
+   * @desc <h5>标题</h5> Author:作者 <br>Date:2022-03-20 <br>Version:1.0.0<br>版本说明
+   * @vue-prop {类型} [step=默认值] (可选) 变量名字 - 变量描述
+   * @vue-prop {Number} initialCounter 
+   * @vue-prop {Number} [step=1] Step
+   * @vue-data {Number} counter - Current counter's value
+   * @vue-computed {Array.<String>} fooList - A list of foo
+   * @vue-computed {Array.<String>} barList - A list of bar
+   * @vue-computed {String} message A message
+   */
+  export default {
+    props: {
+      initialCounter: {type: Number, required: true},
+      step: {type: Number, default: 1}
+    },
+    data() {
+      return {
+        counter: this.initialCounter
+      }
+    },
+    computed: {
+      ...mapState({
+        fooList: state => state.$_foo.fooList,
+        barList: state => state.$_foo.barList
+      }),
+      message() {
+        return `Counter: ${this.counter}`
+      }
+    },
+    methods: {
+      /**
+       * 方法描述
+       * Show a dialog displaying counter value.
+       * @param {Number} counter - Counter value
+       * @return {Number} 描述
+       */
+      showDialog(counter) {
+        alert(`Counter value is ${counter}.`);
+      }
+    },
+  };
+</script>
+
+```
+
+
+
+# 4、执行脚本生成文档
 
 ````shell
 jsdoc -c .jsdoc-tui.js -r
-yarn docs:tui
+npm run docs:tui
 ````
 
+# 5、注意事项路径不要重复，要不然会重复文档两次
+
+![image-20220907001800972](assets/image-20220907001800972.png)
+
+![image-20220907001816309](assets/image-20220907001816309.png)
+
+* SCR/ 已经包含了SRC/BETTER-COMPONENTS
+
+![image-20220907001856346](assets/image-20220907001856346.png)
+
+* 正确写法

后端/Spring/spring源码学习/spring核心编程思想/1、Spring Framework总览.md

@@ -0,0 +1,45 @@
+# 第一章：Spring Framework总览（Overview）
+
+| Spring Framework 版本 | Java 标准版 | Java 企业版           |
+| --------------------- | ----------- | --------------------- |
+| 1.x                   | 1.3+        | J2EE 1.3 +            |
+| 2.x                   | 1.4.2+      | J2EE 1.3 +            |
+| 3.x                   | 5+          | J2EE 1.4 和 Java EE 5 |
+| 4.x                   | 6+          | Java EE 6 和 7        |
+| 5.x                   | 8+          | Java EE 7             |
+
+Spring 编程模型：
+
+- 面向对象编程
+  - 契约接口：Aware、BeanPostProcessor ...
+  - 设计模式：观察者模式、组合模式、模板模式 ...
+  - 对象继承：Abstract* 类
+- 面向切面编程
+  - 动态代理：JdkDynamicAopProxy
+  - 字节码提升：ASM、CGLib、AspectJ...
+- 面向元编程
+  - 注解：模式注解（@Component、@Service、@Respository ...）
+  - 配置：Environment 抽象、PropertySources、BeanDefinition ...
+  - 泛型：GenericTypeResolver、ResolvableType ...
+- 函数驱动
+  - 函数接口：ApplicationEventPublisher
+  - Reactive：Spring WebFlux
+- 模块驱动
+  - Maven Artifacts
+  - OSGI Bundles
+  - Java 9 Automatic Modules
+  - Spring @Enable*
+
+## 面试题精讲
+
+1、什么是spring？
+
+![image-20220912204613395](assets/image-20220912204613395.png)
+
+2、spring有哪些核心模块？
+
+![image-20220912204743731](assets/image-20220912204743731.png)
+
+3、spring的优势和不足？
+
+答案暂无！！

后端/Spring/spring源码学习/spring核心编程思想/2、重新认识IoC.md

@@ -0,0 +1,55 @@
+# 第二章：重新认识 IoC
+
+IoC主要实现策略：
+
+* 依赖查找、依赖注入
+  （1）服务定位模式
+  （2）依赖注入：构造器注入、参数注入、Setter注入、接口注入
+  （3）上下文依赖查询
+  （4）模板方法设计模式
+  （5）策略设计模式
+
+IoC 容器的职责：
+
+- 通用职责
+  - 依赖处理
+    - 依赖查找
+    - 依赖注入
+  - 生命周期管理
+    - 容器
+    - 托管的资源（Java Beans 或其他资源）-- 比如说spring的事件监听，可以关联其他事件的开始或者变更
+  - 配置
+    - 容器 -- 定时任务
+    - 外部化配置 -- 属性配置，xml配置
+    - 托管的资源（Java Beans 或其他资源）-- 对线程池进行配置
+
+依赖查找和依赖注入的区别？
+
+![image-20220912214647116](assets/image-20220912214647116.png)
+
+* 依赖查找是主动或手动的依赖查找方式，通常需要依赖容器或标准 API 实现。而依赖注入则是手动或自动依赖绑定的方式，无需依赖特定的容器和API。
+
+构造器注入   vs  setter注入
+
+![image-20220912214918651](assets/image-20220912214918651.png)
+
+## 面试题
+
+1、什么是IOC？
+
+![image-20220912215825032](assets/image-20220912215825032.png)
+
+2、依赖查找和依赖注入的区别？
+
+![image-20220912220111645](assets/image-20220912220111645.png)
+
+3、Spring 作为 IoC 容器的优势：
+
+- 典型的 IoC 管理，依赖查找和依赖注入
+- AOP 抽象
+- 事务抽象
+- 事件机制
+- SPI 扩展
+- 强大的第三方整合
+- 易测试性
+- 更好的面向对象

后端/Spring/spring源码学习/spring核心编程思想/3、Spring IoC容器概述.md

@@ -0,0 +1,100 @@
+![在这里插入图片描述](assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvbmdoYW8wMDc=,size_16,color_FFFFFF,t_70#pic_center.png)
+
+# 第三章：Spring IoC 容器概述
+
+Spring IoC 依赖查找：
+
+- 根据 Bean 名称查找
+  - 实时查找
+  - 延迟查找
+- 根据 Bean 类型查找
+  - 单个 Bean 对象
+  - 集合 Bean 对象
+- 根据 Bean 名称 + 类型查找
+- 根据 Java 注解查找
+  - 单个 Bean 对象
+  - 集合 Bean 对象
+
+Spring IoC 依赖注入：
+
+- 根据 Bean 名称注入
+- 根据 Bean 类型注入
+  - 单个 Bean 对象
+  - 集合 Bean 对象
+- 注入容器內建 Bean 对象 -- 例如Environment内建bean，在初始化容器的时候就被自动注入了
+- 注入非 Bean 对象 -- 例如beanfactory，不能进行依赖查找。会报错error
+- 注入类型
+  - 实时注入
+  - 延迟注入
+
+spring ioc 依赖来源：
+
+* 自定义bean
+* 容器内建bean对象
+* 容器内建依赖
+
+spring ioc 配置元信息：
+
+* bean定义配置
+  * 基于xml文件
+  * 基于properties文件
+  * 基于java注解
+  * 基于java api
+* ioc容器配置
+  * 基于xml文件
+  * 基于java注解
+  * 基于java api
+* 外部化属性配置
+  * 基于java注解 例如@value注解
+
+
+
+延迟查找和延迟注入，使用到接口 `org.springframework.beans.factory.ObjectProvider` 和 `org.springframework.beans.factory.ObjectFactory` ，`ObjectProvider` 继承 `ObjectFactory`
+
+`BeanFactory` 和 `ApplicationContext` 谁才是 Spring IoC 容器？
+
+- `BeanFactory` 是 Spring 底层 IoC 容器
+- `ApplicationContext` 是具备应用特性的 `BeanFactory` 超集
+- `BeanFactory` 是基本的 IoC 容器，`ApplicationContext` 实现 `BeanFactory` 接口，并在内部使用 `ConfigurableListableBeanFactory` 实现接口方法。
+
+ApplicationContext 除了 IoC 容器角色，还有提供：
+
+- 面向切面（AOP）
+- 配置元信息（Configuration Metadata）
+- 资源管理（Resources）
+- 事件（Events）
+- 国际化（i18n）
+- 注解（Annotations）
+- Environment 抽象（Environment Abstraction）
+
+## ioc容器的简单启动流程
+
+1. 创建beanfactory
+2. 注册内建bean依赖和内建非bean依赖
+3. beanfactory扩展，可以扩展或者添加自定义的bean
+4. 对bean的修改或者扩展
+5. 国际化准备
+6. 应用事件的广播
+7. 事件监听器
+8. 注册应用上下文
+9. 结束启动
+
+## ioc容器停止
+
+1. 关闭bean
+2. 销毁bean工厂
+3. 子类进行下一步操作
+
+# 面试题
+
+1、什么是ioc容器
+
+![image-20220914223626948](assets/image-20220914223626948.png)
+
+2、beanfactory和factorybean的区别？
+
+![image-20220914224020512](assets/image-20220914224020512.png)
+
+3、springioc容器启动时做了哪些准备？
+
+![image-20220914224446817](assets/image-20220914224446817.png)

后端/Spring/spring源码学习/spring核心编程思想/4、Spring Bean 基础.md

@@ -0,0 +1,92 @@
+# 第四章：Spring Bean 基础
+
+## 什么是 `BeanDefinition`？
+
+- `org.springframework.beans.factory.config.BeanDefinition`
+- **BeanDefinition**是 Spring Framework 中定义 Bean 的配置元信息接口，包含：
+  - Bean 的类名
+  - Bean 行为配置元素，如作用域、自动绑定的模式（Autowired），生命周期回调等
+  - 其他 Bean 引用，又可称作合作者（collaborators）或者依赖（dependencies）
+  - 配置设置，比如 Bean 属性（Properties）
+- BeanDefinition 构建
+  - 通过 `BeanDefinitionBuilder`
+  - 通过 `AbstractBeanDefinition` 以及派生类
+
+Bean 名称生成器：`org.springframework.beans.factory.support.BeanNameGenerator`
+
+![image-20220919202012564](assets/image-20220919202012564.png)
+
+![image-20220919203842268](assets/image-20220919203842268.png)
+
+* **多个上下文不唯一**
+
+![image-20220919210150247](assets/image-20220919210150247.png)
+
+## 注册 Spring Bean：
+
+- BeanDefinition 注册
+  - XML 配置元信息
+    - `<bean name="..." ... />`
+  - Java 注解配置元信息
+    - `@Bean`
+    - `@Component`
+    - `@Import`
+  - Java API 配置元信息
+    - 命名方式：`BeanDefinitionRegistry#registerBeanDefinition(String,BeanDefinition)`
+    - 非命名方式：`BeanDefinitionReaderUtils#registerWithGeneratedName(AbstractBeanDefinition,Be`
+      `anDefinitionRegistry)`
+    - 配置类方式：`AnnotatedBeanDefinitionReader#register(Class...)`
+- 外部单例对象注册
+  - Java API 配置元信息
+    - `SingletonBeanRegistry#registerSingleton`
+
+Bean 实例化（Instantiation）
+
+- 常规方式
+  - 通过构造器（配置元信息：XML、Java 注解和 Java API ）
+  - 通过静态工厂方法（配置元信息：XML 和 Java API ）
+  - 通过 Bean 工厂方法（配置元信息：XML和 Java API ）
+  - 通过 `FactoryBean`（配置元信息：XML、Java 注解和 Java API ）
+- 特殊方式
+  - 通过 `ServiceLoaderFactoryBean`（配置元信息：XML、Java 注解和 Java API ）
+  - 通过 `AutowireCapableBeanFactory#createBean(java.lang.Class, int, boolean)`
+  - 通过 `BeanDefinitionRegistry#registerBeanDefinition(String,BeanDefinition)`
+
+## Bean 初始化（Initialization），同时存在时，顺序从上到下：
+
+- `@PostConstruct` 标注方法
+- 实现 `InitializingBean` 接口的 `afterPropertiesSet()` 方法
+- 自定义初始化方法（**BeanDefinition**）
+  - XML 配置：`<bean init-method=”init” ... />`
+  - Java 注解：`@Bean(initMethod=”init”)`
+  - Java API：`AbstractBeanDefinition#setInitMethodName(String)`
+
+Bean 延迟初始化（Lazy Initialization）
+
+- XML 配置：`<bean lazy-init=”true” ... />`
+- Java 注解：`@Lazy(true)`
+
+Bean 销毁（Destroy），同时存在时，顺序从上到下：
+
+- `@PreDestroy` 标注方法
+- 实现 `DisposableBean` 接口的 `destroy()` 方法
+- 自定义销毁方法
+  - XML 配置：`<bean destroy=”destroy” ... />`
+  - Java 注解：`@Bean(destroy=”destroy”)`
+  - Java API：`AbstractBeanDefinition#setDestroyMethodName(String)`
+
+![image-20220921220443149](assets/image-20220921220443149.png)
+
+## 面试题精选
+
+1、如何注册一个spring bean？
+
+![image-20220921221826319](assets/image-20220921221826319.png)
+
+2、什么是spring beandefinition？
+
+代码
+
+3、spring容器是如何管理注册bean？
+
+![image-20220921224726723](assets/image-20220921224726723.png)

后端/Spring/spring源码学习/spring核心编程思想/5、Spring IoC依赖查找.md

@@ -0,0 +1,120 @@
+## 第五章：Spring IoC 依赖查找
+
+![image-20220925160506656](assets/image-20220925160506656.png)
+
+## 单一类型依赖查找接口 - `BeanFactory`
+
+- 根据 Bean 名称查找
+  - `getBean(String)`
+  - Spring 2.5 覆盖默认参数：`getBean(String,Object...)`
+- 根据 Bean 类型查找
+  - Bean 实时查找
+    - Spring 3.0 ： `getBean(Class)`
+    - Spring 4.1 覆盖默认参数：`getBean(Class,Object...)`
+  - Spring 5.1 Bean 延迟查找
+    - `getBeanProvider(Class)`
+    - `getBeanProvider(ResolvableType)`
+- 根据 Bean 名称 + 类型查找：`getBean(String,Class)`
+
+## 集合类型依赖查找接口 - `ListableBeanFactory`
+
+- 根据 Bean 类型查找
+  - 获取同类型 Bean 名称列表
+    - `getBeanNamesForType(Class)`
+    - Spring 4.2 `getBeanNamesForType(ResolvableType)`
+  - 获取同类型 Bean 实例列表
+    - `getBeansOfType(Class)` 以及重载方法
+
+```
+注意通过bean类型进行查找可以会导致bean提前初始化，因为可能需要bean的元信息进行比较。
+```
+
+- 通过注解类型查找
+  - Spring 3.0 获取标注类型 Bean 名称列表
+    - `getBeanNamesForAnnotation(Class<? extends Annotation>)`
+  - Spring 3.0 获取标注类型 Bean 实例列表
+    - `getBeansWithAnnotation(Class<? extends Annotation>)`
+  - Spring 3.0 获取指定名称 + 标注类型 Bean 实例
+    - `findAnnotationOnBean(String,Class<? extends Annotation>)`
+
+## 层次性依赖查找接口 - `HierarchicalBeanFactory`
+
+- 双亲 BeanFactory：`getParentBeanFactory()`
+- 层次性查找
+  - 根据 Bean 名称查找 -- 官方没有
+    - 基于 `containsLocalBean` 方法实现
+  - 根据 Bean 类型查找实例列表
+    - 单一类型：`BeanFactoryUtils#beanOfType`
+    - 集合类型：`BeanFactoryUtils#beansOfTypeIncludingAncestors`
+  - 根据 Java 注解查找名称列表
+    - `BeanFactoryUtils#beanNamesForTypeIncludingAncestors`
+
+## Bean 延迟依赖查找接口
+
+- **org.springframework.beans.factory.ObjectFactory**
+- **org.springframework.beans.factory.ObjectProvider**
+  - Spring 5 对 Java 8 特性扩展
+    - 函数式接口
+      - `getIfAvailable(Supplier)`
+      - `ifAvailable(Consumer)`
+    - Stream 扩展 - `stream()`
+
+## 依赖查找安全性对比：
+
+| 依赖查找类型 | 代表实现                             | 是否安全 |
+| ------------ | ------------------------------------ | -------- |
+| 单一类型查找 | `BeanFactory#getBean`                | 否       |
+|              | `ObjectFactory#getObject`            | 否       |
+|              | `ObjectProvider#getIfAvailable`      | 是       |
+| 集合类型查找 | `ListableBeanFactory#getBeansOfType` | 是       |
+|              | `ObjectProvider#stream`              | 是       |
+
+注意：层次性依赖查找的安全性取决于其扩展的单一或集合类型的 BeanFactory 接口
+
+## AbstractApplicationContext 内建可查找的依赖
+
+| Bean 名称                   | Bean 实例                         | 使用场景                |
+| --------------------------- | --------------------------------- | ----------------------- |
+| environment                 | Environment 对象                  | 外部化配置以及 Profiles |
+| systemProperties            | java.util.Properties 对象         | Java 系统属性           |
+| systemEnvironment           | java.util.Map 对象                | 操作系统环境变量        |
+| messageSource               | MessageSource 对象                | 国际化文案              |
+| lifecycleProcessor          | LifecycleProcessor 对象           | Lifecycle Bean 处理器   |
+| applicationEventMulticaster | ApplicationEventMulticaster 对 象 | Spring 事件广播器       |
+
+## 注解驱动 Spring 应用上下文内建可查找的依赖
+
+| Bean 名称                                                    | Bean 实例                                   | 使用场景                                              |
+| ------------------------------------------------------------ | ------------------------------------------- | ----------------------------------------------------- |
+| org.springframework.context.annotation.internalConfigurationAnnotationProcessor | ConfigurationClassPostProcesso              | 处理 Spring 配置类                                    |
+| org.springframework.context.annotation.internalAutowiredAnnotationProcessor | AutowiredAnnotationBeanPostProcessor 对象   | 处理 @Autowired 以及 @Value 注解                      |
+| org.springframework.context.annotation.internalCommonAnnotationProcessor | CommonAnnotationBeanPostProcessor 对象      | （条件激活）处理 JSR-250 注解，如 @PostConstruct 等   |
+| org.springframework.context.event.internalEventListenerProcessor | EventListenerMethodProcessor 对象           | 处理标注 @EventListener 的 Spring 事件监听方法        |
+| org.springframework.context.event.internalEventListenerFactory | DefaultEventListenerFactory 对象            | @EventListener 事件监听方法适配为 ApplicationListener |
+| org.springframework.context.annotation.internalPersistenceAnnotationProcessor | PersistenceAnnotationBeanPostProcessor 对象 | （条件激活）处理 JPA 注解场景                         |
+
+## 依赖查找中的经典异常，`BeansException` 子类型
+
+| 异常类型                        | 触发条件（举例）                                    | 场景举例                   |
+| ------------------------------- | --------------------------------------------------- | -------------------------- |
+| NoSuchBeanDefinitionException   | 当查找 Bean 不存在于 IoC 容器时 BeanFactory#getBean | ObjectFactory#getObject    |
+| NoUniqueBeanDefinitionException | 类型依赖查找时，IoC 容器存在多个 Bean 实例          | BeanFactory#getBean(Class) |
+| BeanInstantiationException      | 当 Bean 所对应的类型非具体类时                      | BeanFactory#getBean        |
+| BeanCreationException           | 当 Bean 初始化过程中                                | Bean 初始化方法执行异常时  |
+| BeanDefinitionStoreException    | 当 BeanDefinition 配置元信息非法时                  | XML 配置资源无法打开时     |
+
+`BeanFactory.getBean` 方法的执行是**线程安全**的，超过过程中会增加互斥锁
+
+## 面试题
+
+1、ObjectFatory和BeanFactory的区别？
+
+![image-20220925213759430](assets/image-20220925213759430.png)
+
+2、BeanFactory.getBean操作是否线程安全？
+
+![image-20220925214623437](assets/image-20220925214623437.png)
+
+3、Spring依赖查找与注入在来源上面的区别？
+
+![image-20220925214906669](assets/image-20220925214906669.png)

部署文档/云平台/安装云平台环境.md

@@ -444,6 +444,7 @@ spec:
       containers:
         - name: nfs-client-provisioner
           image: quay.io/external_storage/nfs-client-provisioner:latest ##默认是latest版本
+          imagePullPolicy: Never ## 这里选择从本地拉取
           volumeMounts:
             - name: nfs-client-root
               mountPath: /persistentvolumes
@@ -730,6 +731,6 @@ systemctl daemon-reload && systemctl restart docker
 | docker         | 19.03.7 |
 | docker-compose | 2.1.0   |
 | Harbor         | 2.1.5   |
-| kubernetes,    | 1.19.0  |
+| kubernetes     | 1.19.0  |
 | kubesphere     | 3.1.1   |