Patrones. Pocos y de pasadita

Los patrones son soluciones a problemas comunes que podemos encontrar de manera documentada, son las mejores practicas y soluciones a varios problemas que te puedes encontrar en el día a día del desarrollo. Generalmente estos patrones favorecen los objetivos de orientación a objetos y facilitan el trabajo. Existen cientos de ellos, aquí solamente vamos a exponer una introducción a algunos de ellos.

• Singleton. El singleton es una clase de la que solamente queremos crear una sola instancia, podemos pensar por ejemplo en una clase Presidente de Empresa, de estos solamente debería haber uno por Empresa.
  
• Listener. Un listener es una clase que esta atenta a los cambios en alguna instancia de otra clase, podemos pensar en que la clase que reporta los cambios envia avisos a todas las clases interesadas, y estas hacen alguna acción en base a estas notificaciones, de manera similar a alertas sobre eventos.
• Decorator. Una clase de determinado tipo "envuelve" a otra clase del mismo tipo para poder hacer nuevas funcionalidades que pueden ser eco de las de la clase decorada. Los decoradores sirven en muchos casos para crear objetos "con"por ejemplo Cafe con Leche o Leche con Chocolate, o quizas Cafe con Leche con Chocolate.
• Delegate. Es una clase de dependencia en la que una clase expone cierta funcionalidad que es realizada por alguna otra clase o instancia, de manera que el usuario final solo accede a una clase de salida.
• Façade. Los objetos de varias clases se agrupan dentro de una nueva que expone la funcionalidad de todas las clases del grupo dentro de si mismo. Podemos compararlo de manera directa con un control remoto universal, que incluye las funciones de varios controles.
• Factory. Una clase de objetos que son dificiles de configurar se mantienen con constructores de paquete, mientras que una clase de ese mismo paquete permite crear las instancias de los mismos sin pasar por todos los problemas de configuración.
• Interceptor. Una clase funciona como un envoltorio de otra, cada que la claseenvuelta va a realizar una operación le notifica a la primera para que esta pueda cambiar partes del proceso que realiza.
  
• Iterator. Una clase permite recorrer los elementos de una colección.
  
• Abstract Factory. Similar a Factory, pero en este caso se define una clase abstracta que creara los objetos, y es en la implementación concreta donde dichos objetos se crean.
• Strategy. Una clase abstracta define los pasos de un proceso, y el orden que seguiran, pero son las clases concretas quienes determinan la forma exacta en que el proceso se realiza, generalmente implementando partes del proceso.
  

Conceptos para Web

Una lista de los conceptos generales para crear aplicaciones en Web y lo que hace falta, primero el Software:

• Java SDK 1.5 o superior (no necesitas el EE, para eso bajas el Tomcat).
• Apache Tomcat 5.5 o superior.
• Eclipse WTP o Callisto.
• Struts 2.0.9.
• Hibernate 3.2.
• Spring 2.0.
• XDoclet.
• Ant.
• JUnit.
• HTTPUnit.

Las tecnologías vamos a revisarlas poco a poco y con calma, por lo pronto por lo menos debería de instalar el JDK, Eclipse y Tomcat. El resto podemos irlo haciendo poco a poco.

Algunos materiales para el SCJA

Pues aunque no deberian ir necesariamente en este blog vamos a poner algunos materiales que bien podrian servir para medio guiarte en las obscuras profundidades del SCJA:

1. El site oficial del exámen.
   
2. Una guía rápida del UML que deberías conocer.
3. Preguntas de prueba generadas por personas que ya tomaron la certificación.
4. Un site con algunos recursos interesantes.
5. Preguntas de ejemplo desde Alemania. Clic en la izquierda para entrar a cada sección.
6. Mas mocks Cafe4Java.
7. Mock de JavaGuru.
8. Todo junto en JavaRanch.

De vez en cuando voy a poner algunos tópicos sobre esos detalles del SCJA, pero no prometo en realidad nada y no olviden que el detalle es que estudien.

Algo de JTables pa' variar

Bueno, los JTables pueden llegar a se un poco enigmaticos, y hacer que las cosas pasen con ellos a veces resulta un poco díficil, pero con un poco de práctica podemos hacer un buen de cosas con el. Para empezar vamos a ver una manera sencilla de crear un mapeo entre una clase POJO (Plan Old Java Object, Objeto Java Sencillo y Jodido), y lo utilizamos para mostrarlo desde una base de datos a un JTable. Es algo sencillo en realidad. Pero para lograrlo necesitamos una nuevla clase del conjunto Swing, esta clase se llama TableModel y es una interfaz que permite decirle a un JTable que presentar en una tabla. Vamos por ejemplo.

//AbstractTableModel implementa TableModel y la mayoría de sus métodos
class TModelo extends AbstractTableModel {
   private ArrayList lista;

