Vue的生命周期及其相应的三个阶段解读
 
1、生命周期的概念：
 
​ vue中的生命周期指的是 组件 从创建到销毁一个过程，在这个过程中，我们在每一个特定的阶段会触发一些方法（ 这些方法具备一些功能），我们给这些方法起了个名字叫做 生命周期钩子函数（组件钩子 ）。
 
2、为什么要学习生命周期？
 
​ 因为我们想在生命周期钩子中实现项目功能，那么我们必须知道每一个钩子函数的具体用途。
 
3、Vue生命周期的三个阶段：
 
​ Vue的生命周期分为三个阶段，分别为： 初始化，运行中 和 销毁，一共8个钩子函数。
 
注意： 生命周期钩子函数不允许写成箭头函数，因为这里使用箭头函数就会改变this的指向
 
​ -------------------------- 1初始化------------------------------
 
​ beforeCreate
 
​ 1. 组件创建前触发，任务是为了组件的生命周期 和 组件中的事件做准备
 
​ 2. 数据没有获得，真实dom也没有渲染出来
 
​ 3. 可以进行数据请求，提供了一次数据修改的机会
 
​ 4. 执行一次
 
​
 
​ created
 
​ 1. 组件创建结束，任务是数据注入和反应
 
​ 2. 数据得到了(如果修改了数据，这里得到的也是旧数据)，真实dom没有渲染出来
 
​ 3. 可以进行数据请求，提供了一次数据修改的机会
 
​ 4. 执行了一次
 
​ beforeMount
 
​ 1. 组件挂载前
 
​ 2. 任务： 判断el 和 template
 
