java & spring review2

2026-04-13 18:00:27 +08:00 · 2022-11-10 06:43:32 +08:00
parent 31d3f66efa
commit 839a769b9f
60 changed files with 1695 additions and 206 deletions
--- a/idea教程.md
+++ b/idea教程.md
@@ -21,11 +21,16 @@

 ### 工程组织
 > file-project structure。command+;
-* project整个工程，可以直接添加代码，也可以创建模块后，添加代码。
-* module大型项目可以分为很多模块，相互间彼此依赖。先删除模块，再删除模块中的文件。
-* Libraries 项目以来的jar包或者第三方库
-* facet
-* artifact
+* Project整个工程，可以直接添加代码，也可以创建模块后，添加代码。能够配置sdk的版本。
+![](image/2022-11-09-16-49-29.png)
+* Module大型项目可以分为很多模块，相互间彼此依赖。先删除模块，再删除模块中的文件。与Facets对应
+![](image/2022-11-09-16-49-58.png)
+* Libraries 项目以来的jar包或者第三方库。
+![](image/2022-11-09-16-50-42.png)
+* Facets 英文翻译为：方面，（事务的）面。表述了在Module中使用的各种各样的框架、技术和语言。这些Facets让IDEA知道怎么对待module内容，并保证与相应的框架和语言保持一致。
+![](image/2022-11-09-16-52-30.png)
+* Artifacts 英文翻译为：人工产品。是一个项目资源的组合体。例如，一个已编译的java类的集合，一个已打包的java应用。这里可以理解为Maven中的artifactId，成果产物ID，他可以是一个jar或是一个war。
+![](image/2022-11-09-16-53-54.png)

 ### preference设置
 * 外观和行为
--- a/Idea/image/2022-11-09-16-49-29.png
+++ b/Idea/image/2022-11-09-16-49-29.png
--- a/Idea/image/2022-11-09-16-49-58.png
+++ b/Idea/image/2022-11-09-16-49-58.png
--- a/Idea/image/2022-11-09-16-50-42.png
+++ b/Idea/image/2022-11-09-16-50-42.png
--- a/Idea/image/2022-11-09-16-52-30.png
+++ b/Idea/image/2022-11-09-16-52-30.png
--- a/Idea/image/2022-11-09-16-53-54.png
+++ b/Idea/image/2022-11-09-16-53-54.png
--- a/Java基础教程/JDK学习/22
+++ b/Java基础教程/JDK学习/22
--- a/Java三方库/fastjson.md
+++ b/Java三方库/fastjson.md
@@ -0,0 +1,65 @@
+
+两种类型之间转换。
+Java对象和json格式之间转换。
+
+* 序列化：转换成json格式
+  * json字符串
+  * json字节码
+* 反序列化：转换成java格式
+  * java对象
+  * jsonobject如果没有指定java对象
+
+
+
+## 序列化
+
+
+
+```java
+package com.alibaba.fastjson;
+
+public abstract class JSON {
+    // 将Java对象序列化为JSON字符串，支持各种各种Java基本类型和JavaBean
+    public static String toJSONString(Object object, SerializerFeature... features);
+
+    // 将Java对象序列化为JSON字符串，返回JSON字符串的utf-8 bytes
+    public static byte[] toJSONBytes(Object object, SerializerFeature... features);
+
+    // 将Java对象序列化为JSON字符串，写入到Writer中
+    public static void writeJSONString(Writer writer, 
+                                       Object object, 
+                                       SerializerFeature... features);
+
+    // 将Java对象序列化为JSON字符串，按UTF-8编码写入到OutputStream中
+    public static final int writeJSONString(OutputStream os,
+                                            Object object,
+                                            SerializerFeature... features);
+}
+```
+
+
+## 反序列化
+
+```
+package com.alibaba.fastjson;
+
+public abstract class JSON {
+    // 将JSON字符串反序列化为JavaBean
+    public static <T> T parseObject(String jsonStr, 
+                                    Class<T> clazz, 
+                                    Feature... features);
+
+    // 将JSON字符串反序列化为JavaBean
+    public static <T> T parseObject(byte[] jsonBytes,  // UTF-8格式的JSON字符串
+                                    Class<T> clazz, 
+                                    Feature... features);
+
+    // 将JSON字符串反序列化为泛型类型的JavaBean
+    public static <T> T parseObject(String text, 
+                                    TypeReference<T> type, 
+                                    Feature... features);
+
+    // 将JSON字符串反序列为JSONObject
+    public static JSONObject parseObject(String text);
+}
+```
--- a/Java基础教程/JVM原理/Java
+++ b/Java基础教程/JVM原理/Java
@@ -30,6 +30,9 @@
 <!-- GFM-TOC -->


+十四、Java 虚拟机Java 内存结构堆栈垃圾回收JVM 内存区域Java 虚拟机栈class 文件字节码指令JVM 参数调优Java 对象模型HotSpot类加载机制编译和反编译反编译工具（javap）JIT虚拟机性能监控和故障处理工具（jps、jstack、jmap、jstat、jconsole、javap）
+https://link.zhihu.com/?target=https%3A//www.bilibili.com/video/BV1DJ411B7cG%3Ffrom%3Dsearch%26seid%3D1705641531822657605
+
 本文大部分内容参考   **周志明《深入理解 Java 虚拟机》**  ，想要深入学习的话请看原书。

 ## 一、运行时数据区域
