Update Java Notes

Seazean · Seazean · commit 5ab0f3ae6826 · 2021-04-22T22:09:10.000+08:00
diff --git a/Frame.md b/Frame.md
@@ -8282,7 +8282,7 @@ ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.
       * **AOP，跳转注解**，`AbstractAutoProxyCreatorwrapIfNecessary -> creatProxy`
       * 如果不存在循环依赖，动态代理在此处完成，否则会提前创建
     
-  * 循环依赖检查：如果存在循环依赖，在属性填充阶段会生成Bean对象的动态代理，则缓存中放置了提前生成的代理对象，然后使用原始bean继续执行初始化，所以返回最终bean前，把原始bean置换为代理对象返回；
+  * 循环依赖检查：如果存在循环依赖，在属性填充阶段会生成Bean对象的动态代理，则缓存中放置了提前生成的代理对象，然后使用原始bean继续执行初始化，所以返回最终bean前，把原始bean置换为代理对象返回
   
     存在循环依赖，在初始化的后置处理中不会重新创建代理对象，真正创建动态代理Bean的阶段是在获取提前引用阶段，**循环依赖**详解，看后置处理源码：  
   
@@ -8622,21 +8622,20 @@ AnnotationAwareAspectJAutoProxyCreator是这种类型的后置处理器：Instan
    `if(是否实现接口)`为真进入：`applyBeanPostProcessorsBeforeInstantiation`方法
 
    * `this.advisedBeans.containsKey(cacheKey)`：判断当前bean是否在advisedBeans中（保存了所有需要增强bean）
-
-   * `isInfrastructureClass`：判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，或者（子类中）是否是切面Aspect
-
+* `isInfrastructureClass`：判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，或者（子类中）是否是切面Aspect
    * 是否需要跳过：子类`AspectJAwareAdvisorAutoProxyCreator.shouldSkip()`
 
      * `findCandidateAdvisors()`：获取候选的增强器（切面里面的通知方法）每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor**（AAAPC）**
 
      * `if()`：判断每一个增强器是否是 AspectJPointcutAdvisor 类型的，返回true，否则继续执行
-     * `return super.shouldSkip(beanClass, beanName)`：永远返回false  
-
+  * `return super.shouldSkip(beanClass, beanName)`：永远返回false  
    * `getCustomTargetSource(beanClass, beanName)`：返回为空，doCreateBean()
+   
 
