I have a view where there can be a large number of items for the user to scroll through and I&#39;d like to implement infinite scrolling to enable progressive loading of the content.   

It looks like some folks [have done pagination][1] but Google doesn&#39;t bring up anyone discussing how they&#39;ve done infinite lists with Ember/Ember Data.   Anyone already worked through this and have a blog post/example code to share?


  [1]: https://stackoverflow.com/questions/8778259/ember-js-rendering-large-lists-without-locking-up-the-browser


infinite scroll with ember.js (lazy loading)

In .NET 4 the following snippet with a cached property can also be written using the [`System.Lazy&lt;T&gt;`][1] class. I measured the performance of both approaches and it&#39;s pretty much the same. Is there any real benefit or magic for why I should use one over the other? 

**Cached Property**

    public static class Brushes
    {
        private static LinearGradientBrush _myBrush;

        public static LinearGradientBrush MyBrush
        {
            get
            {
                if (_myBrush == null)
                {
                    var linearGradientBrush = new LinearGradientBrush { ...};
                    linearGradientBrush.GradientStops.Add( ... );
                    linearGradientBrush.GradientStops.Add( ... );

                    _myBrush = linearGradientBrush;
                }

                return _myBrush;
            }
        }
    }

**Lazy&amp;lt;T&amp;gt;**

    public static class Brushes
    {
        private static readonly Lazy&lt;LinearGradientBrush&gt; _myBrush =
            new Lazy&lt;LinearGradientBrush&gt;(() =&gt;
                {
                    var linearGradientBrush = new LinearGradientBrush { ...};
                    linearGradientBrush.GradientStops.Add( ... );
                    linearGradientBrush.GradientStops.Add( ... );

                    return linearGradientBrush;
                }
            );

        public static LinearGradientBrush MyBrush
        {
            get { return _myBrush.Value; }
        }
    }


  [1]: http://msdn.microsoft.com/en-us/library/dd642331(VS.100).aspx

Cached property vs Lazy&lt;T&gt;

I get the following exception:

&lt;!-- language: lang-none --&gt;

    Exception in thread &quot;main&quot; org.hibernate.LazyInitializationException: could not initialize proxy - no Session
    	at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:167)
    	at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:215)
    	at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.invoke(JavassistLazyInitializer.java:190)
    	at sei.persistence.wf.entities.Element_$$_jvstc68_47.getNote(Element_$$_jvstc68_47.java)
    	at JSON_to_XML.createBpmnRepresantation(JSON_to_XML.java:139)
    	at JSON_to_XML.main(JSON_to_XML.java:84)

when I try to call from main the following lines:

```java
Model subProcessModel = getModelByModelGroup(1112);
System.out.println(subProcessModel.getElement().getNote());
```

I implemented the `getModelByModelGroup(int modelgroupid)` method firstly like this :

```java
public static Model getModelByModelGroup(int modelGroupId, boolean openTransaction) {
      		
    Session session = SessionFactoryHelper.getSessionFactory().getCurrentSession();		
    Transaction tx = null;
      		
    if (openTransaction) {
        tx = session.getTransaction();
    }

    String responseMessage = &quot;&quot;;
      		
 	try {
        if (openTransaction) {
      	    tx.begin();
        }
      	Query query = session.createQuery(&quot;from Model where modelGroup.id = :modelGroupId&quot;);
      	query.setParameter(&quot;modelGroupId&quot;, modelGroupId);
      	
    	List&lt;Model&gt; modelList = (List&lt;Model&gt;)query.list(); 
      	Model model = null;
      	
        for (Model m : modelList) {
      	    if (m.getModelType().getId() == 3) {
      		    model = m;
      			break;
      		}
        }
      			
      	if (model == null) {
      	    Object[] arrModels = modelList.toArray();
      		if (arrModels.length == 0) {
      		    throw new Exception(&quot;Non esiste &quot;);
            }
      				
      		model = (Model)arrModels[0];
      	}
      			
      	if (openTransaction) {
            tx.commit();
        }
      	
        return model;
      			
   } catch(Exception ex) {
       if (openTransaction) {
           tx.rollback();
       }
       ex.printStackTrace();
       if (responseMessage.compareTo(&quot;&quot;) == 0) {
           responseMessage = &quot;Error&quot; + ex.getMessage();
       }
       return null;
    }
}
```

and got the exception. Then a friend suggested me to always test the session and get the current session to avoid this error. So I did this:

