lazy_lazyload - CSDN
  • @Lazy注解学习

    2018-09-09 10:56:56
    今天主要从以下几方面来介绍一下@Lazy注解 @Lazy注解是什么 @Lazy注解怎么使用   1,@Lazy注解是什么   @Lazy注解用于标识bean是否需要延迟加载,源码如下:       @Target({ElementType....

    转自:http://blog.51cto.com/4247649/2118337

    今天主要从以下几方面来介绍一下@Lazy注解

    • @Lazy注解是什么

    • @Lazy注解怎么使用

     

    1,@Lazy注解是什么

     

    @Lazy注解用于标识bean是否需要延迟加载,源码如下:

     

     

     

    @Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.FIELD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Lazy {
        /**
         * Whether lazy initialization should occur.
         */
        boolean value() default true;
    }
    

     

     

    只有一个参数,默认是true,也就是说只要加了这个注解就会延迟加载

     

    2,@Lazy注解怎么使用

     

    没加注解之前主要容器启动就会实例化bean,如下:

     

     

     

    AnnotationConfigApplicationContext applicationContext2 = new AnnotationConfigApplicationContext(MainConfig.class);
    

     

     

     

    创建user实例
    

     

     

    而加上@Lazy注解则必须在第一次调用的时候才会加载如下:

     

     

     

    /**
         * 定义一个bean对象
         * @return
         */
        @Scope
        @Lazy
        @Bean(value="user0",name="user0",initMethod="initUser",destroyMethod="destroyUser")
        public User getUser(){
            System.out.println("创建user实例");
            return new User("张三",26);
        }
    

     

     

     

     

    AnnotationConfigApplicationContext applicationContext2 = new AnnotationConfigApplicationContext(MainConfig.class);
    User bean2 = applicationContext2.getBean(User.class);
    

     

     

     

    创建user实例
    实例1 === User [userName=张三, age=26]
    

     

     

    @Lazy注解注解的作用主要是减少springIOC容器启动的加载时间

    展开全文
  • Lazy的使用

    2018-01-19 21:21:22
    lazy对象由一个线程创建,其它线程可共用using System; using System.Collections.Generic; using System.Diagnostics; using System.Linq; using System.Text; using System.Threading; using System.Threading....
    lazy对象由一个线程创建,其它线程可共用
    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Linq;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    
    namespace ConsoleApp2
    {
        class Program
        {
            static Lazy<LargeObject> lazyLargeObject = null;
            internal class LargeObject
            {
                int initBy = 0;
                public int InitializedBy => initBy;
    
                public LargeObject()
                {
                    initBy = Thread.CurrentThread.ManagedThreadId;
                    Console.WriteLine("LargeObject created by thread id {0}", initBy);
                }
    
                public long[] Data = new long[100000];
            }
    
            static void Main(string[] args)
            {
    
                lazyLargeObject = new Lazy<LargeObject>();
    
                ManualResetEvent manualResetEvent = new ManualResetEvent(false);
    
                Thread[] threads = new Thread[] { new Thread(ThreadProc), new Thread(ThreadProc) };
    
                foreach (var t in threads)
                {
                    t.Start(manualResetEvent);
                }
    
                manualResetEvent.Set();  //设置事件信号状态,允许一个或多个线程开始处理
                foreach (Thread t in threads)
                {
                    t.Join();
                }
    
    
                SayHello("Helo");
    
    
    
                Console.WriteLine("Hello World!");
                Console.Read();
    
            }
    
             static void ThreadProc(object state)
            {
                ManualResetEvent waitFor = (ManualResetEvent)state;
    
                waitFor.WaitOne();
    
                LargeObject largeObject = lazyLargeObject.Value;
    
                Thread.Sleep(5);
    
                lock (largeObject)
                {
                    largeObject.Data[0] = Thread.CurrentThread.ManagedThreadId;
                    Console.WriteLine("{0}---{1}", largeObject.InitializedBy, largeObject.Data[0]);
                }
            }
    
    
            static void SayHello(string str)
            {
               // Debug.Assert(str == "Hello", "NOt hello");
    
    
                Console.WriteLine("Hello World!");
                Console.Read();
            }
        }
    }
    

    展开全文
  • C#基础知识回顾---你不知道的Lazy<T> 对象的创建方式,始终代表了软件工业的生产力方向,代表了先进软件技术发展的方向,也代表了广大程序开发者的集体智慧。以new的方式创建,通过工厂方法,利用IoC容器,...

    C#基础知识回顾---你不知道的Lazy<T>

        对象的创建方式,始终代表了软件工业的生产力方向,代表了先进软件技术发展的方向,也代表了广大程序开发者的集体智慧。以new的方式创建,通过工厂方法,利用IoC容器,都以不同的方式实现了活生生实例成员的创生。而本文所关注的Lazy<T>也是干这事儿的。不过,简单说来,Lazy<T>要实现的就是按“需”创建,而不是按时创建。

    我们往往有这样的情景,一个关联对象的创建需要较大的开销,为了避免在每次运行时创建这种家伙,有一种聪明的办法叫做实现“懒对象”,或者延迟加载。.NET 4.0之前,实现懒对象的机制,需要开发者自己来实现与管理它的定义如下:

     

    复制代码

    [Serializable]
    public class Lazy<T>
    {
        public Lazy();
        public Lazy(bool isThreadSafe);
        public Lazy(Func<T> valueFactory);
        public Lazy(Func<T> valueFactory, bool isThreadSafe);
    
        public bool IsValueCreated { get; }
        public T Value { get; }
    
        public override string ToString();
    }

    复制代码

    假设,我们有一个大块头:

    复制代码

    public class Big
    {
        public int ID { get; set; }
    
        // Other resources
    }

    复制代码

    从Lazy<T>的定义可知,其Value属性就是我们包装在Lazy Wrapper中的真实Big对象,那么当我们第一次访问lazyBig.Value时,就回自动的创建Big实例。

    复制代码

    static void Main(string[] args)
    {
        Lazy<Big> lazyBig = new Lazy<Big>();
    
        Console.WriteLine(lazyBig.Value.ID);
    }

    复制代码

    当然,有其定义可知,Lazy远没有这么小儿科,它同时还可以为我们提供以下的服务:

    • 通过IsValueCreated,获取是否“已经”创建了实例对象。
    • 解决非默认构造函数问题。

    显而易见。我们的Big类并没有提供带参数构造函数,那么如下的Big类:

    复制代码

    public class Big
    {
        public Big(int id)
        {
            this.ID = id;
        }
    
        public int ID { get; set; }
    
        // Other resources
    }

    复制代码

    上述创建方式将引发运行时异常,提示包装对象没有无参的构造函数。那么,这种情形下的延迟加载,该如何应对呢?其实Lazy<T>的构造中还包括:

    public Lazy(Func<T> valueFactory);

    它正是用来应对这样的挑战:

    static void Main(string[] args)
    {
        // Lazy<Big> lazyBig = new Lazy<Big>();
        Lazy<Big> lazyBig = new Lazy<Big>(() => new Big(100));
    
        Console.WriteLine(lazyBig.Value.ID);
    }

    其实,从public Lazy(Func<T> valueFactory)的定义可知,valueFactory可以返回任意的T实例,那么任何复杂的构造函数,对象工厂或者IoC容器方式都可以在此以轻松的方式兼容,例如:

    public class BigFactory
    {
        public static Big Build()
        {
            return new Big(100);
        }
    }

    可以应用Lazy<T>和BigFactory实现Big的延迟加载:

    static void Main(string[] args)
    {
        Lazy<Big> lazyBig = new Lazy<Big>(() => BigFactory.Build());
    
        Console.WriteLine(lazyBig.Value.ID);
    }
    • 提供多线程环境支持。

    另外的构造器:

    public Lazy(bool isThreadSafe);
    public Lazy(Func<T> valueFactory, bool isThreadSafe);

    中,isThreadSafe则应用于多线程环境下,如果isThreadSafe为false,那么延迟加载对象则一次只能创建于一个线程。

     

    关于Lazy<T>的应用,其实已经不是一个纯粹的语言问题,还涉及了对设计的考量,例如实现整个对象的延迟加载,或者实现延迟属性,考量线程安全等等。就不说教太多。因为,.NET 4.0提供的关注度实在不少,我们眼花缭乱了。

    展开全文
  • v-model修饰符.lazy详解

    2017-11-21 17:59:06
    官网相关内容: ... 部分),但你可以添加一个修饰符 lazy ,从而转变为在 change 事件中同步: input v-model.lazy="msg" > 个人实践理解: 1. 当v-model没有使用.lazy修饰符时: 代码:

    官网相关内容:

    在默认情况下,v-model 在 input 事件中同步输入框的值与数据 (除了 上述 IME 部分),但你可以添加一个修饰符 lazy ,从而转变为在 change 事件中同步:

    <!-- 在 "change" 而不是 "input" 事件中更新 -->
    <input v-model.lazy="msg" >
    个人实践理解:

    1. 当v-model没有使用.lazy修饰符时:

    代码:

    <template>
      <div>
        <div>
          <input v-model="msg" @change="show">
          <span>{{msg}}</span>
        </div>
      </div>
    </template>


    <script>
    export default {
      data () {
        return {
          msg: 123
        }
      },
      methods: {
        show () {
          console.log(this.msg)
        }
      }
    }
    </script>

    效果图:



    结论:

    v-model是双向绑定的,所以当改变input框中的值的时候,span中的内容随之改变而改变。

    2.当v-model使用.lazy修饰符时:

    代码:<input v-model.lazy="msg" @change="show">

    效果图:




    结论:当添加.lazy修饰符之后,改变input框中的内容并不会使得span中的内容发生变化,此时当输入框失去焦点后触发change事件.控制台中输出相应内容。


    小结:加上.lazy后相当于 双向数据绑定不起作用了

    展开全文
  • 如果我们想要 Spring 在启动的时候延迟加载 bean,即在调用某个 bean 的时候再去初始化,那么就可以使用 @Lazy 注解。 @Lazy 的属性 value 取值有 true 和 false 两个 默认值为 true true 表示使用 延迟加载, ...
  • lazy(懒加载)属性解析

    2016-07-21 21:56:31
    关联映射文件中标签中的lazy(懒加载)属性  Lazy(懒加载):只有在正真使用该对象时,才会创建这个对象 Hibernate中的lazy(懒加载):只有我们在正真使用时,它才会发出SQL语句,给我们去查询,如果不使用对象则...
  • LazyUiAutomatorViewer是在UiAutomatorViewer源码基础上进行扩展,添加了xpath生成,页面xpath自动一键抓取导出、选择性抓取导出并自动生成java代码的安卓UI自动化测试辅助工具。该工具能大大节省安卓UI自动化实施...
  • @Lazy注解积累

    2020-07-11 09:57:11
    使用注解: @Lazy 效果:一般情况下,Spring容器在启动时会创建所有的Bean对象,使用@Lazy注解可以将Bean对象的创建延迟到第一次使用Bean的时候 引入步骤 在类上加入@Lazy或者@@Lazy(value=true) 示例代码 Bean对象...
  • lazy<T>

    2019-02-27 10:29:45
    对象的创建方式,始终代表了软件工业...而本文所关注的Lazy&lt;T&gt;也是干这事儿的。不过,简单说来,Lazy&lt;T&gt;要实现的就是按“需”创建,而不是按时创建。   public class Lazy&lt;T...
  • @Lazy注解为什么会失效?它并没有失效,一直都是生效着的,之所以认为它失效了,是没有用对它,没有理解它! 我想让B最后再实例化,因为实例化的时候,会为B创建代理,并且加入增强器。但是有些情况,实例化其它类的...
  • Swift的lazy关键字–延迟加载@(Swift)[Swift, lazy]定义lazy属性就是初始值直到第一次使用的时候才执行计算的属性,这对小内存的手机所产生的性能上的优化是相当可观的。 注意:lazy属性必须是变量(var修饰符),...
  • React Suspense lazy() 懒加载 代码分割 code spliting Suspense和lazy()都是react中比较新的特性,在项目中使用还比较少,但是学习一下有助于在后面的项目中使用,同样可以一窥React未来的发展方向 React.lazy() ...
  • @Scope:调整作用域 和 @Lazy 懒加载 prototype:多实例的:ioc容器启动并不会去调用方法创建对象放在容器中。每次获取的时候才会调用方法创建对象;singleton:单实例的(默认值):若没有配置@Lazy,或@Lazy...
  • 前言 Kotlin 基于 Java 的空指针提出了一个空...那么,可以使用lateinit或者by lazy来修饰它。 lateinit 被lateinit修饰的变量,并不是不用初始化,它需要在生命周期流程中进行获取或者初始化。 lazylazy(...
  • 每次看flask web開發中的關注者這章,總是被relationship中的lazy弄得一頭霧水,今天做筆記記錄下基本介紹lazy: 指定sqlalchemy数据库什么时候加载数据select: 就是访问到属性的时候,就会全部加载该属性的数据...
  • 在spring的配置中的根节点上有个 default-lazy-init="true"配置: 1、spring的default-lazy-init参数 此参数表示延时加载,即在项目启动时不会实例化注解的bean,除非启动项目时需要用到,未实例化的...
  • spring 懒加载 lazy-init

    2019-01-17 20:32:14
    lazy-init  初始化IOC容器不会去创建懒加载的对象 而是使用对象是才创建 默认值是false &lt;bean id="cls" class="com.yc.pojo.Classes" lazy-init="true"&gt;&lt;/...
  • Spring中lazy-init解释

    2018-09-25 15:52:50
    lazy-init是Spring中延迟加载bean的属性。 &lt;bean id="testBean" class="com.eacxzm.TestBean" lazy-init="false"&gt;,那么Spring启动时会立即进行实例化 &lt;bean ...
  • **在输入框中,v-model 默认是同步数据,使用 .lazy 会转变为在 change 事件中同步 , 也就是在失去焦点 或者 按下回车键时才更新** &lt;template&gt; &lt;div&gt; &lt;p&gt;.lazy修饰符...
  • Kotlin 中的 by lazy

    2020-07-26 22:26:15
    Kotlin 中的 by lazy 今天讲下Kotlin中的 by lazy (不想看废话的 直接往下拉 直奔主题) 前言 再讲By lazy前 我们先说说 委托模式 **委托模式(delegation pattern)**是软件设计模式中的一项基本技巧。在委托模式中...
1 2 3 4 5 ... 20
收藏数 179,155
精华内容 71,662
关键字:

lazy