精华内容
下载资源
问答
  • Vue声明周期

    千次阅读 2019-12-03 10:09:19
    Vue声明周期

    https://cn.vuejs.org/v2/guide/instance.html

    生命周期图示:https://img-blog.csdnimg.cn/20191203114644314.png 

    1. vue对象的生命周期
      1). 初始化显示(一次)
        * beforeCreate()
        * created()
        * beforeMount()
        * mounted()
      2). 更新状态(多次)this.xxx = value
        * beforeUpdate()
        * updated()
      3). 销毁vue实例 (一次) vm.$destory()
        * beforeDestory()
        * destoryed()
    2. 常用的生命周期方法
      created()/mounted(): 发送ajax请求, 启动定时器等异步任务
      beforeDestory(): 做收尾工作, 如: 清除定时器

    初始化 只执行一次  

    <script src="https://cdn.bootcss.com/vue/2.6.10/vue.js"></script>
    <script type="text/javascript">
        new Vue({
            el: '#test',
            beforeCreate() {
                console.log('beforeCreate()')
            },
            created() {
                console.log('created()')
            }, beforeMount() {
                console.log('beforeMount()')
            },
            mounted() {
                console.log('mounted()')
            }
        })
    </script>

    更新操作 执行多次

    跟新操作需要和DOM联系起来,不然是没有效果的 

    <div id="test">
        <button @click="updateMsg">updateMsg</button>
        <!--需要在界面显示-->
        <div ref='msg'>{{msg}}</div>
    </div>
    <script src="https://cdn.bootcss.com/vue/2.6.10/vue.js"></script>
    <script type="text/javascript">
        new Vue({
            el: '#test',
            data: {
                msg: ""
            },
            beforeUpdate() {
                console.log('beforeUpdate() ' + this.$refs.msg.innerHTML)
            },
            updated() {
                console.log('updated() ' + this.$refs.msg.innerHTML)
            },
            methods: {
                updateMsg() {
                    this.msg = Math.random() * 1000 | 0
                }
            }
        })
    </script>

     销毁操作 只执行一次  

    <div id="test">
        <button @click="destroyVue">destroyed Vue</button>
        <!--msg依然还在界面上显示,只是Vue对象已经不在管理了-->
        <div ref='msg'>{{msg}}</div>
    </div>
    <script src="https://cdn.bootcss.com/vue/2.6.10/vue.js"></script>
    <script type="text/javascript">
        new Vue({
            el: '#test',
            data: {
                msg: 666
            },
            mounted() {
                this.intervalId = setInterval(() => {
                    console.log('异步任务 run run run...' + this.msg)
                    this.msg = Math.random() * 1000 | 0
                    this.isShow = !this.isShow
                }, 1000)
            },
            beforeDestroy() {
                console.log('beforeDestroy()')
                // 执行收尾的工作(不然程序还会一直执行)
                clearInterval(this.intervalId)
            },
            destroyed() {
                console.log('destroyed()')
            },
            methods: {
                destroyVue() {
                    // clearInterval(this.intervalId)
                    this.$destroy()
                }
            }
        })
    </script>

    <div id="test">
        <button @click="destroyVue">destroyed Vue</button>
        <div ref='msg'>{{msg}}</div>
    </div>
    <script src="https://cdn.bootcss.com/vue/2.6.10/vue.js"></script>
    <script type="text/javascript">
        new Vue({
            el: '#test',
            data: {
                msg: 666
            },
            beforeCreate() {
                console.log('\t\t\tbeforeCreate()')
            },
            created() {
                console.log('\t\t\tcreated()')
            },
            beforeMount() {
                console.log('\t\t\tbeforeMount()')
            },
            mounted() {
                console.log('\t\t\tmounted()')
                this.intervalId = setInterval(() => {
                    console.log('异步任务 run run run...' + this.msg)
                    this.msg = Math.random() * 1000 | 0
                }, 1000)
            },
    
            beforeUpdate() {
                console.log('beforeUpdate()')
            },
            updated() {
                console.log('updated()')
            },
    
            beforeDestroy() {
                console.log('\t\t\tbeforeDestroy()')
            },
            destroyed() {
                console.log('\t\t\tdestroyed()')
            },
            methods: {
                destroyVue() {
                    clearInterval(this.intervalId)
                    this.$destroy()
                }
            }
        })
    </script>

    展开全文
  • 线程的声明周期.xmind

    2021-09-12 15:51:01
    线程的声明周期
  • React的声明周期

    2021-01-08 15:27:33
    React声明周期(16.3版本以前) 分为3个阶段: 1. 加载阶段 1. constructor() // 加载的时候调用一次,可以舒适化state 2. render() // 渲染页面 3. componentDidMount() // 组件挂在后触发 2. 更新阶段 1. ...
  • 对象均有声明生命,而spring对对象的创建生命周期有spring控制,我们有必要其探究其对对象声明周期的创建,更有利于我们更为微观的掌握spring 生命周期:对象的创建、存活、消亡全过程 声明周期分为三个阶段 创建 ...

    上一篇:07-Spring对象的创建次数 singleton|prototype https://blog.csdn.net/fsjwin/article/details/109427054

    对象均有声明生命,而spring对对象的创建生命周期有spring控制,我们有必要其探究其对对象声明周期的创建,更有利于我们更为微观的掌握spring
    生命周期:对象的创建、存活、消亡全过程
    

    声明周期分为三个阶段

    • 创建
    • 初始化
    • 销毁

    1.对象创建

    Product.java代码交代

    package base.lifecycle;
    
    /**
     * @author yuhl
     * @Date 2020/11/1 15:18
     * @Classname Product
     * @Description 对象生命周期
     */
    public class Product {
        String name;
        Double price;
    
        public Product() {
            System.out.println("*****************Product.Product");
        }
    
        public Product(String name, Double price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Double getPrice() {
            return price;
        }
    
        public void setPrice(Double price) {
            this.price = price;
        }
    }
    
    

    1.1单例模式对象的创建

    1. 配置文件
    <!--生命周期-->
        <bean id="product" class="base.lifecycle.Product"/>
    
    1. 测试
    @Test
        public void test16() {
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
        }
    
    1. 结果
    *****************Product.Product
    

    说明单例模式下,在创建工厂时创建了对象。调用了构造函数。

    1.2非单例模式对象的创建

    配置文件:

    <!--生命周期-->
        <bean id="product" class="base.lifecycle.Product" scope="prototype"/>
    

    测试:

     @Test
        public void test16() {
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
        }
    

    结果:
    在创建工厂的时候没有创建对象。

    但是可以在获得对象的时候创建对象
    测试:

     @Test
        public void test16() {
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
            Product product = (Product) ctx.getBean("product");
            //System.out.println(product);
            /*Account account2 = (Account) ctx.getBean("account");
            System.out.println(account1);
            System.out.println(account2);*/
    
        }
    

    此时的结果为:

    *****************Product.Product
    

    说明在获得对象的时候创建了对象,而不是在创建工厂的时候创建的。

    1.3单例模式对象的创建延时加载

    那么单例模式可否不让其在创建工厂的时候创建对象呢?让他在获得对象的时候创建?可以的使用 lazy-init=“true”。
    配置文件:

     <!--生命周期-->
        <bean id="product" class="base.lifecycle.Product" lazy-init="true"/>
    

    测试:

     @Test
        public void test16() {
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
           // Product product = (Product) ctx.getBean("product");
            //System.out.println(product);
            /*Account account2 = (Account) ctx.getBean("account");
            System.out.println(account1);
            System.out.println(account2);*/
    
        }
    

    结果:未调用构造器
    在获取的再次测试:

    @Test
        public void test16() {
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
           Product product = (Product) ctx.getBean("product");
            //System.out.println(product);
            /*Account account2 = (Account) ctx.getBean("account");
            System.out.println(account1);
            System.out.println(account2);*/
    
        }
    

    结果:

    *****************Product.Product
    

    最终结论:在默认单例模式下,可以使用lazy-init="true"来延时加创建对象,待到真正使用的时候再去创建。

    2.对象初始化

    初始化就是spring给程序员以及机会,让我们有机会再对象创建完成后写一些自己的逻辑代码,比如多资源初始化、数据库、io网络等(但是实际开发中很少使用)。也就是说这个初始化方法我们程序员来定义,但是有spring框架去执行。

    这里有两种写初始化的方法

    2.1第一种:实现接口,重写方法

    实现implements InitializingBean接口,重写:afterPropertiesSet()方法

    1. 看代码:
    package base.lifecycle;
    
    import org.springframework.beans.factory.InitializingBean;
    
    /**
     * @author yuhl
     * @Date 2020/11/1 15:18
     * @Classname Product
     * @Description 对象生命周期
     */
    public class Product implements InitializingBean {
        String name;
        Double price;
    
        public Product() {
            System.out.println("*****************Product.Product");
        }
    
        public Product(String name, Double price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Double getPrice() {
            return price;
        }
    
        public void setPrice(Double price) {
            this.price = price;
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("Product.afterPropertiesSet");
        }
    }
    
    
    1. 配置文件:
        <bean id="product" class="base.lifecycle.Product"/>
    
    
    1. 测试:
     @Test
        public void test17() {
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
        }
    
    1. 结果:
    *****************Product.Product
    Product.afterPropertiesSet
    

    说明在初始化后调用了Product.afterPropertiesSet()方法

    2.2第二种:自定义初始化方法,然后通过通配置文件告诉spring是那个方法

    不实现spring提供的类,自定义一个初始化方法myInit()然后在配置文件中告诉spring即可。

    1. 实体类代码
    package base.lifecycle;
    
    import org.springframework.beans.factory.InitializingBean;
    
    /**
     * @author yuhl
     * @Date 2020/11/1 15:18
     * @Classname Product
     * @Description 对象生命周期
     */
    //public class Product implements InitializingBean {
    public class Product  {
        String name;
        Double price;
    
        public Product() {
            System.out.println("*****************Product.Product");
        }
    
        public Product(String name, Double price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Double getPrice() {
            return price;
        }
    
        public void setPrice(Double price) {
            this.price = price;
        }
    
       /* @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("Product.afterPropertiesSet");
        }*/
    
        /**
         * 自定义的init方法,不在实现接口
         * @throws Exception
         */
        public void myInit() throws Exception {
            System.out.println("Product.myInit");
        }
    }
    
    
    1. 配置文件:
    <bean id="product" class="base.lifecycle.Product" init-method="myInit"/>
    

    注意此处的init-method=“myInit”

    1. 运行结果:
    *****************Product.Product
    Product.myInit
    

    2.3上面两个方式均调用了初始化方法,如果均有,则调用先后顺序怎样?

    1. 类代码:
    package base.lifecycle;
    
    import org.springframework.beans.factory.InitializingBean;
    
    /**
     * @author yuhl
     * @Date 2020/11/1 15:18
     * @Classname Product
     * @Description 对象生命周期
     */
    public class Product implements InitializingBean {
    //public class Product  {
        String name;
        Double price;
    
        public Product() {
            System.out.println("*****************Product.Product");
        }
    
        public Product(String name, Double price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Double getPrice() {
            return price;
        }
    
        public void setPrice(Double price) {
            this.price = price;
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("Product.afterPropertiesSet");
        }
    
        /**
         * 自定义的init方法,不在实现接口
         * @throws Exception
         */
        public void myInit() throws Exception {
            System.out.println("Product.myInit");
        }
    }
    
    
    1. 配置文件
    <bean id="product" class="base.lifecycle.Product" init-method="myInit"/>
    
    1. 测试
    *****************Product.Product
    Product.afterPropertiesSet
    Product.myInit
    
    1. 结论
      先调用afterPropertiesSet() 再调用myInit()方法。

    2.4如果再加上对成员变量的注入,则先后顺序怎样呢?

    先给出结论,afterPropertiesSet() 从方法明上也能看出,实在propertie set之后diay9ong的,即,先setter注入,然后afterPropertiesSet() 再调用myInit()方法。
    证明:

    1. Product.java对setter方法添加打印日志
    package base.lifecycle;
    
    import org.springframework.beans.factory.InitializingBean;
    
    /**
     * @author yuhl
     * @Date 2020/11/1 15:18
     * @Classname Product
     * @Description 对象生命周期
     */
    public class Product implements InitializingBean {
    //public class Product  {
        String name;
        Double price;
    
        public Product() {
            System.out.println("*****************Product.Product");
        }
    
        public Product(String name, Double price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            System.out.println("Product.setName");
            this.name = name;
        }
    
        public Double getPrice() {
            return price;
        }
    
        public void setPrice(Double price) {
            System.out.println("Product.setPrice");
            this.price = price;
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("Product.afterPropertiesSet");
        }
    
        /**
         * 自定义的init方法,不在实现接口
         * @throws Exception
         */
        public void myInit() throws Exception {
            System.out.println("Product.myInit");
        }
    }
    
    
    1. 测试据结果:
    *****************Product.Product
    Product.setName
    Product.setPrice
    Product.afterPropertiesSet
    Product.myInit
    

    印证了结论。

    3.对象销毁

    • 销毁和初始化一样可以实现接口DisposableBean重写destroy()方法,或者自定义销毁方法Mydestroy() ,通过配置文件告诉spring。
    • 那么在什么时候会调用这个销毁方法呢?在ClassPathXmlApplicationContext.close()的时候会调用销毁方法。
    • 注意因为ApplicationContext类中没有close()方法,所以需要声明为ClassPathXmlApplicationContext类,在嗲用close方法的时候先调用重写的销毁方法,还是先调用自己手写的销毁方法呢?
      先给出答案,现代用spring的方法,再调用自己重写的销毁方法。
    1. 查看Product.java 实现这个接口:DisposableBean
    package base.lifecycle;
    
    import org.springframework.beans.factory.DisposableBean;
    import org.springframework.beans.factory.InitializingBean;
    
    /**
     * @author yuhl
     * @Date 2020/11/1 15:18
     * @Classname Product
     * @Description 对象生命周期
     */
    public class Product implements InitializingBean , DisposableBean {
    //public class Product  {
        String name;
        Double price;
    
        public Product() {
            System.out.println("*****************Product.Product");
        }
    
        public Product(String name, Double price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            System.out.println("Product.setName");
            this.name = name;
        }
    
        public Double getPrice() {
            return price;
        }
    
        public void setPrice(Double price) {
            System.out.println("Product.setPrice");
            this.price = price;
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("Product.afterPropertiesSet");
        }
    
        /**
         * 自定义的init方法,不在实现接口
         * @throws Exception
         */
        public void myInit() throws Exception {
            System.out.println("Product.myInit");
        }
    
        @Override
        public void destroy() throws Exception {
            System.out.println("Product.destroy");
        }
    
        public void Mydestroy() throws Exception {
            System.out.println("Product.Mydestroy");
        }
    }
    
    
    1. 配置文件
    <!--生命周期-->
        <bean id="product" class="base.lifecycle.Product" init-method="myInit" destroy-method="Mydestroy" scope="singleton">
            <property name="name" value="张三"/>
            <property name="price" value="5.00"/>
        </bean>
    
    1. 测试
    @Test
        public void test18() {
            ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
            ctx.close();
        }
    
    1. 测试结果
    *****************Product.Product
    Product.setName
    Product.setPrice
    Product.afterPropertiesSet
    Product.myInit
    2020-11-01 20:05:48 DEBUG ClassPathXmlApplicationContext:987 - Closing org.springframework.context.support.ClassPathXmlApplicationContext@2d6a9952, started on Sun Nov 01 20:05:48 CST 2020
    Product.destroy
    Product.Mydestroy
    

    从这个结果可看出先调用springg的销毁方法,再调用自定义的方法。
    5. 注意:对于销毁的方法,仅对于singleton对象有效,对于prototype无效,因为prototype对象有jvm控制其销毁过程spring生命周期不管他。

    4.总结

    通过上面的分析我们知道spring对象的声明周期分为三个阶段

    • 创建
    • 初始化
    • 销毁
      具体调用的方法如下图。便于记忆和理解。
      在这里插入图片描述

    由来这幅图,妈妈再也不用担心我记不住bean的声明周期了。哈哈哈!

    下一篇:09-Spring配置文件参数化,抽取properties文件https://blog.csdn.net/fsjwin/article/details/109440615

    展开全文
  • 无代码入侵,获取AppDelegate声明周期
  • JavaWeb学习-Filter-2-Filter声明周期和FilterConfig.pdf
  • IOS 声明周期介绍

    2013-05-24 10:20:04
    PPT 讲述IOS 应用的生命周期 非常详细 易懂 适合入门选手
  • fragment生命周期详解
  • 类的声明周期

    千次阅读 2011-12-19 23:26:57
    当类处于声明周期中时,他的二进制数据位于方法区内,在堆区内还会有一个相应的描述这个类的Class对象。只有当类处于生命周期中时,Java程序才能使用他,比如调用类的静态属性和方法,或者创建类的实例。 当通过...

    1.

    类的生命周期从类被加载、连接和初始化开始,到类被卸载结束。当类处于声明周期中时,他的二进制数据位于方法区内,在堆区内还会有一个相应的描述这个类的Class对象。只有当类处于生命周期中时,Java程序才能使用他,比如调用类的静态属性和方法,或者创建类的实例。

    当通过java命令运行一个java程序时,就启动了一个java虚拟机进程。java虚拟机进程从启动到终止的过程,称为java虚拟机的生命周期。在以下情况下,java虚拟机将结束声明周期

    >程序正常执行结束

    >程序在执行中因为出现异常或错误而异常终止

    >执行System.exit()方法

    >由于操作系统错误而导致Java虚拟机进程终止


    类的加载:



    展开全文
  • Activity_04(Activity的声明周期--Activity Lifecycle--代码. 包含onCreate,onStart,onRestart,onResume,onPause,onStop,onDestroy 的之行顺序等。。
  • vue 父子组件声明周期的执行顺序

    千次阅读 2018-03-15 18:36:18
    App.vue文件,根目录 created() { console. log ( 'APP created' ) ...声明周期的执行顺序: 总的来说,从创建到挂载,是从外到内,再从内到外,且mixins的钩子函数总是在当前组件之前执行
    App.vue文件,根目录
      created() {
        console.log('APP created')
      },
      mounted() {
        console.log('APP mounted')
      },
    MyRepayment 文件,父组件
      created() {
        console.log('父组件 created')
      },
      mounted() {
        console.log('父组件 mounted')
      },
    OwnBankList文件 子组件1
      created() {
        console.log('子组件1 created')
      },
      mounted() {
        console.log('父组件1 mounted')
      },
    SmsCodeDialog文件 子组件2
      created() {
        console.log('子组件2 created')
      },
      mounted() {
        console.log('父组件2 mounted')
      },
    <App>
        <MyRepayment>
            <OwnBankList />
            <SmsCodeDialog />
        </MyRepayment>
    </App>

    声明周期的执行顺序:
    这里写图片描述
    总的来说,从创建到挂载,是从外到内,再从内到外,且mixins的钩子函数总是在当前组件之前执行

    展开全文
  • 在使用 react 新声明周期做开发时发现我可以通过外部传递的 props.mode 来修改 UI 但是在组件内部执行 this.setState() 方法时却不能达到预期的效果?? 解决办法 需要一个hack来辅助:绑定props到state上 ...
  • C++变量作用域和声明周期

    千次阅读 2016-08-10 10:35:06
    对一个C++变量来说,有两个属性非常重要:作用域和生命周期,它们从两个不同的维度描述了一个变量–时间和空间。顾名思义,作用域就是一个变量可以被引用的范围,如:全局作用域、文件作用域、局部作用域;而生命...
  • angular6 路由的声明周期,拦截处理

    千次阅读 2019-07-15 00:08:36
    我们给路由器添加了新的生命周期事件,让开发者可以跟踪running guard启动到激活完成的各个阶段。这些事件可在有子组件更新时,在一个特定的路由器出口上展示加载动画,或者测量性能。 新的事件(按顺序)是...
  • Activity的声明周期

    2012-02-14 23:06:19
    上图最直观
  • 与用于应用程序代码的常规Java类不同,服务器管理无状态会话bean的声明周期它在两个方面影响了一个bean的实现。首先,服务器决定了创建和删除bean实例的时间。应用程序不会控制何时或者甚至创建多少特定的无状态会话...
  • VUE中的beforeDestroy ,ready声明周期

    万次阅读 热门讨论 2018-04-20 09:18:28
    Vue
  • @Override protected void onStart(Intent intent) { ... Button button = ...; button.setClickedListener(listener -> present(new TargetSlice(), new Intent())); ... }
  • 1 从Activity的官方文档中能看到其生命周期为:onCreate, onStart, onResume 然后结束时候依次调用 onPause, onStop, onDestroy. 然后又分为: entire lifetime----》onCreate---

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 322,535
精华内容 129,014
关键字:

声明周期