--- a/Java基础教程/Java标准库/01
+++ b/Java基础教程/Java标准库/01
--- a/Java基础教程/Java标准库/02
+++ b/Java基础教程/Java标准库/02
--- a/Java基础教程/Java标准库/03
+++ b/Java基础教程/Java标准库/03
--- a/Java基础教程/Java标准库/04
+++ b/Java基础教程/Java标准库/04
--- a/Java基础教程/Java标准库/05
+++ b/Java基础教程/Java标准库/05
--- a/Java基础教程/Java标准库/06
+++ b/Java基础教程/Java标准库/06
--- a/Java基础教程/Java标准库/07
+++ b/Java基础教程/Java标准库/07
--- a/Java基础教程/Java标准库/09
+++ b/Java基础教程/Java标准库/09
@@ -39,6 +39,7 @@
  - [八、参考资料](#八参考资料)
 <!-- GFM-TOC -->

+十二、Java 字节流Java IO 流简介Java InputStreamJava OutputStreamJava FileInputStreamJava FileOutputStreamJava ByteArrayInputStreamJava ByteArrayOutputStreamJava ObjectInputStreamJava ObjectOutputStreamJava BufferedInputStreamJava BufferedOutputStreamJava PrintStream十三、Java 字符流Java ReaderJava WriterJava InputStreamReaderJava OutputStreamWriterJava FileReaderJava FileWriterJava BufferedReaderJava BufferedWriterJava StringWriterJava PrintWriter

 ## 一、概览
 ![](image/2022-07-12-11-35-43.png)
--- a/Java基础教程/Java标准库/10
+++ b/Java基础教程/Java标准库/10
@@ -0,0 +1,31 @@
+
+数据结构分为
+
+* 线性数据结构
+* 树型数据结构
+* 图型数据结构
+
+
+C++中的容器分为（都是线性的）
+* 顺序容器
+  * array 数组
+  * vector向量
+  * list 链表
+* 关联容器
+  * map 映射
+  * set 集合
+* 容器适配器
+  * stack 栈
+  * queue 队列
+
+
+Java中的容器分为（都是线性的）
+* 集合collection
+  * List
+  * Queue
+  * Map
+  * Set
+
+![](image/2022-11-08-10-51-54.png)
+
+![](image/2022-11-08-10-54-19.png)
--- a/Java基础教程/Java标准库/11
+++ b/Java基础教程/Java标准库/11
--- a/Java基础教程/Java标准库/12
+++ b/Java基础教程/Java标准库/12
--- a/Java基础教程/Java标准库/13
+++ b/Java基础教程/Java标准库/13
--- a/Java基础教程/Java标准库/14
+++ b/Java基础教程/Java标准库/14
--- a/Java基础教程/Java标准库/15
+++ b/Java基础教程/Java标准库/15
--- a/Java基础教程/Java标准库/20
+++ b/Java基础教程/Java标准库/20
--- a/Java基础教程/Java标准库/30
+++ b/Java基础教程/Java标准库/30
--- a/Java基础教程/Java标准库/40
+++ b/Java基础教程/Java标准库/40
--- a/Java基础教程/Java语言基础/18
+++ b/Java基础教程/Java语言基础/18
--- a/Java基础教程/Java标准库/Arrays类.md
+++ b/Java基础教程/Java标准库/Arrays类.md
--- a/Java基础教程/Java标准库/image/2022-11-08-10-51-54.png
+++ b/Java基础教程/Java标准库/image/2022-11-08-10-51-54.png
--- a/Java基础教程/Java标准库/image/2022-11-08-10-54-19.png
+++ b/Java基础教程/Java标准库/image/2022-11-08-10-54-19.png
--- a/Java基础教程/Java语言基础/01
+++ b/Java基础教程/Java语言基础/01
@@ -45,6 +45,9 @@

 ## 0 引言

+> 本笔记主要介绍java提供的语言级别的支持，不包括标准库的内容。
+
+
 ### Java特性和优势

 > write once run anywhere
--- a/Java基础教程/Java语言基础/02
+++ b/Java基础教程/Java语言基础/02
@@ -1,4 +1,19 @@
-
+- [流程控制](#流程控制)
+  - [1 顺序结构](#1-顺序结构)
+  - [2 选择结构](#2-选择结构)
+    - [if单选结构](#if单选结构)
+    - [if-else结构](#if-else结构)
+    - [if-else嵌套](#if-else嵌套)
+    - [switch](#switch)
+  - [3 循环结构](#3-循环结构)
+    - [while](#while)
+    - [do…while 循环](#dowhile-循环)
+    - [for循环](#for循环)
+    - [增强 for 循环](#增强-for-循环)
+  - [4 break&continue](#4-breakcontinue)
+    - [break 关键字](#break-关键字)
+    - [continue 关键字](#continue-关键字)
+# 流程控制
 ## 1 顺序结构
 1. java的基本结构
 ![](image/2022-07-10-18-27-47.png)
--- a/Java基础教程/Java语言基础/03
+++ b/Java基础教程/Java语言基础/03
@@ -1,3 +1,20 @@
+- [函数方法](#函数方法)
+  - [1 概述](#1-概述)
+    - [方法定义](#方法定义)
+    - [方法优点](#方法优点)
+    - [使用规则](#使用规则)
+  - [2 方法实现](#2-方法实现)
+    - [方法定义](#方法定义-1)
+    - [方法调用](#方法调用)
+    - [void关键字](#void关键字)
+    - [参数传递](#参数传递)
+  - [3 高级用法](#3-高级用法)
+    - [构造方法](#构造方法)
+    - [finalize()方法](#finalize方法)
+    - [方法重载](#方法重载)
+    - [可变参数](#可变参数)
+    - [命令行传参](#命令行传参)
+# 函数方法
 ## 1 概述

 ### 方法定义
--- a/Java基础教程/Java语言基础/04
+++ b/Java基础教程/Java语言基础/04
@@ -1,3 +1,14 @@
+- [Java 数组](#java-数组)
+  - [1 概述](#1-概述)
+    - [概念](#概念)
+    - [数组声明](#数组声明)
+    - [数组定义](#数组定义)
+    - [数组遍历](#数组遍历)
+    - [数组参数](#数组参数)
+    - [数组返回值](#数组返回值)
+    - [多维数组](#多维数组)
+    - [Arrays类](#arrays类)
+# Java 数组
 ## 1 概述

 ### 概念
--- a/Java基础教程/Java语言基础/05
+++ b/Java基础教程/Java语言基础/05
@@ -1,3 +1,26 @@
+- [类与对象](#类与对象)
+  - [1 基本内容](#1-基本内容)
+    - [类的定义](#类的定义)
+    - [五种成分](#五种成分)
+    - [访问权限修饰符](#访问权限修饰符)
+  - [2 成员变量Field](#2-成员变量field)
+    - [变量类型](#变量类型)
+    - [成员变量](#成员变量)
+  - [3 成员方法Method](#3-成员方法method)
+  - [4 构造方法Constructor](#4-构造方法constructor)
+    - [构造方法](#构造方法)
+    - [对象创建](#对象创建)
+    - [访问对象](#访问对象)
+  - [5 代码块CodeBlock](#5-代码块codeblock)
+    - [静态代码块](#静态代码块)
+    - [实例代码块](#实例代码块)
+  - [6 内部类InnerClass](#6-内部类innerclass)
+  - [7 关键字](#7-关键字)
+    - [final](#final)
+    - [this](#this)
+    - [super](#super)
+    - [static](#static)
+    - [instanceof](#instanceof)
 # 类与对象
 ## 1 基本内容
 > 建模全宇宙，用有限的代码描述无限的世界
@@ -154,7 +177,7 @@ referenceVariable.methodName();
 ```


-## 5 代码块
+## 5 代码块CodeBlock

 ### 静态代码块

@@ -249,7 +272,7 @@ public class DaimaKuaiDemo02 {
 // 输出三次：实例代码块执行
 ```

-## 6 内部类
+## 6 内部类InnerClass
 > 见内部类部分

 ## 7 关键字
--- a/Java基础教程/Java语言基础/06
+++ b/Java基础教程/Java语言基础/06
@@ -1,3 +1,12 @@
+- [面相对象的三大特征](#面相对象的三大特征)
+  - [1封装](#1封装)
+  - [2 继承](#2-继承)
+  - [3 多态](#3-多态)
+  - [4 重写、重载、重定义](#4-重写重载重定义)
+    - [定义](#定义)
+    - [重写的原则](#重写的原则)
+    - [与重载的区别](#与重载的区别)
+    - [方法访问的优先级](#方法访问的优先级)
 # 面相对象的三大特征
 ## 1封装
 高内聚、低耦合。属性私有。
--- a/Java基础教程/Java语言基础/07
+++ b/Java基础教程/Java语言基础/07
@@ -1,4 +1,10 @@
-
+- [接口与抽象类](#接口与抽象类)
+  - [1 抽象类](#1-抽象类)
+  - [2 接口](#2-接口)
+  - [3 对比](#3-对比)
+    - [抽象类和接口比较](#抽象类和接口比较)
+    - [抽象类和接口选择](#抽象类和接口选择)
+# 接口与抽象类
 ## 1 抽象类


@@ -71,7 +77,7 @@ public class InterfaceImplementExample implements InterfaceExample {
 }
 ```

-
+## 3 对比
 ### 抽象类和接口比较  

 - 从设计层面上看，抽象类提供了一种 IS-A 关系，需要满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
--- a/Java基础教程/Java语言基础/08
+++ b/Java基础教程/Java语言基础/08
@@ -1,3 +1,21 @@
+- [Java 内部类](#java-内部类)
+	- [1 概述](#1-概述)
+		- [基本概念](#基本概念)
+		- [基本作用](#基本作用)
+	- [2 使用](#2-使用)
+		- [成员内部类](#成员内部类)
+		- [静态内部类](#静态内部类)
+		- [局部内部类](#局部内部类)
+		- [匿名内部类](#匿名内部类)
+		- [一次输出ABC的答案](#一次输出abc的答案)
+		- [重名变量的引用](#重名变量的引用)
+	- [3 原理](#3-原理)
+		- [成员内部类无条件访问外部类的私有变量](#成员内部类无条件访问外部类的私有变量)
+		- [局部内部类和匿名内部类只能访问局部final变量](#局部内部类和匿名内部类只能访问局部final变量)
+		- [静态内部类有特殊的地方吗？](#静态内部类有特殊的地方吗)
+	- [4 常见的与内部类相关的笔试面试题](#4-常见的与内部类相关的笔试面试题)
+		- [根据注释填写(1)，(2)，(3)处的代码](#根据注释填写123处的代码)
+		- [下面这段代码的输出结果是什么？](#下面这段代码的输出结果是什么)
 # Java 内部类

 ## 1 概述
--- a/Java基础教程/Java语言基础/09
+++ b/Java基础教程/Java语言基础/09
@@ -1,4 +1,20 @@
+- [反射机制](#反射机制)
+  - [1 反射概述](#1-反射概述)
+    - [反射机制的作用](#反射机制的作用)
+    - [Class对象](#class对象)
+    - [反射机制的使用](#反射机制的使用)
+    - [反射机制的优点](#反射机制的优点)
+    - [反射的缺点](#反射的缺点)
+    - [反射机制的使用](#反射机制的使用-1)
+  - [2 反射机制实现](#2-反射机制实现)
+    - [Class 中的方法](#class-中的方法)
+    - [Field中的方法](#field中的方法)
+    - [Method中的方法](#method中的方法)
+    - [Constructor中的方法](#constructor中的方法)
+    - [获取一个类的父类以及实现的接口](#获取一个类的父类以及实现的接口)

+
+# 反射机制
 - [深入解析 Java 反射（1）- 基础](http://www.sczyh30.com/posts/Java/java-reflection-1/)
 - [Java反射超详细，一个快乐的野指针](https://blog.csdn.net/qq_44715943/article/details/120587716)
 ## 1 反射概述
--- a/Java基础教程/Java语言基础/10
+++ b/Java基础教程/Java语言基础/10
@@ -1,3 +1,22 @@
+- [泛型机制](#泛型机制)
+  - [1 泛型概述](#1-泛型概述)
+    - [基本概念](#基本概念)
+    - [泛型的基本用法](#泛型的基本用法)
+  - [2 优势](#2-优势)
+    - [安全性](#安全性)
+    - [消除强制转换](#消除强制转换)
+    - [避免了不必要的装箱、拆箱操作，提高程序的性能](#避免了不必要的装箱拆箱操作提高程序的性能)
+    - [提高了代码的重用行](#提高了代码的重用行)
+  - [3 泛型的使用](#3-泛型的使用)
+    - [泛型类](#泛型类)
+    - [泛型接口](#泛型接口)
+    - [泛型方法](#泛型方法)
+  - [4 泛型通配符](#4-泛型通配符)
+  - [5 泛型中的KTVE](#5-泛型中的ktve)
+  - [6 泛型的实现原理](#6-泛型的实现原理)
+
+
+# 泛型机制
 > [Java 泛型详解](https://blog.csdn.net/ChenRui_yz/article/details/122935621)
 ## 1 泛型概述

--- a/Java基础教程/Java语言基础/11
+++ b/Java基础教程/Java语言基础/11
@@ -1,4 +1,25 @@
-## 1 异常机制
+- [1 异常处理机制](#1-异常处理机制)
+  - [异常与错误](#异常与错误)
+  - [异常的产生](#异常的产生)
+  - [异常的层次](#异常的层次)
+- [2 异常使用](#2-异常使用)
+  - [异常处理机制的关键字](#异常处理机制的关键字)
+  - [异常类中的方法](#异常类中的方法)
+  - [捕获异常](#捕获异常)
+  - [多重捕获结构](#多重捕获结构)
+  - [throws/throw 抛出异常](#throwsthrow-抛出异常)
+  - [finally关键字](#finally关键字)
+  - [try-with-resources](#try-with-resources)
+- [3 自定义异常](#3-自定义异常)
+  - [自定义异常](#自定义异常)
+  - [使用自定义的异常](#使用自定义的异常)
+  - [处理自定义的异常](#处理自定义的异常)
+- [4 常见的异常](#4-常见的异常)
+  - [常见的运行时异常](#常见的运行时异常)
+  - [常见的检查性异常](#常见的检查性异常)
+
+
+## 1 异常处理机制

 ### 异常与错误
 异常是程序中的一些错误。
--- a/Java基础教程/Java语言基础/12
+++ b/Java基础教程/Java语言基础/12
@@ -1,3 +1,29 @@
+- [注解机制](#注解机制)
+  - [1 注解概述](#1-注解概述)
+    - [格式](#格式)
+    - [分类](#分类)
+    - [作用](#作用)
+    - [原理](#原理)
+  - [2 注解使用](#2-注解使用)
+    - [注解的实现原理](#注解的实现原理)
+    - [元注解](#元注解)
+    - [注解的使用步骤](#注解的使用步骤)
+    - [属性的数据类型及特别的属性：value和数组](#属性的数据类型及特别的属性value和数组)
+    - [总结](#总结)
+  - [3 JDK中的标准注解](#3-jdk中的标准注解)
+    - [@Override](#override)
+    - [@Deprecated](#deprecated)
+    - [@SuppressWarnings](#suppresswarnings)
+    - [@SafeVarargs](#safevarargs)
+    - [@FunctionalInterface](#functionalinterface)
+  - [4 Spring框架下一个注解的实现](#4-spring框架下一个注解的实现)
+    - [登录校验——定义注解](#登录校验定义注解)
+    - [登录校验——使用注解](#登录校验使用注解)
+    - [登录校验——实现注解](#登录校验实现注解)
+    - [Spring框架下的另一个实现](#spring框架下的另一个实现)
+
+
+# 注解机制
 * [Java注解是怎么实现的](https://www.zhihu.com/question/24401191)
 * [注解 Annotation 实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)
 * [Java注解](https://blog.csdn.net/D1842501760/article/details/124042500)
--- a/Java基础教程/Java语言基础/14
+++ b/Java基础教程/Java语言基础/14
--- a/Java基础教程/Java语言基础/19
+++ b/Java基础教程/Java语言基础/19
@@ -1,30 +0,0 @@
-下面来介绍将小数值舍入为整数的几个方法：Math.ceil()、Math.floor()和Math.round()。
-这三个方法分别遵循下列舍入规则：
-
-Math.ceil()执行向上舍入，即它总是将数值向上舍入为最接近的整数；
-
-Math.floor()执行向下舍入，即它总是将数值向下舍入为最接近的整数；
-
-Math.round()执行标准舍入，即它总是将数值四舍五入为最接近的整数(这也是我们在数学课上学到的舍入规则)。
-
-下面来看几个例子：
-
-Math.ceil(25.9) //26
-
-Math.ceil(25.5) //26
-
-Math.ceil(25.1) //26
-
-Math.ceil(25.0) //25
-
-Math.round(25.9) //26
-
-Math.round(25.5) //26
-
-Math.round(25.1) //25
-
-Math.floor(25.9) //25
-
-Math.floor(25.5) //25
-
-Math.floor(25.1) //25
--- a/Java基础教程/Java语言基础/20
+++ b/Java基础教程/Java语言基础/20
@@ -1 +0,0 @@
-
--- a/Spring/Springboot/01
+++ b/Spring/Springboot/01
@@ -0,0 +1,266 @@
+
+# 内容简介
+> springboot本就是一个专门用来配置的框架，用来整合各种各样的配置。所以主要内容也是与配置相关。
+> * 配置文件
+> * web开发
+> * 数据访问
+> * 但愿测试
+> * 指标监控
+> * 核心原理
+> 。。。
+
+## 1 springboot背景
+springboot + springcloud
+### 微服务
+1. 架构风格
+2. 小型服务，灵活拆分
+3. 自动部署
+4. 去中心化、服务治理
+
+
+### 分布式
+1. 远程调用rpc——http
+2. 服务发现——网关和注册中心
+3. 负载均衡和任务调度
+4. 服务容错——流量控制和熔断
+5. 配置管理——配置中心
+6. 服务监控
+7. 链路追踪
+8. 日志管理
+
+
+### 云原生
+
+1. 服务自愈
+2. 弹性伸缩
+3. 服务隔离
+4. 自动化部署机制
+5. 灰度发布，逐渐替代旧版本
+6. 流量治理
+
+
+
+## 2 springboot概述
+
+### 基本概念
+Spring Boot 是基于 Spring 框架基础上推出的一个全新的框架, 旨在让开发者可以轻松地创建一个可独立运行的，生产级别的应用程序。利用控制反转的核心特性，并通过依赖注入实现控制反转来实现管理对象生命周期容器化，利用面向切面编程进行声明式的事务管理，整合多种持久化技术管理数据访问，提供大量优秀的Web框架方便开发等等。
+
+> [参考文献](https://www.yuque.com/atguigu/springboot/na3pfd)
+
+
+### 框架优势
+
+1. 能够轻松、方便地创建一个 Spring 应用;
+2. 直接使用内嵌的 Tomcat, Jetty, Undertow 容器（无需再手动安装容器，通过部署 WAR 包的方式）;
+3. 内部自动管理各种 Jar 包的版本依赖关系，再也不用为版本冲突而烦恼啦；
+4. 自动化配置 Spring 相关功能，以及第三方库;
+5. 提供诸如指标，健康检查, 外部化配置等功能；
+6. "零配置"，再也不需要手写地狱般的 XML 配置了；
+
+
+#### 框架特点
+
+* REST风格
+* IOC控制反转
+* AOP面向切面
+
+## 3 操作入门
+
+### maven设置
+* 配置maven的Aliyun镜像和jdk版本
+```xml
+<mirrors>
+      <mirror>
+        <id>nexus-aliyun</id>
+        <mirrorOf>central</mirrorOf>
+        <name>Nexus aliyun</name>
+        <url>http://maven.aliyun.com/nexus/content/groups/public</url>
+      </mirror>
+  </mirrors>
+ 
+  <profiles>
+         <profile>
+              <id>jdk-1.8</id>
+              <activation>
+                <activeByDefault>true</activeByDefault>
+                <jdk>1.8</jdk>
+              </activation>
+              <properties>
+                <maven.compiler.source>1.8</maven.compiler.source>
+                <maven.compiler.target>1.8</maven.compiler.target>
+                <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
+              </properties>
+         </profile>
+  </profiles>
+```
+
+
+### 创建maven工程
+
+```
+mvn archetype:generate
+```
+
+### 引入依赖
+
+```
+<parent>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-parent</artifactId>
+    <version>2.3.4.RELEASE</version>
+</parent>
+
+
+<dependencies>
+    <dependency>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-web</artifactId>
+    </dependency>
+
+</dependencies>
+```
+
+### 创建主程序
+
+```java
+/**
+ * 主程序类
+ * @SpringBootApplication：这是一个SpringBoot应用
+ */
+@SpringBootApplication
+public class MainApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(MainApplication.class,args);
+    }
+}
+```
+
+
+### 编写业务逻辑
+
+```java
+@RestController
+public class HelloController {
+
+
+    @RequestMapping("/hello")
+    public String handle01(){
+        return "Hello, Spring Boot 2!";
+    }
+
+
+}
+```
+
+
+### 测试
+
+直接运行main方法
+
+
+### 配置
+
+application.properties
+
+```
+server.port=8888
+```
+
+### 简化部署
+
+```xml
+<build>
+    <plugins>
+        <plugin>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-maven-plugin</artifactId>
+        </plugin>
+    </plugins>
+</build>
+```
+
+
+## 4 工程结构
+
+### 推荐工程结构
+```
+com
+  +- example
+    +- myproject
+      +- Application.java
+      |
+      +- domain
+      |  +- Customer.java
+      |  +- CustomerRepository.java
+      |
+      +- service
+      |  +- CustomerService.java
+      |
+      +- web
+      |  +- CustomerController.java
+      |
+```
+* root package：com.example.myproject，所有的类和其他package都在root package之下。
+* 应用主类：Application.java，该类直接位于root package下。通常我们会在应用主类中做一些框架配置扫描等配置，我们放在root package下可以帮助程序减少手工配置来加载到我们希望被Spring加载的内容
+* com.example.myproject.domain包：用于定义实体映射关系与数据访问相关的接口和实现
+* com.example.myproject.service包：用于编写业务逻辑相关的接口与实现
+* com.example.myproject.web：用于编写Web层相关的实现，比如：Spring MVC的Controller等
+
+> Spring Boot的应用主类会自动扫描root package以及所有子包下的所有类来进行初始化。
+
+
+### 非典型结构下的初始化
+
+1. 使用@ComponentScan注解指定具体的加载包
+
+```java
+@SpringBootApplication
+@ComponentScan(basePackages="com.example")
+public class Bootstrap {
+
+    public static void main(String[] args) {
+        SpringApplication.run(Bootstrap.class, args);
+    }
+
+}
+```
+2. 使用@Bean注解来初始化。在主类中进行初始化。
+```java
+@SpringBootApplication
+public class Bootstrap {
+
+    public static void main(String[] args) {
+        SpringApplication.run(Bootstrap.class, args);
+    }
+
+    @Bean
+    public CustomerController customerController() {
+        return new CustomerController();
+    }
+
+}
+```
+
+
+## 5 自动配置原理
+
+### maven继承关系
+
+```xml
+依赖管理    
+<parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>2.3.4.RELEASE</version>
+</parent>
+
+他的父项目
+ <parent>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-dependencies</artifactId>
+    <version>2.3.4.RELEASE</version>
+  </parent>
+
+几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制
+```
--- a/Spring/Springboot/02
+++ b/Spring/Springboot/02
--- a/Springboot底层注解.md
+++ b/Springboot底层注解.md
--- a/Spring/Springboot/1
+++ b/Spring/Springboot/1
@@ -1,68 +0,0 @@
-## 1 Spring 能做什么
-> [参考文献](https://www.yuque.com/atguigu/springboot/na3pfd)
-
- 
-### Spring框架的功能
-
-1. 微服务。实现功能的进一步拆分
-2. 响应式。异步、非阻塞的框架
-3. 云计算。分布式云开发Spring cloud
-4. web开发。Springmvc
-5. 无服务开发/事件驱动/批处理业务
-
-
-### Spring全家桶逻辑关系
-
-1. Spring Data
-2. SPring cloud
-3. Spring MVC
-4. Spring batch
-5. Spring session
-6. ......
-
-
-以上都是spring framwork的一部分。spring framwork包含以上部分。
- 
-spring boot 是高层框架，底层是spring framwork。 可以用来整合Spring的整个技术栈，防止出现配置地狱。 
-
-### Spring boot的优势
-1. 创建独立应用。Spring boot 能够快速创建出生产级别的应用。  
-2. 内嵌web服务器
-3. 创建自动依赖 ，简化构建配置。
-4. 无代码生成/无编写XML
-
-
-### Spring5框架结构
-
-
-![](image/2022-07-04-10-30-39.png)
-
-
-## 2 Spring boot的背景
-
-### 微服务
-1. 架构风格
-2. 小型服务，灵活拆分
-3. 自动部署
-4. 去中心化、服务治理
-
-
-### 分布式要解决的问题
-1. 远程调用rpc——http
-2. 服务发现——网关和注册中心
-3. 负载均衡和任务调度
-4. 服务容错——流量控制和熔断
-5. 配置管理——配置中心
-6. 服务监控
-7. 链路追踪
-8. 日志管理
-
-
-### 云原生要解决的问题（部署过程）
-
-1. 服务自愈
-2. 弹性伸缩
-3. 服务隔离
-4. 自动化部署机制
-5. 灰度发布，逐渐替代旧版本
-6. 流量治理
--- a/Spring/Springboot/1简介.md
+++ b/Spring/Springboot/1简介.md
@@ -1,83 +0,0 @@
-## 1 简介
-
-Spring Boot 是基于 Spring 框架基础上推出的一个全新的框架, 旨在让开发者可以轻松地创建一个可独立运行的，生产级别的应用程序。利用控制反转的核心特性，并通过依赖注入实现控制反转来实现管理对象生命周期容器化，利用面向切面编程进行声明式的事务管理，整合多种持久化技术管理数据访问，提供大量优秀的Web框架方便开发等等。
-
-### Springboot的优势
-
-1. 能够轻松、方便地创建一个 Spring 应用;
-2. 直接使用内嵌的 Tomcat, Jetty, Undertow 容器（无需再手动安装容器，通过部署 WAR 包的方式）;
-3. 内部自动管理各种 Jar 包的版本依赖关系，再也不用为版本冲突而烦恼啦；
-4. 自动化配置 Spring 相关功能，以及第三方库;
-5. 提供诸如指标，健康检查, 外部化配置等功能；
-6. "零配置"，再也不需要手写地狱般的 XML 配置了；
-
-
-## 2 相关特性
-
-### REST风格
-
-### 控制反转
-
-### 面向切面
-
-
-## 3 工程结构
-
-### 推荐工程结构
-```
-com
-  +- example
-    +- myproject
-      +- Application.java
-      |
-      +- domain
-      |  +- Customer.java
-      |  +- CustomerRepository.java
-      |
-      +- service
-      |  +- CustomerService.java
-      |
-      +- web
-      |  +- CustomerController.java
-      |
-```
-* root package：com.example.myproject，所有的类和其他package都在root package之下。
-* 应用主类：Application.java，该类直接位于root package下。通常我们会在应用主类中做一些框架配置扫描等配置，我们放在root package下可以帮助程序减少手工配置来加载到我们希望被Spring加载的内容
-* com.example.myproject.domain包：用于定义实体映射关系与数据访问相关的接口和实现
-* com.example.myproject.service包：用于编写业务逻辑相关的接口与实现
-* com.example.myproject.web：用于编写Web层相关的实现，比如：Spring MVC的Controller等
-
-> Spring Boot的应用主类会自动扫描root package以及所有子包下的所有类来进行初始化。
-
-
-### 非典型结构下的初始化
-
-1. 使用@ComponentScan注解指定具体的加载包
-
-```
-@SpringBootApplication
-@ComponentScan(basePackages="com.example")
-public class Bootstrap {
-
-    public static void main(String[] args) {
-        SpringApplication.run(Bootstrap.class, args);
-    }
-
-}
-```
-2. 使用@Bean注解来初始化。在主类中进行初始化。
-```
-@SpringBootApplication
-public class Bootstrap {
-
-    public static void main(String[] args) {
-        SpringApplication.run(Bootstrap.class, args);
-    }
-
-    @Bean
-    public CustomerController customerController() {
-        return new CustomerController();
-    }
-
-}
-```
--- a/Spring/注解编程01-spring.md
+++ b/Spring/注解编程01-spring.md
@@ -0,0 +1,667 @@
+# 注解总结
+
+
+> 注解位置
+> 
+> 类注解
+> @Component、@Repository、@Controller、@Service以及JavaEE6的@ManagedBean和@Named注解
+>
+> 方法注解
+> 
+> @Bean、@Autowire、@Value、@Resource以及EJB和WebService相关的注解等
+> 
+> 属性注解
+
+> 必须被扫描到的类
+> 启动类@SpringBootApplication--@ComponentScan-->扫描类@Component->扫描方法@Bean
+
+## 1 配置类相关注解
+> 启动Spring扫描的基础类。
+
+### @SpringBootApplication
+
+@SpringBootApplication申明让spring boot自动给程序进行必要的配置，这个配置等同于：@Configuration ，@EnableAutoConfiguration 和 @ComponentScan 三个配置。
+
+使用了此注解的类首先会让Spring Boot启动对base package以及其sub-pacakage下的类进行component scan。
+
+
+
+### @ComponentScan
+@ComponentScan主要就是定义扫描的路径从中找出标识了需要装配的类自动装配到spring的bean容器中。默认注册到了spring容器中
+
+```java
+//扫描com.demo下的组件
+@ComponentScan(value="com.demo")
+@Configuration
+public class myConfig {
+}
+```
+
+### @Configuration
+Spring3.0，相当于传统的xml配置文件，如果有些第三方库需要用到xml文件，建议仍然通过@Configuration类作为项目的配置主类可以使用@ImportResource注解加载xml配置文件。
+
+proxyBeanMethods属性默认值是true,也就是说该配置类会被代理（CGLIB），在同一个配置文件中调用其它被@Bean注解标注的方法获取对象时会直接从IOC容器之中获取。(@Bean中的参数可以获取@Autowired等，直接从SpringIOC容器红获取。)
+
+```java
+@Configuration
+public class AppConfig {
+    // 未指定bean 的名称，默认采用的是 "方法名" + "首字母小写"的配置方式
+    @Bean
+    public MyBean myBean(){
+        return new MyBean();
+    }
+}
+```
+
+
+### @WishlyConfiguration
+为@Configuration与@ComponentScan的组合注解，可以替代这两个注解
+
+### @Bean
+注解在方法上，声明当前方法的返回值为一个bean，替代xml中的方式（方法上）。@Bean 注解的属性有：value、name、autowire、initMethod、destroyMethod。
+* name 和 value 两个属性是相同的含义的， 在代码中定义了别名。为 bean 起一个名字，如果默认没有写该属性，那么就使用方法的名称为该 bean 的名称。
+* autowire指定 bean 的装配方式， 根据名称 和 根据类型 装配， 一般不设置，采用默认即可。autowire指定的装配方式 有三种Autowire.NO (默认设置)、Autowire.BY_NAME、Autowire.BY_TYPE。
+* initMethod和destroyMethod指定bean的初始化方法和销毁方法， 直接指定方法名称即可，不用带括号。
+```java
+public class MyBean {
+    public MyBean(){
+        System.out.println("MyBean Initializing");
+    }
+    public void init(){
+        System.out.println("Bean 初始化方法被调用");
+    }
+    public void destroy(){
+        System.out.println("Bean 销毁方法被调用");
+    }
+}
+@Configuration
+public class AppConfig {
+    @Bean(initMethod = "init", destroyMethod = "destroy")
+    public MyBean myBean(){
+        return new MyBean();
+    }
+}
+```
+
+### @Scope
+@Scope注解是springIoc容器中的一个作用域，在 Spring IoC 容器中具有以下几种作用域：基本作用域singleton（单例）、prototype(多例)[By 博客园 GoCircle]，Web 作用域（reqeust、session、globalsession），自定义作用域。
+
+prototype原型模式：
+@Scope(value=ConfigurableBeanFactory.SCOPE_PROTOTYPE)在每次注入的时候回自动创建一个新的bean实例
+
+* singleton单例模式：@Scope(value=ConfigurableBeanFactory.SCOPE_SINGLETON)单例模式，在整个应用中只能创建一个实例
+
+* globalsession模式：@Scope(value=WebApplicationContext.SCOPE_GLOBAL_SESSION)全局session中的一般不常用
+
+* Web作用域@Scope(value=WebApplicationContext.SCOPE_APPLICATION)在一个web应用中只创建一个实例
+
+* request模式：@Scope(value=WebApplicationContext.SCOPE_REQUEST)在一个请求中创建一个实例
+
+* session模式：@Scope(value=WebApplicationContext.SCOPE_SESSION)每次创建一个会话中创建一个实例
+
+```java
+@Configuration
+public class myConfig {
+    //默认是单例的。不需要特别说明
+    @Bean("person")
+    public Person person(){
+        return new Person("binghe002", 18);
+    }
+}
+@Configuration
+public class myConfig {
+    //Person对象的作用域修改成prototype,多例的
+    @Scope("prototype")
+    @Bean("person")
+    public Person person(){
+        return new Person("binghe002", 18);
+    }
+}
+```
+
+### 其他配置
+* @StepScope 在Spring Batch中还有涉及
+
+* @PostConstruct 由JSR-250提供，在构造函数执行完之后执行，等价于xml配置文件中bean的initMethod
+
+* @PreDestory 由JSR-250提供，在Bean销毁之前执行，等价于xml配置文件中bean的destroyMethod
+
+* @Conditional是Spring4新提供的注解，它的作用是按照一定的条件进行判断，满足条件给容器注册bean。
+
+### @EnableAutoConfiguration
+SpringBoot自动配置（auto-configuration）：尝试根据你添加的jar依赖自动配置你的Spring应用。
+
+例如，如果你的classpath下存在HSQLDB，并且你没有手动配置任何数据库连接beans，那么我们将自动配置一个内存型（in-memory）数据库。
+
+## 2 声明bean的注解
+spring创建bean的注解
+
+### @Component
+@Component组件，泛指各种组件，就是说当我们的类不属于各种归类的时候（不属于@Controller、@Services等的时候），我们就可以使用@Component来标注这个类，把普通pojo实例化到spring容器中，相当于配置文件中的：`<bean id="" class=""/>`。
+
+```java
+@Component("conversionImpl")
+//其实默认的spring中的Bean id 为 conversionImpl(首字母小写)
+public class ConversionImpl implements Conversion {
+    @Autowired
+    private RedisClient redisClient;
+}
+```
+### @Service
+在业务逻辑层使用（service层）
+```java
+@Service()
+public class UserService{
+    @Resource
+    private UserDao userDao;
+    public void add(){
+        userDao.add();
+    }
+}
+```
+
+### @Repository
+
+在数据访问层使用（dao层）,在daoImpl类上面注解。
+
+### @Controller
+
+在表现层使用，控制器的声明
+
+
+## 3 注入bean的注解
+Spring注入bean的注解
+
+### @Autowired&@Qualifier
+@Autowired为Spring提供的注解，需要导入包org.springframework.beans.factory.annotation.Autowired，只按照byType注入。
+
+可以写在字段和setter方法上。两者如果都写在字段上，那么就不需要再写setter方法。
+
+@Autowired注解是按照类型（byType）装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它的required属性为false。如果我们想使用按照名称（byName）来装配，可以结合@Qualifier注解一起使用。
+
+```java
+public class TestServiceImpl {
+    // 下面两种@Autowired只要使用一种即可
+    @Autowired
+    private UserDao userDao; // 用于字段上
+    @Autowired
+    public void setUserDao(UserDao userDao) { // 用于属性的方法上
+        this.userDao = userDao;
+    }
+
+    @Autowired
+    @Qualifier("userDao")
+    private UserDao userDao;
+}
+```
+
+### @Inject&@Named
+@Inject是JSR330 (Dependency Injection for Java)中的规范，需要导入javax.inject.Inject;实现注入。@Inject可以作用在变量、setter方法、构造函数上。根据类型进行自动装配的，如果需要按名称进行装配，[Power By听雨的人]则需要配合@Named。
+
+@Named("XXX") 中的XXX是 Bean 的名称，所以 @Inject和 @Named结合使用时，自动注入的策略就从 byType 转变成 byName 了。
+
+```
+public class User{
+    private Person person;
+    @Inject
+    pbulic void setPerson(Person person){
+        this.person = person;
+    }
+    @Inject
+    pbulic void setPerson1(@Named("main")Person person)
+    {
+        this.person = person;
+    }
+}
+```
+
+### @Resource
+@Resource默认按照ByName自动注入，由J2EE提供，是JSR250规范的实现，需要导入javax.annotation实现注入。
+
+@Resource有两个重要的属性：name(id)和type，而Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以，如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不制定name也不制定type属性，这时将通过反射机制使用byName自动注入策略。
+
+可以写在字段和setter方法上。两者如果都写在字段上，那么就不需要再写setter方法。
+
+```java
+public class TestServiceImpl {
+    // 下面两种@Resource只要使用一种即可
+    @Resource(name="userDao")
+    private UserDao userDao; // 用于字段上
+    @Resource(name="userDao")
+    public void setUserDao(UserDao userDao) {
+        // 用于属性的setter方法上
+        this.userDao = userDao;
+    }
+}
+```
+
+
+
+## 4 @Import&@ImportResource导入Bean注解
+
+@Import通过快速导入的方式实现把实例加入spring的IOC容器中。但应注意是@Import在使用时,必须要保证能被IOC容器扫描到，所以通常它会和@Configuration或@ComponentScan配套使用。@Import在使用时可以声明在JAVA类上，或者作为元注解使用（即声明在其他注解上）
+
+### @Import直接导入外部类
+```
+public class Dog {
+    public void run() {
+        System.out.println("Dog run");
+    }
+}
+
+@Import(Dog.class)
+@Configuration
+public class AppConfig {
+}
+// 测试类
+public class annoTest {
+    private static AnnotationConfigApplicationContext classPath;
+    @Test
+    public void testConsutrator(){
+        classPath = new AnnotationConfigApplicationContext(AppConfig.class);
+        Dog exampleBean = classPath.getBean(Dog.class);
+        System.out.println(exampleBean);
+    }
+}
+```
+
+### @Import导入实现了ImportSelector的类
+通过ImportSelector类能够实现多个类的导入。
+
+* 返回值： 就是我们实际上要导入到容器中的组件全类名
+* 参数： AnnotationMetadata表示当前被@Import的类上的所有注解信息
+```java
+public class MyImportSelector implements ImportSelector {
+    @Override
+    public String[] selectImports(AnnotationMetadata annotationMetadata) {
+        Set<String> annotationTypes = annotationMetadata.getAnnotationTypes();
+        for (String str:annotationTypes) {
+            System.out.println(str);
+        }
+        return new String[]{"com.picc.spring.annotation.Dog"};
+    }
+}
+
+@Import({MyImportSelector.class})
+@Configuration
+public class AppConfig {
+}
+
+public class annoTest {
+    private static AnnotationConfigApplicationContext classPath;
+    @Test
+    public void testConsutrator(){
+        classPath = new AnnotationConfigApplicationContext(AppConfig.class);
+        Dog exampleBean = classPath.getBean(Dog.class);
+        System.out.println(exampleBean);
+    }
+}
+```
+
+
+### @Import导入实现了ImportBeanDefinitionRegistrar的类
+```
+public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
+    @Override
+    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
+        Set<String> annotationTypes = annotationMetadata.getAnnotationTypes();
+        for (String str:annotationTypes) {
+            System.out.println(str);
+        }
+        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Dog.class);
+        beanDefinitionRegistry.registerBeanDefinition("dog",rootBeanDefinition);
+    }
+}
+
+@Import({MyImportBeanDefinitionRegistrar.class})
+@Configuration
+public class AppConfig {
+}
+```
+
+
+### @ImportResource导入spring配置文件
+
+
+@ImportResource 注解用于导入Spring 的配置文件。使用 @ImportResource 标注在一个配置类上让 Spring 的配置文件生效。
+```java
+@ImportResource(locations = "classpath:applicationContext.xml")
+@SpringBootApplication
+@RestController
+public class FirstSpringbootApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(FirstSpringbootApplication.class, args);
+    }
+}
+```
+### @PropertySource
+
+
+## 5 @Value注解
+@Value的作用是通过注解将常量、配置文件中的值、其他bean的属性值注入到变量中，作为变量的初始值。
+
+### 支持如下方式的注入：
+
+* 注入普通字符
+* 注入操作系统属性
+* 注入表达式结果
+* 注入其它bean属性
+* 注入文件资源
+* 注入网站资源
+* 注入配置文件
+
+```java
+@Value("张三")
+private String name; // 注入普通字符串
+```
+### @Value三种情况的用法。
+```
+${}是去找外部配置的参数，将值赋过来
+#{}是SpEL表达式，去寻找对应变量的内容
+#{}直接写字符串就是将字符串的值注入进去
+```
+
+```java
+// 注入其他Bean属性：注入beanInject对象的属性another，类具体定义见下面
+@Value("#{beanInject.another}")
+private String fromAnotherBean;
+// 注入操作系统属性
+@Value("#{systemProperties['os.name']}")
+private String systemPropertiesName;
+//注入表达式结果
+@Value("#{T(java.lang.Math).random() * 100.0 }")
+private double randomNumber;
+```
+
+
+
+
+## 6 切面（AOP）相关注解
+
+在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程，简称AOP（aspect object programming）。
+
+AOP编程，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑——比如权限管理，事物管理，日志记录等等。这些系统性的编程工作都可以独立编码实现，然后通过AOP技术切入进系统即可。
+
+Spring支持AspectJ的注解式切面编程。
+
+### @Aspect
+声明一个切面（类上）
+
+### @After、@Before、@Around、@AfterRunning、@AfterThrowing
+定义通知（advice），可直接将拦截规则（切点）作为参数。
+* @Before前置通知[By cnblogs.com/GoCircle], 在方法执行之前执行。
+* @After后置通知, 在方法执行之后执行。
+* @AfterRunning 返回通知, 在方法返回结果之后[By cnblogs.com/GoCircle]执行。
+* @AfterThrowing 异常通知, 在方法抛出异常之后。
+* @Around环绕通知, 围绕着方法执行。
+* 
+### @PointCut
+声明切点。声明切点，是植入Advice（通知）的触发条件。每个Pointcut的定义包括2部分，一是表达式，二是方法签名。方法签名必须是 public及v[欢迎转载听雨的人博客]oid型。可以将Pointcut中的方法看作是一个被Advice引用的助记符，因为表达式不直观，因此我们可以通过方法签名的方式为 此表达式命名。因此Pointcut中的方法只需要方法签名，而不需要在方法体内编写实际代码。
+
+```java
+/**
+ * 日志切面
+ */
+@Component
+@Aspect
+public class LoggingAspect {
+    /**
+     * 前置通知：目标方法执行之前执行以下方法体的内容
+     */
+    @Before("execution(* com.qcc.beans.aop.*.*(..))")
+    public void beforeMethod(JoinPoint jp){
+        String methodName = jp.getSignature().getName();
+        System.out.println("【前置通知】the method 【" + methodName + "】 begins with " + Arrays.asList(jp.getArgs()));
+    }
+    /**
+     * 返回通知：目标方法正常执行完毕时执行以下代码
+     */
+    @AfterReturning(value="execution(* com.qcc.beans.aop.*.*(..))",returning="result")
+    public void afterReturningMethod(JoinPoint jp, Object result){
+        String methodName = jp.getSignature().getName();
+        System.out.println("【返回通知】the method 【" + methodName + "】 ends with 【" + result + "】");
+    }
+    /**
+     * 后置通知：目标方法执行之后执行以下方法体的内容，不管是否发生异常。
+     * @param jp
+     */
+    @After("execution(* com.qcc.beans.aop.*.*(..))")
+    public void afterMethod(JoinPoint jp){
+        System.out.println("【后置通知】this is a afterMethod advice...");
+    }
+    /**
+     * 异常通知：目标方法发生异常的时候执行以下代码
+     */
+    @AfterThrowing(value="execution(* com.qcc.beans.aop.*.*(..))",throwing="e")
+    public void afterThorwingMethod(JoinPoint jp, NullPointerException e){
+        String methodName = jp.getSignature().getName();
+        System.out.println("【异常通知】the method 【" + methodName + "】 occurs exception: " + e);
+    }
+}
+```
+
+### @ControllerAdvice&@ExceptionHandler（Exception.class）
+
+相当于一个全局的切面异常类。不建议使用。
+
+包含@Component。可以被扫描到。统一处理异常。用在方法上面表示遇到这个异常就执行以下方法。
+
+### @EnableAspectJAutoProxy
+
+在java配置类中使用@EnableAspectJAutoProxy注解开启Spring对AspectJ代理的支持（类上）
+```java
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Import(AspectJAutoProxyRegistrar.class)
+public @interface EnableAspectJAutoProxy {
+    /**
+     * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
+     * to standard Java interface-based proxies. The default is {@code false}.
+     */
+    boolean proxyTargetClass() default false;
+    /**
+     * Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
+     * for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
+     * Off by default, i.e. no guarantees that {@code AopContext} access will work.
+     * @since 4.3.1
+     */
+    boolean exposeProxy() default false;
+}
+```
+这里有两个方法,一个是控制aop的具体实现方[Power By听雨的人]式,为true 的话使用cglib,为false的话使用java的Proxy,默认为false,第二个参数控制代理的暴露方式,解决内部调用不能使用代理的场景，默认为false。
+
+## 7 环境切换
+@Profile
+
+指定组件在哪个环境的情况下才能被注册到容器中，不指定，任何环境下都能注册这个组件。
+
+@Conditional
+
+通过实现Condition接口，并重写matches方法，从而决定该bean是否被实例化。
+
+
+## 8 异步相关
+@EnableAsync
+
+配置类中通过此注解开启对异步任务的支持；
+
+@Async
+
+在实际执行的bean方法使用该注解来声明其是一个异步任务（方法上或类上所有的方法都将异步，需要@EnableAsync开启异步任务）
+
+## 9 定时任务相关
+@EnableScheduling
+
+在配置类上使用，开启计划任务的支持（类上）
+
+@Scheduled
+
+来申明这是一个任务，包括cron,fixDelay,fixRate等类型（方法上，需先开启计划任务的支持）
+
+
+## 10 属性配置相关
+
+### @ConfigurationProperties
+前缀外部属性将绑定到类的字段上
+
+* 根据 Spring Boot 宽松的绑定规则，类的属性名称必须与外部属性的名称匹配。我们可以简单地用一个值初始化一个字段来定义一个默认值
+* 类本身可以是包私有的类的字段必须有公共setter 方法
+* 激活 @ConfigurationProperties。只有当类所在的包被 Spring @ComponentScan 注解扫描到才会生效。
+
+可以通过添加 @Component 注解让 ComponentScan 扫描到。
+
+```java
+@Component
+@ConfigurationProperties(prefix = "demo")
+class DemoProperties {
+}
+```
+
+
+## 11 Enable***注解说明
+这些注解主要是用来开启对xxx的支持：
+
+@EnableAspectAutoProxy：开启对AspectJ自动代理的支持；
+@EnableAsync：开启异步方法的支持；
+@EnableScheduling：开启计划任务的支持；
+@EnableWebMvc：开启web MVC的配置支持；
+@EnableConfigurationProperties：开启对@ConfigurationProperties注解配置Bean的支持；
+@EnableJpaRepositories：开启对SpringData JPA Repository的支持；
+@EnableTransactionManagement：开启注解式事务的支持；
+@EnableCaching：开启注解式的缓存支持；
+
+## 12 测试相关注解
+@RunWith
+
+运行器，Spring中通常用于对JUnit的支持
+
+@ContextConfiguration
+
+用来加载配置配置文件，其中classes属性用来加载配置类。
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(locations = {"classpath*:/*.xml"})
+public class CDPlayerTest {
+ 
+}
+@ContextConfiguration这个注解通常与@RunWith(SpringJUnit4ClassRunner.class)联合使用用来测试。
+
+@ContextConfiguration括号里的locations = {"classpath*:/*.xml"}就表示将classpath路径里所有的xml文件都包括进来，自动扫描的bean就可以拿到，此时就可以在测试类中使用@Autowired注解来获取之前自动扫描包下的所有bean。
+
+
+## 13 事务注解
+
+### @EnableTransactionManagement
+在入口处增加 @EnableTransactionManagement 注解
+```java
+package com.cm.aps;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+@SpringBootApplication
+@EnableTransactionManagement
+public class ApsApplication {
+    public static void main(String[] args) {
+        SpringApplication.run(ApsApplication.class, args);
+    }
+}
+```
+
+### @Transactional 
+@Transactional 注解放在类级别时，表示所有该类的公共方法都配置相同的事务属性信息。当类级别配置了@Transactional，方法级别也配置了@Transactional，应用程序会以方法级别的事务属性信息来管理事务。
+
+| 属性名 | 说明 |
+|--|--|
+| name |	当在配置文件中有多个 TransactionManager , 可以用该属性指定选择哪个事务管理器。|
+| propagation | 事务的传播行为，默认值为 REQUIRED。|
+| isolation	| 事务的隔离度，默认值采用 DEFAULT。
+| timeout | 事务的超时时间，默认值为-1。如果超过该时间限制但事务还没有完成，则自动回滚事务。|
+| read-only	 | 指定事务是否为只读事务，默认值为 false；为了忽略那些不需要事务的方法，比如读取数据，可以设置 read-only 为 true。|
+| rollback-for | 用于指定能够触发事务回滚的异常类型，如果有多个异常类型需要指定，各类型之间可以通过逗号分隔。|
+| no-rollback-for | 抛出 no-rollback-for 指定的异常类型，不回滚事务。
+
+```java
+@Override
+@Transactional(rollbackFor = Exception.class)  //这里回滚进行定义
+public int update(Prdtv prdtv) throws RuntimeException{
+    //注意在这里处理业务时，不要使用Try ...异常捕获，否则不回滚
+    return prdtvMapper.update(prdtv);
+}
+```
+## 14 json常用注解
+### @JsonIgnoreProperties
+此注解是类注解，作用是json序列化时将java bean中的一些属性忽略掉，序列化和反序列化都受影响。
+
+写法将此标签加在user类的类名上 ，可以多个属性也可以单个属性。
+```
+//生成json时将name和age属性过滤
+@JsonIgnoreProperties({"name"},{"age"})
+public class  user {
+ 
+    private  String name;
+    private int age;
+}
+```
+### @JsonIgnore
+此注解用于属性或者方法上（最好是属性上），作用和上面的@JsonIgnoreProperties一样。
+```
+//生成json 时不生成age 属性
+public class user {
+ 
+    private String name;
+    @JsonIgnore
+    private int age;
+}
+```
+### @JsonFormat
+此注解用于属性或者方法上（最好是属性上），可以方便的把Date类型直接转化为我们想要的模式，比如：
+```
+public class User{
+    @JsonFormat(pattern = “yyyy-MM-dd HH-mm-ss”)
+    private Date date;
+}
+```
+### @JsonSerialize
+此注解用于属性或者getter方法上，用于在序列化时嵌入我们自定义的代码，比如序列化一个double时在其后面限制两位小数点。
+
+### @JsonDeserialize
+此注解用于属性或者setter方法上，用于在反序列化时可以嵌入我们自定义的代码，类似于上面的@JsonSerialize
+
+### @Transient
+如果一个属性并非数据库表的字段映射，就务必将其标示为@Transient，否则ORM框架默认其注解为@Basic；
+
+### @JsonIgnoreType
+标注在类上，当其他类有该类作为属性时，该属性将被忽略。
+
+### @JsonProperty
+@JsonProperty 可以指定某个属性和json映射的名称。例如我们有个json字符串为{“user_name”:”aaa”}，
+而java中命名要遵循驼峰规则，则为userName，这时通过@JsonProperty 注解来指定两者的映射规则即可。这个注解也比较常用。
+```
+public class SomeEntity {
+    @JsonProperty("user_name")
+    private String userName;
+}
+```
+### @JsonPropertyOrder
+只在序列化情况下生效的注解
+
+在将 java pojo 对象序列化成为 json 字符串时，使用 @JsonPropertyOrder 可以指定属性在 json 字符串中的顺序。
+
+### @JsonInclude
+只在序列化情况下生效的注解
+
+在将 java pojo 对象序列化成为 json 字符串时，使用 @JsonInclude 注解可以控制在哪些情况下才将被注解的属性转换成 json，例如只有属性不为 null 时。
+
+### @JsonInclude(JsonInclude.Include.NON_NULL)
+只在序列化情况下生效的注解
+
+这个注解放在类头上，返给前端的json里就没有null类型的字段，即实体类与json互转的时候 属性值为null的不参与序列化。
+另外还有很多其它的范围，例如 NON_EMPTY、NON_DEFAULT等
+
+### @JsonSetter
+在反序列化情况下生效的注解
+@JsonSetter 标注于 setter 方法上，类似 @JsonProperty ，也可以解决 json 键名称和 java pojo 字段名称不匹配的问题。
--- a/Spring/注解编程02-rest.md
+++ b/Spring/注解编程02-rest.md
@@ -0,0 +1,232 @@
+
+## 15 SpringMVC常用注解
+### @EnableWebMvc
+在配置类中开启Web MVC的配置支持。
+
+### @Controller
+在SpringMVC 中，控制器Controller 负责处理由DispatcherServlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个Model ，然后再把该Model 返回给对应的View 进行展示。
+
+使用@Controller 标记一个类是Controller ，然后使用@RequestMapping 和@RequestParam 等一些注解用以定义URL 请求和Controller 方法之间的映射，这样的Controller 就能被外界访问到。
+
+```java
+@Controller
+@RequestMapping(“/demoInfo”)
+public class DemoController {
+    @Autowired
+    private DemoInfoService demoInfoService;
+
+    @RequestMapping("/hello")
+    public String hello(Map<String,Object> map){
+       System.out.println("DemoController.hello()");
+       map.put("hello","from TemplateController.helloHtml");
+       //会使用hello.html或者hello.ftl模板进行渲染显示.
+       return"/hello";
+    }
+}
+```
+
+### @RestController
+Spring4，注解是@Controller和@ResponseBody的合集,表示这是个控制器bean,并且是将函数的返回值直 接填入HTTP响应体中,是REST风格的控制器。
+
+```java
+
+@RestController
+@RequestMapping(“/demoInfo2”)
+publicclass DemoController2 {
+    @RequestMapping("/test")
+    public [Power By听雨的人]String test(){
+       return "ok";
+    }
+}
+```
+
+### @RequestMapping
+用于映射web请求，包括访问路径和参数。提供路由信息，是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
+
+RequestMapping注解有六个属性，下面我们把她分成三类进行说明（下面有相应示例）。
+
+1. value：指定请求的实际地址，指定的地址可以是URI Template 模式（后面将会说明）；
+2. method：  指定请求的method类型， GET、POST、PUT、DELETE等；
+3. consumes： 指定处理请求的提交内容类型（Content-Type），例如application/json, text/html;
+4. produces:指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；
+5. params： 指定request中必须包含某些参数值是，才让该方法处理。
+6. headers： 指定request中必须包含某些指定的header值，才能让该方法处理请求。
+
+```java
+@RestController
+@RequestMapping("/home")
+public class IndexController {
+    /**
+    * 将多个请求映射到一个方法上去
+    */
+    @RequestMapping(value = {
+        “”,
+        “/page”,
+        "page*”,
+        "view/*,**/msg"
+    })
+    String indexMultipleMapping() {
+        return "Hello from index multiple mapping.”;
+    }
+    /**
+    * 是否是必须传参
+    * /home/name?person=xyz 或 /home/name
+    */
+    @RequestMapping(value = “/name”)
+    String getName(@RequestParam(value = "person”, required = false) String personName) {
+        return "Required element of request param”;
+    }
+    /**
+    * 请求类型，请求参数，默认值
+    */
+    @RequestMapping(value = "/name", method = RequestMethod.GET)
+    String getName(@RequestParam(value = "person", defaultValue = "John") String personName) {
+        return "Required element of request param";
+    }
+    /**
+    * 产生一个 JSON 响应
+    */
+    @RequestMapping(value = "/prod", produces = {
+        "application/JSON"
+    })
+    @ResponseBody
+    String getProduces() {
+        return "Produces attribute";
+    }
+    /**
+    * 可以同时处理请求中的 JSON 和 XML 内容
+    */
+    @RequestMapping(value = "/cons", consumes = {
+        "application/JSON",
+        "application/XML"
+    })
+    String getConsumes() {
+        return "Consumes attribute";
+    }
+    /**
+    * 根据请求中的消息头内容缩小请求映射的范围
+    */
+    @RequestMapping(value = “/head”, headers = {
+        "content-type=text/plain”,
+        "content-type=text/html"
+    })
+    String post() {
+        return "Mapping applied along with headers”;
+    }
+    /**
+    * 可以让多个处理方法处理到同一个URL 的请求, 而这些请求的参数是不一样的
+    */
+    @RequestMapping(value = “/fetch”, params = {
+        "personId=10"
+    })
+    String getParams(@RequestParam(“personId”) String id) {
+        return "Fetched parameter using params attribute = " + id;
+    }
+    /**
+    * 使用正则表达式来只处理可以匹配到正则表达式的动态 URI
+    */
+    @RequestMapping(value = “/fetch/{id:[a-z]+}/{name}”, method = RequestMethod.GET)
+    String getDynamicUriValueRegex(@PathVariable(“name”) String name) {
+        System.out.println(“Name is " + name);
+        return "Dynamic URI parameter fetched using regex”;
+    }
+    /**
+    * 向 /home 发起的一个请求将会由 default() 来处理，因为注解并没有指定任何值
+    */
+    @RequestMapping()
+    String
+    default () {
+        return "This is a default method for the class”;
+    }
+}
+```
+
+
+
+### @RequestBody
+允许request的参数在request体中，而不是在直接连接的地址后面。（放在参数前）
+
+### @PathVariable
+用于接收路径参数，比如@RequestMapping(“/hello/{name}”)声明的路径，将注解放在参数前，即可获取该值，通常作为Restful的接口实现方法。
+
+用于将请求URL中的模板变量映射到功能处理方法的参数上，即取出uri模板中的变量作为参数。
+
+```java
+@Controller
+public [cnblogs.com/GoCircle]class="hljs-keyword">class TestController {
+    @RequestMapping(value="/user/{userId}/roles/{roleId}",method = RequestMethod.GET)
+    public String getLogin(@PathVariable("userId") String userId,@PathVariable("roleId") String roleId){
+        System.out.println("User Id : " + userId);
+        System.out.println("Role Id : " + roleId);
+        return "hello";
+    }
+    @RequestMapping(value="/product/{productId}",method = RequestMethod.GET)
+    public String getProduct(@PathVariable("productId") String productId){
+        System.out.println("Product Id : " + productId);
+        return "hello";
+    }
+    @RequestMapping(value="/javabeat/{regexp1:[a-z-]+}",
+    method = RequestMethod.GET)
+    public String getRegExp(@PathVariable("regexp1") String regexp1){
+        System.out.println("URI Part 1 : " + regexp1);
+        return "hello";
+    }
+```
+### @RequestParam
+@RequestParam主要用于在SpringMVC后台控制层获取参数，类似一种是request.getParameter("name")，它有三个常用参数：defaultValue = "0", required = false, value = "isApp"；defaultValue 表示设置默认值，required 通过boolean设置是否是必须要传入的参数，value 值表示接受的传入的参数类型。
+```java
+public Resp test(@RequestParam(value="course_id") Integer id){
+    return Resp.success(customerInfoService.fetch(id));
+}
+```
+### @ResponseBody
+Spring4后出现的注解。支持将返回值放到response内，而不是一个页面，通常用户返回json数据。
+
+作用： 该注解用于将Controller的方法返回的对象，用于构建RESTful的api，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。
+
+使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用。
+```java
+@RequestMapping(“/test”)
+@ResponseBody
+public String test(){
+    return”ok”;
+}
+```
+### @ResponseStatus
+此注解用于方法和exception类上，声明此方法或者异常类返回的http状态码。可以在Controller上使用此注解，这样所有的@RequestMapping都会继承。
+
+
+### @ControllerAdvice
+全局异常处理
+全局数据绑定
+全局数据预处理
+ControllerAdvice的常用场景
+
+### @ExceptionHandler
+用于全局处理控制器里的异常。
+
+### @InitBinder
+用来设置WebDataBinder，WebDataBinder用来自动绑定前台请求参数到Model中。
+
+### @ModelAttribute
+（1）@ModelAttribute注释方法 
+
+如果把@ModelAttribute放在方法的注解上时，代表的是：该Controller的所有方法在调用前，先执行此@ModelAttribute方法。可以把这个@ModelAttribute特性，应用在BaseController当中，所有的Controller继承BaseController，即可实现在调用Controller时，先执行@ModelAttribute方法。比如权限的验证（也可以使用Interceptor）等。
+
+（2）@ModelAttribute注释一个方法的参数 
+
+当作为方法的参数使用，指示的参数应该从模型中检索。如果不存在，它应该首先实例化，然后添加到模型中，一旦出现在模型中，参数字段应该从具有匹配名称的所有请求参数中填充。
+
+
+hellorWord方法的userLogin参数的值来源于getUserLogin()方法中的model属性。
+
+
+### @SessionAttribute
+此注解用于方法的参数上，用于将session中的属性绑定到参数。
+### @CookieValue
+此注解用在@RequestMapping声明的方法的参数上，可以把HTTP cookie中相应名称的cookie绑定上去。cookie即http请求中name为JSESSIONID的cookie值。
+```
+@ReuestMapping("/cookieValue")
+publicvoid getCookieValue(@CookieValue("JSESSIONID") String cookie){
+}
+```
--- a/Spring/注解编程03-jpa.md
+++ b/Spring/注解编程03-jpa.md
@@ -0,0 +1,43 @@
+
+## 16 Springboot JPA注解
+### @Entity
+### @Table(name=”“)
+表明这是一个实体类。一般用于jpa这两个注解一般一块使用，但是如果表名和实体类名相同的话，@Table可以省略
+
+### @MappedSuperClass
+
+用在确定是父类的entity上。父类的属性子类可以继承。
+
+### @NoRepositoryBean
+一般用作父类的repository，有这个注解，spring不会去实例化该repository。
+
+### @Column
+如果字段名与列名相同，则可以省略。
+
+### @Id
+表示该属性为主键。
+
+### @GeneratedValue
+
+@GeneratedValue(strategy = GenerationType.SEQUENCE,generator = “repair_seq”)
+表示主键生成策略是sequence（可以为Auto、IDENTITY、native等，Auto表示可在多个数据库间切换），指定sequence的名字是repair_seq。
+
+### @SequenceGeneretor
+
+@SequenceGeneretor(name = “repair_seq”, sequenceName = “seq_repair”, allocationSize = 1)
+name为sequence的名称，以便使用，sequenceName为数据库的sequence名称，两个名称可以一致。
+
+### @Transient
+表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性。如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则,ORM框架默认其注解为@Basic。@Basic(fetch=FetchType.LAZY)：标记可以指定实体属性的加载方[cnblogs.com/GoCircle]式
+
+### @JsonIgnore
+作用是json序列化时将Java bean中的一些属性忽略掉,序列化和反序列化都受影响。
+
+### @JoinColumn（name=”loginId”）
+[欢迎转载听雨的人博客cnblogs.com/GoCircle]一对一：本表中指向另一个表的外键。一对多：另一个表指向本表的外键。
+
+### @OneToOne、@OneToMany、@ManyToOne
+
+
+对应hibernate配置文件中的一对一，一对多，多对一。
+
--- a/Spring/注解编程04-lombok.md
+++ b/Spring/注解编程04-lombok.md
@@ -0,0 +1,92 @@
+
+
+
+## 17 Lombok
+### @Slf4j
+自动生成该类的 log 静态常量，要打日志就可以直接打，不用再手动 new log 静态常量。
+```java
+public class User{
+    private static final Logger log = LoggerFactory.getLogger(User.class);
+    public static void main(String[] args){
+        log.info("hi");
+    }
+}
+@Slf4j
+public class User{
+    public static void main(String[] args){
+        log.info("hi");
+    }
+}
+```
+### @Log4j2
+注解在类上。为类提供一个属性名为log 的 log4j 日志对象，和@Log4j注解类似。
+
+### @Setter
+注解在属性上。为属性提供 setting 方法。
+
+### @Getter
+注解在属性上。为属性提供 getting 方法。
+
+### @ToString
+生成toString方法，默认情况下，会输出类名、所有属性，属性会按照顺序输出，以逗号分割。
+
+### @EqualsAndHashCode
+默认情况下，会使用所有非瞬态(non-transient)和非静态(non-static)字段来生成equals和hascode方法，也可以指定具体使用哪些属性。
+
+如果某些变量不想要加进判断，可以透过 exclude 排除，也可以使用 of 指定某些字段。
+```java
+@EqualsAndHashCode(exclude = "name")
+public class User{
+    private String name;
+    private Integer age;
+}
+```
+
+### @Data
+注解在类上。等同于添加如下注解：
+```java
+@Getter/@Setter
+
+@ToString
+
+@EqualsAndHashCode
+
+@RequiredArgsConstructor
+```
+
+
+### @NoArgsConstructor
+
+注解在类上。为类提供一个无参的构造方法。
+
+### @AllArgsConstructor
+
+ 注解在类上。为类提供一个全参的构造方法
+### @RequiredArgsConstructor
+
+生成一个包含 "特定参数"的构造器，特定参数指的是那些有加上 final 修饰词的变量。
+
+### @NonNull
+注解在属性上，如果注解了，就必须不能为Null。
+
+### @Nullable
+注解在属性上，如果注解了，就必须可以为Null。
+
+### @Value
+也是整合包，但是他会把所有的变量都设成 final 的，其他的就跟 @Data 一样，等于同时加了以下注解：
+```java
+@Getter (注意没有setter)
+
+@ToString
+
+@EqualsAndHashCode
+
+@RequiredArgsConstructor
+```
+
+### @Builder
+自动生成流式 set 值写法，从此之[By cnblogs.com/GoCircle]后再也不用写一堆 setter 了。
+
+注意，虽然只要加上 @Builder 注解，我们就能够用流式写法快速设定对象的值，但是 setter 还是必须要写不能省略的，因为 Spring 或是其他框架有很多地方都会用到对象的 getter/setter 对他们取值/赋值。
+
+所以通常是 @Data 和 @Builder 会一起用在同个类上，既方便我们流式写代码，也方便框架做事。
--- a/mavenPOM.md
+++ b/mavenPOM.md
@@ -5,13 +5,12 @@ POM( Project Object Model，项目对象模型 ) 是 Maven 工程的基本工作

 pom.xml 项目模型对象文件。POM 中可以指定以下配置：

-* 项目依赖
-* 插件：执行目标
-* 项目构建 profile
-* 项目版本
-* 项目开发者列表
-* 相关邮件列表信息
-
+* 坐标GAV、Name、pakage、author
+* 项目依赖 dependencies/dependency
+* 项目模块 modules/module
+* 项目集成 parent
+* 项目构建 build、plugins/plugin
+* 配置文件 profiles/profile

 ### pom工程之间的关系
 * 在dependency中的依赖关系。
@@ -162,12 +161,44 @@ Maven工程之间，A工程继承B工程

    ${com.ykl.spring.version}
 ```
+
 ### 实际意义

 ![](image/2022-11-05-21-14-18.png)

 * 梳理出一整套版本之间依赖的方案。与我们的火车头版本很想，会总结出一套可以相互兼容没有问题的中间件的合集。

+### 继承内容
+
+父POM中的大多数元素都能被子POM继承，这些元素包含：
+
+```
+groupId
+version
+description
+url
+inceptionYear
+organization
+licenses
+developers
+contributors
+mailingLists
+scm
+issueManagement
+ciManagement
+properties
+dependencyManagement
+dependencies
+repositories
+pluginRepositories
+build
+plugin executions with matching ids
+plugin configuration
+etc.
+reporting
+profiles
+```
+
 ## 4 聚合关系modules

 ### 聚合的含义
--- a/maven与Idea.md
+++ b/maven与Idea.md
@@ -14,6 +14,8 @@
 1. 扳手：配置maven
 2. 打开关闭目录
 3. M：表示执行maven命令
+4. 展示依赖关系图
+5. 查看依赖树


 ## 3 工程导入
--- a/maven命令插件Plugins.md
+++ b/maven命令插件Plugins.md
@@ -85,7 +85,7 @@ mvn archetype:generate -DgroupId=com.ykl -DartifactId=project04-maven-import -Da



-### mvn差价dependcy:依赖管理和分析
+### dependcy:依赖管理和分析


 * 查看依赖列表
--- a/maven/maven源码/resteasytest/.idea/jarRepositories.xml
+++ b/maven/maven源码/resteasytest/.idea/jarRepositories.xml
@@ -21,6 +21,11 @@
      <option name="name" value="alibaba" />
      <option name="url" value="http://mvnrepo.alibaba-inc.com/mvn/repository" />
    </remote-repository>
+    <remote-repository>
+      <option name="id" value="jboss" />
+      <option name="name" value="jboss" />
+      <option name="url" value="http://repository.jboss.org/maven2" />
+    </remote-repository>
    <remote-repository>
      <option name="id" value="central" />
      <option name="name" value="Maven Central repository" />
--- a/maven/maven源码/resteasytest/pom.xml
+++ b/maven/maven源码/resteasytest/pom.xml
@@ -17,6 +17,12 @@
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>
+  <repositories>
+    <repository>
+      <id>jboss</id>
+      <url>http://repository.jboss.org/maven2</url>
+    </repository>
+  </repositories>

  <dependencies>
    <dependency>
@@ -25,8 +31,29 @@
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
+    <!-- core library -->
+    <dependency>
+      <groupId>org.jboss.resteasy</groupId>
+      <artifactId>resteasy-jaxrs</artifactId>
+      <version>3.0.2.Final</version>
+    </dependency>
+    <!-- JAXB support -->
+    <dependency>
+      <groupId>org.jboss.resteasy</groupId>
+      <artifactId>resteasy-jaxb-provider</artifactId>
+      <version>3.0.2.Final</version>
+    </dependency>
+    <dependency>
+      <groupId>org.jboss.resteasy</groupId>
+      <artifactId>jaxrs-api</artifactId>
+      <version>3.0.2.Final</version>
+    </dependency>
+    <dependency>
+      <groupId>org.jboss.resteasy</groupId>
+      <artifactId>resteasy-client</artifactId>
+      <version>3.0.2.Final</version>
+    </dependency>
  </dependencies>
-
  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
--- a/maven/maven源码/resteasytest/src/main/java/org/example/App.java
+++ b/maven/maven源码/resteasytest/src/main/java/org/example/App.java
@@ -1,13 +1,30 @@
 package org.example;

+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.DefaultHttpClient;
+import org.apache.http.util.EntityUtils;
+
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.core.Response;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.Unmarshaller;
+import java.io.StringReader;
+import org.jboss.resteasy.client.jaxrs.ResteasyClient;
+import org.jboss.resteasy.client.jaxrs.ResteasyClientBuilder;
+import org.jboss.resteasy.client.jaxrs.ResteasyWebTarget;
 /**
 * Hello world!
 *
 */
 public class App 
 {
-    public static void main( String[] args )
-    {
-        System.out.println( "Hello World!" );
-    }
+
+
+}
+
+class User{
+
 }