​ 如果el没有，那么我们需要手动挂载new Vue().$mount(’#app’)，如果有，那么判断template
 
​ 如果template有，那么进行render函数，将template即jsx转成vdom
 
​ 如果template没有，那么通过 outerHTML 手动书写模板
 
​ 3. 数据可以获得(旧数据)，但是真实dom还没有渲染
 
​ 4. 可以进行数据请求，也提供了一次数据修改的机会
 
​ 5. 执行一次
 
​ mounted
 
​ 1. 组件挂载结束，任务是将vdom渲染成真实dom，然后挂载到页面
 
​ 2. 数据获得了(旧数据)，真实dom也获得了
 
​ 3. 可以进行数据请求，也可以修改数据
 
​ 4. 执行了一次
 
​ 5. 可以进行真实dom的操作了（ 可以进行第三方库静态数据的实例化了 ）
 
​ 综上总结：
 
​ 1. 数据请求一般写在created里面（因为这里第一次得到数据）
 
​ 2. 第三方库实例化我们一般会往mounted中写（静态的数据）
 
​ -------------------------- 2运行中------------------------------
 
​ 触发条件：数据更新
 
​ beforeUpdate
 
​ 1. 更新前
 
​ 2. 任务是重新渲染 VDOM , 然后通过diff算法比较两次vdom,生成patch 补丁对象
 
​ 3. 这个钩子函数更多的是内部进行一些操作，我们就不再多干预了
 
​ 4. 可以触发多次
 
​ updated
 
​ 1. 更新结束，任务是将patch对象渲染成真实dom
 
​ 2. 真实dom得到了，数据也得到了（ 更新后的新数据）
 
​ 3. 动态数据获取（ 第三方库实例化 ）
 
​ -------------------------- 3销毁------------------------------
 
Vue的销毁有两种形式
 
​ 1. 通过开关的形式
 
​ 2. 通过调用 $destroy 方法（这种还需要手动销毁dom外壳）
 
​ -------------------- vue生命周期的销毁阶段 -------------------
 
​ 触发条件： 当组件销毁时：
 
​ beforeDestroy
 
​ destroyed
 
​ 这两个钩子功能一致的，这两个钩子没有太大的区别
 
​ 作用：
 
​ 用来做善后的,比如计时器的关闭、第三方实例的删除

一个Java类被加载到虚拟机中，它的生命周期才算开始，直到被从内存中卸载，它的生命周期才算结束。从开始到结束，它的整个生命周期包括加载、验证、准备、解析、初始化、使用和卸载7个阶段，其中验证、准备和解析3个阶段又被统称为连接。
 
加载
 
加载阶段主要完成以下三件事： 
 1.通过一个类的全限定名来获取此类的二进制字节流； 
 2.将这个二进制字节流所代表的静态存储结构转为方法区的运行时数据结构； 
 3.在内存中生成一个代表此类的java.lang.Class的对象，作为访问这个类的入口。
 
验证
 
验证阶段主要是为了保证从加载阶段获取的字节流中包含的信息是符合虚拟机要求，并且对虚拟机来说是安全的。这个阶段主要完成4个方面的校验工作，包括文件格式验证、元数据验证、字节码验证和符号引用验证。
 
文件格式验证主要是验证字节流是否符合Class文件格式规范，以及字节流能否被虚拟机处理，例如字节流文件是否以魔数0xCAFEBABE开头、主次版本号是否是虚拟机能处理的版本等。
 
元数据验证主要是对字节码描述的信息进行语义分析，用来确保字节码描述信息符合Java语言规范，例如类的继承关系、类是否继承了不允许被继承的类、类实现了接口是否实现了接口中的所有方法等。
 
字节码验证主要是通过数据流和控制流来分析和确定程序的语义是否合法、符合逻辑，例如验证操作数栈中数据的存取是否会出现类型不匹配、跳转指令是否会跳转到方法体以外的字节码指令上等。
 
符号引用验证主要是确保解析动作能够正常执行，主要对常量池中的符号引用进行匹配性校验，例如符号引用中的类、属性和方法的访问性是否可以被当前类访问、能否通过字符串描述的全限定名来找到对应的类等。
 
准备
 
准备阶段正式为static修饰的变量分配内存并设置初始值。
 
解析
 
解析阶段将常量池中的符号引用替换为直接引用。 
 符号引用就是以一组符号来描述所引用的目标，它能够定位到目标。 
 直接引用就是直接指向目标的指针、相对偏移量或一个能够间接定位到目标的句柄。
 
初始化
 
初始化阶段按照程序员编写的代码给类变量赋值和执行其它资源，例如执行类变量的赋值操作和执行静态语句块等。
 
使用
 
使用阶段就是对象的初始化、操作和回收。
 
卸载
 
卸载阶段就是内存中不再存在该类的引用，完成从内存卸载的过程。 
 

java对象生命周期
 
对象的整个生命周期大致可以分为7个阶段：创建阶段（Creation）、应用阶段（Using）、不可视阶段（Invisible）、不可到达阶段（Unreachable）、可收集阶段（Collected）、终结阶段（Finalized）与释放阶段（Free）。
 
创建阶段
 
一个Java类（除Object类外）至少有一个父类（Object），这个规则既是强制的，也是隐式的。你可能已经注意到在创建一个Java类的时候，并没有显式地声明扩展（extends）一个Object父类。
 
public class A { 
     … 
} 
这个声明等同于下面的声明： 
public class A extends java.lang.Object { 
     … 
} 
 
创建对象时应该遵循的规则
 
避免在循环体中创建对象，即使该对象占用内存空间不大。
 
… … 
for (int i = 0; i < 10000; ++i) { 
    Object obj = new Object(); 
    System.out.println("obj= "+ obj); 
} 
… … 
 
上面这种写法违法了该规则，会浪费大量空间。
 
… … 
Object obj = null; 
for (int i = 0; i < 10000; ++i) { 
    obj = new Object(); 
    System.out.println("obj= "+ obj); 
} 
… … 
 
这种写法，仅在内存中保存一份对该对象的引用，而不像上面的第一种编写方式中代码会在内存中产生大量的对象应用，浪费大量的内存空间，而且增大了系统做垃圾回收的负荷。
 
不要对一个对象进行多次初始化，这同样会带来较大的内存开销，降低系统性能。
 
应用阶段
 
强引用
 
强引用（Strong Reference）是指JVM内存管理器从根引用集合（Root Set）出发遍寻堆中所有到达对象的路径。当到达某对象的任意路径都不含有引用对象时，对这个对象的引用就被称为强引用。
 
软引用
 
软引用（Soft Reference）的主要特点是具有较强的引用功能。只有当内存不够的时候，才回收这类内存，因此在内存足够的时候，它们通常不被回收。
 
… … 
import java.lang.ref.SoftReference; 
… 
A a = new A(); 
… 
// 使用 a 
… 
// 使用完了a，将它设置为soft 引用类型，并且释放强引用； 
SoftReference sr = new SoftReference(a); 
a = null; 
… 
// 下次使用时 
if (sr!=null) { 
     a = sr.get(); 
} 
else{ 
     // GC由于内存资源不足，可能系统已回收了a的软引用， 
     // 因此需要重新装载。 
     a = new A(); 
     sr=new SoftReference(a); 
} 
 
弱引用
 
GC在进行回收时，需要通过算法检查是否回收Soft引用对象，而对于Weak引用对象， GC总是进行回收。因此Weak引用对象会更容易、更快被GC回收。
 
… … 
import java.lang.ref.WeakReference; 
… 
A a = new A(); 
… 
// 使用 a 
… 
// 使用完了a，将它设置为weak 引用类型，并且释放强引用； 
WeakReference wr = new WeakReference (a); 
a = null; 
… 
// 下次使用时 
if (wr!=null) { 
    a = wr.get(); 
} 
else{ 
    a = new A(); 
    wr = new WeakReference (a); 
} 
… … 
 
虚引用
 
虚引用（Phantom Reference）的用途较少，主要用于辅助finalize函数的使用。Phantom对象指一些执行完了finalize函数，并且为不可达对象，但是还没有被GC回收的对象。
 
不可视阶段
 
… … 
public void process () { 
    try { 
         Object obj = new Object(); 
         obj.doSomething(); 
     } catch (Exception e) { 
     e.printStackTrace(); 
     } 
     while (isLoop) { // ... loops forever 
      // 这个区域对于obj对象来说已经是不可视的了 
         // 因此下面的代码在编译时会引发错误 
         obj.doSomething();  
     } 
} 
… … 
 
如果一个对象已使用完，而且在其可视区域不再使用，此时应该主动将其设置为空（null）。可以在上面的代码行obj.doSomething();下添加代码行obj = null;，这样一行代码强制将obj对象置为空值。这样做的意义是，可以帮助JVM及时地发现这个垃圾对象，并且可以及时地回收该对象所占用的系统资源。
 
不可到达阶段
 
在虚拟机所管理的对象引用根集合中再也找不到直接或间接的强引用，这些对象通常是指所有线程栈中的临时变量，所有已装载的类的静态变量或者对本地代码接口（JNI）的引用。这些对象都是要被垃圾回收器回收的预备对象，但此时该对象并不能被垃圾回收器直接回收。其实所有垃圾回收算法所面临的问题是相同的——找出由分配器分配的，但是用户程序不可到达的内存块。
 
可收集阶段、终结阶段与释放阶段
 
垃圾回收器发现该对象已经不可到达。
finalize方法已经被执行。
对象空间已被重用。
 
当对象处于上面的三种情况时，该对象就处于可收集阶段、终结阶段与释放阶段了。虚拟机就可以直接将该对象回收了。
 
java类生命周期
 
一个java类的完整的生命周期会经历加载、连接、初始化、使用、和卸载五个阶段
 
jvm（java虚拟机）中的几个比较重要的内存区域
 
方法区：在java的虚拟机中有一块专门用来存放已经加载的类信息、常量、静态变量以及方法代码的内存区域，叫做方法区。
常量池：常量池是方法区的一部分，主要用来存放常量和类中的符号引用等信息。
堆区：用于存放类的对象实例。
栈区：也叫java虚拟机栈，是由一个一个的栈帧组成的后进先出的栈式结构，栈桢中存放方法运行时产生的局部变量、方法出口等信息。当调用一个方法时，虚拟机栈中就会创建一个栈帧存放这些数据，当方法调用完成时，栈帧消失，如果方法中调用了其他方法，则继续在栈顶创建新的栈桢。
 
初始化
 
如果一个类被直接引用，就会触发类的初始化。在java中，直接引用的情况有：
 
通过new关键字实例化对象、读取或设置类的静态变量、调用类的静态方法。
通过反射方式执行以上三种行为。
初始化子类的时候，会触发父类的初始化。
作为程序入口直接运行时（也就是直接调用main方法）。
除了以上四种情况，其他使用类的方式叫做被动引用，而被动引用不会触发类的初始化。
 
卸载
 
在类使用完之后，如果满足下面的情况，类就会被卸载：
 
该类所有的实例都已经被回收，也就是java堆中不存在该类的任何实例。
加载该类的ClassLoader已经被回收
该类对应的java.lang.Class对象没有任何地方被引用，无法在任何地方通过反射访问该类的方法

 Servlet生命周期分为三个阶段：
 
 　　1，初始化阶段  调用init()方法
 
 　　2，响应客户请求阶段　　调用service()方法
 
 　　3，终止阶段　　调用destroy()方法
 
 
 
 Servlet初始化阶段：
 
 　　在下列时刻Servlet容器装载Servlet：
 
 　　　　1，Servlet容器启动时自动装载某些Servlet，实现它只需要在web.XML文件中的<Servlet></Servlet>之间添加如下代码：
 
 
 
 
  
 
      
 
       
 
        <loadon-startup>
        1
        </loadon-startup> 
       
 
      
 
 
 
 
 
 　　　　2，在Servlet容器启动后，客户首次向Servlet发送请求
 
 　　　　3，Servlet类文件被更新后，重新装载Servlet
 
 　　Servlet被装载后，Servlet容器创建一个Servlet实例并且调用Servlet的init()方法进行初始化。在Servlet的整个生命周期内，init()方法只被调用一次。
 
 　　　　
 
 Servlet工作原理：
 
 　　首先简单解释一下Servlet接收和响应客户请求的过程，首先客户发送一个请求，Servlet是调用service()方法对请求进行响应的，通过源代码可见，service()方法中对请求的方式进行了匹配，选择调用doGet,doPost等这些方法，然后再进入对应的方法中调用逻辑层的方法，实现对客户的响应。在Servlet接口和GenericServlet中是没有doGet,doPost等等这些方法的，HttpServlet中定义了这些方法，但是都是返回error信息，所以，我们每次定义一个Servlet的时候，都必须实现doGet或doPost等这些方法。
 
 　　每一个自定义的Servlet都必须实现Servlet的接口，Servlet接口中定义了五个方法，其中比较重要的三个方法涉及到Servlet的生命周期，分别是上文提到的init(),service(),destroy()方法。GenericServlet是一个通用的，不特定于任何协议的Servlet,它实现了Servlet接口。而HttpServlet继承于GenericServlet，因此HttpServlet也实现了Servlet接口。所以我们定义Servlet的时候只需要继承HttpServlet即可。
 
 　　Servlet接口和GenericServlet是不特定于任何协议的，而HttpServlet是特定于HTTP协议的类，所以HttpServlet中实现了service()方法，并将请求ServletRequest,ServletResponse强转为HttpRequest和HttpResponse。
 
 
 
 
  
 
      
 
       
 
        public 
        void 
        service(ServletRequest req,ServletResponse res) 
       
 
       
 
          
        throws 
        ServletException,IOException
       
 
       
 
        {
       
 
       
 
              
        HttpRequest request;
       
 
       
 
              
        HttpResponse response;
       
 
       

          
       
 
       
 
             
        try
       
 
       
 
             
        {
       
 
       
 
                 
        req = (HttpRequest)request;
       
 
       
 
                 
        res = (HttpResponse)response;
       
 
       
 
              
        }
        catch
        (ClassCastException e)
       
 
       
 
              
        {
       
 
       
 
                 
        throw 
        new 
        ServletException(
        "non-HTTP request response"
        ); 
       
 
       
 
              
        }
       
 
       
 
              
        service(request,response);
       
 
       
 
        }
       
 
      
 
 
 
 
 
     代码的最后调用了HTTPServlet自己的service(request,response)方法，然后根据请求去调用对应的doXXX方法，因为HttpServlet中的doXXX方法都是返回错误信息，
 
 
 
 
  
 
      
 
       
 
        protected 
        void 
        doGet(HttpServletRequest res,HttpServletResponse resp)
       
 
       
 
          
        throws 
        ServletException,IOException
       
 
       
 
        {
       
 
       
 
           
        String protocol = req.getProtocol();
       
 
       
 
           
        String msg = IStrings.getString(
        "http.method_get_not_supported"
        );
       
 
       
 
           
        if
        (protocol.equals(
        "1.1"
        ))
       
 
       
 
           
        {
       
 
       
 
              
        resp.sendError(HttpServletResponse.SC.METHOD.NOT.ALLOWED,msg);
       
 
       
 
            
        }
       
 
       
 
           
        esle
       
 
       
 
            
        {
       
 
       
 
              
        resp.sendError(HttpServletResponse.SC_BAD_REQUEST,msg);
       
 
       
 
            
        }
       
 
       
 
        }
       
 
      
 
 
 
 
 
 所以需要我们在自定义的Servlet中override这些方法！
 
 
 
 　　　　源码面前，了无秘密！
 
 ---------------------------------------------------------------------------------------------------------------------------------
 
 Servlet响应请求阶段：
 
 　　对于用户到达Servlet的请求，Servlet容器会创建特定于这个请求的ServletRequest对象和ServletResponse对象，然后调用Servlet的service方法。service方法从ServletRequest对象获得客户请求信息，处理该请求，并通过ServletResponse对象向客户返回响应信息。
 
 　　对于Tomcat来说，它会将传递过来的参数放在一个Hashtable中，该Hashtable的定义是：
 
 
 
 
 
 
  
 
      
 
       
 
        private 
        Hashtable<String String[]> paramHashStringArray = 
        new 
        Hashtable<String String[]>();
       
 
      
 
 
 
 
 
 
 
 　　这是一个String-->String[]的键值映射。
 
 　　HashMap线程不安全的，Hashtable线程安全。
 
 -----------------------------------------------------------------------------------------------------------------------------------
 
 Servlet终止阶段：
 
 　　当WEB应用被终止，或Servlet容器终止运行，或Servlet容器重新装载Servlet新实例时，Servlet容器会先调用Servlet的destroy()方法，在destroy()方法中可以释放掉Servlet所占用的资源。
 
 
 
 -----------------------------------------------------------------------------------------------------------------------------------
 
 Servlet何时被创建：
 
 　　1，默认情况下，当WEB客户第一次请求访问某个Servlet的时候，WEB容器将创建这个Servlet的实例。
 
 　　2，当web.xml文件中如果<servlet>元素中指定了<load-on-startup>子元素时，Servlet容器在启动web服务器时，将按照顺序创建并初始化Servlet对象。
 
 　　注意：在web.xml文件中，某些Servlet只有<serlvet>元素，没有<servlet-mapping>元素，这样我们无法通过url的方式访问这些Servlet，这种Servlet通常会在<servlet>元素中配置一个<load-on-startup>子元素，让容器在启动的时候自动加载这些Servlet并调用init()方法，完成一些全局性的初始化工作。
 
 
 
 
 Web应用何时被启动：
 
 　　1，当Servlet容器启动的时候，所有的Web应用都会被启动
 
 　　2，控制器启动web应用
 
 
 -----------------------------------------------------------------------------------------------------------------------------------------------
 
 
 Servlet与JSP的比较：
 
 　　有许多相似之处，都可以生成动态网页。
 
 　　JSP的优点是擅长于网页制作，生成动态页面比较直观，缺点是不容易跟踪与排错。
 
 　　Servlet是纯Java语言，擅长于处理流程和业务逻辑，缺点是生成动态网页不直观。