```java
public static Model getModelByModelGroup(int modelGroupId) {
    Session session = null;
    boolean openSession = session == null;
    Transaction tx = null;
    if (openSession) {
        session = SessionFactoryHelper.getSessionFactory().getCurrentSession();	
      	tx = session.getTransaction();
    }
    String responseMessage = &quot;&quot;;
    		
    try {
        if (openSession) {
      	    tx.begin();
        }
		Query query = session.createQuery(&quot;from Model where modelGroup.id = :modelGroupId&quot;);
      	query.setParameter(&quot;modelGroupId&quot;, modelGroupId);
      	
    	List&lt;Model&gt; modelList = (List&lt;Model&gt;)query.list(); 
      	Model model = null;
      	
        for (Model m : modelList) {
      	    if (m.getModelType().getId() == 3) {
      		    model = m;
      			break;
      		}
        }
      			
      	if (model == null) {
      	    Object[] arrModels = modelList.toArray();
      		if (arrModels.length == 0) {
      		    throw new RuntimeException(&quot;Non esiste&quot;);
            }
      				
      		model = (Model)arrModels[0];
      			
      		if (openSession) {
      		    tx.commit();
            }
      		return model;
      	} catch(RuntimeException ex) {
      	    if (openSession) {
  			    tx.rollback();
            }
      		ex.printStackTrace();
      		if (responseMessage.compareTo(&quot;&quot;) == 0) {
      		    responseMessage = &quot;Error&quot; + ex.getMessage();
            }
      		return null;		
      	}
    }
}
```

but still, get the same error. 
I have been reading a lot for this error and found some possible solutions. One of them was to set lazyLoad to false but I am not allowed to do this that&#39;s why I was suggested to control the session

How to fix org.hibernate.LazyInitializationException - could not initialize proxy - no Session

In this application we are developing, we noticed that a view was particularly slow. I profiled the view and noticed that there was one query executed by hibernate which took 10 seconds even if there only were two object in the database to fetch. All `OneToMany` and `ManyToMany` relations were lazy so that wasn&#39;t the problem. When inspecting the actual SQL being executed, I noticed that there were over 80 joins in the query. 

Further inspecting the issue, I noticed that the problem was caused by the deep hierarchy of `OneToOne` and `ManyToOne` relations between entity classes. So, I thought, I&#39;ll just make them fetched lazy, that should solve the problem. But annotating either `@OneToOne(fetch=FetchType.LAZY)` or `@ManyToOne(fetch=FetchType.LAZY)` doesn&#39;t seem to work. Either I get an exception or then they are not actually replaced with a proxy object and thus being lazy.

Any ideas how I&#39;ll get this to work? Note that I do not use the `persistence.xml` to define relations or configuration details, everything is done in java code.

How can I make a JPA OneToOne relation lazy

This may be a really elementry question but whats a nice way to include multiple children entities when writing a query that spans THREE levels (or more)?

i.e. I have 4 tables: `Company`, `Employee`, `Employee_Car` and `Employee_Country`

Company has a 1:m relationship with Employee.

Employee has a 1:m relationship with both Employee_Car and Employee_Country.

If i want to write a query that returns the data from all 4 the tables, I am currently writing:

    Company company = context.Companies
                             .Include(&quot;Employee.Employee_Car&quot;)
                             .Include(&quot;Employee.Employee_Country&quot;)
                             .FirstOrDefault(c =&gt; c.Id == companyID);

There has to be a more elegant way! This is long winded and generates horrendous SQL

I am using EF4 with VS 2010

Entity framework linq query Include() multiple children entities

What is lazy loading in Java? I don&#39;t understand the process. Can anybody help me to understand the process of lazy loading?

What is lazy loading in Hibernate?

During a Hibernate `Session`, I am loading some objects and some of them are loaded as proxies due to lazy loading. It&#39;s all OK and I don&#39;t want to turn lazy loading off.

But later I need to send some of the objects (actually one object) to the GWT client via RPC. And it happens that this concrete object is a proxy. So I need to turn it into a real object. I can&#39;t find a method like &quot;materialize&quot; in Hibernate.

How can I turn some of the objects from proxies to reals knowing their class and ID?

At the moment the only solution I see is to evict that object from Hibernate&#39;s cache and reload it, but it is really bad for many reasons.

How to convert a Hibernate proxy to a real entity object

I have a very large javascript file I would like to load only if the user clicks on a certain button.  I am using jQuery as my framework.  Is there a built-in method or plugin that will help me do this?  

Some more detail:
I have a &quot;Add Comment&quot; button that should load the TinyMCE javascript file (I&#39;ve boiled all the TinyMCE stuff down to a single JS file), then call tinyMCE.init(...).

I don&#39;t want to load this at the initial page load because not everyone will click &quot;Add Comment&quot;.

I understand I can just do:

    $(&quot;#addComment&quot;).click(function(e) { document.write(&quot;&lt;script...&quot;) });

but is there a better/encapsulated way?

JQuery to load Javascript file dynamically

And what kind of alternative strategies do you use for avoiding LazyLoadExceptions?


I do understand that open session in view has issues with:

 - Layered applications running in different jvm&#39;s
 - Transactions are committed only at the end, and most probably you would like the results before.
 
But, if you know that your application is running on a single vm, why not ease your pain by using an open session in view strategy?



Why is Hibernate Open Session in View considered a bad practice?

***What I have:***

    @Entity
    public class MyEntity {
      @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, orphanRemoval = true)
      @JoinColumn(name = &quot;myentiy_id&quot;)
      private List&lt;Address&gt; addreses;
    
      @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, orphanRemoval = true)
      @JoinColumn(name = &quot;myentiy_id&quot;)
      private List&lt;Person&gt; persons;
    
      //....
    }
    
    public void handle() {
    
       Session session = createNewSession();
       MyEntity entity = (MyEntity) session.get(MyEntity.class, entityId);
       proceed(session); // FLUSH, COMMIT, CLOSE session!
    
       Utils.objectToJson(entity); //TROUBLES, because it can&#39;t convert to json lazy collections
    }

