Datatable Single Selection con RadioButton en JSF- icefaces

Aunque algunos frameworks JSF ya incluyen una funcionalidad se selecciona simple en su componente Datatable tal es el caso de Primefaces, esta pequeña entrada se hace un ejercicio con JSF y Icefaces framework que no trae la funcionalidad en la version 3.2.

El requerimiento es realizar una selección simple en un componente Datatable mediante un RadioButton y cargar el objeto Dto seleccionado en el BackingBean.

Al termino del ejercicio se muestra un componente como el siguiente:

Tecnologias usadas en el ejemplo:

Servidor : Glassfish 4

Icefaces 3.3.0

JSF 2.2

JavaEE 7 

Maven

El truco esta en fusionar 2 componentes con una sola lista de origen, un SelectOneMenu y un Datatable, el ejemplo lo ilustro como imagen para que se entienda mejor, al final de la explicación pondré el link del proyecto.

Tenemos un Dto:

public class PersonaDto {    

    private int id;

    private String nombre;

    private int edad;

    public PersonaDto(int id, String nombre, int edad) {

        this.id = id;

        this.nombre = nombre;

        this.edad = edad;

    }

   //...Getters and Setters          

}

Nuestro JSF ManagedBean :

import java.io.Serializable;

import java.util.Arrays;

import java.util.List;

import javax.annotation.PostConstruct;

import javax.faces.bean.ManagedBean;

import javax.faces.bean.SessionScoped;

import javax.faces.bean.ViewScoped;

import javax.faces.event.ValueChangeEvent;

 private List<PersonaDto> listaPersona;

    private PersonaDto personaSeleccionada;

    private int indexSelected;

     

    public DatatableSelect() {

    }

    

    //cargar valores    

    @PostConstruct

    public void postInit(){

        System.out.println("Cargando valores para mostrar en la grilla..");

        

        listaPersona = Arrays.asList(

                new PersonaDto(1, "Jose Alfredo Jimenez", 45),

                new PersonaDto(2, "Rodrigo X X", 50),

                new PersonaDto(3, "Miguel Y Y", 45)

        );

    }

    public void valueChangeRadioSelected(ValueChangeEvent change) {

        System.out.println("valueChangeRadioSelected");        

        

        final Object indexObject = change.getNewValue();

               

        setIndexSelected(indexObject != null ? (Integer) indexObject : -1);

        

        System.out.println("index"+indexObject);

        

        System.out.println("index se"+indexSelected);

        

        if (indexSelected != -1) {

            

            this.personaSeleccionada = listaPersona.get(indexSelected);            

            

            System.out.println("Persona seleccionada ");

            System.out.println("Id : "+this.personaSeleccionada.getId());

            System.out.println("Nombre : "+this.personaSeleccionada.getNombre());

            System.out.println("Edad : "+this.personaSeleccionada.getEdad());

        }

    }

    

    

    public List<PersonaDto> getListaPersona() {

        return listaPersona;

    }   

    public int getIndexSelected() {

        return indexSelected;

    }

    public void setIndexSelected(int indexSelected) {

        this.indexSelected = indexSelected;

    }

    public PersonaDto getPersonaSeleccionada() {

        return personaSeleccionada;

    }

Tenemos nuestro código en JSF-ICefaces:

Espero haberme explicado :)... dejo el código por aquí en Github.

Posteriormente actualizaré con la selección múltiple con Checkbox (en cuanto haya tiempo).

Patron de diseño Iterador (Java)

Patrón de Diseño ITERADOR

Proposito
 El patrón Iterador es un mecanismo de acceso a los elementos que constituyen una estructura de datos para la utilización de estos sin exponer su estructura interna.

Motivación

El patrón surge del deseo de acceder a los elementos de un contenedor de objetos (por ejemplo, una lista) sin exponer su representación interna. Además, es posible que se necesite más de una forma de recorrer la estructura siendo para ello necesario crear modificaciones en la clase.

La solución que propone el patrón es añadir métodos que permitan recorrer la estructura sin referenciar explícitamente su representación. La responsabilidad del recorrido se traslada a un objeto iterador.

El problema de introducir este objeto iterador reside en que los clientes necesitan conocer la estructura para crear el iterador apropiado.

Esto se soluciona generalizando los distintos iteradores en una abstracción y dotando a las estructuras de datos de un método de fabricación que cree un iterador concreto.

Aplicabilidad

El patrón iterator permite el acceso al contenido de una estructura sin exponer su representación interna. Además diferentes iteradores pueden presentar diferentes tipos de recorrido sobre la estructura (recorrido de principio a fin, recorrido con saltos...). Por otro lado los iteradores no tienen por qué limitarse a recorrer la estructura, sino que podrían incorporar otro tipo de lógica (por ejemplo, filtrado de elementos). Es más, dados diferentes tipos de estructuras, el patrón iterador permite recorrerlas todas utilizando una interfaz común uniforme

Consecuencias

El patrón Iterador permite por tanto diferentes tipos de recorrido de un agregado y varios recorridos simultáneos, simplificando la interfaz del agregado.

Estructura

Fuente Wikipedia

Explicación Simple:

El objetivo principal de este patrón es la manipulación de datos mediante los indices de una estructura ya sea estática (Arrays) o dinámica (Listas). la condición de este patrón es que el acceso debe de ser secuencial mente, a continuación se mencionan algunas de las operaciones que puede contener una clase iterador:

      -Recorridos uno a uno hacia delante.

      -Recorridos uno a uno hacia atras.

      -Recorridos en saltos.

      -Aplicación de Filtros.

      -Aplicación de operaciones.

      -Consulta de un dato por su posición.

      -etc..