-   **进入applyBeanPostProcessorsAfterInitialization：后置处理器创建AOP**
-
-   ```java
+   
+**进入applyBeanPostProcessorsAfterInitialization：后置处理器创建AOP**
+   
+```java
    //如果Bean被子类标识为要代理的bean，则使用配置的拦截器创建代理
    public Object postProcessAfterInitialization(@Nullable Object bean,String bN){
        if (bean != null) {
@@ -8650,32 +8649,32 @@ AnnotationAwareAspectJAutoProxyCreator是这种类型的后置处理器：Instan
        return bean;
    }
    ```
-
-   创建动态代理：`wrapIfNecessary()`调用`createProxy()`（wrap包装）
-
-   注释：Create proxy if we have advice
-
-   * `getAdvicesAndAdvisorsForBean()`：获取当前bean的所有增强器 (通知方法)，**为空就直接返回**
-
-     * findEligibleAdvisors()：找到哪些通知方法是需要切入当前bean方法的
+   
+创建动态代理：`wrapIfNecessary()`调用`createProxy()`（wrap包装）
+   
+注释：Create proxy if we have advice
+   
+* `getAdvicesAndAdvisorsForBean()`：获取当前bean的所有增强器 (通知方法)，**为空就直接返回**
+   
+  * findEligibleAdvisors()：找到哪些通知方法是需要切入当前bean方法的
      * AopUtils.findAdvisorsThatCanApply()：获取到能在bean使用的增强器
      * sortAdvisors(eligibleAdvisors)：给增强器排序
-
-   * `this.advisedBeans.put(cacheKey, Boolean.TRUE)`：保存当前bean在advisedBeans中
-
-   * `Object proxy = createProxy(...)`：如果增强器不为空就创建代理，创建当前bean的代理对象
-
-     * buildAdvisors(beanName, specificInterceptors)：获取所有增强器（通知方法）
-
-     * 保存到proxyFactory
-
-     * `return proxyFactory.getProxy(getProxyClassLoader())`：返回代理对象
-
-     * ProxyFactory类：`return createAopProxy().getProxy(classLoader)`
-
-     DefaultAopProxyFactory类：给容器中返回当前组件使用增强了的代理对象
-
-     ```java
+   
+* `this.advisedBeans.put(cacheKey, Boolean.TRUE)`：保存当前bean在advisedBeans中
+   
+* `Object proxy = createProxy(...)`：如果增强器不为空就创建代理，创建当前bean的代理对象
+   
+  * buildAdvisors(beanName, specificInterceptors)：获取所有增强器（通知方法）
+   
+  * 保存到proxyFactory
+   
+  * `return proxyFactory.getProxy(getProxyClassLoader())`：返回代理对象
+   
+  * ProxyFactory类：`return createAopProxy().getProxy(classLoader)`
+   
+  DefaultAopProxyFactory类：给容器中返回当前组件使用增强了的代理对象
+   
+  ```java
      @Override
      public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
          if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
@@ -8691,7 +8690,7 @@ AnnotationAwareAspectJAutoProxyCreator是这种类型的后置处理器：Instan
          }
      }
      ```
-
+   
 4. 给容器中返回使用cglib增强了的代理对象，**初始化完成，加入容器**
 
 5. 以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程
diff --git a/Java.md b/Java.md
@@ -2779,7 +2779,7 @@ public class Student {
 
 #### 概述
 
-**String 被声明为 final，因此它不可被继承 (Integer 等包装类也不能被继承）**
+**String 被声明为 final，因此不可被继承 (Integer 等包装类也不能被继承）**
 
 ```java
 public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
@@ -2790,8 +2790,9 @@ public final class String implements java.io.Serializable, Comparable<String>, C
 }
 ```
 
-在 Java 9 之后，String 类的实现改用 byte 数组存储字符串，同时使用 `coder` 来标识使用了哪种编码。
-value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组，并且 String 内部没有改变 value 数组的方法，因此可以**保证 String 不可变**，也保证线程安全
+在 Java 9 之后，String 类的实现改用 byte 数组存储字符串，同时使用 `coder` 来标识使用了哪种编码
+
+value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组，并且 String 内部没有改变 value 数组的方法，因此可以**保证 String 不可变，也保证线程安全**
 
 **注意：不能改变的意思是每次更改字符串都会产生新的对象，并不是对原始对象进行改变**
 
@@ -2818,13 +2819,10 @@ s = s + "cd"; //s = abccd 新对象
 
 使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 "abc" 字符串对象）:
 
-- 通过构造方法创建
-
-  通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
+- 通过构造方法创建：通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
 
-- 直接赋值方式创建
+- 直接赋值方式创建：以“ ”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会在 String Pool 中创建一个字符串对象，并在字符串池中维护
 
-  以“ ”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会在 String Pool 中创建一个字符串对象，并在字符串池中维护
 
 #### 常用API
 
@@ -14595,7 +14593,9 @@ public class MyRunnable implements Runnable{
 	5.把未来任务对象包装成线程对象
 	6.调用线程的start()方法启动线程
 
-`public FutureTask(Callable<V> callable)`：未来任务对象，其实就是一个Runnable对象，这样就被包装成线程对象，未来任务对象可以在线程执行完毕之后去**得到线程的执行结果**
+`public FutureTask(Callable<V> callable)`：未来任务对象，在线程执行完后**得到线程的执行结果**
+
+* 其实就是Runnable对象，这样被包装成未来任务对象
 
 `public V get()`：同步等待 task 执行完毕的结果
 
@@ -18098,6 +18098,93 @@ class MyAtomicInteger {
 
 
 
+***
+
+
+
+### final
+
+#### 原理
+
+```java
+public class TestFinal {
+	final int a = 20;
+}
+```
+
+字节码：
+
+```java
+0: aload_0
+1: invokespecial #1 // Method java/lang/Object."<init>":()V
+4: aload_0
+5: bipush 20	//将值直接放入栈中
+7: putfield #2 // Field a:I
+<-- 写屏障
+10: return
+```
+
+final 变量的赋值通过 putfield 指令来完成，在这条指令之后也会加入写屏障，保证在其它线程读到它的值时不会出现为 0 的情况
+
+其他线程访问final修饰的变量会复制一份放入栈中，效率更高
+
+
+
+***
+
+
+
+#### 不可变
+
+不可变：如果一个对象不能够修改其内部状态（属性），那么就是不可变对象
+
+不可变对象线程安全的，因为不存在并发修改，是另一种避免竞争的方式
+
+String 类也是不可变的，该类和类中所有属性都是 final 的
+
+* 类用 final 修饰保证了该类中的方法不能被覆盖，防止子类无意间破坏不可变性保
+
+* 属性用 final 修饰保证了该属性是只读的，不能修改
+
+  ```java
+  public final class String
+      implements java.io.Serializable, Comparable<String>, CharSequence {
+      /** The value is used for character storage. */
+      private final char value[];
+      //....
+  }
+  ```
+
+更改String类数据时，会构造新字符串对象，生成新的 char[] value，这种通过创建副本对象来避免共享的方式称之为**保护性拷贝（defensive copy）**
+
+
+
+***
+
+
+
+### 无状态
+
+无状态：因为成员变量保存的数据也可以称为状态信息，因此没有成员变量
+
+Servlet 为了保证其线程安全，一般不为 Servlet 设置成员变量，这种没有任何成员变量的类是线程安全的
+
+
+
+***
+
+
+
+## 线程池
+
+
+
+
+
+
+
+
+
 
 
 
diff --git a/Web.md b/Web.md
@@ -5167,7 +5167,7 @@ Filter：过滤器，是JavaWeb三大组件之一，另外两个是Servlet和Lis
 
 
 
-### Filter相关类
+### 相关类
 
 #### Filter类
 
@@ -5584,11 +5584,13 @@ Filter初始化函数init的参数是FilterConfig 对象
 
 
 
-### 五种拦截行为
+### 拦截行为
 
 Filter过滤器默认拦截的是请求，但是在实际开发中，我们还有请求转发和请求包含，以及由服务器触发调用的全局错误页面。默认情况下过滤器是不参与过滤的，需要配置web.xml
 
-开启功能后，当访问页面发生相关行为后，会执行过滤器的操作。
+开启功能后，当访问页面发生相关行为后，会执行过滤器的操作
+
+五种拦截行为：
 
 ```xml
 <!--配置过滤器-->
@@ -5669,7 +5671,7 @@ Filter过滤器默认拦截的是请求，但是在实际开发中，我们还
 
 
 
-### 过滤器与Servlet
+### 对比Servlet
 
 | 方法/类型                                          | Servlet                           | Filter                                        | 备注                                                         |
 | -------------------------------------------------- | --------------------------------- | --------------------------------------------- | ------------------------------------------------------------ |