***What a problem:***

The problem is that I can&#39;t pull lazy collection after session has been closed. But I also can&#39;t not close a session in *proceed* method. 

***What a solution (coarse solution):***

a) Before session is closed, force hibernate to pull lazy collections

    entity.getAddresses().size();
    entity.getPersons().size();

....

b) Maybe more ellegant way is to use `@Fetch(FetchMode.SUBSELECT)` annotation

***Question:***

What is a best practice/common way/more ellegant way to do it? Means convert my object to JSON.

Hibernate: best practice to pull all lazy collections

I&#39;ve noticed this in numerous &quot;modern&quot; websites (e.g. facebook and google image search) where the images below the fold load only when user scrolls down the page enough to bring them inside the visible viewport region (**upon view source, the page shows _X_ number of `&lt;img&gt;` tags but they are not fetched from the server straight away**). What is this technique called, how does it work and in how many browsers does it work. And is there a jQuery plugin that can achieve this behavior with minimum coding.

Edit
====

Bonus: can someone explain if there is a &quot;onScrolledIntoView&quot; or similar event for HTML elements. If not, how do these plugins work?

How to load images dynamically (or lazily) when users scrolls them into view

What is Lazy Loading?

[Edit after reading a few answers]
Why do people use this term so often? 

Say you just use a ASP/ADO recordset and load it with data or ADO.NET Datasource for a gridview.

I guess I should have asked why people use the term Lazy Loading, what &quot;other&quot; types are their?

What is Lazy Loading?

Is there any way to disable lazy loading for specific query on Entity Framework 6? I want to use it regularly, but sometimes I want to disable it. I&#39;m using virtual properties to lazy load them.

Entity Framework: How to disable lazy loading for specific query?

I am trying to implement lazy loading but getting error as following
**

&gt; ERROR Error: Uncaught (in promise): Error: BrowserModule has already
&gt; been loaded. If you need access to common directives such as NgIf and
&gt; NgFor from a lazy loaded module, import CommonModule instead.

**

Need Help on this.
Here are my Modules 

 1. Shared MOdule

&gt;     @NgModule({
&gt;     
&gt;       declarations: [TimePipe],
&gt;       providers: [
&gt;         EmsEmployeeService,
&gt;         EmsDesignationService,
&gt;         EmsOrganizationService,
&gt;         EmsAuthService,
&gt;         AmsEmployeeService,
&gt;         AmsShiftService,
&gt;         ValidatorService,
&gt;         AmsLeaveService,
&gt;         AmsAttendanceService,
&gt;         AmsDeviceService,
&gt;         AmsOrganizationService,
&gt;         AmsAlertService,
&gt;         AmsHolidayService,
&gt;         AutoCompleteService,
&gt;         AmsTimelogsService,
&gt;         LocalStorageService
&gt;       ],
&gt;       imports: [
&gt;         HttpModule,
&gt;         ToastyModule.forRoot(),
&gt;         AgmCoreModule.forRoot({
&gt;           apiKey: &#39;xxxxxxxxxxxxxxxxxxxxxxxxxxx&#39;
&gt;         }),
&gt;       ],
&gt;       exports: [
&gt;         FormsModule,
&gt;         HttpModule,
&gt;         BrowserAnimationsModule,
&gt;         RouterModule,
&gt;         MaterialModule,
&gt;         MdDatepickerModule,
&gt;         MdNativeDateModule,
&gt;         ToastyModule,
&gt;         FileUploadModule,
&gt;         NgxPaginationModule,
&gt;         NguiAutoCompleteModule,
&gt;         AgmCoreModule,
&gt;         TimePipe
&gt;       ]
&gt;     })
&gt;     export class SharedModule { }

 2.SettingModule

&gt;      @NgModule({
&gt;       imports: [
&gt;         CommonModule,
&gt;         SharedModule,
&gt;         SettingsRoutingModule
&gt;       ],
&gt;       declarations: [
&gt;         SettingsComponent,
&gt;         ShiftsComponent,
&gt;         DevicesComponent,
&gt;         AlertsComponent,
&gt;         HolidaysComponent,
&gt;         AlterTypesComponent,
&gt;         AlterEditComponent,
&gt;         ShiftTypeNewComponent,
&gt;         DeviceLogsComponent,
&gt;         ChannelTypesComponent,
&gt;         ChannelTypeEditComponent
&gt;       ], exports: [
&gt;         SettingsComponent,
&gt;         ShiftsComponent,
&gt;         DevicesComponent,
&gt;         AlertsComponent,
&gt;         HolidaysComponent,
&gt;         AlterTypesComponent,
&gt;         AlterEditComponent,
&gt;         ShiftTypeNewComponent,
&gt;         DeviceLogsComponent,
&gt;         ChannelTypesComponent,
&gt;         ChannelTypeEditComponent,
&gt;       ]
&gt;     })
&gt;     export class SettingsModule { }

    3.SettingRoutingModule