   //Cargamos los datos a una lista de POJO's
   public TModelo(ResultSet rs) {
       try {
           rs.first();
           do {
               POJO pojo = new POJO();
               pojo.campo1 = rs.getString(1);
               pojo.campo2 = rs.getInteger(2);
               pojo.campo3 = rs.getString(3);

               lista.add(pojo);
           } while(rs.next());
       } catch(Exception e) { ; }
   }

   //Indicar cuantas filas va a tener la tabla
   public int getRowCount() { return lista.size(); }
   //Indicar cuantas columnas va a tener la tabla. El numero de campos en este caso
   public int getColumnCount() { return 3; }
   //Objeto en cada celda
   public Object getValueAt(int fila, int columna) {
       try {
           POJO pojo = (POJO) lista.get(fila);
           if(columna == 0)
               return pojo.campo1;
           if(columna == 1)
               return new Integer(pojo.campo2);
           if(columna == 2)
               return pojo.campo3;
       } catch(Exception e) {
           //Regresamos un valor vacio por si las moscas
           return "";
       }
   }
   //nombre de las columnas
   public String getColumnName(int col) {
       if(columna == 0) return "Campo 1";
       if(columna == 1) return "Campo 2";
       if(columna == 2) return "Campo 3";
   }
   //Indicamos si determinada celda es editable
   public boolean isCellEditable(int f, int c) {
       return false;
   }
}

//Una clase POJO muy sencilla
//Esto no deberia hacerse, deberiamos usar geters y seters
class POJO {
   public String campo1;
   public int campo2;
   public String campo3;
}

Una vez que tenemos un TableModel podemos crear una Tabla con los datos que tiene el modelo mismo.

JTable tabla = new JTable(new TModelo(rs));

JFrame fra = new JFrame();
//Si se agrega la tabla de manera directa entonces no se muestran los encabezados
fra.add(new JScrollPane(tabla));

Ahora, un TableModel puede servir para hacer muchas cosas, por ejemplo, podemos filtrar los datos de uno de ellos por medio de otro, a esto se le conoce como Decorator.

class FilterModel extends AbstractModel {
    private TableModel original;
    private ArrayList pasan = new ArrayList();

    public FilterModel(TableModel tm) {
        original = tm;
    }

    //Implementamos un filtro sencillo para un solo campo sobre el modelo anterior
    public void filtra(String valor) {
        //Quitamos todo
        pasan.clear();

        //Filtramos cada valor y ponemos los que coinciden con el valor
        for(int i = 0; i < original.getRowCount(); i++)
            if(("" + original.getValueAt(i, 1)).indexOf(valor) != -1)
                pasan.add(new Integer(i));
    }

    public String getColumnName(int c) { return original.getColumnName(c); }
    public int getColumnCount() { return original.getColumnCount(); }
    public int getRowCount() { return pasan.size(); }
    public Object getValueAt(int f, int c) {
        int real = ((Integer) pasan.get(f)).intValue();
        return original.getValueAt(real, c);
    }
}

Una forma sencilla de hacer las cosas.

Chaito sres...

Haciendo Frames Internos

En Java lo más parecido que hay a un formulario MDI son los Frames Internos, estos son miniventanas que se pegan a una ventana marcada como JDesktopPane como contenedor principal, y deben agregarse a estos.

Vamos a ver como funcionan de manera general estas cosas raras:

JFrame padre = new JFrame("Varios Frames internos");

JDesktopPane jdp = new JDesktopPane();

padre.setContentPane(jdp);

//Crea un Frame interno que no puede cambiar su tamaño, puede cerrarse, no puede 
//maximizarse y puede minimizarse. Los parametros son aleatorios y en ese orden.
JInternalFrame jif = new JInternalFrame("Titulo", false, true, false, true);
jif.pack();
jif.setVisible();

//Después ponemos el elemento en el frame
jdp.add(jif);

Ahora, algunas veces puedes querer que un InternalFrame no pueda cerrarse o dejarse mientras estemos usandolo. Esto en realidad no se puede hacer de manera sencilla; pero usando listeners podemos equilibrar las cosas. Vamos a ver como crear un JInternalFrame que funciona de cierta manera como una ventan modal:

JInternalFrame jif = new JInternalFrame();
jif.addInternalFrameListener(new InternalFrameAdapter() {
    public void internalFrameIconified(InternalFrameEvent e) {
        ((JInternalFrame) e.getSource()).setVisible(true);
    }

    public void internalFrameDeactivated(InternalFrameEvent e) {
        ((JInternalFrame) e.getSource()).setVisible(true);
    }
});

Esa es una forma rápida de hacer que las cosas funcionen de la manera que no deberían hacerlo. Si lo que estan buscando es una forma de mostrar dialogos Internos no hay más que reemplazar los métodos showXXXXDialog de JOptionPane por showInternalXXXXDialog.