Anécdotas de las Curvas del Seno: Lazy Loading en ice:dataTable con ICEfaces

Lazy Loading en ice:dataTable con ICEfaces

Posted in Etiquetas: 2.0, icefaces, java, jsf, lazy loading, spring | viernes, septiembre 30, 2011

¿Que és lazy loading? pues traduciendolo a mi manera en español podria referirse a carga ociosa, es decir carga ociosa de datos. ¿para que se utiliza? sucede que cuando se utiliza un dataTable con JSF siempre se le envia la lista completa de registros que se obtienen de una busqueda en la base de datos y los carga todos de una vez en la tabla para usarlos con un paginador, ¿pero que sucede si tenemos una busqueda de miles de registros? no podemos carga toda esa lista en el dataTable, entonces surge la necesidad de solo traer que necesitamos ver en el paginador por bloques.

Algunos diran que ya existe un articulo en la documentación oficial de ICEfaces para realizar un lazy loading, pero el punto es que es muy dificil de entender ya que agregan otras funcionalidades que estan demas y mi objetivo es simplificar el entendimiento de la técnica.

En esta ocasión utilizare netbeans, tomcat y spring para el acceso a datos.

Utilizare tambien la tabla "Manufacturer" de la base de datos derby "Sample" embebida en netbeans, ya que es la unica que tiene algunos cuantos registros para efectos de prueba.

No entrare en detalle de como configurar un proyecto JSF con ICEfaces ni de como integrarlo con Spring para el acceso a datos, supondre que se ha leido las entradas respectivas.

Suponiendo que ya se ha generado el entity de la tabla Manufacturer creo mi acceso a datos.

Luego la implementación

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.dani.ejemplo.dao;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;
import org.springframework.orm.jpa.JpaCallback;
import org.springframework.orm.jpa.support.JpaDaoSupport;

/**
 *
 * @author dherrera
 */
public class DerbyImpl extends JpaDaoSupport implements DerbyDAO{

public int getTotalManufacturers() {
        Long count=(Long) getJpaTemplate().find("Select count(m) From Manufacturer m").get(0);
        return count.intValue();
    }

public List<Manufacturer> getFindManufacturers(final int firstRow, final int max) {
        return getJpaTemplate().execute(new JpaCallback<List<Manufacturer>>() {

public List<Manufacturer> doInJpa(EntityManager em) throws PersistenceException {
                return em.createQuery("Select m From Manufacturer m").setFirstResult(firstRow).
                        setMaxResults(max).
                        getResultList();
            }
        });
    }

}

Luego creo mi configuracion en spring

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
          http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
          http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
">

<tx:annotation-driven transaction-manager="transactionManager"/>
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="dataSource" ref="dataSource"/>
    <property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>

<jee:jndi-lookup id="dataSource" jndi-name="jdbc/derby"/>

</beans>

Ahora la parte fundamental es crear un custom DataModel

package org.dani.ejemplo.web.model;

import java.util.List;
import javax.faces.model.DataModel;

/**
 *
 * @author dherrera
 */
public class LazyModel<T> extends DataModel{

List<T> list;
    private int pageSize;
    private int totalRows;
    private int rowIndex = -1;

public LazyModel(int totalRows,int pageSize, List<T> list) {
        super();
        this.pageSize=pageSize;
        this.totalRows=totalRows;
        this.list=list;
    }

@Override
    public boolean isRowAvailable() {
        if(list == null)
            return false;

int index = getRowIndex();
        return (index >=0 && index < list.size());
    }

@Override
    public int getRowCount() {
        return totalRows;
    }

@Override
    public Object getRowData() {
        if(list == null)
            return null;
        else if(!isRowAvailable())
            throw new IllegalArgumentException();
        else {
            int dataIndex = getRowIndex();
            return list.get(dataIndex);
        }
    }

@Override
    public int getRowIndex() {
        return (rowIndex % pageSize);
    }

@Override
    public void setRowIndex(int i) {
        rowIndex=i;
    }

@Override
    public Object getWrappedData() {
        return list;
    }

@Override
    public void setWrappedData(Object o) {
        this.list=(List<T>) o;
    }

}

Ahora me dedico a crear los managed beans.

package org.dani.ejemplo.web;

import com.icesoft.faces.component.datapaginator.DataPaginator;
import java.io.Serializable;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.ViewScoped;
import javax.faces.event.ActionEvent;
import org.dani.ejemplo.dao.DerbyDAO;
import org.dani.ejemplo.dao.Manufacturer;
import org.dani.ejemplo.web.model.LazyModel;

/**
 *
 * @author dherrera
 */