&gt;     const settings_routes: Routes = [
&gt;       { path: &#39;&#39;, redirectTo: &#39;shifts&#39;, pathMatch: &#39;full&#39; },
&gt;       { path: &#39;shifts&#39;, component: ShiftsComponent },
&gt;       { path: &#39;shifts/new&#39;, component: ShiftTypeNewComponent },
&gt;       { path: &#39;shifts/edit/:id&#39;, component: ShiftTypeNewComponent },
&gt;       { path: &#39;devices&#39;, component: DevicesComponent },
&gt;       { path: &#39;deviceLogs&#39;, component: DeviceLogsComponent },
&gt;       { path: &#39;holidays&#39;, component: HolidaysComponent },
&gt;       { path: &#39;alerts&#39;, component: AlertsComponent },
&gt;       { path: &#39;alerts/types&#39;, component: AlterTypesComponent },
&gt;       { path: &#39;alerts/:id&#39;, component: AlterEditComponent },
&gt;       { path: &#39;channelTypes&#39;, component: ChannelTypesComponent },
&gt;       { path: &#39;channelTypes/:id&#39;, component: ChannelTypeEditComponent }
&gt;     ];
&gt;     
&gt;     
&gt;     const routes: Routes = [
&gt;       { path: &#39;&#39;, component: SettingsComponent, children: settings_routes }
&gt;     ];
&gt;     
&gt;     
&gt;     
&gt;     @NgModule({
&gt;       imports: [RouterModule.forChild(routes)],
&gt;       exports: [RouterModule]
&gt;     })
&gt;     export class SettingsRoutingModule { }

4. App-routing-module

&gt;     const attdendance_routes: Routes = [
&gt;       { path: &#39;&#39;, redirectTo: &#39;daily&#39;, pathMatch: &#39;full&#39; },
&gt;       { path: &#39;monthly&#39;, component: MonthlyComponent },
&gt;       { path: &#39;daily&#39;, component: DailyComponent },
&gt;     
&gt;       { path: &#39;daily/:empId&#39;, component: AttendanceDetailsComponent },
&gt;       { path: &#39;details/:empId&#39;, component: AttendanceDetailsComponent },
&gt;       { path: &#39;monthly/:empId&#39;, component: AttendanceDetailsComponent },
&gt;       { path: &#39;leaves/:empId&#39;, component: AttendanceDetailsComponent },
&gt;     
&gt;       { path: &#39;details/:empId/apply-leave&#39;, component: ApplyLeaveComponent },
&gt;       { path: &#39;daily/:empId/apply-leave&#39;, component: ApplyLeaveComponent },
&gt;       { path: &#39;daily/:empId/attendance-logs/:ofDate&#39;, component: AttendanceLogsComponent },
&gt;       { path: &#39;monthly/:empId/apply-leave&#39;, component: ApplyLeaveComponent },
&gt;       { path: &#39;leaves/:empId/apply-leave&#39;, component: ApplyLeaveComponent },
&gt;       { path: &#39;leaves/new/apply&#39;, component: ApplyLeaveComponent },
&gt;     
&gt;       { path: &#39;leaves&#39;, component: LeavesComponent },
&gt;       { path: &#39;leave-balances&#39;, component: LeaveBalancesComponent },
&gt;       { path: &#39;leave-balances/:empId&#39;, component: AttendanceDetailsComponent },
&gt;       { path: &#39;manage-leaves&#39;, component: ManageLeavesComponent },
&gt;     
&gt;     ];
&gt;     
&gt;
&gt;     
&gt;     const emp_routes: Routes = [
&gt;       { path: &#39;&#39;, redirectTo: &#39;list&#39;, pathMatch: &#39;full&#39; },
&gt;       { path: &#39;list&#39;, component: EmployeeListComponent },
&gt;       { path: &#39;list/:id&#39;, component: EmpEditComponent },
&gt;       { path: &#39;designations&#39;, component: DesignationsComponent }
&gt;     ];
&gt;     
&gt;     
&gt;     
&gt;     const page_routes: Routes = [
&gt;       { path: &#39;&#39;, redirectTo: &#39;attendances&#39;, pathMatch: &#39;full&#39; },
&gt;       { path: &#39;employees&#39;, component: EmployeesComponent, children: emp_routes },
&gt;       { path: &#39;attendances&#39;, component: AttendancesComponent, children: attdendance_routes },
&gt;
&gt;       { path: &#39;settings&#39;, loadChildren: &#39;./pages/settings/settings.module#SettingsModule&#39; },
&gt;     ];
&gt;     
&gt;     // main routes
&gt;     const routes: Routes = [
&gt;       { path: &#39;&#39;, redirectTo: &#39;pages&#39;, pathMatch: &#39;full&#39; },
&gt;       { path: &#39;login&#39;, component: LoginComponent, canActivate: [LoginGuard] },
&gt;       { path: &#39;pages&#39;, component: PagesComponent, canActivate: [UserGuard], children: page_routes },
&gt;       { path: &#39;loginViaOrg&#39;, component: OrgLoginComponent },
&gt;       { path: &#39;download&#39;, component: AppDownloadComponent },
&gt;       { path: &#39;**&#39;, redirectTo: &#39;pages&#39; },
&gt;     ];
&gt;     
&gt;     @NgModule({
&gt;       imports: [RouterModule.forRoot(routes, { useHash: true })],
&gt;       exports: [RouterModule]
&gt;     })
&gt;     export class AppRoutingModule { }

5.AppModule

&gt;     @NgModule({
&gt;     
&gt;       declarations: [
&gt;         AppComponent,
&gt;         PagesComponent,
&gt;         LoginComponent,
&gt;         EmployeesComponent,
&gt;         OrgLoginComponent,
&gt;         EmployeeListComponent,
&gt;         EmpEditComponent,
&gt;         DayEventDialogComponent,
&gt;         AttendancesComponent,
&gt;         MonthlyComponent,
&gt;         AttendanceDetailsComponent,
&gt;         DailyComponent,
&gt;         DeviceDialogComponent,
&gt;         LeaveActionDialogComponent,
&gt;         LeavesComponent,
&gt;         LeaveBalancesComponent,
&gt;         ManageLeavesComponent,
&gt;         ApplyLeaveComponent,
&gt;         ConfirmDialogComponent,
&gt;         ResetPasswordDialogComponent,
&gt;         AppDownloadComponent,
&gt;         DesignationsComponent,
&gt;         AttendanceLogsComponent,
&gt;       ],
&gt;     
&gt;       entryComponents: [
&gt;         DayEventDialogComponent,
&gt;         DeviceDialogComponent,
&gt;         LeaveActionDialogComponent,
&gt;         ConfirmDialogComponent,
&gt;         ResetPasswordDialogComponent
&gt;       ],
&gt;     
&gt;       imports: [
&gt;         BrowserModule,
&gt;         // CommonModule,
&gt;         SharedModule,
&gt;         AppRoutingModule,
&gt;         // feature modules
&gt;         // SettingsModule
&gt;       ],
&gt;     
&gt;       providers: [
&gt;         LoginGuard, UserGuard,
&gt;       ],
&gt;     
&gt;       bootstrap: [AppComponent]
&gt;     })
&gt;     export class AppModule { }



Lazy Loading BrowserModule has already been loaded

In the context of ORM / Lazy loading of entities, my understanding of the term &quot;Hydration&quot; is as follows:

&quot;Hydrating&quot; describes the process of populating some or all of the previously unpopulated attributes of an entity fetched using lazy loading.

Eg:  class `Author` is loaded from the database:

    @Entity
    class Author
    {
         @Id
         long id;
         List&lt;Book&gt; books;
    }

Initially, the `books` collection is not populated.

It is my understanding that the process of loading the `books` collection from the database is referred to as &quot;Hydrating&quot; the collection.



Is this definition correct, and is the term common place?  Is there another more common term I should be using for this process?





Clarifying terminology - What does &quot;hydrating&quot; a JPA or Hibernate entity mean when fetching the entity from the DB

I tend to use [Hibernate](http://www.hibernate.org/docs) in combination with [Spring](http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/orm.html#orm-hibernate) framework and it&#39;s declarative transaction demarcation capabilities (e.g., [@Transactional](http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/transaction.html#transaction-declarative-annotations)). 

As we all known, hibernate tries to be as *non-invasive* and as *transparent* as possible, however this proves **a bit more challenging** when employing **`lazy-loaded`** relationships. 

---

I see a number of design alternatives with different levels of transparency. 



1. Make relationships not lazy-loaded (e.g., `fetchType=FetchType.EAGER)`
  - This vioalites the entire idea of lazy loading .. 
2. Initialize collections using `Hibernate.initialize(proxyObj);`
  - This implies relatively high-coupling to the DAO
  - Although we can define an interface with `initialize`, other implementations are not guaranteed to provide any equivalent. 
3. Add transaction behaviour to the persistent `Model` objects themselves (using either [dynamic proxy](http://download.oracle.com/javase/6/docs/api/) or `@Transactional`)
  - I&#39;ve not tried the dynamic proxy approach, although I never seemed to get @Transactional working on the persistent objects themselves. Probably due to that hibernate is operation on a proxy to bein with. 
  - Loss of control when transactions are actually taking place
4. Provide both lazy/non-lazy API, e.g, `loadData()` and `loadDataWithDeps()`
  - Forces the application to know when to employ which routine, again tight coupling
  - Method overflow, `loadDataWithA()`, ...., `loadDataWithX()`
5. Force lookup for dependencies, e.g., by only providing `byId()` operations
  - Requires alot of non-object oriented routines, e.g., `findZzzById(zid)`, and then `getYyyIds(zid)` instead of `z.getY()`
  - It can be useful to fetch each object in a collection one-by-one if there&#39;s a large processing overhead between the transactions. 
6. Make part of the *application* @Transactional instead of only the [DAO](http://en.wikipedia.org/wiki/Data_access_object)
  - Possible considerations of nested transactions
  - Requires routines adapted for transaction management (e.g., suffiently small)
  - Small programmatic impact, although might result in large transactions
7. Provide the DAO with dynamic [fetch profiles](http://docs.jboss.org/hibernate/stable/annotations/reference/en/html_single/#d0e3524), e.g., `loadData(id, fetchProfile);`
  - Applications must know which profile to use when
8. AoP type of transactions, e.g., intercept operations and perform transactions when necessary
  - Requires byte-code manipulation or proxy usage
  - Loss of control when transactions are performed
  - Black magic, as always :)

Did I miss any option?

---


Which is your preferred approach when trying to minimize the impact of `lazy-loaded` relationships in your application design? 

(Oh, and sorry for [WoT](http://www.urbandictionary.com/define.php?term=wall%20of%20text))

Hibernate lazy-load application design

I faced the problem that **one-to-one lazy loading** doesn&#39;t work in hibernate. I&#39;ve **already solved it**, but still **don&#39;t** properly **understand** what happens. 

My code (**lazy loading doesn&#39;t work here**, when I pull Person - Address is also fetched):

    @Entity
    public class Person{
    
      @Id
      @SequenceGenerator(name = &quot;person_sequence&quot;, sequenceName = &quot;sq_person&quot;)
      @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = &quot;person_sequence&quot;)
      @Column(name = &quot;id&quot;)
      private long personID;
    
      @OneToOne(mappedBy=&quot;person&quot;, cascade=CascadeType.ALL, fetch = FetchType.LAZY)
      private Adress address;
      //.. getters, setters
    }
    
    @Entity
    public class Address {
      
      @Id
      @Column(name=&quot;id&quot;, unique=true, nullable=false)
      @GeneratedValue(generator=&quot;gen&quot;)
      @GenericGenerator(name=&quot;gen&quot;, strategy=&quot;foreign&quot;, parameters=@Parameter(name=&quot;property&quot;, value=&quot;person&quot;))
      private long personID;
    
      @PrimaryKeyJoinColumn
      @OneToOne
      private FileInfo person;
    }

**But**: if I add **`optional=false`** in OneToOne relationship, lazy loading **works fine**!

    @OneToOne(mappedBy=&quot;person&quot;, cascade=CascadeType.ALL, optional = false, fetch = FetchType.LAZY)
    private Adress address;

**Question/Entreaty:** please, explain to me how `optional=false` annotation helps to achieve lazy loading.

**P.S.** I&#39;ve read posts [post1][1] and [post2][2], and understand why simple OneToOne can&#39;t be lazy, but I still can&#39;t grasp `optional=false` magic.


  [1]: https://stackoverflow.com/questions/1444227/making-a-onetoone-relation-lazy
  [2]: https://community.jboss.org/wiki/SomeExplanationsOnLazyLoadingone-to-one

Hibernate: one-to-one lazy loading, optional = false

I recently started implementing lazy loading in my application. I was wondering whether there is any way to create a routing.module.ts while generating a new module in angular-cli application other than creating it manually?

Generate a routing module while creating a module in angular-cli

Is it bad practice to change my getter method like version 2 in my class.

Version 1:

     public String getMyValue(){
         return this.myValue
     }

Version 2:

     public String getMyValue(){
 
        if(this.myValue == null || this.myValue.isEmpty()){
           this.myValue = &quot;N/A&quot;;
        }

        return this.myValue;
     }


Is it bad practice to have my getter method change the stored value?

I just noticed that `static` members of Swift `structs` are implicitly `lazy`. 

For instance, this will only call the `init` once:

    class Baz {
        init(){
            print(&quot;initializing a Baz&quot;)
        }
    }
    struct Foo {
        static let bar = Baz()
    }
    
    var z = Foo.bar
    z = Foo.bar

What&#39;s the rationale behind this?

What if I want the opposite behaviour?

Implicitly lazy static members in Swift

Can I filter out results from an arrayCollection in Doctrine 2 while using lazy loading? For example,

    // users = ArrayCollection with User entities containing an &quot;active&quot; property
    $customer-&gt;users-&gt;filter(&#39;active&#39; =&gt; TRUE)-&gt;first()

It&#39;s unclear for me how the filter method is actually used.

Doctrine 2 ArrayCollection filter method

It seems that lazy loading is enabled by default in EF4.  At least, in my project, I can see that the value of

    dataContext.ContextOptions.LazyLoadingEnabled

is true by default.  I don&#39;t want lazy loading and I don&#39;t want to have to write:

    dataContext.ContextOptions.LazyLoadingEnabled = false;

each time I get a new context.  So is there a way to turn it off by default, say, across the whole project?

Disable lazy loading by default in Entity Framework 4

I was trying to find any solution for this error but nothing works for me. I have simple Angular2 App created with Angular-CLI. When I serve this app in browser I&#39;m getting this error: `EXCEPTION: Uncaught (in promise): Error: Cannot find module &#39;/app/test.module&#39;.`  I was trying using different path in loadChildren: 

    &#39;/app/test.module&#39;
    &#39;./app/test.module&#39;
    &#39;./test.module&#39;
    &#39;/src/app/test.module&#39;

**Folders**

    src/
      app/
        app-routing.module.ts
        app.component.ts
        app.module.ts
        test.component.ts
        test.module.ts

**app.module.ts**
```js
import { BrowserModule } from &#39;@angular/platform-browser&#39;;
import { NgModule } from &#39;@angular/core&#39;;
import { FormsModule } from &#39;@angular/forms&#39;;
import { HttpModule } from &#39;@angular/http&#39;;
    
import { RoutingModule } from &#39;./app-routing.module&#39;;
    
import { AppComponent } from &#39;./app.component&#39;;
    
@NgModule({
  declarations: [
    AppComponent
  ],
  imports: [
    BrowserModule,
    FormsModule,
    HttpModule,
    RoutingModule
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule { }
```
**app-routing.module.ts**
```js
import { NgModule } from &#39;@angular/core&#39;;
import { Routes, RouterModule } from &#39;@angular/router&#39;;
    
    
const routes: Routes = [
  { path: &#39;&#39;, loadChildren: &#39;/app/test.module&#39; }
];
    
@NgModule({
  imports: [RouterModule.forRoot(routes)],
  exports: [RouterModule],
  providers: []
})
export class RoutingModule { }
```    

**test.module.ts**
```js
import { NgModule } from &#39;@angular/core&#39;;
import { Routes, RouterModule } from &#39;@angular/router&#39;;
import { CommonModule } from &#39;@angular/common&#39;;
import { TestComponent } from &#39;./test.component&#39;;
    
export const routes: Routes = [
    { path: &#39;&#39;, component: TestComponent }
];
    
@NgModule({
  imports: [
    CommonModule,
    RouterModule.forChild(routes)
  ],
  exports: [TestComponent],
  declarations: [TestComponent]
})
export default class TestModule { }
```    

**stack trace**
```js
        error_handler.js:45EXCEPTION: Uncaught (in promise): Error: Cannot find module &#39;/app/test.module&#39;.ErrorHandler.handleError @ error_handler.js:45next @ application_ref.js:273schedulerFn @ async.js:82SafeSubscriber.__tryOrUnsub @ Subscriber.js:223SafeSubscriber.next @ Subscriber.js:172Subscriber._next @ Subscriber.js:125Subscriber.next @ Subscriber.js:89Subject.next @ Subject.js:55EventEmitter.emit @ async.js:74onError @ ng_zone.js:120onHandleError @ ng_zone_impl.js:64ZoneDelegate.handleError @ zone.js:207Zone.runGuarded @ zone.js:113_loop_1 @ zone.js:379drainMicroTaskQueue @ zone.js:386
    2016-10-08 14:22:50.612 error_handler.js:50ORIGINAL STACKTRACE:ErrorHandler.handleError @ error_handler.js:50next @ application_ref.js:273schedulerFn @ async.js:82SafeSubscriber.__tryOrUnsub @ Subscriber.js:223SafeSubscriber.next @ Subscriber.js:172Subscriber._next @ Subscriber.js:125Subscriber.next @ Subscriber.js:89Subject.next @ Subject.js:55EventEmitter.emit @ async.js:74onError @ ng_zone.js:120onHandleError @ ng_zone_impl.js:64ZoneDelegate.handleError @ zone.js:207Zone.runGuarded @ zone.js:113_loop_1 @ zone.js:379drainMicroTaskQueue @ zone.js:386
    2016-10-08 14:22:50.613 error_handler.js:51Error: Uncaught (in promise): Error: Cannot find module &#39;/app/test.module&#39;.
        at resolvePromise (zone.js:429)
        at zone.js:406
        at ZoneDelegate.invoke (zone.js:203)
        at Object.onInvoke (ng_zone_impl.js:43)
        at ZoneDelegate.invoke (zone.js:202)
        at Zone.run (zone.js:96)
        at zone.js:462
        at ZoneDelegate.invokeTask (zone.js:236)
        at Object.onInvokeTask (ng_zone_impl.js:34)
        at ZoneDelegate.invokeTask (zone.js:235)ErrorHandler.handleError @ error_handler.js:51next @ application_ref.js:273schedulerFn @ async.js:82SafeSubscriber.__tryOrUnsub @ Subscriber.js:223SafeSubscriber.next @ Subscriber.js:172Subscriber._next @ Subscriber.js:125Subscriber.next @ Subscriber.js:89Subject.next @ Subject.js:55EventEmitter.emit @ async.js:74onError @ ng_zone.js:120onHandleError @ ng_zone_impl.js:64ZoneDelegate.handleError @ zone.js:207Zone.runGuarded @ zone.js:113_loop_1 @ zone.js:379drainMicroTaskQueue @ zone.js:386
    2016-10-08 14:22:50.614 zone.js:355Unhandled Promise rejection: Cannot find module &#39;/app/test.module&#39;. ; Zone: angular ; Task: Promise.then ; Value: Error: Cannot find module &#39;/app/test.module&#39;.(…) Error: Cannot find module &#39;/app/test.module&#39;.
        at webpackEmptyContext (http://localhost:4200/main.bundle.js:49550:8)
        at SystemJsNgModuleLoader.loadAndCompile (http://localhost:4200/main.bundle.js:57952:40)
        at SystemJsNgModuleLoader.load (http://localhost:4200/main.bundle.js:57945:60)
        at RouterConfigLoader.loadModuleFactory (http://localhost:4200/main.bundle.js:22354:128)
        at RouterConfigLoader.load (http://localhost:4200/main.bundle.js:22346:81)
        at MergeMapSubscriber.project (http://localhost:4200/main.bundle.js:61105:111)
        at MergeMapSubscriber._tryNext (http://localhost:4200/main.bundle.js:32515:27)
        at MergeMapSubscriber._next (http://localhost:4200/main.bundle.js:32505:18)
        at MergeMapSubscriber.Subscriber.next (http://localhost:4200/main.bundle.js:7085:18)
        at ScalarObservable._subscribe (http://localhost:4200/main.bundle.js:48555:24)consoleError @ zone.js:355_loop_1 @ zone.js:382drainMicroTaskQueue @ zone.js:386
    2016-10-08 14:22:50.620 zone.js:357Error: Uncaught (in promise): Error: Cannot find module &#39;/app/test.module&#39;.(…)consoleError @ zone.js:357_loop_1 @ zone.js:382drainMicroTaskQueue @ zone.js:386
```

Angular2 lazy loading module error &#39;cannot find module&#39;

This is a conceptual question. In my particular case, I am using [slick.js][1] to create an image carousel for a website. Since these are high resolution photographs, I want to speed up the page load time by allowing the photographs to be loaded asynchronously instead of on page load.

When looking through the documentation for this library, I saw the settings available for the &#39;lazyLoad&#39; property with little information as to what those settings mean in practice.

Essentially my question is, what is the difference between progressive and on-demand in the context of lazy loading.


  [1]: http://kenwheeler.github.io/slick/

lazy loading: progressive vs on-demand

I want to keep all the transformation, stoke and animations identical and was thinking if we can pass resource ID or asset name in Glide to load it locally?

Using Glide for Android, how do I load images from asset and resources?

As many of you know it is widely used to lazy load images.

Now i want to use this as lazy load div background images.

How can i do that ?

I am currently able to use http://www.appelsiini.net/projects/lazyload that plugin

So i need to modify it in a way that it will work with div backgrounds

Need help. Thank you.

The below part i suppose lazy loads images

    $self.one(&quot;appear&quot;, function() {
        if (!this.loaded) {
            if (settings.appear) {
                var elements_left = elements.length;
                settings.appear.call(self, elements_left, settings);
            }
            $(&quot;&lt;img /&gt;&quot;)
                .bind(&quot;load&quot;, function() {
                    $self
                        .hide()
                        .attr(&quot;src&quot;, $self.data(settings.data_attribute))
                        [settings.effect](settings.effect_speed);
                    self.loaded = true;

                    /* Remove image from array so it is not looped next time. */
                    var temp = $.grep(elements, function(element) {
                        return !element.loaded;
                    });
                    elements = $(temp);

                    if (settings.load) {
                        var elements_left = elements.length;
                        settings.load.call(self, elements_left, settings);
                    }
                })
                .attr(&quot;src&quot;, $self.data(settings.data_attribute));
        }
    });

Jquery plugin lazy load

How to Lazy Load div background images

I have a service that gets a JPA entity from outside code. In this service I would like to iterate over a lazily loaded collection that is an attribute of this entity to see if the client has added something to it relative to the current version in the DB.

However, the client may have never touched the collection so it&#39;s still not initialized. This results in the well known 

`org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.example.SomeEntity.`

Of course, if the client never touched the collection, my service doesn&#39;t have to check it for possible changes. The thing is that I can&#39;t seem to find a way to test whether the collection is initialized or not. I guess I could call `size()` on it and if it throws `LazyInitializationException` I would know, but I&#39;m trying not to depend on such patterns.

Is there some `isInitialized()` method somewhere?

All Lazy Loading Solutions on Gang of Coders

Total of 27 Lazy Loading Solutions