Lo que no se puede hacer:

      X-Ordenaciones.(ya que requiere de un recorrido unico de principio a fin  las veces que tenga como talla.).

El principal problema que viene a resolver  este patron es lo siguiente.

Suponemos que tenemos una clase con un vector de tipo (int) la cual queremos saber cuantos de ellos son pares. estaría de esta manera: 

La forma simple de saber cuales son pares seria de manera sencilla y sin patron , un metodo que imprimiera los pares.

public class VectorDatos{

      int[] datos  = new int[5];

     public VectorDatos(){

           //llenamos el vector con los 5 datos

            datos[0] = 10;

            datos[1] = 3;

            datos[2] = 6;

            datos[3] = 5;

             datos[4] = 1;

      }

   public void filtrarPares()

     {

          for(int i=0;i<5;i++)

          {

                if(getValor(i) / 2 ==0)

                   {

                               imprimirPosicion(i);

                   }

           }             

     }

  public void imprimirPosicion(int pos)

   {

            System.out.printf("Valor : "+getValor(pos) .toString());

    }

    public int getValor(int pos){
        return datos[pos];
    }
    public void setValor(int pos, int valor){
        datos[pos] = valor;
    }
    public int dimension(){
        return _datos.length;
    } 

}

ahora si quisiera saber cuales son los impares, la solucion seria hacer otro metodo y anexarlos a la clase quedaria asi:

public class VectorDatos{

      int[] datos  = new int[5];

     public VectorDatos(){

           //llenamos el vector con los 5 datos

            datos[0] = 10;

            datos[1] = 3;

            datos[2] = 6;

            datos[3] = 5;

             datos[4] = 1;

      }

   public void filtrarPares()

     {

          for(int i=0;i<5;i++)

          {

                if(getValor(i) / 2 ==0)

                   {

                               imprimirPosicion(i);

                   }

           }             

     }

 public void filtrarImpares()

     {

          for(int i=0;i<5;i++)

          {

                if(getValor(i) / 2 !=0)

                   {

                               imprimirPosicion(i);

                   }

           }             

     }

  public void imprimirPosicion(int pos)

   {

            System.out.printf("Valor : "+getValor(pos) .toString());

    }

    public int getValor(int pos){
        return datos[pos];
    }
    public void setValor(int pos, int valor){
        datos[pos] = valor;
    }
    public int dimension(){
        return _datos.length;
    } 

}

y si quisiera anexarle otro metodo que me filtrara a los ceros, seguiria siendo la misma solucion crear un metodo y anexarlo esto convertiria a la clase con una codificación basta. 

Lo que el patrón Iterador propone es crear una clase que realice recorridos independientemente de la clase que manipula los valores de la estructura.

la clase iterador quedaria asi:

public class IteradorParesImpares {
    private int[] _vector;
    private int _posicion;

    public IteradorVector(VectorDatos vector) {
        _vector = vector._datos;
        _posicion = 0;
    } 

 public void filtrarPares()

     {

          for(int i=0;i<5;i++)

          {

                if(getValor(i) / 2 ==0)

                   {

                               imprimirPosicion(i);

                   }

           }             

     }

 public void filtrarImpares()

     {

          for(int i=0;i<5;i++)

          {

                if(getValor(i) / 2 !=0)

                   {

                               imprimirPosicion(i);

                   }

           }             

     }

  public void imprimirPosicion(int pos)

   {

            System.out.printf("Valor : "+getValor(pos) .toString());

    }

    public boolean hasNext(){
        if (_posicion < _vector.length)
                    return true;
            else
                    return false;
    }
    public Object next(){
            int valor = _vector[_posicion];
            _posicion++;
            return valor;
    }    

 public int getValor(int pos){
        return datos[pos];
    }
    public void setValor(int pos, int valor){
        datos[pos] = valor;
    } 
}

y la nueva clase manipulador de datos se le anexaría un método el cual al mandarlo a llamar que retorne un objeto de la clase del iterador deseado.

public class VectorDatos {
   
    public int[] datos;
 

      int[] datos  = new int[5];

     public VectorDatos(){

           //llenamos el vector con los 5 datos

            datos[0] = 10;

            datos[1] = 3;

            datos[2] = 6;

            datos[3] = 5;

            datos[4] = 1;

      }

   
    public int getValor(int pos){
        return _datos[pos];
    }
    public void setValor(int pos, int valor){
        _datos[pos] = valor;
    }
    public int dimension(){
        return _datos.length;
    } 

//nuevo metodo que manda a llamar al iterador deseado
    public  IteradorParesImpares  iterador(){
        return new IteradorVector(this);
    }
}

y  se utilizaria asi :

       public static void main(String[] args) {
    }

        // TODO code application logic here

        VectorDatos vector = new VectorDatos();

        //Creación del iterador

        IteradorParesImpares iterador = vector.iterador();

        //Recorrido con el iterador

        while (iterador.hasNext())

        System.out.println(iterador.next()); 

       // filtrar pares e impares

          iterador.filtrarPares();

          iterador.filtrarImpares();

          } 

Podriamos crear mas iteradores con diferentes funciones y usarlos con la misma estructura, solo tendríamos que crear un nuevo método en la clase manupulador que cree el objeto iterador y se pase el this como parametro.

(Espero les haya servidor, recibo sugerencias y comentarios de cualquier tipo)