@ManagedBean
@ViewScoped
public class ViewBean extends AbstractManagedBean implements Serializable{

@ManagedProperty("#{dao}")
    private DerbyDAO dao;
    private int firstRow;
    private int pageSize;

@PostConstruct
    public void init() {
        firstRow=1;
        pageSize=Integer.valueOf(getBundleValue("paginator.page_size"));
    }

public LazyModel<Manufacturer> getModel() {
        int totalRows=dao.getTotalManufacturers();
        
        List<Manufacturer> list=dao.getFindManufacturers(firstRow, pageSize);
        return new LazyModel<Manufacturer>(totalRows, pageSize, list);
    }

public void pageListener(ActionEvent evt) {
        DataPaginator paginator=(DataPaginator) evt.getSource();
        this.firstRow=paginator.getFirstRow();
    }

public void setDao(DerbyDAO dao) {
        this.dao = dao;
    }
}

Por ultimo el diseño de la página xhtml

<?xml version='1.0' encoding='UTF-8' ?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
	xmlns:ui="http://java.sun.com/jsf/facelets"
	xmlns:f="http://java.sun.com/jsf/core"
	xmlns:h="http://java.sun.com/jsf/html"
        xmlns:icecore="http://www.icefaces.org/icefaces/core"
        xmlns:ace="http://www.icefaces.org/icefaces/components"
        xmlns:ice="http://www.icesoft.com/icefaces/component"
       >
    <h:head>
        <title>ICEfaces 2</title>
        <link rel="stylesheet" type="text/css" href="./xmlhttp/css/rime/rime.css"/>
    </h:head>
    <h:body styleClass="ice-skin-rime">
      <h:form id="form">
          <ice:outputConnectionStatus/>
          <ice:dataPaginator for="tabla"
                             actionListener="#{viewBean.pageListener}"
                             paginator="true" fastStep="#{setting['paginator.page_size']}" paginatorMaxPages="#{setting['paginator.max_pages']}">
            <f:facet name="first">
                    <ice:graphicImage style="border:none;"
                                      url="./xmlhttp/css/xp/css-images/arrow-first.gif"/>
                </f:facet>
                <f:facet name="last">
                    <ice:graphicImage style="border:none;"
                                      url="./xmlhttp/css/xp/css-images/arrow-last.gif"/>
                </f:facet>
                <f:facet name="previous">
                    <ice:graphicImage style="border:none;"
                                      url="./xmlhttp/css/xp/css-images/arrow-previous.gif"/>
                </f:facet>
                <f:facet name="next">
                    <ice:graphicImage style="border:none;"
                                      url="./xmlhttp/css/xp/css-images/arrow-next.gif"/>
                </f:facet>
                <f:facet name="fastforward">
                    <ice:graphicImage style="border:none;"
                                      url="./xmlhttp/css/xp/css-images/arrow-ff.gif"/>
                </f:facet>
                <f:facet name="fastrewind">
                    <ice:graphicImage style="border:none;"
                                      url="./xmlhttp/css/xp/css-images/arrow-fr.gif"/>
                </f:facet>
          </ice:dataPaginator>

<ice:dataTable id="tabla" value="#{viewBean.model}" var="m"
                         rows="#{setting['paginator.page_size']}">
              <ice:column>
                  <f:facet name="header"><ice:outputText value="#{setting['customer.name']}"/></f:facet>
                  <ice:outputText value="#{m.name}"/>
              </ice:column>
              <ice:column>
                  <f:facet name="header"><ice:outputText value="#{setting['customer.email']}"/></f:facet>
                  <ice:outputText value="#{m.email}"/>
              </ice:column>
          </ice:dataTable>
      </h:form>
    </h:body>
    <h:outputStylesheet library="org.icefaces.component.skins" name="rime.css" />
</html>

El resultado sera el siguiente

A través del trace se puede observar que por cada vez que se cambia de pagina se obtiene el bloque de registros que interesa.

Adjunto el codigo fuente para efectos de estudio.

Comentarios (2)

2 Response to "Lazy Loading en ice:dataTable con ICEfaces"

Michael Rojas says:
miércoles, mayo 09, 2012
Este comentario ha sido eliminado por el autor.
Michael Rojas says:
miércoles, mayo 09, 2012

Tu guía está perfecta, me sirvió de mucho porque como dices todas las demás agregan funcionalidades que no son necesarias y lo único que hacen es complicar el como entender la idea principal.

Muchas Gracias :D

Publicar un comentario

Lazy Loading en ice:dataTable con ICEfaces

2 Response to "Lazy Loading en ice:dataTable con ICEfaces"

Acerca de mi

Busca en el blog

Seguidores

Archivo de blog